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
1101 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1103 if (noside
== EVAL_SKIP
)
1105 return value_array (tem2
, tem3
, argvec
);
1109 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1111 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1113 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1115 if (noside
== EVAL_SKIP
)
1117 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1120 case TERNOP_SLICE_COUNT
:
1122 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1124 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1126 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1128 return value_slice (array
, lowbound
, length
);
1132 /* Skip third and second args to evaluate the first one. */
1133 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1134 if (value_logical_not (arg1
))
1136 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1137 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1141 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1142 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1146 case OP_OBJC_SELECTOR
:
1147 { /* Objective C @selector operator. */
1148 char *sel
= &exp
->elts
[pc
+ 2].string
;
1149 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1150 struct type
*selector_type
;
1152 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1153 if (noside
== EVAL_SKIP
)
1157 sel
[len
] = 0; /* Make sure it's terminated. */
1159 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1160 return value_from_longest (selector_type
,
1161 lookup_child_selector (exp
->gdbarch
, sel
));
1164 case OP_OBJC_MSGCALL
:
1165 { /* Objective C message (method) call. */
1167 CORE_ADDR responds_selector
= 0;
1168 CORE_ADDR method_selector
= 0;
1170 CORE_ADDR selector
= 0;
1172 int struct_return
= 0;
1173 int sub_no_side
= 0;
1175 struct value
*msg_send
= NULL
;
1176 struct value
*msg_send_stret
= NULL
;
1177 int gnu_runtime
= 0;
1179 struct value
*target
= NULL
;
1180 struct value
*method
= NULL
;
1181 struct value
*called_method
= NULL
;
1183 struct type
*selector_type
= NULL
;
1184 struct type
*long_type
;
1186 struct value
*ret
= NULL
;
1189 selector
= exp
->elts
[pc
+ 1].longconst
;
1190 nargs
= exp
->elts
[pc
+ 2].longconst
;
1191 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1196 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1197 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1199 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1200 sub_no_side
= EVAL_NORMAL
;
1202 sub_no_side
= noside
;
1204 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1206 if (value_as_long (target
) == 0)
1207 return value_from_longest (long_type
, 0);
1209 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1212 /* Find the method dispatch (Apple runtime) or method lookup
1213 (GNU runtime) function for Objective-C. These will be used
1214 to lookup the symbol information for the method. If we
1215 can't find any symbol information, then we'll use these to
1216 call the method, otherwise we can call the method
1217 directly. The msg_send_stret function is used in the special
1218 case of a method that returns a structure (Apple runtime
1222 struct type
*type
= selector_type
;
1224 type
= lookup_function_type (type
);
1225 type
= lookup_pointer_type (type
);
1226 type
= lookup_function_type (type
);
1227 type
= lookup_pointer_type (type
);
1229 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1231 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1233 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1234 msg_send_stret
= value_from_pointer (type
,
1235 value_as_address (msg_send_stret
));
1239 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1240 /* Special dispatcher for methods returning structs. */
1242 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1245 /* Verify the target object responds to this method. The
1246 standard top-level 'Object' class uses a different name for
1247 the verification method than the non-standard, but more
1248 often used, 'NSObject' class. Make sure we check for both. */
1251 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1252 if (responds_selector
== 0)
1254 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1256 if (responds_selector
== 0)
1257 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1260 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1261 if (method_selector
== 0)
1263 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1265 if (method_selector
== 0)
1266 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1268 /* Call the verification method, to make sure that the target
1269 class implements the desired method. */
1271 argvec
[0] = msg_send
;
1273 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1274 argvec
[3] = value_from_longest (long_type
, selector
);
1277 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1280 /* Function objc_msg_lookup returns a pointer. */
1282 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1284 if (value_as_long (ret
) == 0)
1285 error (_("Target does not respond to this message selector."));
1287 /* Call "methodForSelector:" method, to get the address of a
1288 function method that implements this selector for this
1289 class. If we can find a symbol at that address, then we
1290 know the return type, parameter types etc. (that's a good
1293 argvec
[0] = msg_send
;
1295 argvec
[2] = value_from_longest (long_type
, method_selector
);
1296 argvec
[3] = value_from_longest (long_type
, selector
);
1299 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1303 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1306 /* ret should now be the selector. */
1308 addr
= value_as_long (ret
);
1311 struct symbol
*sym
= NULL
;
1313 /* The address might point to a function descriptor;
1314 resolve it to the actual code address instead. */
1315 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1318 /* Is it a high_level symbol? */
1319 sym
= find_pc_function (addr
);
1321 method
= value_of_variable (sym
, 0);
1324 /* If we found a method with symbol information, check to see
1325 if it returns a struct. Otherwise assume it doesn't. */
1331 struct type
*val_type
;
1333 funaddr
= find_function_addr (method
, &val_type
);
1335 b
= block_for_pc (funaddr
);
1337 CHECK_TYPEDEF (val_type
);
1339 if ((val_type
== NULL
)
1340 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1342 if (expect_type
!= NULL
)
1343 val_type
= expect_type
;
1346 struct_return
= using_struct_return (exp
->gdbarch
,
1347 value_type (method
),
1350 else if (expect_type
!= NULL
)
1352 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1353 check_typedef (expect_type
));
1356 /* Found a function symbol. Now we will substitute its
1357 value in place of the message dispatcher (obj_msgSend),
1358 so that we call the method directly instead of thru
1359 the dispatcher. The main reason for doing this is that
1360 we can now evaluate the return value and parameter values
1361 according to their known data types, in case we need to
1362 do things like promotion, dereferencing, special handling
1363 of structs and doubles, etc.
1365 We want to use the type signature of 'method', but still
1366 jump to objc_msgSend() or objc_msgSend_stret() to better
1367 mimic the behavior of the runtime. */
1371 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1372 error (_("method address has symbol information "
1373 "with non-function type; skipping"));
1375 /* Create a function pointer of the appropriate type, and
1376 replace its value with the value of msg_send or
1377 msg_send_stret. We must use a pointer here, as
1378 msg_send and msg_send_stret are of pointer type, and
1379 the representation may be different on systems that use
1380 function descriptors. */
1383 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1384 value_as_address (msg_send_stret
));
1387 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1388 value_as_address (msg_send
));
1393 called_method
= msg_send_stret
;
1395 called_method
= msg_send
;
1398 if (noside
== EVAL_SKIP
)
1401 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1403 /* If the return type doesn't look like a function type,
1404 call an error. This can happen if somebody tries to
1405 turn a variable into a function call. This is here
1406 because people often want to call, eg, strcmp, which
1407 gdb doesn't know is a function. If gdb isn't asked for
1408 it's opinion (ie. through "whatis"), it won't offer
1411 struct type
*type
= value_type (called_method
);
1413 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1414 type
= TYPE_TARGET_TYPE (type
);
1415 type
= TYPE_TARGET_TYPE (type
);
1419 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1420 return allocate_value (expect_type
);
1422 return allocate_value (type
);
1425 error (_("Expression of type other than "
1426 "\"method returning ...\" used as a method"));
1429 /* Now depending on whether we found a symbol for the method,
1430 we will either call the runtime dispatcher or the method
1433 argvec
[0] = called_method
;
1435 argvec
[2] = value_from_longest (long_type
, selector
);
1436 /* User-supplied arguments. */
1437 for (tem
= 0; tem
< nargs
; tem
++)
1438 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1439 argvec
[tem
+ 3] = 0;
1441 if (gnu_runtime
&& (method
!= NULL
))
1443 /* Function objc_msg_lookup returns a pointer. */
1444 deprecated_set_value_type (argvec
[0],
1445 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1447 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1450 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1457 op
= exp
->elts
[*pos
].opcode
;
1458 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1459 /* Allocate arg vector, including space for the function to be
1460 called in argvec[0] and a terminating NULL. */
1461 argvec
= (struct value
**)
1462 alloca (sizeof (struct value
*) * (nargs
+ 3));
1463 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1466 /* First, evaluate the structure into arg2. */
1469 if (noside
== EVAL_SKIP
)
1472 if (op
== STRUCTOP_MEMBER
)
1474 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1478 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1481 /* If the function is a virtual function, then the
1482 aggregate value (providing the structure) plays
1483 its part by providing the vtable. Otherwise,
1484 it is just along for the ride: call the function
1487 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1489 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1490 != TYPE_CODE_METHODPTR
)
1491 error (_("Non-pointer-to-member value used in pointer-to-member "
1494 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1496 struct type
*method_type
= check_typedef (value_type (arg1
));
1498 arg1
= value_zero (method_type
, not_lval
);
1501 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1503 /* Now, say which argument to start evaluating from. */
1506 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1508 /* Hair for method invocations. */
1512 /* First, evaluate the structure into arg2. */
1514 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1515 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1516 if (noside
== EVAL_SKIP
)
1519 if (op
== STRUCTOP_STRUCT
)
1521 /* If v is a variable in a register, and the user types
1522 v.method (), this will produce an error, because v has
1525 A possible way around this would be to allocate a
1526 copy of the variable on the stack, copy in the
1527 contents, call the function, and copy out the
1528 contents. I.e. convert this from call by reference
1529 to call by copy-return (or whatever it's called).
1530 However, this does not work because it is not the
1531 same: the method being called could stash a copy of
1532 the address, and then future uses through that address
1533 (after the method returns) would be expected to
1534 use the variable itself, not some copy of it. */
1535 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1539 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1541 /* Check to see if the operator '->' has been
1542 overloaded. If the operator has been overloaded
1543 replace arg2 with the value returned by the custom
1544 operator and continue evaluation. */
1545 while (unop_user_defined_p (op
, arg2
))
1547 volatile struct gdb_exception except
;
1548 struct value
*value
= NULL
;
1549 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1551 value
= value_x_unop (arg2
, op
, noside
);
1554 if (except
.reason
< 0)
1556 if (except
.error
== NOT_FOUND_ERROR
)
1559 throw_exception (except
);
1564 /* Now, say which argument to start evaluating from. */
1567 else if (op
== OP_SCOPE
1568 && overload_resolution
1569 && (exp
->language_defn
->la_language
== language_cplus
))
1571 /* Unpack it locally so we can properly handle overload
1577 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1578 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1579 type
= exp
->elts
[pc2
+ 1].type
;
1580 name
= &exp
->elts
[pc2
+ 3].string
;
1583 function_name
= NULL
;
1584 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1586 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1588 get_selected_block (0),
1590 if (function
== NULL
)
1591 error (_("No symbol \"%s\" in namespace \"%s\"."),
1592 name
, TYPE_TAG_NAME (type
));
1598 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1599 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1600 function_name
= name
;
1602 arg2
= value_zero (type
, lval_memory
);
1607 else if (op
== OP_ADL_FUNC
)
1609 /* Save the function position and move pos so that the arguments
1610 can be evaluated. */
1616 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1617 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1621 /* Non-method function call. */
1625 /* If this is a C++ function wait until overload resolution. */
1626 if (op
== OP_VAR_VALUE
1627 && overload_resolution
1628 && (exp
->language_defn
->la_language
== language_cplus
))
1630 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1635 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1636 type
= value_type (argvec
[0]);
1637 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1638 type
= TYPE_TARGET_TYPE (type
);
1639 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1641 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1643 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1651 /* Evaluate arguments. */
1652 for (; tem
<= nargs
; tem
++)
1654 /* Ensure that array expressions are coerced into pointer
1656 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1659 /* Signal end of arglist. */
1661 if (op
== OP_ADL_FUNC
)
1663 struct symbol
*symp
;
1666 int string_pc
= save_pos1
+ 3;
1668 /* Extract the function name. */
1669 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1670 func_name
= (char *) alloca (name_len
+ 1);
1671 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1673 /* Prepare list of argument types for overload resolution. */
1674 arg_types
= (struct type
**)
1675 alloca (nargs
* (sizeof (struct type
*)));
1676 for (ix
= 1; ix
<= nargs
; ix
++)
1677 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1679 find_overload_match (arg_types
, nargs
, func_name
,
1680 NON_METHOD
, /* not method */
1681 0, /* strict match */
1682 NULL
, NULL
, /* pass NULL symbol since
1683 symbol is unknown */
1684 NULL
, &symp
, NULL
, 0);
1686 /* Now fix the expression being evaluated. */
1687 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1688 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1691 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1692 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1694 int static_memfuncp
;
1697 /* Method invocation : stuff "this" as first parameter. */
1702 /* Name of method from expression. */
1703 tstr
= &exp
->elts
[pc2
+ 2].string
;
1706 tstr
= function_name
;
1708 if (overload_resolution
&& (exp
->language_defn
->la_language
1711 /* Language is C++, do some overload resolution before
1713 struct value
*valp
= NULL
;
1715 /* Prepare list of argument types for overload resolution. */
1716 arg_types
= (struct type
**)
1717 alloca (nargs
* (sizeof (struct type
*)));
1718 for (ix
= 1; ix
<= nargs
; ix
++)
1719 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1721 (void) find_overload_match (arg_types
, nargs
, tstr
,
1722 METHOD
, /* method */
1723 0, /* strict match */
1724 &arg2
, /* the object */
1726 &static_memfuncp
, 0);
1728 if (op
== OP_SCOPE
&& !static_memfuncp
)
1730 /* For the time being, we don't handle this. */
1731 error (_("Call to overloaded function %s requires "
1735 argvec
[1] = arg2
; /* the ``this'' pointer */
1736 argvec
[0] = valp
; /* Use the method found after overload
1740 /* Non-C++ case -- or no overload resolution. */
1742 struct value
*temp
= arg2
;
1744 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1746 op
== STRUCTOP_STRUCT
1747 ? "structure" : "structure pointer");
1748 /* value_struct_elt updates temp with the correct value
1749 of the ``this'' pointer if necessary, so modify argvec[1] to
1750 reflect any ``this'' changes. */
1752 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1753 value_address (temp
)
1754 + value_embedded_offset (temp
));
1755 argvec
[1] = arg2
; /* the ``this'' pointer */
1758 if (static_memfuncp
)
1760 argvec
[1] = argvec
[0];
1765 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1770 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1772 /* Non-member function being called. */
1773 /* fn: This can only be done for C++ functions. A C-style function
1774 in a C++ program, for instance, does not have the fields that
1775 are expected here. */
1777 if (overload_resolution
&& (exp
->language_defn
->la_language
1780 /* Language is C++, do some overload resolution before
1782 struct symbol
*symp
;
1785 /* If a scope has been specified disable ADL. */
1789 if (op
== OP_VAR_VALUE
)
1790 function
= exp
->elts
[save_pos1
+2].symbol
;
1792 /* Prepare list of argument types for overload resolution. */
1793 arg_types
= (struct type
**)
1794 alloca (nargs
* (sizeof (struct type
*)));
1795 for (ix
= 1; ix
<= nargs
; ix
++)
1796 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1798 (void) find_overload_match (arg_types
, nargs
,
1799 NULL
, /* no need for name */
1800 NON_METHOD
, /* not method */
1801 0, /* strict match */
1802 NULL
, function
, /* the function */
1803 NULL
, &symp
, NULL
, no_adl
);
1805 if (op
== OP_VAR_VALUE
)
1807 /* Now fix the expression being evaluated. */
1808 exp
->elts
[save_pos1
+2].symbol
= symp
;
1809 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1813 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1817 /* Not C++, or no overload resolution allowed. */
1818 /* Nothing to be done; argvec already correctly set up. */
1823 /* It is probably a C-style function. */
1824 /* Nothing to be done; argvec already correctly set up. */
1829 if (noside
== EVAL_SKIP
)
1831 if (argvec
[0] == NULL
)
1832 error (_("Cannot evaluate function -- may be inlined"));
1833 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1835 /* If the return type doesn't look like a function type, call an
1836 error. This can happen if somebody tries to turn a variable into
1837 a function call. This is here because people often want to
1838 call, eg, strcmp, which gdb doesn't know is a function. If
1839 gdb isn't asked for it's opinion (ie. through "whatis"),
1840 it won't offer it. */
1842 struct type
*ftype
= value_type (argvec
[0]);
1844 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1846 /* We don't know anything about what the internal
1847 function might return, but we have to return
1849 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1852 else if (TYPE_TARGET_TYPE (ftype
))
1853 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1855 error (_("Expression of type other than "
1856 "\"Function returning ...\" used as function"));
1858 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1859 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1860 argvec
[0], nargs
, argvec
+ 1);
1862 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1863 /* pai: FIXME save value from call_function_by_hand, then adjust
1864 pc by adjust_fn_pc if +ve. */
1866 case OP_F77_UNDETERMINED_ARGLIST
:
1868 /* Remember that in F77, functions, substring ops and
1869 array subscript operations cannot be disambiguated
1870 at parse time. We have made all array subscript operations,
1871 substring operations as well as function calls come here
1872 and we now have to discover what the heck this thing actually was.
1873 If it is a function, we process just as if we got an OP_FUNCALL. */
1875 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1878 /* First determine the type code we are dealing with. */
1879 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1880 type
= check_typedef (value_type (arg1
));
1881 code
= TYPE_CODE (type
);
1883 if (code
== TYPE_CODE_PTR
)
1885 /* Fortran always passes variable to subroutines as pointer.
1886 So we need to look into its target type to see if it is
1887 array, string or function. If it is, we need to switch
1888 to the target value the original one points to. */
1889 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1891 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1892 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1893 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1895 arg1
= value_ind (arg1
);
1896 type
= check_typedef (value_type (arg1
));
1897 code
= TYPE_CODE (type
);
1903 case TYPE_CODE_ARRAY
:
1904 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1905 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1907 goto multi_f77_subscript
;
1909 case TYPE_CODE_STRING
:
1910 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1911 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1914 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1915 return value_subscript (arg1
, value_as_long (arg2
));
1919 case TYPE_CODE_FUNC
:
1920 /* It's a function call. */
1921 /* Allocate arg vector, including space for the function to be
1922 called in argvec[0] and a terminating NULL. */
1923 argvec
= (struct value
**)
1924 alloca (sizeof (struct value
*) * (nargs
+ 2));
1927 for (; tem
<= nargs
; tem
++)
1928 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1929 argvec
[tem
] = 0; /* signal end of arglist */
1933 error (_("Cannot perform substring on this type"));
1937 /* We have a complex number, There should be 2 floating
1938 point numbers that compose it. */
1940 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1941 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1943 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1945 case STRUCTOP_STRUCT
:
1946 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1947 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1948 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1949 if (noside
== EVAL_SKIP
)
1951 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1952 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1953 &exp
->elts
[pc
+ 2].string
,
1958 struct value
*temp
= arg1
;
1960 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1965 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1966 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1967 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1968 if (noside
== EVAL_SKIP
)
1971 /* Check to see if operator '->' has been overloaded. If so replace
1972 arg1 with the value returned by evaluating operator->(). */
1973 while (unop_user_defined_p (op
, arg1
))
1975 volatile struct gdb_exception except
;
1976 struct value
*value
= NULL
;
1977 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1979 value
= value_x_unop (arg1
, op
, noside
);
1982 if (except
.reason
< 0)
1984 if (except
.error
== NOT_FOUND_ERROR
)
1987 throw_exception (except
);
1992 /* JYG: if print object is on we need to replace the base type
1993 with rtti type in order to continue on with successful
1994 lookup of member / method only available in the rtti type. */
1996 struct type
*type
= value_type (arg1
);
1997 struct type
*real_type
;
1998 int full
, top
, using_enc
;
1999 struct value_print_options opts
;
2001 get_user_print_options (&opts
);
2002 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
2003 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
2005 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
2008 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
2009 real_type
= lookup_pointer_type (real_type
);
2011 real_type
= lookup_reference_type (real_type
);
2013 arg1
= value_cast (real_type
, arg1
);
2018 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2019 return value_zero (lookup_struct_elt_type (value_type (arg1
),
2020 &exp
->elts
[pc
+ 2].string
,
2025 struct value
*temp
= arg1
;
2027 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
2028 NULL
, "structure pointer");
2031 case STRUCTOP_MEMBER
:
2033 if (op
== STRUCTOP_MEMBER
)
2034 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2036 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2038 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2040 if (noside
== EVAL_SKIP
)
2043 type
= check_typedef (value_type (arg2
));
2044 switch (TYPE_CODE (type
))
2046 case TYPE_CODE_METHODPTR
:
2047 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2048 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2051 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2052 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2053 return value_ind (arg2
);
2056 case TYPE_CODE_MEMBERPTR
:
2057 /* Now, convert these values to an address. */
2058 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
2061 mem_offset
= value_as_long (arg2
);
2063 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2064 value_as_long (arg1
) + mem_offset
);
2065 return value_ind (arg3
);
2068 error (_("non-pointer-to-member value used "
2069 "in pointer-to-member construct"));
2073 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2074 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2075 for (ix
= 0; ix
< nargs
; ++ix
)
2076 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
2078 expect_type
= make_params (nargs
, arg_types
);
2079 *(pos
) += 3 + nargs
;
2080 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
2081 xfree (TYPE_FIELDS (expect_type
));
2082 xfree (TYPE_MAIN_TYPE (expect_type
));
2083 xfree (expect_type
);
2087 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2088 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2089 if (noside
== EVAL_SKIP
)
2091 if (binop_user_defined_p (op
, arg1
, arg2
))
2092 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2094 return value_concat (arg1
, arg2
);
2097 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2098 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2100 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2102 if (binop_user_defined_p (op
, arg1
, arg2
))
2103 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2105 return value_assign (arg1
, arg2
);
2107 case BINOP_ASSIGN_MODIFY
:
2109 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2110 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2111 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2113 op
= exp
->elts
[pc
+ 1].opcode
;
2114 if (binop_user_defined_p (op
, arg1
, arg2
))
2115 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2116 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2118 && is_integral_type (value_type (arg2
)))
2119 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2120 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2122 && is_integral_type (value_type (arg2
)))
2123 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2126 struct value
*tmp
= arg1
;
2128 /* For shift and integer exponentiation operations,
2129 only promote the first argument. */
2130 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2131 && is_integral_type (value_type (arg2
)))
2132 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2134 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2136 arg2
= value_binop (tmp
, arg2
, op
);
2138 return value_assign (arg1
, arg2
);
2141 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2142 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2143 if (noside
== EVAL_SKIP
)
2145 if (binop_user_defined_p (op
, arg1
, arg2
))
2146 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2147 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2148 && is_integral_type (value_type (arg2
)))
2149 return value_ptradd (arg1
, value_as_long (arg2
));
2150 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2151 && is_integral_type (value_type (arg1
)))
2152 return value_ptradd (arg2
, value_as_long (arg1
));
2155 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2156 return value_binop (arg1
, arg2
, BINOP_ADD
);
2160 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2161 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2162 if (noside
== EVAL_SKIP
)
2164 if (binop_user_defined_p (op
, arg1
, arg2
))
2165 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2166 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2167 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2169 /* FIXME -- should be ptrdiff_t */
2170 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2171 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2173 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2174 && is_integral_type (value_type (arg2
)))
2175 return value_ptradd (arg1
, - value_as_long (arg2
));
2178 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2179 return value_binop (arg1
, arg2
, BINOP_SUB
);
2190 case BINOP_BITWISE_AND
:
2191 case BINOP_BITWISE_IOR
:
2192 case BINOP_BITWISE_XOR
:
2193 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2194 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2195 if (noside
== EVAL_SKIP
)
2197 if (binop_user_defined_p (op
, arg1
, arg2
))
2198 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2201 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2202 fudge arg2 to avoid division-by-zero, the caller is
2203 (theoretically) only looking for the type of the result. */
2204 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2205 /* ??? Do we really want to test for BINOP_MOD here?
2206 The implementation of value_binop gives it a well-defined
2209 || op
== BINOP_INTDIV
2212 && value_logical_not (arg2
))
2214 struct value
*v_one
, *retval
;
2216 v_one
= value_one (value_type (arg2
), not_lval
);
2217 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2218 retval
= value_binop (arg1
, v_one
, op
);
2223 /* For shift and integer exponentiation operations,
2224 only promote the first argument. */
2225 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2226 && is_integral_type (value_type (arg2
)))
2227 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2229 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2231 return value_binop (arg1
, arg2
, op
);
2236 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2237 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2238 if (noside
== EVAL_SKIP
)
2240 error (_("':' operator used in invalid context"));
2242 case BINOP_SUBSCRIPT
:
2243 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2244 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2245 if (noside
== EVAL_SKIP
)
2247 if (binop_user_defined_p (op
, arg1
, arg2
))
2248 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2251 /* If the user attempts to subscript something that is not an
2252 array or pointer type (like a plain int variable for example),
2253 then report this as an error. */
2255 arg1
= coerce_ref (arg1
);
2256 type
= check_typedef (value_type (arg1
));
2257 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2258 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2260 if (TYPE_NAME (type
))
2261 error (_("cannot subscript something of type `%s'"),
2264 error (_("cannot subscript requested type"));
2267 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2268 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2270 return value_subscript (arg1
, value_as_long (arg2
));
2274 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2275 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2276 if (noside
== EVAL_SKIP
)
2278 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2279 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2281 case MULTI_SUBSCRIPT
:
2283 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2284 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2287 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2288 /* FIXME: EVAL_SKIP handling may not be correct. */
2289 if (noside
== EVAL_SKIP
)
2300 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2301 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2303 /* If the user attempts to subscript something that has no target
2304 type (like a plain int variable for example), then report this
2307 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2310 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2316 error (_("cannot subscript something of type `%s'"),
2317 TYPE_NAME (value_type (arg1
)));
2321 if (binop_user_defined_p (op
, arg1
, arg2
))
2323 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2327 arg1
= coerce_ref (arg1
);
2328 type
= check_typedef (value_type (arg1
));
2330 switch (TYPE_CODE (type
))
2333 case TYPE_CODE_ARRAY
:
2334 case TYPE_CODE_STRING
:
2335 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2338 case TYPE_CODE_BITSTRING
:
2339 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2340 arg1
= value_bitstring_subscript (type
, arg1
,
2341 value_as_long (arg2
));
2345 if (TYPE_NAME (type
))
2346 error (_("cannot subscript something of type `%s'"),
2349 error (_("cannot subscript requested type"));
2355 multi_f77_subscript
:
2357 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2358 int ndimensions
= 1, i
;
2359 struct value
*array
= arg1
;
2361 if (nargs
> MAX_FORTRAN_DIMS
)
2362 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2364 ndimensions
= calc_f77_array_dims (type
);
2366 if (nargs
!= ndimensions
)
2367 error (_("Wrong number of subscripts"));
2369 gdb_assert (nargs
> 0);
2371 /* Now that we know we have a legal array subscript expression
2372 let us actually find out where this element exists in the array. */
2374 /* Take array indices left to right. */
2375 for (i
= 0; i
< nargs
; i
++)
2377 /* Evaluate each subscript; it must be a legal integer in F77. */
2378 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2380 /* Fill in the subscript array. */
2382 subscript_array
[i
] = value_as_long (arg2
);
2385 /* Internal type of array is arranged right to left. */
2386 for (i
= nargs
; i
> 0; i
--)
2388 struct type
*array_type
= check_typedef (value_type (array
));
2389 LONGEST index
= subscript_array
[i
- 1];
2391 lower
= f77_get_lowerbound (array_type
);
2392 array
= value_subscripted_rvalue (array
, index
, lower
);
2398 case BINOP_LOGICAL_AND
:
2399 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2400 if (noside
== EVAL_SKIP
)
2402 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2407 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2410 if (binop_user_defined_p (op
, arg1
, arg2
))
2412 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2413 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2417 tem
= value_logical_not (arg1
);
2418 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2419 (tem
? EVAL_SKIP
: noside
));
2420 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2421 return value_from_longest (type
,
2422 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2425 case BINOP_LOGICAL_OR
:
2426 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2427 if (noside
== EVAL_SKIP
)
2429 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2434 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2437 if (binop_user_defined_p (op
, arg1
, arg2
))
2439 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2440 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2444 tem
= value_logical_not (arg1
);
2445 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2446 (!tem
? EVAL_SKIP
: noside
));
2447 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2448 return value_from_longest (type
,
2449 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2453 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2454 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2455 if (noside
== EVAL_SKIP
)
2457 if (binop_user_defined_p (op
, arg1
, arg2
))
2459 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2463 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2464 tem
= value_equal (arg1
, arg2
);
2465 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2466 return value_from_longest (type
, (LONGEST
) tem
);
2469 case BINOP_NOTEQUAL
:
2470 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2471 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2472 if (noside
== EVAL_SKIP
)
2474 if (binop_user_defined_p (op
, arg1
, arg2
))
2476 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2480 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2481 tem
= value_equal (arg1
, arg2
);
2482 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2483 return value_from_longest (type
, (LONGEST
) ! tem
);
2487 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2488 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2489 if (noside
== EVAL_SKIP
)
2491 if (binop_user_defined_p (op
, arg1
, arg2
))
2493 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2497 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2498 tem
= value_less (arg1
, arg2
);
2499 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2500 return value_from_longest (type
, (LONGEST
) tem
);
2504 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2505 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2506 if (noside
== EVAL_SKIP
)
2508 if (binop_user_defined_p (op
, arg1
, arg2
))
2510 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2514 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2515 tem
= value_less (arg2
, arg1
);
2516 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2517 return value_from_longest (type
, (LONGEST
) tem
);
2521 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2522 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2523 if (noside
== EVAL_SKIP
)
2525 if (binop_user_defined_p (op
, arg1
, arg2
))
2527 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2531 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2532 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2533 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2534 return value_from_longest (type
, (LONGEST
) tem
);
2538 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2539 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2540 if (noside
== EVAL_SKIP
)
2542 if (binop_user_defined_p (op
, arg1
, arg2
))
2544 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2548 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2549 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2550 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2551 return value_from_longest (type
, (LONGEST
) tem
);
2555 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2556 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2557 if (noside
== EVAL_SKIP
)
2559 type
= check_typedef (value_type (arg2
));
2560 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2561 error (_("Non-integral right operand for \"@\" operator."));
2562 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2564 return allocate_repeat_value (value_type (arg1
),
2565 longest_to_int (value_as_long (arg2
)));
2568 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2571 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2572 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2575 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2576 if (noside
== EVAL_SKIP
)
2578 if (unop_user_defined_p (op
, arg1
))
2579 return value_x_unop (arg1
, op
, noside
);
2582 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2583 return value_pos (arg1
);
2587 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2588 if (noside
== EVAL_SKIP
)
2590 if (unop_user_defined_p (op
, arg1
))
2591 return value_x_unop (arg1
, op
, noside
);
2594 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2595 return value_neg (arg1
);
2598 case UNOP_COMPLEMENT
:
2599 /* C++: check for and handle destructor names. */
2600 op
= exp
->elts
[*pos
].opcode
;
2602 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2603 if (noside
== EVAL_SKIP
)
2605 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2606 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2609 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2610 return value_complement (arg1
);
2613 case UNOP_LOGICAL_NOT
:
2614 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2615 if (noside
== EVAL_SKIP
)
2617 if (unop_user_defined_p (op
, arg1
))
2618 return value_x_unop (arg1
, op
, noside
);
2621 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2622 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2626 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2627 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2628 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2629 type
= check_typedef (value_type (arg1
));
2630 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2631 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2632 error (_("Attempt to dereference pointer "
2633 "to member without an object"));
2634 if (noside
== EVAL_SKIP
)
2636 if (unop_user_defined_p (op
, arg1
))
2637 return value_x_unop (arg1
, op
, noside
);
2638 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2640 type
= check_typedef (value_type (arg1
));
2641 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2642 || TYPE_CODE (type
) == TYPE_CODE_REF
2643 /* In C you can dereference an array to get the 1st elt. */
2644 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2646 return value_zero (TYPE_TARGET_TYPE (type
),
2648 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2649 /* GDB allows dereferencing an int. */
2650 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2653 error (_("Attempt to take contents of a non-pointer value."));
2656 /* Allow * on an integer so we can cast it to whatever we want.
2657 This returns an int, which seems like the most C-like thing to
2658 do. "long long" variables are rare enough that
2659 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2660 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2661 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2662 (CORE_ADDR
) value_as_address (arg1
));
2663 return value_ind (arg1
);
2666 /* C++: check for and handle pointer to members. */
2668 op
= exp
->elts
[*pos
].opcode
;
2670 if (noside
== EVAL_SKIP
)
2672 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2677 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2684 if (noside
== EVAL_SKIP
)
2686 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2689 return evaluate_subexp_for_sizeof (exp
, pos
);
2693 type
= exp
->elts
[pc
+ 1].type
;
2694 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2695 if (noside
== EVAL_SKIP
)
2697 if (type
!= value_type (arg1
))
2698 arg1
= value_cast (type
, arg1
);
2701 case UNOP_DYNAMIC_CAST
:
2703 type
= exp
->elts
[pc
+ 1].type
;
2704 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2705 if (noside
== EVAL_SKIP
)
2707 return value_dynamic_cast (type
, arg1
);
2709 case UNOP_REINTERPRET_CAST
:
2711 type
= exp
->elts
[pc
+ 1].type
;
2712 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2713 if (noside
== EVAL_SKIP
)
2715 return value_reinterpret_cast (type
, arg1
);
2719 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2720 if (noside
== EVAL_SKIP
)
2722 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2723 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2725 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2726 value_as_address (arg1
));
2728 case UNOP_MEMVAL_TLS
:
2730 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2731 if (noside
== EVAL_SKIP
)
2733 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2734 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2739 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2740 value_as_address (arg1
));
2741 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2744 case UNOP_PREINCREMENT
:
2745 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2746 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2748 else if (unop_user_defined_p (op
, arg1
))
2750 return value_x_unop (arg1
, op
, noside
);
2754 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2755 arg2
= value_ptradd (arg1
, 1);
2758 struct value
*tmp
= arg1
;
2760 arg2
= value_one (value_type (arg1
), not_lval
);
2761 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2762 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2765 return value_assign (arg1
, arg2
);
2768 case UNOP_PREDECREMENT
:
2769 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2770 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2772 else if (unop_user_defined_p (op
, arg1
))
2774 return value_x_unop (arg1
, op
, noside
);
2778 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2779 arg2
= value_ptradd (arg1
, -1);
2782 struct value
*tmp
= arg1
;
2784 arg2
= value_one (value_type (arg1
), not_lval
);
2785 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2786 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2789 return value_assign (arg1
, arg2
);
2792 case UNOP_POSTINCREMENT
:
2793 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2794 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2796 else if (unop_user_defined_p (op
, arg1
))
2798 return value_x_unop (arg1
, op
, noside
);
2802 arg3
= value_non_lval (arg1
);
2804 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2805 arg2
= value_ptradd (arg1
, 1);
2808 struct value
*tmp
= arg1
;
2810 arg2
= value_one (value_type (arg1
), not_lval
);
2811 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2812 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2815 value_assign (arg1
, arg2
);
2819 case UNOP_POSTDECREMENT
:
2820 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2821 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2823 else if (unop_user_defined_p (op
, arg1
))
2825 return value_x_unop (arg1
, op
, noside
);
2829 arg3
= value_non_lval (arg1
);
2831 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2832 arg2
= value_ptradd (arg1
, -1);
2835 struct value
*tmp
= arg1
;
2837 arg2
= value_one (value_type (arg1
), not_lval
);
2838 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2839 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2842 value_assign (arg1
, arg2
);
2848 return value_of_this (1);
2852 return value_of_local ("self", 1);
2855 /* The value is not supposed to be used. This is here to make it
2856 easier to accommodate expressions that contain types. */
2858 if (noside
== EVAL_SKIP
)
2860 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2862 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2864 /* If this is a typedef, then find its immediate target. We
2865 use check_typedef to resolve stubs, but we ignore its
2866 result because we do not want to dig past all
2868 check_typedef (type
);
2869 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2870 type
= TYPE_TARGET_TYPE (type
);
2871 return allocate_value (type
);
2874 error (_("Attempt to use a type name as an expression"));
2877 /* Removing this case and compiling with gcc -Wall reveals that
2878 a lot of cases are hitting this case. Some of these should
2879 probably be removed from expression.h; others are legitimate
2880 expressions which are (apparently) not fully implemented.
2882 If there are any cases landing here which mean a user error,
2883 then they should be separate cases, with more descriptive
2886 error (_("GDB does not (yet) know how to "
2887 "evaluate that kind of expression"));
2891 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2894 /* Evaluate a subexpression of EXP, at index *POS,
2895 and return the address of that subexpression.
2896 Advance *POS over the subexpression.
2897 If the subexpression isn't an lvalue, get an error.
2898 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2899 then only the type of the result need be correct. */
2901 static struct value
*
2902 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2912 op
= exp
->elts
[pc
].opcode
;
2918 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2920 /* We can't optimize out "&*" if there's a user-defined operator*. */
2921 if (unop_user_defined_p (op
, x
))
2923 x
= value_x_unop (x
, op
, noside
);
2924 goto default_case_after_eval
;
2927 return coerce_array (x
);
2931 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2932 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2935 var
= exp
->elts
[pc
+ 2].symbol
;
2937 /* C++: The "address" of a reference should yield the address
2938 * of the object pointed to. Let value_addr() deal with it. */
2939 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2943 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2946 lookup_pointer_type (SYMBOL_TYPE (var
));
2947 enum address_class sym_class
= SYMBOL_CLASS (var
);
2949 if (sym_class
== LOC_CONST
2950 || sym_class
== LOC_CONST_BYTES
2951 || sym_class
== LOC_REGISTER
)
2952 error (_("Attempt to take address of register or constant."));
2955 value_zero (type
, not_lval
);
2958 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2961 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2962 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2963 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2964 &exp
->elts
[pc
+ 3].string
,
2967 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2972 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2973 default_case_after_eval
:
2974 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2976 struct type
*type
= check_typedef (value_type (x
));
2978 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2979 return value_zero (lookup_pointer_type (value_type (x
)),
2981 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2982 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2985 error (_("Attempt to take address of "
2986 "value not located in memory."));
2988 return value_addr (x
);
2992 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2993 When used in contexts where arrays will be coerced anyway, this is
2994 equivalent to `evaluate_subexp' but much faster because it avoids
2995 actually fetching array contents (perhaps obsolete now that we have
2998 Note that we currently only do the coercion for C expressions, where
2999 arrays are zero based and the coercion is correct. For other languages,
3000 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3001 to decide if coercion is appropriate. */
3004 evaluate_subexp_with_coercion (struct expression
*exp
,
3005 int *pos
, enum noside noside
)
3014 op
= exp
->elts
[pc
].opcode
;
3019 var
= exp
->elts
[pc
+ 2].symbol
;
3020 type
= check_typedef (SYMBOL_TYPE (var
));
3021 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3022 && !TYPE_VECTOR (type
)
3023 && CAST_IS_CONVERSION (exp
->language_defn
))
3026 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3027 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3033 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3037 /* Evaluate a subexpression of EXP, at index *POS,
3038 and return a value for the size of that subexpression.
3039 Advance *POS over the subexpression. */
3041 static struct value
*
3042 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
3044 /* FIXME: This should be size_t. */
3045 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3052 op
= exp
->elts
[pc
].opcode
;
3056 /* This case is handled specially
3057 so that we avoid creating a value for the result type.
3058 If the result type is very big, it's desirable not to
3059 create a value unnecessarily. */
3062 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3063 type
= check_typedef (value_type (val
));
3064 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3065 && TYPE_CODE (type
) != TYPE_CODE_REF
3066 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3067 error (_("Attempt to take contents of a non-pointer value."));
3068 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3069 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3073 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3074 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3078 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3080 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3083 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3084 return value_from_longest (size_type
,
3085 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3089 /* Parse a type expression in the string [P..P+LENGTH). */
3092 parse_and_eval_type (char *p
, int length
)
3094 char *tmp
= (char *) alloca (length
+ 4);
3095 struct expression
*expr
;
3098 memcpy (tmp
+ 1, p
, length
);
3099 tmp
[length
+ 1] = ')';
3100 tmp
[length
+ 2] = '0';
3101 tmp
[length
+ 3] = '\0';
3102 expr
= parse_expression (tmp
);
3103 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3104 error (_("Internal error in eval_type."));
3105 return expr
->elts
[1].type
;
3109 calc_f77_array_dims (struct type
*array_type
)
3112 struct type
*tmp_type
;
3114 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3115 error (_("Can't get dimensions for a non-array type"));
3117 tmp_type
= array_type
;
3119 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3121 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)