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 /* No promotion required. */
610 /* For other languages the result type is unchanged from gdb
611 version 6.7 for backward compatibility.
612 If either arg was long double, make sure that value is also long
613 double. Otherwise use double. */
614 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
615 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
616 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
618 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
622 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
623 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
625 /* No promotion required. */
628 /* Integral operations here. */
629 /* FIXME: Also mixed integral/booleans, with result an integer. */
631 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
632 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
633 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
634 int is_unsigned1
= TYPE_UNSIGNED (type1
);
635 int is_unsigned2
= TYPE_UNSIGNED (type2
);
636 unsigned int result_len
;
637 int unsigned_operation
;
639 /* Determine type length and signedness after promotion for
641 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
644 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
646 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
649 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
652 if (promoted_len1
> promoted_len2
)
654 unsigned_operation
= is_unsigned1
;
655 result_len
= promoted_len1
;
657 else if (promoted_len2
> promoted_len1
)
659 unsigned_operation
= is_unsigned2
;
660 result_len
= promoted_len2
;
664 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
665 result_len
= promoted_len1
;
668 switch (language
->la_language
)
674 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
676 promoted_type
= (unsigned_operation
677 ? builtin
->builtin_unsigned_int
678 : builtin
->builtin_int
);
680 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
682 promoted_type
= (unsigned_operation
683 ? builtin
->builtin_unsigned_long
684 : builtin
->builtin_long
);
688 promoted_type
= (unsigned_operation
689 ? builtin
->builtin_unsigned_long_long
690 : builtin
->builtin_long_long
);
695 /* For other languages the result type is unchanged from gdb
696 version 6.7 for backward compatibility.
697 If either arg was long long, make sure that value is also long
698 long. Otherwise use long. */
699 if (unsigned_operation
)
701 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
702 promoted_type
= builtin
->builtin_unsigned_long_long
;
704 promoted_type
= builtin
->builtin_unsigned_long
;
708 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
709 promoted_type
= builtin
->builtin_long_long
;
711 promoted_type
= builtin
->builtin_long
;
719 /* Promote both operands to common type. */
720 *arg1
= value_cast (promoted_type
, *arg1
);
721 *arg2
= value_cast (promoted_type
, *arg2
);
726 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
728 type
= check_typedef (type
);
729 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
730 type
= TYPE_TARGET_TYPE (type
);
732 switch (TYPE_CODE (type
))
738 case TYPE_CODE_ARRAY
:
739 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
746 /* Constructs a fake method with the given parameter types.
747 This function is used by the parser to construct an "expected"
748 type for method overload resolution. */
751 make_params (int num_types
, struct type
**param_types
)
753 struct type
*type
= XZALLOC (struct type
);
754 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
755 TYPE_LENGTH (type
) = 1;
756 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
757 TYPE_VPTR_FIELDNO (type
) = -1;
758 TYPE_CHAIN (type
) = type
;
759 TYPE_NFIELDS (type
) = num_types
;
760 TYPE_FIELDS (type
) = (struct field
*)
761 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
763 while (num_types
-- > 0)
764 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
770 evaluate_subexp_standard (struct type
*expect_type
,
771 struct expression
*exp
, int *pos
,
776 int pc
, pc2
= 0, oldpos
;
777 struct value
*arg1
= NULL
;
778 struct value
*arg2
= NULL
;
782 struct value
**argvec
;
787 struct type
**arg_types
;
789 struct symbol
*function
= NULL
;
790 char *function_name
= NULL
;
793 op
= exp
->elts
[pc
].opcode
;
798 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
799 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
800 if (noside
== EVAL_SKIP
)
802 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
803 &exp
->elts
[pc
+ 3].string
,
804 expect_type
, 0, noside
);
806 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
811 return value_from_longest (exp
->elts
[pc
+ 1].type
,
812 exp
->elts
[pc
+ 2].longconst
);
816 return value_from_double (exp
->elts
[pc
+ 1].type
,
817 exp
->elts
[pc
+ 2].doubleconst
);
821 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
822 exp
->elts
[pc
+ 2].decfloatconst
);
827 if (noside
== EVAL_SKIP
)
830 /* JYG: We used to just return value_zero of the symbol type
831 if we're asked to avoid side effects. Otherwise we return
832 value_of_variable (...). However I'm not sure if
833 value_of_variable () has any side effect.
834 We need a full value object returned here for whatis_exp ()
835 to call evaluate_type () and then pass the full value to
836 value_rtti_target_type () if we are dealing with a pointer
837 or reference to a base class and print object is on. */
840 volatile struct gdb_exception except
;
841 struct value
*ret
= NULL
;
843 TRY_CATCH (except
, RETURN_MASK_ERROR
)
845 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
846 exp
->elts
[pc
+ 1].block
);
849 if (except
.reason
< 0)
851 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
852 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
), not_lval
);
854 throw_exception (except
);
863 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
867 const char *name
= &exp
->elts
[pc
+ 2].string
;
871 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
872 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
873 name
, strlen (name
));
875 error (_("Register $%s not available."), name
);
877 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
878 a value with the appropriate register type. Unfortunately,
879 we don't have easy access to the type of user registers.
880 So for these registers, we fetch the register value regardless
881 of the evaluation mode. */
882 if (noside
== EVAL_AVOID_SIDE_EFFECTS
883 && regno
< gdbarch_num_regs (exp
->gdbarch
)
884 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
885 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
887 val
= value_of_register (regno
, get_selected_frame (NULL
));
889 error (_("Value of register %s not available."), name
);
895 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
896 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
900 return value_of_internalvar (exp
->gdbarch
,
901 exp
->elts
[pc
+ 1].internalvar
);
904 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
905 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
906 if (noside
== EVAL_SKIP
)
908 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
909 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
911 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
912 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
913 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
914 if (noside
== EVAL_SKIP
)
918 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
921 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
923 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
924 if (noside
== EVAL_SKIP
)
926 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
,
927 builtin_type (exp
->gdbarch
)->builtin_int
);
932 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
933 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
934 nargs
= tem3
- tem2
+ 1;
935 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
937 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
938 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
940 struct value
*rec
= allocate_value (expect_type
);
942 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
943 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
946 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
947 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
949 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
950 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
951 struct value
*array
= allocate_value (expect_type
);
952 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
953 LONGEST low_bound
, high_bound
, index
;
955 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
958 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
961 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
962 for (tem
= nargs
; --nargs
>= 0;)
964 struct value
*element
;
967 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
970 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
972 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
973 if (value_type (element
) != element_type
)
974 element
= value_cast (element_type
, element
);
977 int continue_pc
= *pos
;
980 index
= init_array_element (array
, element
, exp
, pos
, noside
,
981 low_bound
, high_bound
);
986 if (index
> high_bound
)
987 /* to avoid memory corruption */
988 error (_("Too many array elements"));
989 memcpy (value_contents_raw (array
)
990 + (index
- low_bound
) * element_size
,
991 value_contents (element
),
999 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1000 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1002 struct value
*set
= allocate_value (expect_type
);
1003 gdb_byte
*valaddr
= value_contents_raw (set
);
1004 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1005 struct type
*check_type
= element_type
;
1006 LONGEST low_bound
, high_bound
;
1008 /* get targettype of elementtype */
1009 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1010 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1011 check_type
= TYPE_TARGET_TYPE (check_type
);
1013 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1014 error (_("(power)set type with unknown size"));
1015 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1016 for (tem
= 0; tem
< nargs
; tem
++)
1018 LONGEST range_low
, range_high
;
1019 struct type
*range_low_type
, *range_high_type
;
1020 struct value
*elem_val
;
1022 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1025 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1026 range_low_type
= value_type (elem_val
);
1027 range_low
= value_as_long (elem_val
);
1028 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1029 range_high_type
= value_type (elem_val
);
1030 range_high
= value_as_long (elem_val
);
1034 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1035 range_low_type
= range_high_type
= value_type (elem_val
);
1036 range_low
= range_high
= value_as_long (elem_val
);
1038 /* check types of elements to avoid mixture of elements from
1039 different types. Also check if type of element is "compatible"
1040 with element type of powerset */
1041 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1042 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1043 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1044 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1045 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1046 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1047 && (range_low_type
!= range_high_type
)))
1048 /* different element modes */
1049 error (_("POWERSET tuple elements of different mode"));
1050 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1051 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1052 && range_low_type
!= check_type
))
1053 error (_("incompatible POWERSET tuple elements"));
1054 if (range_low
> range_high
)
1056 warning (_("empty POWERSET tuple range"));
1059 if (range_low
< low_bound
|| range_high
> high_bound
)
1060 error (_("POWERSET tuple element out of range"));
1061 range_low
-= low_bound
;
1062 range_high
-= low_bound
;
1063 for (; range_low
<= range_high
; range_low
++)
1065 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1067 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1068 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1069 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1076 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1077 for (tem
= 0; tem
< nargs
; tem
++)
1079 /* Ensure that array expressions are coerced into pointer objects. */
1080 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1082 if (noside
== EVAL_SKIP
)
1084 return value_array (tem2
, tem3
, argvec
);
1088 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1090 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1092 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1094 if (noside
== EVAL_SKIP
)
1096 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1099 case TERNOP_SLICE_COUNT
:
1101 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1103 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1105 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1107 return value_slice (array
, lowbound
, length
);
1111 /* Skip third and second args to evaluate the first one. */
1112 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1113 if (value_logical_not (arg1
))
1115 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1116 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1120 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1121 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1125 case OP_OBJC_SELECTOR
:
1126 { /* Objective C @selector operator. */
1127 char *sel
= &exp
->elts
[pc
+ 2].string
;
1128 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1129 struct type
*selector_type
;
1131 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1132 if (noside
== EVAL_SKIP
)
1136 sel
[len
] = 0; /* Make sure it's terminated. */
1138 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1139 return value_from_longest (selector_type
,
1140 lookup_child_selector (exp
->gdbarch
, sel
));
1143 case OP_OBJC_MSGCALL
:
1144 { /* Objective C message (method) call. */
1146 CORE_ADDR responds_selector
= 0;
1147 CORE_ADDR method_selector
= 0;
1149 CORE_ADDR selector
= 0;
1151 int struct_return
= 0;
1152 int sub_no_side
= 0;
1154 struct value
*msg_send
= NULL
;
1155 struct value
*msg_send_stret
= NULL
;
1156 int gnu_runtime
= 0;
1158 struct value
*target
= NULL
;
1159 struct value
*method
= NULL
;
1160 struct value
*called_method
= NULL
;
1162 struct type
*selector_type
= NULL
;
1163 struct type
*long_type
;
1165 struct value
*ret
= NULL
;
1168 selector
= exp
->elts
[pc
+ 1].longconst
;
1169 nargs
= exp
->elts
[pc
+ 2].longconst
;
1170 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1175 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1176 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1178 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1179 sub_no_side
= EVAL_NORMAL
;
1181 sub_no_side
= noside
;
1183 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1185 if (value_as_long (target
) == 0)
1186 return value_from_longest (long_type
, 0);
1188 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1191 /* Find the method dispatch (Apple runtime) or method lookup
1192 (GNU runtime) function for Objective-C. These will be used
1193 to lookup the symbol information for the method. If we
1194 can't find any symbol information, then we'll use these to
1195 call the method, otherwise we can call the method
1196 directly. The msg_send_stret function is used in the special
1197 case of a method that returns a structure (Apple runtime
1201 struct type
*type
= selector_type
;
1203 type
= lookup_function_type (type
);
1204 type
= lookup_pointer_type (type
);
1205 type
= lookup_function_type (type
);
1206 type
= lookup_pointer_type (type
);
1208 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1210 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1212 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1213 msg_send_stret
= value_from_pointer (type
,
1214 value_as_address (msg_send_stret
));
1218 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1219 /* Special dispatcher for methods returning structs */
1221 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1224 /* Verify the target object responds to this method. The
1225 standard top-level 'Object' class uses a different name for
1226 the verification method than the non-standard, but more
1227 often used, 'NSObject' class. Make sure we check for both. */
1230 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1231 if (responds_selector
== 0)
1233 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1235 if (responds_selector
== 0)
1236 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1239 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1240 if (method_selector
== 0)
1242 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1244 if (method_selector
== 0)
1245 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1247 /* Call the verification method, to make sure that the target
1248 class implements the desired method. */
1250 argvec
[0] = msg_send
;
1252 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1253 argvec
[3] = value_from_longest (long_type
, selector
);
1256 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1259 /* Function objc_msg_lookup returns a pointer. */
1261 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1263 if (value_as_long (ret
) == 0)
1264 error (_("Target does not respond to this message selector."));
1266 /* Call "methodForSelector:" method, to get the address of a
1267 function method that implements this selector for this
1268 class. If we can find a symbol at that address, then we
1269 know the return type, parameter types etc. (that's a good
1272 argvec
[0] = msg_send
;
1274 argvec
[2] = value_from_longest (long_type
, method_selector
);
1275 argvec
[3] = value_from_longest (long_type
, selector
);
1278 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1282 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1285 /* ret should now be the selector. */
1287 addr
= value_as_long (ret
);
1290 struct symbol
*sym
= NULL
;
1292 /* The address might point to a function descriptor;
1293 resolve it to the actual code address instead. */
1294 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1297 /* Is it a high_level symbol? */
1298 sym
= find_pc_function (addr
);
1300 method
= value_of_variable (sym
, 0);
1303 /* If we found a method with symbol information, check to see
1304 if it returns a struct. Otherwise assume it doesn't. */
1310 struct type
*val_type
;
1312 funaddr
= find_function_addr (method
, &val_type
);
1314 b
= block_for_pc (funaddr
);
1316 CHECK_TYPEDEF (val_type
);
1318 if ((val_type
== NULL
)
1319 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1321 if (expect_type
!= NULL
)
1322 val_type
= expect_type
;
1325 struct_return
= using_struct_return (exp
->gdbarch
,
1326 value_type (method
), val_type
);
1328 else if (expect_type
!= NULL
)
1330 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1331 check_typedef (expect_type
));
1334 /* Found a function symbol. Now we will substitute its
1335 value in place of the message dispatcher (obj_msgSend),
1336 so that we call the method directly instead of thru
1337 the dispatcher. The main reason for doing this is that
1338 we can now evaluate the return value and parameter values
1339 according to their known data types, in case we need to
1340 do things like promotion, dereferencing, special handling
1341 of structs and doubles, etc.
1343 We want to use the type signature of 'method', but still
1344 jump to objc_msgSend() or objc_msgSend_stret() to better
1345 mimic the behavior of the runtime. */
1349 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1350 error (_("method address has symbol information with non-function type; skipping"));
1352 /* Create a function pointer of the appropriate type, and replace
1353 its value with the value of msg_send or msg_send_stret. We must
1354 use a pointer here, as msg_send and msg_send_stret are of pointer
1355 type, and the representation may be different on systems that use
1356 function descriptors. */
1359 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1360 value_as_address (msg_send_stret
));
1363 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1364 value_as_address (msg_send
));
1369 called_method
= msg_send_stret
;
1371 called_method
= msg_send
;
1374 if (noside
== EVAL_SKIP
)
1377 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1379 /* If the return type doesn't look like a function type,
1380 call an error. This can happen if somebody tries to
1381 turn a variable into a function call. This is here
1382 because people often want to call, eg, strcmp, which
1383 gdb doesn't know is a function. If gdb isn't asked for
1384 it's opinion (ie. through "whatis"), it won't offer
1387 struct type
*type
= value_type (called_method
);
1389 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1390 type
= TYPE_TARGET_TYPE (type
);
1391 type
= TYPE_TARGET_TYPE (type
);
1395 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1396 return allocate_value (expect_type
);
1398 return allocate_value (type
);
1401 error (_("Expression of type other than \"method returning ...\" used as a method"));
1404 /* Now depending on whether we found a symbol for the method,
1405 we will either call the runtime dispatcher or the method
1408 argvec
[0] = called_method
;
1410 argvec
[2] = value_from_longest (long_type
, selector
);
1411 /* User-supplied arguments. */
1412 for (tem
= 0; tem
< nargs
; tem
++)
1413 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1414 argvec
[tem
+ 3] = 0;
1416 if (gnu_runtime
&& (method
!= NULL
))
1418 /* Function objc_msg_lookup returns a pointer. */
1419 deprecated_set_value_type (argvec
[0],
1420 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1421 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1424 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1431 op
= exp
->elts
[*pos
].opcode
;
1432 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1433 /* Allocate arg vector, including space for the function to be
1434 called in argvec[0] and a terminating NULL */
1435 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1436 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1439 /* First, evaluate the structure into arg2 */
1442 if (noside
== EVAL_SKIP
)
1445 if (op
== STRUCTOP_MEMBER
)
1447 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1451 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1454 /* If the function is a virtual function, then the
1455 aggregate value (providing the structure) plays
1456 its part by providing the vtable. Otherwise,
1457 it is just along for the ride: call the function
1460 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1462 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1463 != TYPE_CODE_METHODPTR
)
1464 error (_("Non-pointer-to-member value used in pointer-to-member "
1467 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1469 struct type
*method_type
= check_typedef (value_type (arg1
));
1471 arg1
= value_zero (method_type
, not_lval
);
1474 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1476 /* Now, say which argument to start evaluating from */
1479 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1481 /* Hair for method invocations */
1485 /* First, evaluate the structure into arg2 */
1487 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1488 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1489 if (noside
== EVAL_SKIP
)
1492 if (op
== STRUCTOP_STRUCT
)
1494 /* If v is a variable in a register, and the user types
1495 v.method (), this will produce an error, because v has
1498 A possible way around this would be to allocate a
1499 copy of the variable on the stack, copy in the
1500 contents, call the function, and copy out the
1501 contents. I.e. convert this from call by reference
1502 to call by copy-return (or whatever it's called).
1503 However, this does not work because it is not the
1504 same: the method being called could stash a copy of
1505 the address, and then future uses through that address
1506 (after the method returns) would be expected to
1507 use the variable itself, not some copy of it. */
1508 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1512 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1514 /* Check to see if the operator '->' has been overloaded. If the operator
1515 has been overloaded replace arg2 with the value returned by the custom
1516 operator and continue evaluation. */
1517 while (unop_user_defined_p (op
, arg2
))
1519 volatile struct gdb_exception except
;
1520 struct value
*value
= NULL
;
1521 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1523 value
= value_x_unop (arg2
, op
, noside
);
1526 if (except
.reason
< 0)
1528 if (except
.error
== NOT_FOUND_ERROR
)
1531 throw_exception (except
);
1536 /* Now, say which argument to start evaluating from */
1539 else if (op
== OP_SCOPE
1540 && overload_resolution
1541 && (exp
->language_defn
->la_language
== language_cplus
))
1543 /* Unpack it locally so we can properly handle overload
1549 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1550 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1551 type
= exp
->elts
[pc2
+ 1].type
;
1552 name
= &exp
->elts
[pc2
+ 3].string
;
1555 function_name
= NULL
;
1556 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1558 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1560 get_selected_block (0),
1562 if (function
== NULL
)
1563 error (_("No symbol \"%s\" in namespace \"%s\"."),
1564 name
, TYPE_TAG_NAME (type
));
1570 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1571 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1572 function_name
= name
;
1574 arg2
= value_zero (type
, lval_memory
);
1579 else if (op
== OP_ADL_FUNC
)
1581 /* Save the function position and move pos so that the arguments
1582 can be evaluated. */
1588 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1589 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1593 /* Non-method function call */
1597 /* If this is a C++ function wait until overload resolution. */
1598 if (op
== OP_VAR_VALUE
1599 && overload_resolution
1600 && (exp
->language_defn
->la_language
== language_cplus
))
1602 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1607 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1608 type
= value_type (argvec
[0]);
1609 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1610 type
= TYPE_TARGET_TYPE (type
);
1611 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1613 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1615 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1622 /* Evaluate arguments */
1623 for (; tem
<= nargs
; tem
++)
1625 /* Ensure that array expressions are coerced into pointer objects. */
1626 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1629 /* signal end of arglist */
1631 if (op
== OP_ADL_FUNC
)
1633 struct symbol
*symp
;
1636 int string_pc
= save_pos1
+ 3;
1638 /* Extract the function name. */
1639 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1640 func_name
= (char *) alloca (name_len
+ 1);
1641 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1643 /* Prepare list of argument types for overload resolution */
1644 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1645 for (ix
= 1; ix
<= nargs
; ix
++)
1646 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1648 find_overload_match (arg_types
, nargs
, func_name
,
1649 NON_METHOD
/* not method */ , 0 /* strict match */ ,
1650 NULL
, NULL
/* pass NULL symbol since symbol is unknown */ ,
1651 NULL
, &symp
, NULL
, 0);
1653 /* Now fix the expression being evaluated. */
1654 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1655 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1658 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1659 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1661 int static_memfuncp
;
1664 /* Method invocation : stuff "this" as first parameter */
1669 /* Name of method from expression */
1670 tstr
= &exp
->elts
[pc2
+ 2].string
;
1673 tstr
= function_name
;
1675 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1677 /* Language is C++, do some overload resolution before evaluation */
1678 struct value
*valp
= NULL
;
1680 /* Prepare list of argument types for overload resolution */
1681 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1682 for (ix
= 1; ix
<= nargs
; ix
++)
1683 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1685 (void) find_overload_match (arg_types
, nargs
, tstr
,
1686 METHOD
/* method */ , 0 /* strict match */ ,
1687 &arg2
/* the object */ , NULL
,
1688 &valp
, NULL
, &static_memfuncp
, 0);
1690 if (op
== OP_SCOPE
&& !static_memfuncp
)
1692 /* For the time being, we don't handle this. */
1693 error (_("Call to overloaded function %s requires "
1697 argvec
[1] = arg2
; /* the ``this'' pointer */
1698 argvec
[0] = valp
; /* use the method found after overload resolution */
1701 /* Non-C++ case -- or no overload resolution */
1703 struct value
*temp
= arg2
;
1705 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1707 op
== STRUCTOP_STRUCT
1708 ? "structure" : "structure pointer");
1709 /* value_struct_elt updates temp with the correct value
1710 of the ``this'' pointer if necessary, so modify argvec[1] to
1711 reflect any ``this'' changes. */
1712 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1713 value_address (temp
)
1714 + value_embedded_offset (temp
));
1715 argvec
[1] = arg2
; /* the ``this'' pointer */
1718 if (static_memfuncp
)
1720 argvec
[1] = argvec
[0];
1725 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1730 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1732 /* Non-member function being called */
1733 /* fn: This can only be done for C++ functions. A C-style function
1734 in a C++ program, for instance, does not have the fields that
1735 are expected here */
1737 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1739 /* Language is C++, do some overload resolution before evaluation */
1740 struct symbol
*symp
;
1743 /* If a scope has been specified disable ADL. */
1747 if (op
== OP_VAR_VALUE
)
1748 function
= exp
->elts
[save_pos1
+2].symbol
;
1750 /* Prepare list of argument types for overload resolution */
1751 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1752 for (ix
= 1; ix
<= nargs
; ix
++)
1753 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1755 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1756 NON_METHOD
/* not method */ , 0 /* strict match */ ,
1757 NULL
, function
/* the function */ ,
1758 NULL
, &symp
, NULL
, no_adl
);
1760 if (op
== OP_VAR_VALUE
)
1762 /* Now fix the expression being evaluated */
1763 exp
->elts
[save_pos1
+2].symbol
= symp
;
1764 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1768 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1772 /* Not C++, or no overload resolution allowed */
1773 /* nothing to be done; argvec already correctly set up */
1778 /* It is probably a C-style function */
1779 /* nothing to be done; argvec already correctly set up */
1784 if (noside
== EVAL_SKIP
)
1786 if (argvec
[0] == NULL
)
1787 error (_("Cannot evaluate function -- may be inlined"));
1788 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1790 /* If the return type doesn't look like a function type, call an
1791 error. This can happen if somebody tries to turn a variable into
1792 a function call. This is here because people often want to
1793 call, eg, strcmp, which gdb doesn't know is a function. If
1794 gdb isn't asked for it's opinion (ie. through "whatis"),
1795 it won't offer it. */
1797 struct type
*ftype
= value_type (argvec
[0]);
1799 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1801 /* We don't know anything about what the internal
1802 function might return, but we have to return
1804 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1807 else if (TYPE_TARGET_TYPE (ftype
))
1808 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1810 error (_("Expression of type other than \"Function returning ...\" used as function"));
1812 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1813 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1814 argvec
[0], nargs
, argvec
+ 1);
1816 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1817 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1819 case OP_F77_UNDETERMINED_ARGLIST
:
1821 /* Remember that in F77, functions, substring ops and
1822 array subscript operations cannot be disambiguated
1823 at parse time. We have made all array subscript operations,
1824 substring operations as well as function calls come here
1825 and we now have to discover what the heck this thing actually was.
1826 If it is a function, we process just as if we got an OP_FUNCALL. */
1828 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1831 /* First determine the type code we are dealing with. */
1832 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1833 type
= check_typedef (value_type (arg1
));
1834 code
= TYPE_CODE (type
);
1836 if (code
== TYPE_CODE_PTR
)
1838 /* Fortran always passes variable to subroutines as pointer.
1839 So we need to look into its target type to see if it is
1840 array, string or function. If it is, we need to switch
1841 to the target value the original one points to. */
1842 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1844 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1845 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1846 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1848 arg1
= value_ind (arg1
);
1849 type
= check_typedef (value_type (arg1
));
1850 code
= TYPE_CODE (type
);
1856 case TYPE_CODE_ARRAY
:
1857 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1858 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1860 goto multi_f77_subscript
;
1862 case TYPE_CODE_STRING
:
1863 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1864 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1867 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1868 return value_subscript (arg1
, value_as_long (arg2
));
1872 case TYPE_CODE_FUNC
:
1873 /* It's a function call. */
1874 /* Allocate arg vector, including space for the function to be
1875 called in argvec[0] and a terminating NULL */
1876 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1879 for (; tem
<= nargs
; tem
++)
1880 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1881 argvec
[tem
] = 0; /* signal end of arglist */
1885 error (_("Cannot perform substring on this type"));
1889 /* We have a complex number, There should be 2 floating
1890 point numbers that compose it */
1892 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1893 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1895 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1897 case STRUCTOP_STRUCT
:
1898 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1899 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1900 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1901 if (noside
== EVAL_SKIP
)
1903 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1904 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1905 &exp
->elts
[pc
+ 2].string
,
1910 struct value
*temp
= arg1
;
1912 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1917 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1918 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1919 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1920 if (noside
== EVAL_SKIP
)
1923 /* Check to see if operator '->' has been overloaded. If so replace
1924 arg1 with the value returned by evaluating operator->(). */
1925 while (unop_user_defined_p (op
, arg1
))
1927 volatile struct gdb_exception except
;
1928 struct value
*value
= NULL
;
1929 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1931 value
= value_x_unop (arg1
, op
, noside
);
1934 if (except
.reason
< 0)
1936 if (except
.error
== NOT_FOUND_ERROR
)
1939 throw_exception (except
);
1944 /* JYG: if print object is on we need to replace the base type
1945 with rtti type in order to continue on with successful
1946 lookup of member / method only available in the rtti type. */
1948 struct type
*type
= value_type (arg1
);
1949 struct type
*real_type
;
1950 int full
, top
, using_enc
;
1951 struct value_print_options opts
;
1953 get_user_print_options (&opts
);
1954 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1955 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1957 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1960 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1961 real_type
= lookup_pointer_type (real_type
);
1963 real_type
= lookup_reference_type (real_type
);
1965 arg1
= value_cast (real_type
, arg1
);
1970 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1971 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1972 &exp
->elts
[pc
+ 2].string
,
1977 struct value
*temp
= arg1
;
1979 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1980 NULL
, "structure pointer");
1983 case STRUCTOP_MEMBER
:
1985 if (op
== STRUCTOP_MEMBER
)
1986 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1988 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1990 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1992 if (noside
== EVAL_SKIP
)
1995 type
= check_typedef (value_type (arg2
));
1996 switch (TYPE_CODE (type
))
1998 case TYPE_CODE_METHODPTR
:
1999 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2000 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2003 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2004 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2005 return value_ind (arg2
);
2008 case TYPE_CODE_MEMBERPTR
:
2009 /* Now, convert these values to an address. */
2010 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
2013 mem_offset
= value_as_long (arg2
);
2015 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2016 value_as_long (arg1
) + mem_offset
);
2017 return value_ind (arg3
);
2020 error (_("non-pointer-to-member value used in pointer-to-member construct"));
2024 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2025 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2026 for (ix
= 0; ix
< nargs
; ++ix
)
2027 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
2029 expect_type
= make_params (nargs
, arg_types
);
2030 *(pos
) += 3 + nargs
;
2031 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
2032 xfree (TYPE_FIELDS (expect_type
));
2033 xfree (TYPE_MAIN_TYPE (expect_type
));
2034 xfree (expect_type
);
2038 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2039 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2040 if (noside
== EVAL_SKIP
)
2042 if (binop_user_defined_p (op
, arg1
, arg2
))
2043 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2045 return value_concat (arg1
, arg2
);
2048 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2049 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2051 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2053 if (binop_user_defined_p (op
, arg1
, arg2
))
2054 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2056 return value_assign (arg1
, arg2
);
2058 case BINOP_ASSIGN_MODIFY
:
2060 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2061 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2062 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2064 op
= exp
->elts
[pc
+ 1].opcode
;
2065 if (binop_user_defined_p (op
, arg1
, arg2
))
2066 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2067 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2069 && is_integral_type (value_type (arg2
)))
2070 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2071 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2073 && is_integral_type (value_type (arg2
)))
2074 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2077 struct value
*tmp
= arg1
;
2079 /* For shift and integer exponentiation operations,
2080 only promote the first argument. */
2081 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2082 && is_integral_type (value_type (arg2
)))
2083 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2085 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2087 arg2
= value_binop (tmp
, arg2
, op
);
2089 return value_assign (arg1
, arg2
);
2092 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2093 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2094 if (noside
== EVAL_SKIP
)
2096 if (binop_user_defined_p (op
, arg1
, arg2
))
2097 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2098 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2099 && is_integral_type (value_type (arg2
)))
2100 return value_ptradd (arg1
, value_as_long (arg2
));
2101 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2102 && is_integral_type (value_type (arg1
)))
2103 return value_ptradd (arg2
, value_as_long (arg1
));
2106 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2107 return value_binop (arg1
, arg2
, BINOP_ADD
);
2111 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2112 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2113 if (noside
== EVAL_SKIP
)
2115 if (binop_user_defined_p (op
, arg1
, arg2
))
2116 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2117 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2118 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2120 /* FIXME -- should be ptrdiff_t */
2121 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2122 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2124 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2125 && is_integral_type (value_type (arg2
)))
2126 return value_ptradd (arg1
, - value_as_long (arg2
));
2129 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2130 return value_binop (arg1
, arg2
, BINOP_SUB
);
2141 case BINOP_BITWISE_AND
:
2142 case BINOP_BITWISE_IOR
:
2143 case BINOP_BITWISE_XOR
:
2144 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2145 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2146 if (noside
== EVAL_SKIP
)
2148 if (binop_user_defined_p (op
, arg1
, arg2
))
2149 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2152 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2153 fudge arg2 to avoid division-by-zero, the caller is
2154 (theoretically) only looking for the type of the result. */
2155 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2156 /* ??? Do we really want to test for BINOP_MOD here?
2157 The implementation of value_binop gives it a well-defined
2160 || op
== BINOP_INTDIV
2163 && value_logical_not (arg2
))
2165 struct value
*v_one
, *retval
;
2167 v_one
= value_one (value_type (arg2
), not_lval
);
2168 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2169 retval
= value_binop (arg1
, v_one
, op
);
2174 /* For shift and integer exponentiation operations,
2175 only promote the first argument. */
2176 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2177 && is_integral_type (value_type (arg2
)))
2178 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2180 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2182 return value_binop (arg1
, arg2
, op
);
2187 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2188 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2189 if (noside
== EVAL_SKIP
)
2191 error (_("':' operator used in invalid context"));
2193 case BINOP_SUBSCRIPT
:
2194 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2195 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2196 if (noside
== EVAL_SKIP
)
2198 if (binop_user_defined_p (op
, arg1
, arg2
))
2199 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2202 /* If the user attempts to subscript something that is not an
2203 array or pointer type (like a plain int variable for example),
2204 then report this as an error. */
2206 arg1
= coerce_ref (arg1
);
2207 type
= check_typedef (value_type (arg1
));
2208 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2209 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2211 if (TYPE_NAME (type
))
2212 error (_("cannot subscript something of type `%s'"),
2215 error (_("cannot subscript requested type"));
2218 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2219 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2221 return value_subscript (arg1
, value_as_long (arg2
));
2225 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2226 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2227 if (noside
== EVAL_SKIP
)
2229 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2230 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2232 case MULTI_SUBSCRIPT
:
2234 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2235 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2238 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2239 /* FIXME: EVAL_SKIP handling may not be correct. */
2240 if (noside
== EVAL_SKIP
)
2251 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2252 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2254 /* If the user attempts to subscript something that has no target
2255 type (like a plain int variable for example), then report this
2258 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2261 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2267 error (_("cannot subscript something of type `%s'"),
2268 TYPE_NAME (value_type (arg1
)));
2272 if (binop_user_defined_p (op
, arg1
, arg2
))
2274 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2278 arg1
= coerce_ref (arg1
);
2279 type
= check_typedef (value_type (arg1
));
2281 switch (TYPE_CODE (type
))
2284 case TYPE_CODE_ARRAY
:
2285 case TYPE_CODE_STRING
:
2286 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2289 case TYPE_CODE_BITSTRING
:
2290 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2291 arg1
= value_bitstring_subscript (type
, arg1
,
2292 value_as_long (arg2
));
2296 if (TYPE_NAME (type
))
2297 error (_("cannot subscript something of type `%s'"),
2300 error (_("cannot subscript requested type"));
2306 multi_f77_subscript
:
2308 int subscript_array
[MAX_FORTRAN_DIMS
];
2309 int array_size_array
[MAX_FORTRAN_DIMS
];
2310 int ndimensions
= 1, i
;
2311 struct type
*tmp_type
;
2312 int offset_item
; /* The array offset where the item lives */
2314 if (nargs
> MAX_FORTRAN_DIMS
)
2315 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2317 tmp_type
= check_typedef (value_type (arg1
));
2318 ndimensions
= calc_f77_array_dims (type
);
2320 if (nargs
!= ndimensions
)
2321 error (_("Wrong number of subscripts"));
2323 gdb_assert (nargs
> 0);
2325 /* Now that we know we have a legal array subscript expression
2326 let us actually find out where this element exists in the array. */
2329 /* Take array indices left to right */
2330 for (i
= 0; i
< nargs
; i
++)
2332 /* Evaluate each subscript, It must be a legal integer in F77 */
2333 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2335 /* Fill in the subscript and array size arrays */
2337 subscript_array
[i
] = value_as_long (arg2
);
2340 /* Internal type of array is arranged right to left */
2341 for (i
= 0; i
< nargs
; i
++)
2343 upper
= f77_get_upperbound (tmp_type
);
2344 lower
= f77_get_lowerbound (tmp_type
);
2346 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
2348 /* Zero-normalize subscripts so that offsetting will work. */
2350 subscript_array
[nargs
- i
- 1] -= lower
;
2352 /* If we are at the bottom of a multidimensional
2353 array type then keep a ptr to the last ARRAY
2354 type around for use when calling value_subscript()
2355 below. This is done because we pretend to value_subscript
2356 that we actually have a one-dimensional array
2357 of base element type that we apply a simple
2361 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
2364 /* Now let us calculate the offset for this item */
2366 offset_item
= subscript_array
[ndimensions
- 1];
2368 for (i
= ndimensions
- 1; i
> 0; --i
)
2370 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
2372 /* Let us now play a dirty trick: we will take arg1
2373 which is a value node pointing to the topmost level
2374 of the multidimensional array-set and pretend
2375 that it is actually a array of the final element
2376 type, this will ensure that value_subscript()
2377 returns the correct type value */
2379 deprecated_set_value_type (arg1
, tmp_type
);
2380 return value_subscripted_rvalue (arg1
, offset_item
, 0);
2383 case BINOP_LOGICAL_AND
:
2384 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2385 if (noside
== EVAL_SKIP
)
2387 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2392 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2395 if (binop_user_defined_p (op
, arg1
, arg2
))
2397 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2398 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2402 tem
= value_logical_not (arg1
);
2403 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2404 (tem
? EVAL_SKIP
: noside
));
2405 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2406 return value_from_longest (type
,
2407 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2410 case BINOP_LOGICAL_OR
:
2411 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2412 if (noside
== EVAL_SKIP
)
2414 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2419 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2422 if (binop_user_defined_p (op
, arg1
, arg2
))
2424 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2425 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2429 tem
= value_logical_not (arg1
);
2430 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2431 (!tem
? EVAL_SKIP
: noside
));
2432 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2433 return value_from_longest (type
,
2434 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2438 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2439 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2440 if (noside
== EVAL_SKIP
)
2442 if (binop_user_defined_p (op
, arg1
, arg2
))
2444 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2448 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2449 tem
= value_equal (arg1
, arg2
);
2450 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2451 return value_from_longest (type
, (LONGEST
) tem
);
2454 case BINOP_NOTEQUAL
:
2455 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2456 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2457 if (noside
== EVAL_SKIP
)
2459 if (binop_user_defined_p (op
, arg1
, arg2
))
2461 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2465 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2466 tem
= value_equal (arg1
, arg2
);
2467 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2468 return value_from_longest (type
, (LONGEST
) ! tem
);
2472 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2473 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2474 if (noside
== EVAL_SKIP
)
2476 if (binop_user_defined_p (op
, arg1
, arg2
))
2478 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2482 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2483 tem
= value_less (arg1
, arg2
);
2484 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2485 return value_from_longest (type
, (LONGEST
) tem
);
2489 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2490 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2491 if (noside
== EVAL_SKIP
)
2493 if (binop_user_defined_p (op
, arg1
, arg2
))
2495 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2499 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2500 tem
= value_less (arg2
, arg1
);
2501 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2502 return value_from_longest (type
, (LONGEST
) tem
);
2506 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2507 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2508 if (noside
== EVAL_SKIP
)
2510 if (binop_user_defined_p (op
, arg1
, arg2
))
2512 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2516 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2517 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2518 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2519 return value_from_longest (type
, (LONGEST
) tem
);
2523 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2524 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2525 if (noside
== EVAL_SKIP
)
2527 if (binop_user_defined_p (op
, arg1
, arg2
))
2529 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2533 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2534 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2535 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2536 return value_from_longest (type
, (LONGEST
) tem
);
2540 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2541 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2542 if (noside
== EVAL_SKIP
)
2544 type
= check_typedef (value_type (arg2
));
2545 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2546 error (_("Non-integral right operand for \"@\" operator."));
2547 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2549 return allocate_repeat_value (value_type (arg1
),
2550 longest_to_int (value_as_long (arg2
)));
2553 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2556 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2557 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2560 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2561 if (noside
== EVAL_SKIP
)
2563 if (unop_user_defined_p (op
, arg1
))
2564 return value_x_unop (arg1
, op
, noside
);
2567 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2568 return value_pos (arg1
);
2572 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2573 if (noside
== EVAL_SKIP
)
2575 if (unop_user_defined_p (op
, arg1
))
2576 return value_x_unop (arg1
, op
, noside
);
2579 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2580 return value_neg (arg1
);
2583 case UNOP_COMPLEMENT
:
2584 /* C++: check for and handle destructor names. */
2585 op
= exp
->elts
[*pos
].opcode
;
2587 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2588 if (noside
== EVAL_SKIP
)
2590 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2591 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2594 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2595 return value_complement (arg1
);
2598 case UNOP_LOGICAL_NOT
:
2599 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2600 if (noside
== EVAL_SKIP
)
2602 if (unop_user_defined_p (op
, arg1
))
2603 return value_x_unop (arg1
, op
, noside
);
2606 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2607 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2611 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2612 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2613 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2614 type
= check_typedef (value_type (arg1
));
2615 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2616 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2617 error (_("Attempt to dereference pointer to member without an object"));
2618 if (noside
== EVAL_SKIP
)
2620 if (unop_user_defined_p (op
, arg1
))
2621 return value_x_unop (arg1
, op
, noside
);
2622 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2624 type
= check_typedef (value_type (arg1
));
2625 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2626 || TYPE_CODE (type
) == TYPE_CODE_REF
2627 /* In C you can dereference an array to get the 1st elt. */
2628 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2630 return value_zero (TYPE_TARGET_TYPE (type
),
2632 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2633 /* GDB allows dereferencing an int. */
2634 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2637 error (_("Attempt to take contents of a non-pointer value."));
2640 /* Allow * on an integer so we can cast it to whatever we want.
2641 This returns an int, which seems like the most C-like thing to
2642 do. "long long" variables are rare enough that
2643 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2644 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2645 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2646 (CORE_ADDR
) value_as_address (arg1
));
2647 return value_ind (arg1
);
2650 /* C++: check for and handle pointer to members. */
2652 op
= exp
->elts
[*pos
].opcode
;
2654 if (noside
== EVAL_SKIP
)
2656 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2661 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2667 if (noside
== EVAL_SKIP
)
2669 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2672 return evaluate_subexp_for_sizeof (exp
, pos
);
2676 type
= exp
->elts
[pc
+ 1].type
;
2677 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2678 if (noside
== EVAL_SKIP
)
2680 if (type
!= value_type (arg1
))
2681 arg1
= value_cast (type
, arg1
);
2684 case UNOP_DYNAMIC_CAST
:
2686 type
= exp
->elts
[pc
+ 1].type
;
2687 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2688 if (noside
== EVAL_SKIP
)
2690 return value_dynamic_cast (type
, arg1
);
2692 case UNOP_REINTERPRET_CAST
:
2694 type
= exp
->elts
[pc
+ 1].type
;
2695 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2696 if (noside
== EVAL_SKIP
)
2698 return value_reinterpret_cast (type
, arg1
);
2702 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2703 if (noside
== EVAL_SKIP
)
2705 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2706 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2708 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2709 value_as_address (arg1
));
2711 case UNOP_MEMVAL_TLS
:
2713 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2714 if (noside
== EVAL_SKIP
)
2716 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2717 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2722 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2723 value_as_address (arg1
));
2724 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2727 case UNOP_PREINCREMENT
:
2728 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2729 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2731 else if (unop_user_defined_p (op
, arg1
))
2733 return value_x_unop (arg1
, op
, noside
);
2737 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2738 arg2
= value_ptradd (arg1
, 1);
2741 struct value
*tmp
= arg1
;
2743 arg2
= value_one (value_type (arg1
), not_lval
);
2744 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2745 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2748 return value_assign (arg1
, arg2
);
2751 case UNOP_PREDECREMENT
:
2752 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2753 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2755 else if (unop_user_defined_p (op
, arg1
))
2757 return value_x_unop (arg1
, op
, noside
);
2761 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2762 arg2
= value_ptradd (arg1
, -1);
2765 struct value
*tmp
= arg1
;
2767 arg2
= value_one (value_type (arg1
), not_lval
);
2768 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2769 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2772 return value_assign (arg1
, arg2
);
2775 case UNOP_POSTINCREMENT
:
2776 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2777 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2779 else if (unop_user_defined_p (op
, arg1
))
2781 return value_x_unop (arg1
, op
, noside
);
2785 arg3
= value_non_lval (arg1
);
2787 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2788 arg2
= value_ptradd (arg1
, 1);
2791 struct value
*tmp
= arg1
;
2793 arg2
= value_one (value_type (arg1
), not_lval
);
2794 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2795 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2798 value_assign (arg1
, arg2
);
2802 case UNOP_POSTDECREMENT
:
2803 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2804 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2806 else if (unop_user_defined_p (op
, arg1
))
2808 return value_x_unop (arg1
, op
, noside
);
2812 arg3
= value_non_lval (arg1
);
2814 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2815 arg2
= value_ptradd (arg1
, -1);
2818 struct value
*tmp
= arg1
;
2820 arg2
= value_one (value_type (arg1
), not_lval
);
2821 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2822 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2825 value_assign (arg1
, arg2
);
2831 return value_of_this (1);
2835 return value_of_local ("self", 1);
2838 /* The value is not supposed to be used. This is here to make it
2839 easier to accommodate expressions that contain types. */
2841 if (noside
== EVAL_SKIP
)
2843 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2845 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2847 /* If this is a typedef, then find its immediate target. We
2848 use check_typedef to resolve stubs, but we ignore its
2849 result because we do not want to dig past all
2851 check_typedef (type
);
2852 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2853 type
= TYPE_TARGET_TYPE (type
);
2854 return allocate_value (type
);
2857 error (_("Attempt to use a type name as an expression"));
2860 /* Removing this case and compiling with gcc -Wall reveals that
2861 a lot of cases are hitting this case. Some of these should
2862 probably be removed from expression.h; others are legitimate
2863 expressions which are (apparently) not fully implemented.
2865 If there are any cases landing here which mean a user error,
2866 then they should be separate cases, with more descriptive
2870 GDB does not (yet) know how to evaluate that kind of expression"));
2874 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2877 /* Evaluate a subexpression of EXP, at index *POS,
2878 and return the address of that subexpression.
2879 Advance *POS over the subexpression.
2880 If the subexpression isn't an lvalue, get an error.
2881 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2882 then only the type of the result need be correct. */
2884 static struct value
*
2885 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2895 op
= exp
->elts
[pc
].opcode
;
2901 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2903 /* We can't optimize out "&*" if there's a user-defined operator*. */
2904 if (unop_user_defined_p (op
, x
))
2906 x
= value_x_unop (x
, op
, noside
);
2907 goto default_case_after_eval
;
2910 return coerce_array (x
);
2914 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2915 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2918 var
= exp
->elts
[pc
+ 2].symbol
;
2920 /* C++: The "address" of a reference should yield the address
2921 * of the object pointed to. Let value_addr() deal with it. */
2922 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2926 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2929 lookup_pointer_type (SYMBOL_TYPE (var
));
2930 enum address_class sym_class
= SYMBOL_CLASS (var
);
2932 if (sym_class
== LOC_CONST
2933 || sym_class
== LOC_CONST_BYTES
2934 || sym_class
== LOC_REGISTER
)
2935 error (_("Attempt to take address of register or constant."));
2938 value_zero (type
, not_lval
);
2941 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2944 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2945 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2946 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2947 &exp
->elts
[pc
+ 3].string
,
2950 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2955 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2956 default_case_after_eval
:
2957 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2959 struct type
*type
= check_typedef (value_type (x
));
2961 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2962 return value_zero (lookup_pointer_type (value_type (x
)),
2964 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2965 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2968 error (_("Attempt to take address of value not located in memory."));
2970 return value_addr (x
);
2974 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2975 When used in contexts where arrays will be coerced anyway, this is
2976 equivalent to `evaluate_subexp' but much faster because it avoids
2977 actually fetching array contents (perhaps obsolete now that we have
2980 Note that we currently only do the coercion for C expressions, where
2981 arrays are zero based and the coercion is correct. For other languages,
2982 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2983 to decide if coercion is appropriate.
2988 evaluate_subexp_with_coercion (struct expression
*exp
,
2989 int *pos
, enum noside noside
)
2998 op
= exp
->elts
[pc
].opcode
;
3003 var
= exp
->elts
[pc
+ 2].symbol
;
3004 type
= check_typedef (SYMBOL_TYPE (var
));
3005 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3006 && !TYPE_VECTOR (type
)
3007 && CAST_IS_CONVERSION (exp
->language_defn
))
3010 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3011 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3017 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3021 /* Evaluate a subexpression of EXP, at index *POS,
3022 and return a value for the size of that subexpression.
3023 Advance *POS over the subexpression. */
3025 static struct value
*
3026 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
3028 /* FIXME: This should be size_t. */
3029 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3036 op
= exp
->elts
[pc
].opcode
;
3040 /* This case is handled specially
3041 so that we avoid creating a value for the result type.
3042 If the result type is very big, it's desirable not to
3043 create a value unnecessarily. */
3046 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3047 type
= check_typedef (value_type (val
));
3048 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3049 && TYPE_CODE (type
) != TYPE_CODE_REF
3050 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3051 error (_("Attempt to take contents of a non-pointer value."));
3052 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3053 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3057 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3058 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3062 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3064 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3067 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3068 return value_from_longest (size_type
,
3069 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3073 /* Parse a type expression in the string [P..P+LENGTH). */
3076 parse_and_eval_type (char *p
, int length
)
3078 char *tmp
= (char *) alloca (length
+ 4);
3079 struct expression
*expr
;
3082 memcpy (tmp
+ 1, p
, length
);
3083 tmp
[length
+ 1] = ')';
3084 tmp
[length
+ 2] = '0';
3085 tmp
[length
+ 3] = '\0';
3086 expr
= parse_expression (tmp
);
3087 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3088 error (_("Internal error in eval_type."));
3089 return expr
->elts
[1].type
;
3093 calc_f77_array_dims (struct type
*array_type
)
3096 struct type
*tmp_type
;
3098 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3099 error (_("Can't get dimensions for a non-array type"));
3101 tmp_type
= array_type
;
3103 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3105 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)