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, 2011 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
),
873 throw_exception (except
);
882 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
886 const char *name
= &exp
->elts
[pc
+ 2].string
;
890 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
891 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
892 name
, strlen (name
));
894 error (_("Register $%s not available."), name
);
896 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
897 a value with the appropriate register type. Unfortunately,
898 we don't have easy access to the type of user registers.
899 So for these registers, we fetch the register value regardless
900 of the evaluation mode. */
901 if (noside
== EVAL_AVOID_SIDE_EFFECTS
902 && regno
< gdbarch_num_regs (exp
->gdbarch
)
903 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
904 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
906 val
= value_of_register (regno
, get_selected_frame (NULL
));
908 error (_("Value of register %s not available."), name
);
914 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
915 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
919 return value_of_internalvar (exp
->gdbarch
,
920 exp
->elts
[pc
+ 1].internalvar
);
923 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
924 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
925 if (noside
== EVAL_SKIP
)
927 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
928 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
930 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
931 NSString constant. */
932 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
933 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
934 if (noside
== EVAL_SKIP
)
938 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
941 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
943 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
944 if (noside
== EVAL_SKIP
)
946 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
,
947 builtin_type (exp
->gdbarch
)->builtin_int
);
952 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
953 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
954 nargs
= tem3
- tem2
+ 1;
955 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
957 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
958 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
960 struct value
*rec
= allocate_value (expect_type
);
962 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
963 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
966 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
967 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
969 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
970 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
971 struct value
*array
= allocate_value (expect_type
);
972 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
973 LONGEST low_bound
, high_bound
, index
;
975 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
978 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
981 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
982 for (tem
= nargs
; --nargs
>= 0;)
984 struct value
*element
;
987 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
990 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
992 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
993 if (value_type (element
) != element_type
)
994 element
= value_cast (element_type
, element
);
997 int continue_pc
= *pos
;
1000 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1001 low_bound
, high_bound
);
1006 if (index
> high_bound
)
1007 /* to avoid memory corruption */
1008 error (_("Too many array elements"));
1009 memcpy (value_contents_raw (array
)
1010 + (index
- low_bound
) * element_size
,
1011 value_contents (element
),
1019 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1020 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1022 struct value
*set
= allocate_value (expect_type
);
1023 gdb_byte
*valaddr
= value_contents_raw (set
);
1024 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1025 struct type
*check_type
= element_type
;
1026 LONGEST low_bound
, high_bound
;
1028 /* get targettype of elementtype */
1029 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1030 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1031 check_type
= TYPE_TARGET_TYPE (check_type
);
1033 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1034 error (_("(power)set type with unknown size"));
1035 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1036 for (tem
= 0; tem
< nargs
; tem
++)
1038 LONGEST range_low
, range_high
;
1039 struct type
*range_low_type
, *range_high_type
;
1040 struct value
*elem_val
;
1042 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1045 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1046 range_low_type
= value_type (elem_val
);
1047 range_low
= value_as_long (elem_val
);
1048 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1049 range_high_type
= value_type (elem_val
);
1050 range_high
= value_as_long (elem_val
);
1054 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1055 range_low_type
= range_high_type
= value_type (elem_val
);
1056 range_low
= range_high
= value_as_long (elem_val
);
1058 /* check types of elements to avoid mixture of elements from
1059 different types. Also check if type of element is "compatible"
1060 with element type of powerset */
1061 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1062 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1063 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1064 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1065 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1066 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1067 && (range_low_type
!= range_high_type
)))
1068 /* different element modes */
1069 error (_("POWERSET tuple elements of different mode"));
1070 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1071 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1072 && range_low_type
!= check_type
))
1073 error (_("incompatible POWERSET tuple elements"));
1074 if (range_low
> range_high
)
1076 warning (_("empty POWERSET tuple range"));
1079 if (range_low
< low_bound
|| range_high
> high_bound
)
1080 error (_("POWERSET tuple element out of range"));
1081 range_low
-= low_bound
;
1082 range_high
-= low_bound
;
1083 for (; range_low
<= range_high
; range_low
++)
1085 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1087 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1088 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1089 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1096 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1097 for (tem
= 0; tem
< nargs
; tem
++)
1099 /* Ensure that array expressions are coerced into pointer objects. */
1100 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1102 if (noside
== EVAL_SKIP
)
1104 return value_array (tem2
, tem3
, argvec
);
1108 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1110 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1112 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1114 if (noside
== EVAL_SKIP
)
1116 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1119 case TERNOP_SLICE_COUNT
:
1121 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1123 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1125 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1127 return value_slice (array
, lowbound
, length
);
1131 /* Skip third and second args to evaluate the first one. */
1132 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1133 if (value_logical_not (arg1
))
1135 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1136 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1140 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1141 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1145 case OP_OBJC_SELECTOR
:
1146 { /* Objective C @selector operator. */
1147 char *sel
= &exp
->elts
[pc
+ 2].string
;
1148 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1149 struct type
*selector_type
;
1151 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1152 if (noside
== EVAL_SKIP
)
1156 sel
[len
] = 0; /* Make sure it's terminated. */
1158 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1159 return value_from_longest (selector_type
,
1160 lookup_child_selector (exp
->gdbarch
, sel
));
1163 case OP_OBJC_MSGCALL
:
1164 { /* Objective C message (method) call. */
1166 CORE_ADDR responds_selector
= 0;
1167 CORE_ADDR method_selector
= 0;
1169 CORE_ADDR selector
= 0;
1171 int struct_return
= 0;
1172 int sub_no_side
= 0;
1174 struct value
*msg_send
= NULL
;
1175 struct value
*msg_send_stret
= NULL
;
1176 int gnu_runtime
= 0;
1178 struct value
*target
= NULL
;
1179 struct value
*method
= NULL
;
1180 struct value
*called_method
= NULL
;
1182 struct type
*selector_type
= NULL
;
1183 struct type
*long_type
;
1185 struct value
*ret
= NULL
;
1188 selector
= exp
->elts
[pc
+ 1].longconst
;
1189 nargs
= exp
->elts
[pc
+ 2].longconst
;
1190 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1195 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1196 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1198 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1199 sub_no_side
= EVAL_NORMAL
;
1201 sub_no_side
= noside
;
1203 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1205 if (value_as_long (target
) == 0)
1206 return value_from_longest (long_type
, 0);
1208 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1211 /* Find the method dispatch (Apple runtime) or method lookup
1212 (GNU runtime) function for Objective-C. These will be used
1213 to lookup the symbol information for the method. If we
1214 can't find any symbol information, then we'll use these to
1215 call the method, otherwise we can call the method
1216 directly. The msg_send_stret function is used in the special
1217 case of a method that returns a structure (Apple runtime
1221 struct type
*type
= selector_type
;
1223 type
= lookup_function_type (type
);
1224 type
= lookup_pointer_type (type
);
1225 type
= lookup_function_type (type
);
1226 type
= lookup_pointer_type (type
);
1228 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1230 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1232 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1233 msg_send_stret
= value_from_pointer (type
,
1234 value_as_address (msg_send_stret
));
1238 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1239 /* Special dispatcher for methods returning structs */
1241 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1244 /* Verify the target object responds to this method. The
1245 standard top-level 'Object' class uses a different name for
1246 the verification method than the non-standard, but more
1247 often used, 'NSObject' class. Make sure we check for both. */
1250 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1251 if (responds_selector
== 0)
1253 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1255 if (responds_selector
== 0)
1256 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1259 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1260 if (method_selector
== 0)
1262 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1264 if (method_selector
== 0)
1265 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1267 /* Call the verification method, to make sure that the target
1268 class implements the desired method. */
1270 argvec
[0] = msg_send
;
1272 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1273 argvec
[3] = value_from_longest (long_type
, selector
);
1276 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1279 /* Function objc_msg_lookup returns a pointer. */
1281 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1283 if (value_as_long (ret
) == 0)
1284 error (_("Target does not respond to this message selector."));
1286 /* Call "methodForSelector:" method, to get the address of a
1287 function method that implements this selector for this
1288 class. If we can find a symbol at that address, then we
1289 know the return type, parameter types etc. (that's a good
1292 argvec
[0] = msg_send
;
1294 argvec
[2] = value_from_longest (long_type
, method_selector
);
1295 argvec
[3] = value_from_longest (long_type
, selector
);
1298 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1302 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1305 /* ret should now be the selector. */
1307 addr
= value_as_long (ret
);
1310 struct symbol
*sym
= NULL
;
1312 /* The address might point to a function descriptor;
1313 resolve it to the actual code address instead. */
1314 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1317 /* Is it a high_level symbol? */
1318 sym
= find_pc_function (addr
);
1320 method
= value_of_variable (sym
, 0);
1323 /* If we found a method with symbol information, check to see
1324 if it returns a struct. Otherwise assume it doesn't. */
1330 struct type
*val_type
;
1332 funaddr
= find_function_addr (method
, &val_type
);
1334 b
= block_for_pc (funaddr
);
1336 CHECK_TYPEDEF (val_type
);
1338 if ((val_type
== NULL
)
1339 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1341 if (expect_type
!= NULL
)
1342 val_type
= expect_type
;
1345 struct_return
= using_struct_return (exp
->gdbarch
,
1346 value_type (method
),
1349 else if (expect_type
!= NULL
)
1351 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1352 check_typedef (expect_type
));
1355 /* Found a function symbol. Now we will substitute its
1356 value in place of the message dispatcher (obj_msgSend),
1357 so that we call the method directly instead of thru
1358 the dispatcher. The main reason for doing this is that
1359 we can now evaluate the return value and parameter values
1360 according to their known data types, in case we need to
1361 do things like promotion, dereferencing, special handling
1362 of structs and doubles, etc.
1364 We want to use the type signature of 'method', but still
1365 jump to objc_msgSend() or objc_msgSend_stret() to better
1366 mimic the behavior of the runtime. */
1370 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1371 error (_("method address has symbol information "
1372 "with non-function type; skipping"));
1374 /* Create a function pointer of the appropriate type, and
1375 replace its value with the value of msg_send or
1376 msg_send_stret. We must use a pointer here, as
1377 msg_send and msg_send_stret are of pointer type, and
1378 the representation may be different on systems that use
1379 function descriptors. */
1382 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1383 value_as_address (msg_send_stret
));
1386 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1387 value_as_address (msg_send
));
1392 called_method
= msg_send_stret
;
1394 called_method
= msg_send
;
1397 if (noside
== EVAL_SKIP
)
1400 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1402 /* If the return type doesn't look like a function type,
1403 call an error. This can happen if somebody tries to
1404 turn a variable into a function call. This is here
1405 because people often want to call, eg, strcmp, which
1406 gdb doesn't know is a function. If gdb isn't asked for
1407 it's opinion (ie. through "whatis"), it won't offer
1410 struct type
*type
= value_type (called_method
);
1412 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1413 type
= TYPE_TARGET_TYPE (type
);
1414 type
= TYPE_TARGET_TYPE (type
);
1418 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1419 return allocate_value (expect_type
);
1421 return allocate_value (type
);
1424 error (_("Expression of type other than "
1425 "\"method returning ...\" used as a method"));
1428 /* Now depending on whether we found a symbol for the method,
1429 we will either call the runtime dispatcher or the method
1432 argvec
[0] = called_method
;
1434 argvec
[2] = value_from_longest (long_type
, selector
);
1435 /* User-supplied arguments. */
1436 for (tem
= 0; tem
< nargs
; tem
++)
1437 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1438 argvec
[tem
+ 3] = 0;
1440 if (gnu_runtime
&& (method
!= NULL
))
1442 /* Function objc_msg_lookup returns a pointer. */
1443 deprecated_set_value_type (argvec
[0],
1444 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1446 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1449 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1456 op
= exp
->elts
[*pos
].opcode
;
1457 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1458 /* Allocate arg vector, including space for the function to be
1459 called in argvec[0] and a terminating NULL */
1460 argvec
= (struct value
**)
1461 alloca (sizeof (struct value
*) * (nargs
+ 3));
1462 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1465 /* First, evaluate the structure into arg2 */
1468 if (noside
== EVAL_SKIP
)
1471 if (op
== STRUCTOP_MEMBER
)
1473 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1477 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1480 /* If the function is a virtual function, then the
1481 aggregate value (providing the structure) plays
1482 its part by providing the vtable. Otherwise,
1483 it is just along for the ride: call the function
1486 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1488 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1489 != TYPE_CODE_METHODPTR
)
1490 error (_("Non-pointer-to-member value used in pointer-to-member "
1493 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1495 struct type
*method_type
= check_typedef (value_type (arg1
));
1497 arg1
= value_zero (method_type
, not_lval
);
1500 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1502 /* Now, say which argument to start evaluating from */
1505 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1507 /* Hair for method invocations */
1511 /* First, evaluate the structure into arg2 */
1513 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1514 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1515 if (noside
== EVAL_SKIP
)
1518 if (op
== STRUCTOP_STRUCT
)
1520 /* If v is a variable in a register, and the user types
1521 v.method (), this will produce an error, because v has
1524 A possible way around this would be to allocate a
1525 copy of the variable on the stack, copy in the
1526 contents, call the function, and copy out the
1527 contents. I.e. convert this from call by reference
1528 to call by copy-return (or whatever it's called).
1529 However, this does not work because it is not the
1530 same: the method being called could stash a copy of
1531 the address, and then future uses through that address
1532 (after the method returns) would be expected to
1533 use the variable itself, not some copy of it. */
1534 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1538 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1540 /* Check to see if the operator '->' has been
1541 overloaded. If the operator has been overloaded
1542 replace arg2 with the value returned by the custom
1543 operator and continue evaluation. */
1544 while (unop_user_defined_p (op
, arg2
))
1546 volatile struct gdb_exception except
;
1547 struct value
*value
= NULL
;
1548 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1550 value
= value_x_unop (arg2
, op
, noside
);
1553 if (except
.reason
< 0)
1555 if (except
.error
== NOT_FOUND_ERROR
)
1558 throw_exception (except
);
1563 /* Now, say which argument to start evaluating from */
1566 else if (op
== OP_SCOPE
1567 && overload_resolution
1568 && (exp
->language_defn
->la_language
== language_cplus
))
1570 /* Unpack it locally so we can properly handle overload
1576 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1577 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1578 type
= exp
->elts
[pc2
+ 1].type
;
1579 name
= &exp
->elts
[pc2
+ 3].string
;
1582 function_name
= NULL
;
1583 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1585 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1587 get_selected_block (0),
1589 if (function
== NULL
)
1590 error (_("No symbol \"%s\" in namespace \"%s\"."),
1591 name
, TYPE_TAG_NAME (type
));
1597 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1598 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1599 function_name
= name
;
1601 arg2
= value_zero (type
, lval_memory
);
1606 else if (op
== OP_ADL_FUNC
)
1608 /* Save the function position and move pos so that the arguments
1609 can be evaluated. */
1615 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1616 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1620 /* Non-method function call */
1624 /* If this is a C++ function wait until overload resolution. */
1625 if (op
== OP_VAR_VALUE
1626 && overload_resolution
1627 && (exp
->language_defn
->la_language
== language_cplus
))
1629 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1634 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1635 type
= value_type (argvec
[0]);
1636 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1637 type
= TYPE_TARGET_TYPE (type
);
1638 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1640 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1642 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1650 /* Evaluate arguments */
1651 for (; tem
<= nargs
; tem
++)
1653 /* Ensure that array expressions are coerced into pointer objects. */
1654 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1657 /* signal end of arglist */
1659 if (op
== OP_ADL_FUNC
)
1661 struct symbol
*symp
;
1664 int string_pc
= save_pos1
+ 3;
1666 /* Extract the function name. */
1667 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1668 func_name
= (char *) alloca (name_len
+ 1);
1669 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1671 /* Prepare list of argument types for overload resolution */
1672 arg_types
= (struct type
**)
1673 alloca (nargs
* (sizeof (struct type
*)));
1674 for (ix
= 1; ix
<= nargs
; ix
++)
1675 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1677 find_overload_match (arg_types
, nargs
, func_name
,
1678 NON_METHOD
, /* not method */
1679 0, /* strict match */
1680 NULL
, NULL
, /* pass NULL symbol since
1681 symbol is unknown */
1682 NULL
, &symp
, NULL
, 0);
1684 /* Now fix the expression being evaluated. */
1685 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1686 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1689 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1690 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1692 int static_memfuncp
;
1695 /* Method invocation : stuff "this" as first parameter */
1700 /* Name of method from expression */
1701 tstr
= &exp
->elts
[pc2
+ 2].string
;
1704 tstr
= function_name
;
1706 if (overload_resolution
&& (exp
->language_defn
->la_language
1709 /* Language is C++, do some overload resolution before
1711 struct value
*valp
= NULL
;
1713 /* Prepare list of argument types for overload resolution */
1714 arg_types
= (struct type
**)
1715 alloca (nargs
* (sizeof (struct type
*)));
1716 for (ix
= 1; ix
<= nargs
; ix
++)
1717 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1719 (void) find_overload_match (arg_types
, nargs
, tstr
,
1720 METHOD
, /* method */
1721 0, /* strict match */
1722 &arg2
, /* the object */
1724 &static_memfuncp
, 0);
1726 if (op
== OP_SCOPE
&& !static_memfuncp
)
1728 /* For the time being, we don't handle this. */
1729 error (_("Call to overloaded function %s requires "
1733 argvec
[1] = arg2
; /* the ``this'' pointer */
1734 argvec
[0] = valp
; /* use the method found after overload
1738 /* Non-C++ case -- or no overload resolution */
1740 struct value
*temp
= arg2
;
1742 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1744 op
== STRUCTOP_STRUCT
1745 ? "structure" : "structure pointer");
1746 /* value_struct_elt updates temp with the correct value
1747 of the ``this'' pointer if necessary, so modify argvec[1] to
1748 reflect any ``this'' changes. */
1750 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1751 value_address (temp
)
1752 + value_embedded_offset (temp
));
1753 argvec
[1] = arg2
; /* the ``this'' pointer */
1756 if (static_memfuncp
)
1758 argvec
[1] = argvec
[0];
1763 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1768 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1770 /* Non-member function being called */
1771 /* fn: This can only be done for C++ functions. A C-style function
1772 in a C++ program, for instance, does not have the fields that
1773 are expected here */
1775 if (overload_resolution
&& (exp
->language_defn
->la_language
1778 /* Language is C++, do some overload resolution before
1780 struct symbol
*symp
;
1783 /* If a scope has been specified disable ADL. */
1787 if (op
== OP_VAR_VALUE
)
1788 function
= exp
->elts
[save_pos1
+2].symbol
;
1790 /* Prepare list of argument types for overload resolution */
1791 arg_types
= (struct type
**)
1792 alloca (nargs
* (sizeof (struct type
*)));
1793 for (ix
= 1; ix
<= nargs
; ix
++)
1794 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1796 (void) find_overload_match (arg_types
, nargs
,
1797 NULL
, /* no need for name */
1798 NON_METHOD
, /* not method */
1799 0, /* strict match */
1800 NULL
, function
, /* the function */
1801 NULL
, &symp
, NULL
, no_adl
);
1803 if (op
== OP_VAR_VALUE
)
1805 /* Now fix the expression being evaluated */
1806 exp
->elts
[save_pos1
+2].symbol
= symp
;
1807 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1811 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1815 /* Not C++, or no overload resolution allowed */
1816 /* nothing to be done; argvec already correctly set up */
1821 /* It is probably a C-style function */
1822 /* nothing to be done; argvec already correctly set up */
1827 if (noside
== EVAL_SKIP
)
1829 if (argvec
[0] == NULL
)
1830 error (_("Cannot evaluate function -- may be inlined"));
1831 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1833 /* If the return type doesn't look like a function type, call an
1834 error. This can happen if somebody tries to turn a variable into
1835 a function call. This is here because people often want to
1836 call, eg, strcmp, which gdb doesn't know is a function. If
1837 gdb isn't asked for it's opinion (ie. through "whatis"),
1838 it won't offer it. */
1840 struct type
*ftype
= value_type (argvec
[0]);
1842 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1844 /* We don't know anything about what the internal
1845 function might return, but we have to return
1847 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1850 else if (TYPE_TARGET_TYPE (ftype
))
1851 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1853 error (_("Expression of type other than "
1854 "\"Function returning ...\" used as function"));
1856 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1857 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1858 argvec
[0], nargs
, argvec
+ 1);
1860 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1861 /* pai: FIXME save value from call_function_by_hand, then adjust
1862 pc by adjust_fn_pc if +ve. */
1864 case OP_F77_UNDETERMINED_ARGLIST
:
1866 /* Remember that in F77, functions, substring ops and
1867 array subscript operations cannot be disambiguated
1868 at parse time. We have made all array subscript operations,
1869 substring operations as well as function calls come here
1870 and we now have to discover what the heck this thing actually was.
1871 If it is a function, we process just as if we got an OP_FUNCALL. */
1873 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1876 /* First determine the type code we are dealing with. */
1877 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1878 type
= check_typedef (value_type (arg1
));
1879 code
= TYPE_CODE (type
);
1881 if (code
== TYPE_CODE_PTR
)
1883 /* Fortran always passes variable to subroutines as pointer.
1884 So we need to look into its target type to see if it is
1885 array, string or function. If it is, we need to switch
1886 to the target value the original one points to. */
1887 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1889 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1890 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1891 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1893 arg1
= value_ind (arg1
);
1894 type
= check_typedef (value_type (arg1
));
1895 code
= TYPE_CODE (type
);
1901 case TYPE_CODE_ARRAY
:
1902 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1903 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1905 goto multi_f77_subscript
;
1907 case TYPE_CODE_STRING
:
1908 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1909 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1912 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1913 return value_subscript (arg1
, value_as_long (arg2
));
1917 case TYPE_CODE_FUNC
:
1918 /* It's a function call. */
1919 /* Allocate arg vector, including space for the function to be
1920 called in argvec[0] and a terminating NULL */
1921 argvec
= (struct value
**)
1922 alloca (sizeof (struct value
*) * (nargs
+ 2));
1925 for (; tem
<= nargs
; tem
++)
1926 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1927 argvec
[tem
] = 0; /* signal end of arglist */
1931 error (_("Cannot perform substring on this type"));
1935 /* We have a complex number, There should be 2 floating
1936 point numbers that compose it */
1938 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1939 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1941 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1943 case STRUCTOP_STRUCT
:
1944 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1945 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1946 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1947 if (noside
== EVAL_SKIP
)
1949 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1950 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1951 &exp
->elts
[pc
+ 2].string
,
1956 struct value
*temp
= arg1
;
1958 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1963 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1964 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1965 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1966 if (noside
== EVAL_SKIP
)
1969 /* Check to see if operator '->' has been overloaded. If so replace
1970 arg1 with the value returned by evaluating operator->(). */
1971 while (unop_user_defined_p (op
, arg1
))
1973 volatile struct gdb_exception except
;
1974 struct value
*value
= NULL
;
1975 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1977 value
= value_x_unop (arg1
, op
, noside
);
1980 if (except
.reason
< 0)
1982 if (except
.error
== NOT_FOUND_ERROR
)
1985 throw_exception (except
);
1990 /* JYG: if print object is on we need to replace the base type
1991 with rtti type in order to continue on with successful
1992 lookup of member / method only available in the rtti type. */
1994 struct type
*type
= value_type (arg1
);
1995 struct type
*real_type
;
1996 int full
, top
, using_enc
;
1997 struct value_print_options opts
;
1999 get_user_print_options (&opts
);
2000 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
2001 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
2003 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
2006 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
2007 real_type
= lookup_pointer_type (real_type
);
2009 real_type
= lookup_reference_type (real_type
);
2011 arg1
= value_cast (real_type
, arg1
);
2016 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2017 return value_zero (lookup_struct_elt_type (value_type (arg1
),
2018 &exp
->elts
[pc
+ 2].string
,
2023 struct value
*temp
= arg1
;
2025 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
2026 NULL
, "structure pointer");
2029 case STRUCTOP_MEMBER
:
2031 if (op
== STRUCTOP_MEMBER
)
2032 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2034 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2036 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2038 if (noside
== EVAL_SKIP
)
2041 type
= check_typedef (value_type (arg2
));
2042 switch (TYPE_CODE (type
))
2044 case TYPE_CODE_METHODPTR
:
2045 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2046 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2049 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2050 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2051 return value_ind (arg2
);
2054 case TYPE_CODE_MEMBERPTR
:
2055 /* Now, convert these values to an address. */
2056 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
2059 mem_offset
= value_as_long (arg2
);
2061 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2062 value_as_long (arg1
) + mem_offset
);
2063 return value_ind (arg3
);
2066 error (_("non-pointer-to-member value used "
2067 "in pointer-to-member construct"));
2071 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2072 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2073 for (ix
= 0; ix
< nargs
; ++ix
)
2074 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
2076 expect_type
= make_params (nargs
, arg_types
);
2077 *(pos
) += 3 + nargs
;
2078 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
2079 xfree (TYPE_FIELDS (expect_type
));
2080 xfree (TYPE_MAIN_TYPE (expect_type
));
2081 xfree (expect_type
);
2085 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2086 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2087 if (noside
== EVAL_SKIP
)
2089 if (binop_user_defined_p (op
, arg1
, arg2
))
2090 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2092 return value_concat (arg1
, arg2
);
2095 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2096 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2098 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2100 if (binop_user_defined_p (op
, arg1
, arg2
))
2101 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2103 return value_assign (arg1
, arg2
);
2105 case BINOP_ASSIGN_MODIFY
:
2107 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2108 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2109 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2111 op
= exp
->elts
[pc
+ 1].opcode
;
2112 if (binop_user_defined_p (op
, arg1
, arg2
))
2113 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2114 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2116 && is_integral_type (value_type (arg2
)))
2117 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2118 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2120 && is_integral_type (value_type (arg2
)))
2121 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2124 struct value
*tmp
= arg1
;
2126 /* For shift and integer exponentiation operations,
2127 only promote the first argument. */
2128 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2129 && is_integral_type (value_type (arg2
)))
2130 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2132 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2134 arg2
= value_binop (tmp
, arg2
, op
);
2136 return value_assign (arg1
, arg2
);
2139 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2140 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2141 if (noside
== EVAL_SKIP
)
2143 if (binop_user_defined_p (op
, arg1
, arg2
))
2144 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2145 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2146 && is_integral_type (value_type (arg2
)))
2147 return value_ptradd (arg1
, value_as_long (arg2
));
2148 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2149 && is_integral_type (value_type (arg1
)))
2150 return value_ptradd (arg2
, value_as_long (arg1
));
2153 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2154 return value_binop (arg1
, arg2
, BINOP_ADD
);
2158 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2159 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2160 if (noside
== EVAL_SKIP
)
2162 if (binop_user_defined_p (op
, arg1
, arg2
))
2163 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2164 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2165 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2167 /* FIXME -- should be ptrdiff_t */
2168 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2169 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2171 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2172 && is_integral_type (value_type (arg2
)))
2173 return value_ptradd (arg1
, - value_as_long (arg2
));
2176 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2177 return value_binop (arg1
, arg2
, BINOP_SUB
);
2188 case BINOP_BITWISE_AND
:
2189 case BINOP_BITWISE_IOR
:
2190 case BINOP_BITWISE_XOR
:
2191 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2192 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2193 if (noside
== EVAL_SKIP
)
2195 if (binop_user_defined_p (op
, arg1
, arg2
))
2196 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2199 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2200 fudge arg2 to avoid division-by-zero, the caller is
2201 (theoretically) only looking for the type of the result. */
2202 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2203 /* ??? Do we really want to test for BINOP_MOD here?
2204 The implementation of value_binop gives it a well-defined
2207 || op
== BINOP_INTDIV
2210 && value_logical_not (arg2
))
2212 struct value
*v_one
, *retval
;
2214 v_one
= value_one (value_type (arg2
), not_lval
);
2215 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2216 retval
= value_binop (arg1
, v_one
, op
);
2221 /* For shift and integer exponentiation operations,
2222 only promote the first argument. */
2223 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2224 && is_integral_type (value_type (arg2
)))
2225 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2227 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2229 return value_binop (arg1
, arg2
, op
);
2234 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2235 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2236 if (noside
== EVAL_SKIP
)
2238 error (_("':' operator used in invalid context"));
2240 case BINOP_SUBSCRIPT
:
2241 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2242 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2243 if (noside
== EVAL_SKIP
)
2245 if (binop_user_defined_p (op
, arg1
, arg2
))
2246 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2249 /* If the user attempts to subscript something that is not an
2250 array or pointer type (like a plain int variable for example),
2251 then report this as an error. */
2253 arg1
= coerce_ref (arg1
);
2254 type
= check_typedef (value_type (arg1
));
2255 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2256 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2258 if (TYPE_NAME (type
))
2259 error (_("cannot subscript something of type `%s'"),
2262 error (_("cannot subscript requested type"));
2265 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2266 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2268 return value_subscript (arg1
, value_as_long (arg2
));
2272 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2273 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2274 if (noside
== EVAL_SKIP
)
2276 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2277 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2279 case MULTI_SUBSCRIPT
:
2281 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2282 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2285 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2286 /* FIXME: EVAL_SKIP handling may not be correct. */
2287 if (noside
== EVAL_SKIP
)
2298 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2299 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2301 /* If the user attempts to subscript something that has no target
2302 type (like a plain int variable for example), then report this
2305 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2308 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2314 error (_("cannot subscript something of type `%s'"),
2315 TYPE_NAME (value_type (arg1
)));
2319 if (binop_user_defined_p (op
, arg1
, arg2
))
2321 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2325 arg1
= coerce_ref (arg1
);
2326 type
= check_typedef (value_type (arg1
));
2328 switch (TYPE_CODE (type
))
2331 case TYPE_CODE_ARRAY
:
2332 case TYPE_CODE_STRING
:
2333 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2336 case TYPE_CODE_BITSTRING
:
2337 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2338 arg1
= value_bitstring_subscript (type
, arg1
,
2339 value_as_long (arg2
));
2343 if (TYPE_NAME (type
))
2344 error (_("cannot subscript something of type `%s'"),
2347 error (_("cannot subscript requested type"));
2353 multi_f77_subscript
:
2355 int subscript_array
[MAX_FORTRAN_DIMS
];
2356 int array_size_array
[MAX_FORTRAN_DIMS
];
2357 int ndimensions
= 1, i
;
2358 struct type
*tmp_type
;
2359 int offset_item
; /* The array offset where the item lives */
2361 if (nargs
> MAX_FORTRAN_DIMS
)
2362 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2364 tmp_type
= check_typedef (value_type (arg1
));
2365 ndimensions
= calc_f77_array_dims (type
);
2367 if (nargs
!= ndimensions
)
2368 error (_("Wrong number of subscripts"));
2370 gdb_assert (nargs
> 0);
2372 /* Now that we know we have a legal array subscript expression
2373 let us actually find out where this element exists in the array. */
2376 /* Take array indices left to right */
2377 for (i
= 0; i
< nargs
; i
++)
2379 /* Evaluate each subscript, It must be a legal integer in F77 */
2380 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2382 /* Fill in the subscript and array size arrays */
2384 subscript_array
[i
] = value_as_long (arg2
);
2387 /* Internal type of array is arranged right to left */
2388 for (i
= 0; i
< nargs
; i
++)
2390 upper
= f77_get_upperbound (tmp_type
);
2391 lower
= f77_get_lowerbound (tmp_type
);
2393 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
2395 /* Zero-normalize subscripts so that offsetting will work. */
2397 subscript_array
[nargs
- i
- 1] -= lower
;
2399 /* If we are at the bottom of a multidimensional
2400 array type then keep a ptr to the last ARRAY
2401 type around for use when calling value_subscript()
2402 below. This is done because we pretend to value_subscript
2403 that we actually have a one-dimensional array
2404 of base element type that we apply a simple
2408 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
2411 /* Now let us calculate the offset for this item */
2413 offset_item
= subscript_array
[ndimensions
- 1];
2415 for (i
= ndimensions
- 1; i
> 0; --i
)
2417 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
2419 /* Let us now play a dirty trick: we will take arg1
2420 which is a value node pointing to the topmost level
2421 of the multidimensional array-set and pretend
2422 that it is actually a array of the final element
2423 type, this will ensure that value_subscript()
2424 returns the correct type value */
2426 deprecated_set_value_type (arg1
, tmp_type
);
2427 return value_subscripted_rvalue (arg1
, offset_item
, 0);
2430 case BINOP_LOGICAL_AND
:
2431 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2432 if (noside
== EVAL_SKIP
)
2434 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2439 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2442 if (binop_user_defined_p (op
, arg1
, arg2
))
2444 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2445 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2449 tem
= value_logical_not (arg1
);
2450 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2451 (tem
? EVAL_SKIP
: noside
));
2452 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2453 return value_from_longest (type
,
2454 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2457 case BINOP_LOGICAL_OR
:
2458 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2459 if (noside
== EVAL_SKIP
)
2461 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2466 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2469 if (binop_user_defined_p (op
, arg1
, arg2
))
2471 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2472 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2476 tem
= value_logical_not (arg1
);
2477 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2478 (!tem
? EVAL_SKIP
: noside
));
2479 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2480 return value_from_longest (type
,
2481 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2485 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2486 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2487 if (noside
== EVAL_SKIP
)
2489 if (binop_user_defined_p (op
, arg1
, arg2
))
2491 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2495 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2496 tem
= value_equal (arg1
, arg2
);
2497 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2498 return value_from_longest (type
, (LONGEST
) tem
);
2501 case BINOP_NOTEQUAL
:
2502 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2503 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2504 if (noside
== EVAL_SKIP
)
2506 if (binop_user_defined_p (op
, arg1
, arg2
))
2508 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2512 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2513 tem
= value_equal (arg1
, arg2
);
2514 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2515 return value_from_longest (type
, (LONGEST
) ! tem
);
2519 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2520 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2521 if (noside
== EVAL_SKIP
)
2523 if (binop_user_defined_p (op
, arg1
, arg2
))
2525 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2529 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2530 tem
= value_less (arg1
, arg2
);
2531 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2532 return value_from_longest (type
, (LONGEST
) tem
);
2536 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2537 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2538 if (noside
== EVAL_SKIP
)
2540 if (binop_user_defined_p (op
, arg1
, arg2
))
2542 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2546 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2547 tem
= value_less (arg2
, arg1
);
2548 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2549 return value_from_longest (type
, (LONGEST
) tem
);
2553 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2554 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2555 if (noside
== EVAL_SKIP
)
2557 if (binop_user_defined_p (op
, arg1
, arg2
))
2559 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2563 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2564 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2565 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2566 return value_from_longest (type
, (LONGEST
) tem
);
2570 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2571 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2572 if (noside
== EVAL_SKIP
)
2574 if (binop_user_defined_p (op
, arg1
, arg2
))
2576 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2580 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2581 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2582 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2583 return value_from_longest (type
, (LONGEST
) tem
);
2587 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2588 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2589 if (noside
== EVAL_SKIP
)
2591 type
= check_typedef (value_type (arg2
));
2592 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2593 error (_("Non-integral right operand for \"@\" operator."));
2594 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2596 return allocate_repeat_value (value_type (arg1
),
2597 longest_to_int (value_as_long (arg2
)));
2600 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2603 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2604 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2607 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2608 if (noside
== EVAL_SKIP
)
2610 if (unop_user_defined_p (op
, arg1
))
2611 return value_x_unop (arg1
, op
, noside
);
2614 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2615 return value_pos (arg1
);
2619 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2620 if (noside
== EVAL_SKIP
)
2622 if (unop_user_defined_p (op
, arg1
))
2623 return value_x_unop (arg1
, op
, noside
);
2626 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2627 return value_neg (arg1
);
2630 case UNOP_COMPLEMENT
:
2631 /* C++: check for and handle destructor names. */
2632 op
= exp
->elts
[*pos
].opcode
;
2634 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2635 if (noside
== EVAL_SKIP
)
2637 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2638 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2641 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2642 return value_complement (arg1
);
2645 case UNOP_LOGICAL_NOT
:
2646 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2647 if (noside
== EVAL_SKIP
)
2649 if (unop_user_defined_p (op
, arg1
))
2650 return value_x_unop (arg1
, op
, noside
);
2653 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2654 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2658 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2659 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2660 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2661 type
= check_typedef (value_type (arg1
));
2662 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2663 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2664 error (_("Attempt to dereference pointer "
2665 "to member without an object"));
2666 if (noside
== EVAL_SKIP
)
2668 if (unop_user_defined_p (op
, arg1
))
2669 return value_x_unop (arg1
, op
, noside
);
2670 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2672 type
= check_typedef (value_type (arg1
));
2673 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2674 || TYPE_CODE (type
) == TYPE_CODE_REF
2675 /* In C you can dereference an array to get the 1st elt. */
2676 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2678 return value_zero (TYPE_TARGET_TYPE (type
),
2680 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2681 /* GDB allows dereferencing an int. */
2682 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2685 error (_("Attempt to take contents of a non-pointer value."));
2688 /* Allow * on an integer so we can cast it to whatever we want.
2689 This returns an int, which seems like the most C-like thing to
2690 do. "long long" variables are rare enough that
2691 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2692 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2693 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2694 (CORE_ADDR
) value_as_address (arg1
));
2695 return value_ind (arg1
);
2698 /* C++: check for and handle pointer to members. */
2700 op
= exp
->elts
[*pos
].opcode
;
2702 if (noside
== EVAL_SKIP
)
2704 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2709 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2716 if (noside
== EVAL_SKIP
)
2718 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2721 return evaluate_subexp_for_sizeof (exp
, pos
);
2725 type
= exp
->elts
[pc
+ 1].type
;
2726 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2727 if (noside
== EVAL_SKIP
)
2729 if (type
!= value_type (arg1
))
2730 arg1
= value_cast (type
, arg1
);
2733 case UNOP_DYNAMIC_CAST
:
2735 type
= exp
->elts
[pc
+ 1].type
;
2736 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2737 if (noside
== EVAL_SKIP
)
2739 return value_dynamic_cast (type
, arg1
);
2741 case UNOP_REINTERPRET_CAST
:
2743 type
= exp
->elts
[pc
+ 1].type
;
2744 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2745 if (noside
== EVAL_SKIP
)
2747 return value_reinterpret_cast (type
, arg1
);
2751 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2752 if (noside
== EVAL_SKIP
)
2754 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2755 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2757 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2758 value_as_address (arg1
));
2760 case UNOP_MEMVAL_TLS
:
2762 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2763 if (noside
== EVAL_SKIP
)
2765 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2766 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2771 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2772 value_as_address (arg1
));
2773 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2776 case UNOP_PREINCREMENT
:
2777 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2778 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2780 else if (unop_user_defined_p (op
, arg1
))
2782 return value_x_unop (arg1
, op
, noside
);
2786 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2787 arg2
= value_ptradd (arg1
, 1);
2790 struct value
*tmp
= arg1
;
2792 arg2
= value_one (value_type (arg1
), not_lval
);
2793 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2794 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2797 return value_assign (arg1
, arg2
);
2800 case UNOP_PREDECREMENT
:
2801 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2802 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2804 else if (unop_user_defined_p (op
, arg1
))
2806 return value_x_unop (arg1
, op
, noside
);
2810 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2811 arg2
= value_ptradd (arg1
, -1);
2814 struct value
*tmp
= arg1
;
2816 arg2
= value_one (value_type (arg1
), not_lval
);
2817 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2818 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2821 return value_assign (arg1
, arg2
);
2824 case UNOP_POSTINCREMENT
:
2825 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2826 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2828 else if (unop_user_defined_p (op
, arg1
))
2830 return value_x_unop (arg1
, op
, noside
);
2834 arg3
= value_non_lval (arg1
);
2836 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2837 arg2
= value_ptradd (arg1
, 1);
2840 struct value
*tmp
= arg1
;
2842 arg2
= value_one (value_type (arg1
), not_lval
);
2843 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2844 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2847 value_assign (arg1
, arg2
);
2851 case UNOP_POSTDECREMENT
:
2852 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2853 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2855 else if (unop_user_defined_p (op
, arg1
))
2857 return value_x_unop (arg1
, op
, noside
);
2861 arg3
= value_non_lval (arg1
);
2863 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2864 arg2
= value_ptradd (arg1
, -1);
2867 struct value
*tmp
= arg1
;
2869 arg2
= value_one (value_type (arg1
), not_lval
);
2870 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2871 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2874 value_assign (arg1
, arg2
);
2880 return value_of_this (1);
2884 return value_of_local ("self", 1);
2887 /* The value is not supposed to be used. This is here to make it
2888 easier to accommodate expressions that contain types. */
2890 if (noside
== EVAL_SKIP
)
2892 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2894 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2896 /* If this is a typedef, then find its immediate target. We
2897 use check_typedef to resolve stubs, but we ignore its
2898 result because we do not want to dig past all
2900 check_typedef (type
);
2901 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2902 type
= TYPE_TARGET_TYPE (type
);
2903 return allocate_value (type
);
2906 error (_("Attempt to use a type name as an expression"));
2909 /* Removing this case and compiling with gcc -Wall reveals that
2910 a lot of cases are hitting this case. Some of these should
2911 probably be removed from expression.h; others are legitimate
2912 expressions which are (apparently) not fully implemented.
2914 If there are any cases landing here which mean a user error,
2915 then they should be separate cases, with more descriptive
2918 error (_("GDB does not (yet) know how to "
2919 "evaluate that kind of expression"));
2923 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2926 /* Evaluate a subexpression of EXP, at index *POS,
2927 and return the address of that subexpression.
2928 Advance *POS over the subexpression.
2929 If the subexpression isn't an lvalue, get an error.
2930 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2931 then only the type of the result need be correct. */
2933 static struct value
*
2934 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2944 op
= exp
->elts
[pc
].opcode
;
2950 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2952 /* We can't optimize out "&*" if there's a user-defined operator*. */
2953 if (unop_user_defined_p (op
, x
))
2955 x
= value_x_unop (x
, op
, noside
);
2956 goto default_case_after_eval
;
2959 return coerce_array (x
);
2963 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2964 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2967 var
= exp
->elts
[pc
+ 2].symbol
;
2969 /* C++: The "address" of a reference should yield the address
2970 * of the object pointed to. Let value_addr() deal with it. */
2971 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2975 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2978 lookup_pointer_type (SYMBOL_TYPE (var
));
2979 enum address_class sym_class
= SYMBOL_CLASS (var
);
2981 if (sym_class
== LOC_CONST
2982 || sym_class
== LOC_CONST_BYTES
2983 || sym_class
== LOC_REGISTER
)
2984 error (_("Attempt to take address of register or constant."));
2987 value_zero (type
, not_lval
);
2990 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2993 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2994 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2995 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2996 &exp
->elts
[pc
+ 3].string
,
2999 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3004 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3005 default_case_after_eval
:
3006 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3008 struct type
*type
= check_typedef (value_type (x
));
3010 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3011 return value_zero (lookup_pointer_type (value_type (x
)),
3013 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
3014 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3017 error (_("Attempt to take address of "
3018 "value not located in memory."));
3020 return value_addr (x
);
3024 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3025 When used in contexts where arrays will be coerced anyway, this is
3026 equivalent to `evaluate_subexp' but much faster because it avoids
3027 actually fetching array contents (perhaps obsolete now that we have
3030 Note that we currently only do the coercion for C expressions, where
3031 arrays are zero based and the coercion is correct. For other languages,
3032 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3033 to decide if coercion is appropriate.
3038 evaluate_subexp_with_coercion (struct expression
*exp
,
3039 int *pos
, enum noside noside
)
3048 op
= exp
->elts
[pc
].opcode
;
3053 var
= exp
->elts
[pc
+ 2].symbol
;
3054 type
= check_typedef (SYMBOL_TYPE (var
));
3055 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3056 && !TYPE_VECTOR (type
)
3057 && CAST_IS_CONVERSION (exp
->language_defn
))
3060 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3061 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3067 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3071 /* Evaluate a subexpression of EXP, at index *POS,
3072 and return a value for the size of that subexpression.
3073 Advance *POS over the subexpression. */
3075 static struct value
*
3076 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
3078 /* FIXME: This should be size_t. */
3079 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3086 op
= exp
->elts
[pc
].opcode
;
3090 /* This case is handled specially
3091 so that we avoid creating a value for the result type.
3092 If the result type is very big, it's desirable not to
3093 create a value unnecessarily. */
3096 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3097 type
= check_typedef (value_type (val
));
3098 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3099 && TYPE_CODE (type
) != TYPE_CODE_REF
3100 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3101 error (_("Attempt to take contents of a non-pointer value."));
3102 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3103 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3107 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3108 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3112 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3114 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3117 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3118 return value_from_longest (size_type
,
3119 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3123 /* Parse a type expression in the string [P..P+LENGTH). */
3126 parse_and_eval_type (char *p
, int length
)
3128 char *tmp
= (char *) alloca (length
+ 4);
3129 struct expression
*expr
;
3132 memcpy (tmp
+ 1, p
, length
);
3133 tmp
[length
+ 1] = ')';
3134 tmp
[length
+ 2] = '0';
3135 tmp
[length
+ 3] = '\0';
3136 expr
= parse_expression (tmp
);
3137 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3138 error (_("Internal error in eval_type."));
3139 return expr
->elts
[1].type
;
3143 calc_f77_array_dims (struct type
*array_type
)
3146 struct type
*tmp_type
;
3148 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3149 error (_("Can't get dimensions for a non-array type"));
3151 tmp_type
= array_type
;
3153 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3155 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)