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 treats the value of the expression
97 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
99 parse_and_eval_long (char *exp
)
101 struct expression
*expr
= parse_expression (exp
);
103 struct cleanup
*old_chain
=
104 make_cleanup (free_current_contents
, &expr
);
106 retval
= value_as_long (evaluate_expression (expr
));
107 do_cleanups (old_chain
);
112 parse_and_eval (char *exp
)
114 struct expression
*expr
= parse_expression (exp
);
116 struct cleanup
*old_chain
=
117 make_cleanup (free_current_contents
, &expr
);
119 val
= evaluate_expression (expr
);
120 do_cleanups (old_chain
);
124 /* Parse up to a comma (or to a closeparen)
125 in the string EXPP as an expression, evaluate it, and return the value.
126 EXPP is advanced to point to the comma. */
129 parse_to_comma_and_eval (char **expp
)
131 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
133 struct cleanup
*old_chain
=
134 make_cleanup (free_current_contents
, &expr
);
136 val
= evaluate_expression (expr
);
137 do_cleanups (old_chain
);
141 /* Evaluate an expression in internal prefix form
142 such as is constructed by parse.y.
144 See expression.h for info on the format of an expression. */
147 evaluate_expression (struct expression
*exp
)
151 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
154 /* Evaluate an expression, avoiding all memory references
155 and getting a value whose type alone is correct. */
158 evaluate_type (struct expression
*exp
)
162 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
165 /* Evaluate a subexpression, avoiding all memory references and
166 getting a value whose type alone is correct. */
169 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
171 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
174 /* Find the current value of a watchpoint on EXP. Return the value in
175 *VALP and *RESULTP and the chain of intermediate and final values
176 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
179 If a memory error occurs while evaluating the expression, *RESULTP will
180 be set to NULL. *RESULTP may be a lazy value, if the result could
181 not be read from memory. It is used to determine whether a value
182 is user-specified (we should watch the whole value) or intermediate
183 (we should watch only the bit used to locate the final value).
185 If the final value, or any intermediate value, could not be read
186 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
187 set to any referenced values. *VALP will never be a lazy value.
188 This is the value which we store in struct breakpoint.
190 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
191 value chain. The caller must free the values individually. If
192 VAL_CHAIN is NULL, all generated values will be left on the value
196 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
197 struct value
**resultp
, struct value
**val_chain
)
199 struct value
*mark
, *new_mark
, *result
;
200 volatile struct gdb_exception ex
;
208 /* Evaluate the expression. */
209 mark
= value_mark ();
212 TRY_CATCH (ex
, RETURN_MASK_ALL
)
214 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
218 /* Ignore memory errors, we want watchpoints pointing at
219 inaccessible memory to still be created; otherwise, throw the
220 error to some higher catcher. */
226 throw_exception (ex
);
231 new_mark
= value_mark ();
232 if (mark
== new_mark
)
237 /* Make sure it's not lazy, so that after the target stops again we
238 have a non-lazy previous value to compare with. */
240 && (!value_lazy (result
) || gdb_value_fetch_lazy (result
)))
245 /* Return the chain of intermediate values. We use this to
246 decide which addresses to watch. */
247 *val_chain
= new_mark
;
248 value_release_to_mark (mark
);
252 /* Extract a field operation from an expression. If the subexpression
253 of EXP starting at *SUBEXP is not a structure dereference
254 operation, return NULL. Otherwise, return the name of the
255 dereferenced field, and advance *SUBEXP to point to the
256 subexpression of the left-hand-side of the dereference. This is
257 used when completing field names. */
260 extract_field_op (struct expression
*exp
, int *subexp
)
265 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
266 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
268 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
269 result
= &exp
->elts
[*subexp
+ 2].string
;
270 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
274 /* If the next expression is an OP_LABELED, skips past it,
275 returning the label. Otherwise, does nothing and returns NULL. */
278 get_label (struct expression
*exp
, int *pos
)
280 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
283 char *name
= &exp
->elts
[pc
+ 2].string
;
284 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
286 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
293 /* This function evaluates tuples (in (the deleted) Chill) or
294 brace-initializers (in C/C++) for structure types. */
296 static struct value
*
297 evaluate_struct_tuple (struct value
*struct_val
,
298 struct expression
*exp
,
299 int *pos
, enum noside noside
, int nargs
)
301 struct type
*struct_type
= check_typedef (value_type (struct_val
));
302 struct type
*substruct_type
= struct_type
;
303 struct type
*field_type
;
311 struct value
*val
= NULL
;
316 /* Skip past the labels, and count them. */
317 while (get_label (exp
, pos
) != NULL
)
322 char *label
= get_label (exp
, &pc
);
326 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
329 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
331 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
334 subfieldno
= fieldno
;
335 substruct_type
= struct_type
;
339 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
342 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
344 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
345 if ((field_name
== 0 || *field_name
== '\0')
346 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
349 for (; variantno
< TYPE_NFIELDS (field_type
);
353 = TYPE_FIELD_TYPE (field_type
, variantno
);
354 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
357 subfieldno
< TYPE_NFIELDS (substruct_type
);
360 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
371 error (_("there is no field named %s"), label
);
377 /* Unlabelled tuple element - go to next field. */
381 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
384 substruct_type
= struct_type
;
390 /* Skip static fields. */
391 while (fieldno
< TYPE_NFIELDS (struct_type
)
392 && field_is_static (&TYPE_FIELD (struct_type
,
395 subfieldno
= fieldno
;
396 if (fieldno
>= TYPE_NFIELDS (struct_type
))
397 error (_("too many initializers"));
398 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
399 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
400 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
401 error (_("don't know which variant you want to set"));
405 /* Here, struct_type is the type of the inner struct,
406 while substruct_type is the type of the inner struct.
407 These are the same for normal structures, but a variant struct
408 contains anonymous union fields that contain substruct fields.
409 The value fieldno is the index of the top-level (normal or
410 anonymous union) field in struct_field, while the value
411 subfieldno is the index of the actual real (named inner) field
412 in substruct_type. */
414 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
416 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
418 /* Now actually set the field in struct_val. */
420 /* Assign val to field fieldno. */
421 if (value_type (val
) != field_type
)
422 val
= value_cast (field_type
, val
);
424 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
425 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
427 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
428 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
430 modify_field (struct_type
, addr
,
431 value_as_long (val
), bitpos
% 8, bitsize
);
433 memcpy (addr
, value_contents (val
),
434 TYPE_LENGTH (value_type (val
)));
436 while (--nlabels
> 0);
441 /* Recursive helper function for setting elements of array tuples for
442 (the deleted) Chill. The target is ARRAY (which has bounds
443 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
444 and NOSIDE are as usual. Evaluates index expresions and sets the
445 specified element(s) of ARRAY to ELEMENT. Returns last index
449 init_array_element (struct value
*array
, struct value
*element
,
450 struct expression
*exp
, int *pos
,
451 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
454 int element_size
= TYPE_LENGTH (value_type (element
));
456 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
459 init_array_element (array
, element
, exp
, pos
, noside
,
460 low_bound
, high_bound
);
461 return init_array_element (array
, element
,
462 exp
, pos
, noside
, low_bound
, high_bound
);
464 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
469 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
470 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
471 if (low
< low_bound
|| high
> high_bound
)
472 error (_("tuple range index out of range"));
473 for (index
= low
; index
<= high
; index
++)
475 memcpy (value_contents_raw (array
)
476 + (index
- low_bound
) * element_size
,
477 value_contents (element
), element_size
);
482 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
483 if (index
< low_bound
|| index
> high_bound
)
484 error (_("tuple index out of range"));
485 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
486 value_contents (element
), element_size
);
491 static struct value
*
492 value_f90_subarray (struct value
*array
,
493 struct expression
*exp
, int *pos
, enum noside noside
)
496 LONGEST low_bound
, high_bound
;
497 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
498 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
502 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
503 low_bound
= TYPE_LOW_BOUND (range
);
505 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
507 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
508 high_bound
= TYPE_HIGH_BOUND (range
);
510 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
512 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
516 /* Promote value ARG1 as appropriate before performing a unary operation
518 If the result is not appropriate for any particular language then it
519 needs to patch this function. */
522 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
527 *arg1
= coerce_ref (*arg1
);
528 type1
= check_typedef (value_type (*arg1
));
530 if (is_integral_type (type1
))
532 switch (language
->la_language
)
535 /* Perform integral promotion for ANSI C/C++.
536 If not appropropriate for any particular language
537 it needs to modify this function. */
539 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
541 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
542 *arg1
= value_cast (builtin_int
, *arg1
);
549 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
550 operation on those two operands.
551 If the result is not appropriate for any particular language then it
552 needs to patch this function. */
555 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
556 struct value
**arg1
, struct value
**arg2
)
558 struct type
*promoted_type
= NULL
;
562 *arg1
= coerce_ref (*arg1
);
563 *arg2
= coerce_ref (*arg2
);
565 type1
= check_typedef (value_type (*arg1
));
566 type2
= check_typedef (value_type (*arg2
));
568 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
569 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
570 && !is_integral_type (type1
))
571 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
572 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
573 && !is_integral_type (type2
)))
576 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
577 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
579 /* No promotion required. */
581 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
582 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
584 switch (language
->la_language
)
590 case language_opencl
:
591 /* No promotion required. */
595 /* For other languages the result type is unchanged from gdb
596 version 6.7 for backward compatibility.
597 If either arg was long double, make sure that value is also long
598 double. Otherwise use double. */
599 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
600 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
601 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
603 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
607 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
608 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
610 /* No promotion required. */
613 /* Integral operations here. */
614 /* FIXME: Also mixed integral/booleans, with result an integer. */
616 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
617 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
618 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
619 int is_unsigned1
= TYPE_UNSIGNED (type1
);
620 int is_unsigned2
= TYPE_UNSIGNED (type2
);
621 unsigned int result_len
;
622 int unsigned_operation
;
624 /* Determine type length and signedness after promotion for
626 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
629 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
631 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
634 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
637 if (promoted_len1
> promoted_len2
)
639 unsigned_operation
= is_unsigned1
;
640 result_len
= promoted_len1
;
642 else if (promoted_len2
> promoted_len1
)
644 unsigned_operation
= is_unsigned2
;
645 result_len
= promoted_len2
;
649 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
650 result_len
= promoted_len1
;
653 switch (language
->la_language
)
659 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
661 promoted_type
= (unsigned_operation
662 ? builtin
->builtin_unsigned_int
663 : builtin
->builtin_int
);
665 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
667 promoted_type
= (unsigned_operation
668 ? builtin
->builtin_unsigned_long
669 : builtin
->builtin_long
);
673 promoted_type
= (unsigned_operation
674 ? builtin
->builtin_unsigned_long_long
675 : builtin
->builtin_long_long
);
678 case language_opencl
:
679 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
680 (language
, gdbarch
, "int")))
684 ? lookup_unsigned_typename (language
, gdbarch
, "int")
685 : lookup_signed_typename (language
, gdbarch
, "int"));
687 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
688 (language
, gdbarch
, "long")))
692 ? lookup_unsigned_typename (language
, gdbarch
, "long")
693 : lookup_signed_typename (language
, gdbarch
,"long"));
697 /* For other languages the result type is unchanged from gdb
698 version 6.7 for backward compatibility.
699 If either arg was long long, make sure that value is also long
700 long. Otherwise use long. */
701 if (unsigned_operation
)
703 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
704 promoted_type
= builtin
->builtin_unsigned_long_long
;
706 promoted_type
= builtin
->builtin_unsigned_long
;
710 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
711 promoted_type
= builtin
->builtin_long_long
;
713 promoted_type
= builtin
->builtin_long
;
721 /* Promote both operands to common type. */
722 *arg1
= value_cast (promoted_type
, *arg1
);
723 *arg2
= value_cast (promoted_type
, *arg2
);
728 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
730 type
= check_typedef (type
);
731 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
732 type
= TYPE_TARGET_TYPE (type
);
734 switch (TYPE_CODE (type
))
740 case TYPE_CODE_ARRAY
:
741 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
748 /* Constructs a fake method with the given parameter types.
749 This function is used by the parser to construct an "expected"
750 type for method overload resolution. */
753 make_params (int num_types
, struct type
**param_types
)
755 struct type
*type
= XZALLOC (struct type
);
756 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
757 TYPE_LENGTH (type
) = 1;
758 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
759 TYPE_VPTR_FIELDNO (type
) = -1;
760 TYPE_CHAIN (type
) = type
;
761 TYPE_NFIELDS (type
) = num_types
;
762 TYPE_FIELDS (type
) = (struct field
*)
763 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
765 while (num_types
-- > 0)
766 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
772 evaluate_subexp_standard (struct type
*expect_type
,
773 struct expression
*exp
, int *pos
,
778 int pc
, pc2
= 0, oldpos
;
779 struct value
*arg1
= NULL
;
780 struct value
*arg2
= NULL
;
784 struct value
**argvec
;
789 struct type
**arg_types
;
791 struct symbol
*function
= NULL
;
792 char *function_name
= NULL
;
795 op
= exp
->elts
[pc
].opcode
;
800 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
801 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
802 if (noside
== EVAL_SKIP
)
804 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
805 &exp
->elts
[pc
+ 3].string
,
806 expect_type
, 0, noside
);
808 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
813 return value_from_longest (exp
->elts
[pc
+ 1].type
,
814 exp
->elts
[pc
+ 2].longconst
);
818 return value_from_double (exp
->elts
[pc
+ 1].type
,
819 exp
->elts
[pc
+ 2].doubleconst
);
823 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
824 exp
->elts
[pc
+ 2].decfloatconst
);
829 if (noside
== EVAL_SKIP
)
832 /* JYG: We used to just return value_zero of the symbol type
833 if we're asked to avoid side effects. Otherwise we return
834 value_of_variable (...). However I'm not sure if
835 value_of_variable () has any side effect.
836 We need a full value object returned here for whatis_exp ()
837 to call evaluate_type () and then pass the full value to
838 value_rtti_target_type () if we are dealing with a pointer
839 or reference to a base class and print object is on. */
842 volatile struct gdb_exception except
;
843 struct value
*ret
= NULL
;
845 TRY_CATCH (except
, RETURN_MASK_ERROR
)
847 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
848 exp
->elts
[pc
+ 1].block
);
851 if (except
.reason
< 0)
853 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
854 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
857 throw_exception (except
);
866 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
870 const char *name
= &exp
->elts
[pc
+ 2].string
;
874 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
875 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
876 name
, strlen (name
));
878 error (_("Register $%s not available."), name
);
880 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
881 a value with the appropriate register type. Unfortunately,
882 we don't have easy access to the type of user registers.
883 So for these registers, we fetch the register value regardless
884 of the evaluation mode. */
885 if (noside
== EVAL_AVOID_SIDE_EFFECTS
886 && regno
< gdbarch_num_regs (exp
->gdbarch
)
887 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
888 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
890 val
= value_of_register (regno
, get_selected_frame (NULL
));
892 error (_("Value of register %s not available."), name
);
898 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
899 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
903 return value_of_internalvar (exp
->gdbarch
,
904 exp
->elts
[pc
+ 1].internalvar
);
907 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
908 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
909 if (noside
== EVAL_SKIP
)
911 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
912 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
914 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
915 NSString constant. */
916 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
917 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
918 if (noside
== EVAL_SKIP
)
922 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
925 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
927 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
928 if (noside
== EVAL_SKIP
)
930 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
,
931 builtin_type (exp
->gdbarch
)->builtin_int
);
936 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
937 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
938 nargs
= tem3
- tem2
+ 1;
939 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
941 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
942 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
944 struct value
*rec
= allocate_value (expect_type
);
946 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
947 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
950 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
951 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
953 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
954 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
955 struct value
*array
= allocate_value (expect_type
);
956 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
957 LONGEST low_bound
, high_bound
, index
;
959 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
962 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
965 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
966 for (tem
= nargs
; --nargs
>= 0;)
968 struct value
*element
;
971 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
974 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
976 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
977 if (value_type (element
) != element_type
)
978 element
= value_cast (element_type
, element
);
981 int continue_pc
= *pos
;
984 index
= init_array_element (array
, element
, exp
, pos
, noside
,
985 low_bound
, high_bound
);
990 if (index
> high_bound
)
991 /* To avoid memory corruption. */
992 error (_("Too many array elements"));
993 memcpy (value_contents_raw (array
)
994 + (index
- low_bound
) * element_size
,
995 value_contents (element
),
1003 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1004 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1006 struct value
*set
= allocate_value (expect_type
);
1007 gdb_byte
*valaddr
= value_contents_raw (set
);
1008 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1009 struct type
*check_type
= element_type
;
1010 LONGEST low_bound
, high_bound
;
1012 /* Get targettype of elementtype. */
1013 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1014 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1015 check_type
= TYPE_TARGET_TYPE (check_type
);
1017 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1018 error (_("(power)set type with unknown size"));
1019 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1020 for (tem
= 0; tem
< nargs
; tem
++)
1022 LONGEST range_low
, range_high
;
1023 struct type
*range_low_type
, *range_high_type
;
1024 struct value
*elem_val
;
1026 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1029 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1030 range_low_type
= value_type (elem_val
);
1031 range_low
= value_as_long (elem_val
);
1032 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1033 range_high_type
= value_type (elem_val
);
1034 range_high
= value_as_long (elem_val
);
1038 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1039 range_low_type
= range_high_type
= value_type (elem_val
);
1040 range_low
= range_high
= value_as_long (elem_val
);
1042 /* Check types of elements to avoid mixture of elements from
1043 different types. Also check if type of element is "compatible"
1044 with element type of powerset. */
1045 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1046 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1047 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1048 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1049 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1050 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1051 && (range_low_type
!= range_high_type
)))
1052 /* different element modes. */
1053 error (_("POWERSET tuple elements of different mode"));
1054 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1055 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1056 && range_low_type
!= check_type
))
1057 error (_("incompatible POWERSET tuple elements"));
1058 if (range_low
> range_high
)
1060 warning (_("empty POWERSET tuple range"));
1063 if (range_low
< low_bound
|| range_high
> high_bound
)
1064 error (_("POWERSET tuple element out of range"));
1065 range_low
-= low_bound
;
1066 range_high
-= low_bound
;
1067 for (; range_low
<= range_high
; range_low
++)
1069 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1071 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1072 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1073 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1080 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1081 for (tem
= 0; tem
< nargs
; tem
++)
1083 /* Ensure that array expressions are coerced into pointer
1085 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1087 if (noside
== EVAL_SKIP
)
1089 return value_array (tem2
, tem3
, argvec
);
1093 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1095 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1097 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1099 if (noside
== EVAL_SKIP
)
1101 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1104 case TERNOP_SLICE_COUNT
:
1106 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1108 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1110 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1112 return value_slice (array
, lowbound
, length
);
1116 /* Skip third and second args to evaluate the first one. */
1117 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1118 if (value_logical_not (arg1
))
1120 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1121 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1125 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1126 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1130 case OP_OBJC_SELECTOR
:
1131 { /* Objective C @selector operator. */
1132 char *sel
= &exp
->elts
[pc
+ 2].string
;
1133 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1134 struct type
*selector_type
;
1136 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1137 if (noside
== EVAL_SKIP
)
1141 sel
[len
] = 0; /* Make sure it's terminated. */
1143 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1144 return value_from_longest (selector_type
,
1145 lookup_child_selector (exp
->gdbarch
, sel
));
1148 case OP_OBJC_MSGCALL
:
1149 { /* Objective C message (method) call. */
1151 CORE_ADDR responds_selector
= 0;
1152 CORE_ADDR method_selector
= 0;
1154 CORE_ADDR selector
= 0;
1156 int struct_return
= 0;
1157 int sub_no_side
= 0;
1159 struct value
*msg_send
= NULL
;
1160 struct value
*msg_send_stret
= NULL
;
1161 int gnu_runtime
= 0;
1163 struct value
*target
= NULL
;
1164 struct value
*method
= NULL
;
1165 struct value
*called_method
= NULL
;
1167 struct type
*selector_type
= NULL
;
1168 struct type
*long_type
;
1170 struct value
*ret
= NULL
;
1173 selector
= exp
->elts
[pc
+ 1].longconst
;
1174 nargs
= exp
->elts
[pc
+ 2].longconst
;
1175 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1180 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1181 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1183 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1184 sub_no_side
= EVAL_NORMAL
;
1186 sub_no_side
= noside
;
1188 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1190 if (value_as_long (target
) == 0)
1191 return value_from_longest (long_type
, 0);
1193 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1196 /* Find the method dispatch (Apple runtime) or method lookup
1197 (GNU runtime) function for Objective-C. These will be used
1198 to lookup the symbol information for the method. If we
1199 can't find any symbol information, then we'll use these to
1200 call the method, otherwise we can call the method
1201 directly. The msg_send_stret function is used in the special
1202 case of a method that returns a structure (Apple runtime
1206 struct type
*type
= selector_type
;
1208 type
= lookup_function_type (type
);
1209 type
= lookup_pointer_type (type
);
1210 type
= lookup_function_type (type
);
1211 type
= lookup_pointer_type (type
);
1213 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1215 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1217 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1218 msg_send_stret
= value_from_pointer (type
,
1219 value_as_address (msg_send_stret
));
1223 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1224 /* Special dispatcher for methods returning structs. */
1226 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1229 /* Verify the target object responds to this method. The
1230 standard top-level 'Object' class uses a different name for
1231 the verification method than the non-standard, but more
1232 often used, 'NSObject' class. Make sure we check for both. */
1235 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1236 if (responds_selector
== 0)
1238 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1240 if (responds_selector
== 0)
1241 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1244 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1245 if (method_selector
== 0)
1247 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1249 if (method_selector
== 0)
1250 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1252 /* Call the verification method, to make sure that the target
1253 class implements the desired method. */
1255 argvec
[0] = msg_send
;
1257 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1258 argvec
[3] = value_from_longest (long_type
, selector
);
1261 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1264 /* Function objc_msg_lookup returns a pointer. */
1266 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1268 if (value_as_long (ret
) == 0)
1269 error (_("Target does not respond to this message selector."));
1271 /* Call "methodForSelector:" method, to get the address of a
1272 function method that implements this selector for this
1273 class. If we can find a symbol at that address, then we
1274 know the return type, parameter types etc. (that's a good
1277 argvec
[0] = msg_send
;
1279 argvec
[2] = value_from_longest (long_type
, method_selector
);
1280 argvec
[3] = value_from_longest (long_type
, selector
);
1283 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1287 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1290 /* ret should now be the selector. */
1292 addr
= value_as_long (ret
);
1295 struct symbol
*sym
= NULL
;
1297 /* The address might point to a function descriptor;
1298 resolve it to the actual code address instead. */
1299 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1302 /* Is it a high_level symbol? */
1303 sym
= find_pc_function (addr
);
1305 method
= value_of_variable (sym
, 0);
1308 /* If we found a method with symbol information, check to see
1309 if it returns a struct. Otherwise assume it doesn't. */
1314 struct type
*val_type
;
1316 funaddr
= find_function_addr (method
, &val_type
);
1318 block_for_pc (funaddr
);
1320 CHECK_TYPEDEF (val_type
);
1322 if ((val_type
== NULL
)
1323 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1325 if (expect_type
!= NULL
)
1326 val_type
= expect_type
;
1329 struct_return
= using_struct_return (exp
->gdbarch
,
1330 value_type (method
),
1333 else if (expect_type
!= NULL
)
1335 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1336 check_typedef (expect_type
));
1339 /* Found a function symbol. Now we will substitute its
1340 value in place of the message dispatcher (obj_msgSend),
1341 so that we call the method directly instead of thru
1342 the dispatcher. The main reason for doing this is that
1343 we can now evaluate the return value and parameter values
1344 according to their known data types, in case we need to
1345 do things like promotion, dereferencing, special handling
1346 of structs and doubles, etc.
1348 We want to use the type signature of 'method', but still
1349 jump to objc_msgSend() or objc_msgSend_stret() to better
1350 mimic the behavior of the runtime. */
1354 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1355 error (_("method address has symbol information "
1356 "with non-function type; skipping"));
1358 /* Create a function pointer of the appropriate type, and
1359 replace its value with the value of msg_send or
1360 msg_send_stret. We must use a pointer here, as
1361 msg_send and msg_send_stret are of pointer type, and
1362 the representation may be different on systems that use
1363 function descriptors. */
1366 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1367 value_as_address (msg_send_stret
));
1370 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1371 value_as_address (msg_send
));
1376 called_method
= msg_send_stret
;
1378 called_method
= msg_send
;
1381 if (noside
== EVAL_SKIP
)
1384 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1386 /* If the return type doesn't look like a function type,
1387 call an error. This can happen if somebody tries to
1388 turn a variable into a function call. This is here
1389 because people often want to call, eg, strcmp, which
1390 gdb doesn't know is a function. If gdb isn't asked for
1391 it's opinion (ie. through "whatis"), it won't offer
1394 struct type
*type
= value_type (called_method
);
1396 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1397 type
= TYPE_TARGET_TYPE (type
);
1398 type
= TYPE_TARGET_TYPE (type
);
1402 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1403 return allocate_value (expect_type
);
1405 return allocate_value (type
);
1408 error (_("Expression of type other than "
1409 "\"method returning ...\" used as a method"));
1412 /* Now depending on whether we found a symbol for the method,
1413 we will either call the runtime dispatcher or the method
1416 argvec
[0] = called_method
;
1418 argvec
[2] = value_from_longest (long_type
, selector
);
1419 /* User-supplied arguments. */
1420 for (tem
= 0; tem
< nargs
; tem
++)
1421 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1422 argvec
[tem
+ 3] = 0;
1424 if (gnu_runtime
&& (method
!= NULL
))
1426 /* Function objc_msg_lookup returns a pointer. */
1427 deprecated_set_value_type (argvec
[0],
1428 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1430 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1433 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1440 op
= exp
->elts
[*pos
].opcode
;
1441 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1442 /* Allocate arg vector, including space for the function to be
1443 called in argvec[0] and a terminating NULL. */
1444 argvec
= (struct value
**)
1445 alloca (sizeof (struct value
*) * (nargs
+ 3));
1446 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1449 /* First, evaluate the structure into arg2. */
1452 if (noside
== EVAL_SKIP
)
1455 if (op
== STRUCTOP_MEMBER
)
1457 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1461 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1464 /* If the function is a virtual function, then the
1465 aggregate value (providing the structure) plays
1466 its part by providing the vtable. Otherwise,
1467 it is just along for the ride: call the function
1470 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1472 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1473 != TYPE_CODE_METHODPTR
)
1474 error (_("Non-pointer-to-member value used in pointer-to-member "
1477 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1479 struct type
*method_type
= check_typedef (value_type (arg1
));
1481 arg1
= value_zero (method_type
, not_lval
);
1484 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1486 /* Now, say which argument to start evaluating from. */
1489 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1491 /* Hair for method invocations. */
1495 /* First, evaluate the structure into arg2. */
1497 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1498 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1499 if (noside
== EVAL_SKIP
)
1502 if (op
== STRUCTOP_STRUCT
)
1504 /* If v is a variable in a register, and the user types
1505 v.method (), this will produce an error, because v has
1508 A possible way around this would be to allocate a
1509 copy of the variable on the stack, copy in the
1510 contents, call the function, and copy out the
1511 contents. I.e. convert this from call by reference
1512 to call by copy-return (or whatever it's called).
1513 However, this does not work because it is not the
1514 same: the method being called could stash a copy of
1515 the address, and then future uses through that address
1516 (after the method returns) would be expected to
1517 use the variable itself, not some copy of it. */
1518 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1522 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1524 /* Check to see if the operator '->' has been
1525 overloaded. If the operator has been overloaded
1526 replace arg2 with the value returned by the custom
1527 operator and continue evaluation. */
1528 while (unop_user_defined_p (op
, arg2
))
1530 volatile struct gdb_exception except
;
1531 struct value
*value
= NULL
;
1532 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1534 value
= value_x_unop (arg2
, op
, noside
);
1537 if (except
.reason
< 0)
1539 if (except
.error
== NOT_FOUND_ERROR
)
1542 throw_exception (except
);
1547 /* Now, say which argument to start evaluating from. */
1550 else if (op
== OP_SCOPE
1551 && overload_resolution
1552 && (exp
->language_defn
->la_language
== language_cplus
))
1554 /* Unpack it locally so we can properly handle overload
1560 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1561 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1562 type
= exp
->elts
[pc2
+ 1].type
;
1563 name
= &exp
->elts
[pc2
+ 3].string
;
1566 function_name
= NULL
;
1567 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1569 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1571 get_selected_block (0),
1573 if (function
== NULL
)
1574 error (_("No symbol \"%s\" in namespace \"%s\"."),
1575 name
, TYPE_TAG_NAME (type
));
1581 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1582 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1583 function_name
= name
;
1585 arg2
= value_zero (type
, lval_memory
);
1590 else if (op
== OP_ADL_FUNC
)
1592 /* Save the function position and move pos so that the arguments
1593 can be evaluated. */
1599 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1600 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1604 /* Non-method function call. */
1608 /* If this is a C++ function wait until overload resolution. */
1609 if (op
== OP_VAR_VALUE
1610 && overload_resolution
1611 && (exp
->language_defn
->la_language
== language_cplus
))
1613 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1618 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1619 type
= value_type (argvec
[0]);
1620 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1621 type
= TYPE_TARGET_TYPE (type
);
1622 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1624 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1626 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1634 /* Evaluate arguments. */
1635 for (; tem
<= nargs
; tem
++)
1637 /* Ensure that array expressions are coerced into pointer
1639 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1642 /* Signal end of arglist. */
1644 if (op
== OP_ADL_FUNC
)
1646 struct symbol
*symp
;
1649 int string_pc
= save_pos1
+ 3;
1651 /* Extract the function name. */
1652 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1653 func_name
= (char *) alloca (name_len
+ 1);
1654 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1656 /* Prepare list of argument types for overload resolution. */
1657 arg_types
= (struct type
**)
1658 alloca (nargs
* (sizeof (struct type
*)));
1659 for (ix
= 1; ix
<= nargs
; ix
++)
1660 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1662 find_overload_match (arg_types
, nargs
, func_name
,
1663 NON_METHOD
, /* not method */
1664 0, /* strict match */
1665 NULL
, NULL
, /* pass NULL symbol since
1666 symbol is unknown */
1667 NULL
, &symp
, NULL
, 0);
1669 /* Now fix the expression being evaluated. */
1670 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1671 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1674 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1675 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1677 int static_memfuncp
;
1680 /* Method invocation : stuff "this" as first parameter. */
1685 /* Name of method from expression. */
1686 tstr
= &exp
->elts
[pc2
+ 2].string
;
1689 tstr
= function_name
;
1691 if (overload_resolution
&& (exp
->language_defn
->la_language
1694 /* Language is C++, do some overload resolution before
1696 struct value
*valp
= NULL
;
1698 /* Prepare list of argument types for overload resolution. */
1699 arg_types
= (struct type
**)
1700 alloca (nargs
* (sizeof (struct type
*)));
1701 for (ix
= 1; ix
<= nargs
; ix
++)
1702 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1704 (void) find_overload_match (arg_types
, nargs
, tstr
,
1705 METHOD
, /* method */
1706 0, /* strict match */
1707 &arg2
, /* the object */
1709 &static_memfuncp
, 0);
1711 if (op
== OP_SCOPE
&& !static_memfuncp
)
1713 /* For the time being, we don't handle this. */
1714 error (_("Call to overloaded function %s requires "
1718 argvec
[1] = arg2
; /* the ``this'' pointer */
1719 argvec
[0] = valp
; /* Use the method found after overload
1723 /* Non-C++ case -- or no overload resolution. */
1725 struct value
*temp
= arg2
;
1727 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1729 op
== STRUCTOP_STRUCT
1730 ? "structure" : "structure pointer");
1731 /* value_struct_elt updates temp with the correct value
1732 of the ``this'' pointer if necessary, so modify argvec[1] to
1733 reflect any ``this'' changes. */
1735 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1736 value_address (temp
)
1737 + value_embedded_offset (temp
));
1738 argvec
[1] = arg2
; /* the ``this'' pointer */
1741 if (static_memfuncp
)
1743 argvec
[1] = argvec
[0];
1748 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1753 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1755 /* Non-member function being called. */
1756 /* fn: This can only be done for C++ functions. A C-style function
1757 in a C++ program, for instance, does not have the fields that
1758 are expected here. */
1760 if (overload_resolution
&& (exp
->language_defn
->la_language
1763 /* Language is C++, do some overload resolution before
1765 struct symbol
*symp
;
1768 /* If a scope has been specified disable ADL. */
1772 if (op
== OP_VAR_VALUE
)
1773 function
= exp
->elts
[save_pos1
+2].symbol
;
1775 /* Prepare list of argument types for overload resolution. */
1776 arg_types
= (struct type
**)
1777 alloca (nargs
* (sizeof (struct type
*)));
1778 for (ix
= 1; ix
<= nargs
; ix
++)
1779 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1781 (void) find_overload_match (arg_types
, nargs
,
1782 NULL
, /* no need for name */
1783 NON_METHOD
, /* not method */
1784 0, /* strict match */
1785 NULL
, function
, /* the function */
1786 NULL
, &symp
, NULL
, no_adl
);
1788 if (op
== OP_VAR_VALUE
)
1790 /* Now fix the expression being evaluated. */
1791 exp
->elts
[save_pos1
+2].symbol
= symp
;
1792 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1796 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1800 /* Not C++, or no overload resolution allowed. */
1801 /* Nothing to be done; argvec already correctly set up. */
1806 /* It is probably a C-style function. */
1807 /* Nothing to be done; argvec already correctly set up. */
1812 if (noside
== EVAL_SKIP
)
1814 if (argvec
[0] == NULL
)
1815 error (_("Cannot evaluate function -- may be inlined"));
1816 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1818 /* If the return type doesn't look like a function type, call an
1819 error. This can happen if somebody tries to turn a variable into
1820 a function call. This is here because people often want to
1821 call, eg, strcmp, which gdb doesn't know is a function. If
1822 gdb isn't asked for it's opinion (ie. through "whatis"),
1823 it won't offer it. */
1825 struct type
*ftype
= value_type (argvec
[0]);
1827 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1829 /* We don't know anything about what the internal
1830 function might return, but we have to return
1832 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1835 else if (TYPE_GNU_IFUNC (ftype
))
1836 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1837 else if (TYPE_TARGET_TYPE (ftype
))
1838 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1840 error (_("Expression of type other than "
1841 "\"Function returning ...\" used as function"));
1843 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1844 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1845 argvec
[0], nargs
, argvec
+ 1);
1847 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1848 /* pai: FIXME save value from call_function_by_hand, then adjust
1849 pc by adjust_fn_pc if +ve. */
1851 case OP_F77_UNDETERMINED_ARGLIST
:
1853 /* Remember that in F77, functions, substring ops and
1854 array subscript operations cannot be disambiguated
1855 at parse time. We have made all array subscript operations,
1856 substring operations as well as function calls come here
1857 and we now have to discover what the heck this thing actually was.
1858 If it is a function, we process just as if we got an OP_FUNCALL. */
1860 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1863 /* First determine the type code we are dealing with. */
1864 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1865 type
= check_typedef (value_type (arg1
));
1866 code
= TYPE_CODE (type
);
1868 if (code
== TYPE_CODE_PTR
)
1870 /* Fortran always passes variable to subroutines as pointer.
1871 So we need to look into its target type to see if it is
1872 array, string or function. If it is, we need to switch
1873 to the target value the original one points to. */
1874 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1876 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1877 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1878 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1880 arg1
= value_ind (arg1
);
1881 type
= check_typedef (value_type (arg1
));
1882 code
= TYPE_CODE (type
);
1888 case TYPE_CODE_ARRAY
:
1889 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1890 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1892 goto multi_f77_subscript
;
1894 case TYPE_CODE_STRING
:
1895 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1896 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1899 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1900 return value_subscript (arg1
, value_as_long (arg2
));
1904 case TYPE_CODE_FUNC
:
1905 /* It's a function call. */
1906 /* Allocate arg vector, including space for the function to be
1907 called in argvec[0] and a terminating NULL. */
1908 argvec
= (struct value
**)
1909 alloca (sizeof (struct value
*) * (nargs
+ 2));
1912 for (; tem
<= nargs
; tem
++)
1913 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1914 argvec
[tem
] = 0; /* signal end of arglist */
1918 error (_("Cannot perform substring on this type"));
1922 /* We have a complex number, There should be 2 floating
1923 point numbers that compose it. */
1925 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1926 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1928 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1930 case STRUCTOP_STRUCT
:
1931 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1932 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1933 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1934 if (noside
== EVAL_SKIP
)
1936 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1937 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1938 &exp
->elts
[pc
+ 2].string
,
1943 struct value
*temp
= arg1
;
1945 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1950 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1951 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1952 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1953 if (noside
== EVAL_SKIP
)
1956 /* Check to see if operator '->' has been overloaded. If so replace
1957 arg1 with the value returned by evaluating operator->(). */
1958 while (unop_user_defined_p (op
, arg1
))
1960 volatile struct gdb_exception except
;
1961 struct value
*value
= NULL
;
1962 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1964 value
= value_x_unop (arg1
, op
, noside
);
1967 if (except
.reason
< 0)
1969 if (except
.error
== NOT_FOUND_ERROR
)
1972 throw_exception (except
);
1977 /* JYG: if print object is on we need to replace the base type
1978 with rtti type in order to continue on with successful
1979 lookup of member / method only available in the rtti type. */
1981 struct type
*type
= value_type (arg1
);
1982 struct type
*real_type
;
1983 int full
, top
, using_enc
;
1984 struct value_print_options opts
;
1986 get_user_print_options (&opts
);
1987 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1988 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1990 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1993 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1994 real_type
= lookup_pointer_type (real_type
);
1996 real_type
= lookup_reference_type (real_type
);
1998 arg1
= value_cast (real_type
, arg1
);
2003 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2004 return value_zero (lookup_struct_elt_type (value_type (arg1
),
2005 &exp
->elts
[pc
+ 2].string
,
2010 struct value
*temp
= arg1
;
2012 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
2013 NULL
, "structure pointer");
2016 case STRUCTOP_MEMBER
:
2018 if (op
== STRUCTOP_MEMBER
)
2019 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2021 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2023 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2025 if (noside
== EVAL_SKIP
)
2028 type
= check_typedef (value_type (arg2
));
2029 switch (TYPE_CODE (type
))
2031 case TYPE_CODE_METHODPTR
:
2032 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2033 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2036 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2037 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2038 return value_ind (arg2
);
2041 case TYPE_CODE_MEMBERPTR
:
2042 /* Now, convert these values to an address. */
2043 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
2046 mem_offset
= value_as_long (arg2
);
2048 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2049 value_as_long (arg1
) + mem_offset
);
2050 return value_ind (arg3
);
2053 error (_("non-pointer-to-member value used "
2054 "in pointer-to-member construct"));
2058 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2059 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2060 for (ix
= 0; ix
< nargs
; ++ix
)
2061 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
2063 expect_type
= make_params (nargs
, arg_types
);
2064 *(pos
) += 3 + nargs
;
2065 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
2066 xfree (TYPE_FIELDS (expect_type
));
2067 xfree (TYPE_MAIN_TYPE (expect_type
));
2068 xfree (expect_type
);
2072 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2073 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2074 if (noside
== EVAL_SKIP
)
2076 if (binop_user_defined_p (op
, arg1
, arg2
))
2077 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2079 return value_concat (arg1
, arg2
);
2082 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2083 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2085 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2087 if (binop_user_defined_p (op
, arg1
, arg2
))
2088 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2090 return value_assign (arg1
, arg2
);
2092 case BINOP_ASSIGN_MODIFY
:
2094 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2095 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2096 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2098 op
= exp
->elts
[pc
+ 1].opcode
;
2099 if (binop_user_defined_p (op
, arg1
, arg2
))
2100 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2101 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2103 && is_integral_type (value_type (arg2
)))
2104 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2105 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2107 && is_integral_type (value_type (arg2
)))
2108 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2111 struct value
*tmp
= arg1
;
2113 /* For shift and integer exponentiation operations,
2114 only promote the first argument. */
2115 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2116 && is_integral_type (value_type (arg2
)))
2117 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2119 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2121 arg2
= value_binop (tmp
, arg2
, op
);
2123 return value_assign (arg1
, arg2
);
2126 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2127 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2128 if (noside
== EVAL_SKIP
)
2130 if (binop_user_defined_p (op
, arg1
, arg2
))
2131 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2132 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2133 && is_integral_type (value_type (arg2
)))
2134 return value_ptradd (arg1
, value_as_long (arg2
));
2135 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2136 && is_integral_type (value_type (arg1
)))
2137 return value_ptradd (arg2
, value_as_long (arg1
));
2140 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2141 return value_binop (arg1
, arg2
, BINOP_ADD
);
2145 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2146 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2147 if (noside
== EVAL_SKIP
)
2149 if (binop_user_defined_p (op
, arg1
, arg2
))
2150 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2151 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2152 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2154 /* FIXME -- should be ptrdiff_t */
2155 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2156 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2158 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2159 && is_integral_type (value_type (arg2
)))
2160 return value_ptradd (arg1
, - value_as_long (arg2
));
2163 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2164 return value_binop (arg1
, arg2
, BINOP_SUB
);
2175 case BINOP_BITWISE_AND
:
2176 case BINOP_BITWISE_IOR
:
2177 case BINOP_BITWISE_XOR
:
2178 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2179 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2180 if (noside
== EVAL_SKIP
)
2182 if (binop_user_defined_p (op
, arg1
, arg2
))
2183 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2186 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2187 fudge arg2 to avoid division-by-zero, the caller is
2188 (theoretically) only looking for the type of the result. */
2189 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2190 /* ??? Do we really want to test for BINOP_MOD here?
2191 The implementation of value_binop gives it a well-defined
2194 || op
== BINOP_INTDIV
2197 && value_logical_not (arg2
))
2199 struct value
*v_one
, *retval
;
2201 v_one
= value_one (value_type (arg2
), not_lval
);
2202 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2203 retval
= value_binop (arg1
, v_one
, op
);
2208 /* For shift and integer exponentiation operations,
2209 only promote the first argument. */
2210 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2211 && is_integral_type (value_type (arg2
)))
2212 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2214 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2216 return value_binop (arg1
, arg2
, op
);
2221 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2222 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2223 if (noside
== EVAL_SKIP
)
2225 error (_("':' operator used in invalid context"));
2227 case BINOP_SUBSCRIPT
:
2228 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2229 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2230 if (noside
== EVAL_SKIP
)
2232 if (binop_user_defined_p (op
, arg1
, arg2
))
2233 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2236 /* If the user attempts to subscript something that is not an
2237 array or pointer type (like a plain int variable for example),
2238 then report this as an error. */
2240 arg1
= coerce_ref (arg1
);
2241 type
= check_typedef (value_type (arg1
));
2242 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2243 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2245 if (TYPE_NAME (type
))
2246 error (_("cannot subscript something of type `%s'"),
2249 error (_("cannot subscript requested type"));
2252 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2253 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2255 return value_subscript (arg1
, value_as_long (arg2
));
2259 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2260 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2261 if (noside
== EVAL_SKIP
)
2263 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2264 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2266 case MULTI_SUBSCRIPT
:
2268 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2269 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2272 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2273 /* FIXME: EVAL_SKIP handling may not be correct. */
2274 if (noside
== EVAL_SKIP
)
2285 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2286 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2288 /* If the user attempts to subscript something that has no target
2289 type (like a plain int variable for example), then report this
2292 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2295 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2301 error (_("cannot subscript something of type `%s'"),
2302 TYPE_NAME (value_type (arg1
)));
2306 if (binop_user_defined_p (op
, arg1
, arg2
))
2308 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2312 arg1
= coerce_ref (arg1
);
2313 type
= check_typedef (value_type (arg1
));
2315 switch (TYPE_CODE (type
))
2318 case TYPE_CODE_ARRAY
:
2319 case TYPE_CODE_STRING
:
2320 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2323 case TYPE_CODE_BITSTRING
:
2324 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2325 arg1
= value_bitstring_subscript (type
, arg1
,
2326 value_as_long (arg2
));
2330 if (TYPE_NAME (type
))
2331 error (_("cannot subscript something of type `%s'"),
2334 error (_("cannot subscript requested type"));
2340 multi_f77_subscript
:
2342 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2343 int ndimensions
= 1, i
;
2344 struct value
*array
= arg1
;
2346 if (nargs
> MAX_FORTRAN_DIMS
)
2347 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2349 ndimensions
= calc_f77_array_dims (type
);
2351 if (nargs
!= ndimensions
)
2352 error (_("Wrong number of subscripts"));
2354 gdb_assert (nargs
> 0);
2356 /* Now that we know we have a legal array subscript expression
2357 let us actually find out where this element exists in the array. */
2359 /* Take array indices left to right. */
2360 for (i
= 0; i
< nargs
; i
++)
2362 /* Evaluate each subscript; it must be a legal integer in F77. */
2363 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2365 /* Fill in the subscript array. */
2367 subscript_array
[i
] = value_as_long (arg2
);
2370 /* Internal type of array is arranged right to left. */
2371 for (i
= nargs
; i
> 0; i
--)
2373 struct type
*array_type
= check_typedef (value_type (array
));
2374 LONGEST index
= subscript_array
[i
- 1];
2376 lower
= f77_get_lowerbound (array_type
);
2377 array
= value_subscripted_rvalue (array
, index
, lower
);
2383 case BINOP_LOGICAL_AND
:
2384 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2385 if (noside
== EVAL_SKIP
)
2387 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2392 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2395 if (binop_user_defined_p (op
, arg1
, arg2
))
2397 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2398 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2402 tem
= value_logical_not (arg1
);
2403 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2404 (tem
? EVAL_SKIP
: noside
));
2405 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2406 return value_from_longest (type
,
2407 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2410 case BINOP_LOGICAL_OR
:
2411 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2412 if (noside
== EVAL_SKIP
)
2414 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2419 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2422 if (binop_user_defined_p (op
, arg1
, arg2
))
2424 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2425 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2429 tem
= value_logical_not (arg1
);
2430 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2431 (!tem
? EVAL_SKIP
: noside
));
2432 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2433 return value_from_longest (type
,
2434 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2438 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2439 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2440 if (noside
== EVAL_SKIP
)
2442 if (binop_user_defined_p (op
, arg1
, arg2
))
2444 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2448 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2449 tem
= value_equal (arg1
, arg2
);
2450 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2451 return value_from_longest (type
, (LONGEST
) tem
);
2454 case BINOP_NOTEQUAL
:
2455 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2456 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2457 if (noside
== EVAL_SKIP
)
2459 if (binop_user_defined_p (op
, arg1
, arg2
))
2461 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2465 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2466 tem
= value_equal (arg1
, arg2
);
2467 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2468 return value_from_longest (type
, (LONGEST
) ! tem
);
2472 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2473 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2474 if (noside
== EVAL_SKIP
)
2476 if (binop_user_defined_p (op
, arg1
, arg2
))
2478 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2482 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2483 tem
= value_less (arg1
, arg2
);
2484 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2485 return value_from_longest (type
, (LONGEST
) tem
);
2489 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2490 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2491 if (noside
== EVAL_SKIP
)
2493 if (binop_user_defined_p (op
, arg1
, arg2
))
2495 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2499 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2500 tem
= value_less (arg2
, arg1
);
2501 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2502 return value_from_longest (type
, (LONGEST
) tem
);
2506 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2507 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2508 if (noside
== EVAL_SKIP
)
2510 if (binop_user_defined_p (op
, arg1
, arg2
))
2512 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2516 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2517 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2518 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2519 return value_from_longest (type
, (LONGEST
) tem
);
2523 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2524 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2525 if (noside
== EVAL_SKIP
)
2527 if (binop_user_defined_p (op
, arg1
, arg2
))
2529 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2533 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2534 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2535 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2536 return value_from_longest (type
, (LONGEST
) tem
);
2540 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2541 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2542 if (noside
== EVAL_SKIP
)
2544 type
= check_typedef (value_type (arg2
));
2545 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2546 error (_("Non-integral right operand for \"@\" operator."));
2547 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2549 return allocate_repeat_value (value_type (arg1
),
2550 longest_to_int (value_as_long (arg2
)));
2553 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2556 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2557 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2560 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2561 if (noside
== EVAL_SKIP
)
2563 if (unop_user_defined_p (op
, arg1
))
2564 return value_x_unop (arg1
, op
, noside
);
2567 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2568 return value_pos (arg1
);
2572 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2573 if (noside
== EVAL_SKIP
)
2575 if (unop_user_defined_p (op
, arg1
))
2576 return value_x_unop (arg1
, op
, noside
);
2579 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2580 return value_neg (arg1
);
2583 case UNOP_COMPLEMENT
:
2584 /* C++: check for and handle destructor names. */
2585 op
= exp
->elts
[*pos
].opcode
;
2587 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2588 if (noside
== EVAL_SKIP
)
2590 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2591 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2594 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2595 return value_complement (arg1
);
2598 case UNOP_LOGICAL_NOT
:
2599 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2600 if (noside
== EVAL_SKIP
)
2602 if (unop_user_defined_p (op
, arg1
))
2603 return value_x_unop (arg1
, op
, noside
);
2606 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2607 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2611 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2612 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2613 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2614 type
= check_typedef (value_type (arg1
));
2615 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2616 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2617 error (_("Attempt to dereference pointer "
2618 "to member without an object"));
2619 if (noside
== EVAL_SKIP
)
2621 if (unop_user_defined_p (op
, arg1
))
2622 return value_x_unop (arg1
, op
, noside
);
2623 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2625 type
= check_typedef (value_type (arg1
));
2626 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2627 || TYPE_CODE (type
) == TYPE_CODE_REF
2628 /* In C you can dereference an array to get the 1st elt. */
2629 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2631 return value_zero (TYPE_TARGET_TYPE (type
),
2633 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2634 /* GDB allows dereferencing an int. */
2635 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2638 error (_("Attempt to take contents of a non-pointer value."));
2641 /* Allow * on an integer so we can cast it to whatever we want.
2642 This returns an int, which seems like the most C-like thing to
2643 do. "long long" variables are rare enough that
2644 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2645 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2646 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2647 (CORE_ADDR
) value_as_address (arg1
));
2648 return value_ind (arg1
);
2651 /* C++: check for and handle pointer to members. */
2653 op
= exp
->elts
[*pos
].opcode
;
2655 if (noside
== EVAL_SKIP
)
2657 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2662 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2669 if (noside
== EVAL_SKIP
)
2671 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2674 return evaluate_subexp_for_sizeof (exp
, pos
);
2678 type
= exp
->elts
[pc
+ 1].type
;
2679 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2680 if (noside
== EVAL_SKIP
)
2682 if (type
!= value_type (arg1
))
2683 arg1
= value_cast (type
, arg1
);
2686 case UNOP_DYNAMIC_CAST
:
2688 type
= exp
->elts
[pc
+ 1].type
;
2689 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2690 if (noside
== EVAL_SKIP
)
2692 return value_dynamic_cast (type
, arg1
);
2694 case UNOP_REINTERPRET_CAST
:
2696 type
= exp
->elts
[pc
+ 1].type
;
2697 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2698 if (noside
== EVAL_SKIP
)
2700 return value_reinterpret_cast (type
, arg1
);
2704 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2705 if (noside
== EVAL_SKIP
)
2707 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2708 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2710 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2711 value_as_address (arg1
));
2713 case UNOP_MEMVAL_TLS
:
2715 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2716 if (noside
== EVAL_SKIP
)
2718 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2719 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2724 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2725 value_as_address (arg1
));
2726 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2729 case UNOP_PREINCREMENT
:
2730 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2731 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2733 else if (unop_user_defined_p (op
, arg1
))
2735 return value_x_unop (arg1
, op
, noside
);
2739 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2740 arg2
= value_ptradd (arg1
, 1);
2743 struct value
*tmp
= arg1
;
2745 arg2
= value_one (value_type (arg1
), not_lval
);
2746 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2747 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2750 return value_assign (arg1
, arg2
);
2753 case UNOP_PREDECREMENT
:
2754 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2755 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2757 else if (unop_user_defined_p (op
, arg1
))
2759 return value_x_unop (arg1
, op
, noside
);
2763 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2764 arg2
= value_ptradd (arg1
, -1);
2767 struct value
*tmp
= arg1
;
2769 arg2
= value_one (value_type (arg1
), not_lval
);
2770 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2771 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2774 return value_assign (arg1
, arg2
);
2777 case UNOP_POSTINCREMENT
:
2778 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2779 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2781 else if (unop_user_defined_p (op
, arg1
))
2783 return value_x_unop (arg1
, op
, noside
);
2787 arg3
= value_non_lval (arg1
);
2789 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2790 arg2
= value_ptradd (arg1
, 1);
2793 struct value
*tmp
= arg1
;
2795 arg2
= value_one (value_type (arg1
), not_lval
);
2796 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2797 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2800 value_assign (arg1
, arg2
);
2804 case UNOP_POSTDECREMENT
:
2805 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2806 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2808 else if (unop_user_defined_p (op
, arg1
))
2810 return value_x_unop (arg1
, op
, noside
);
2814 arg3
= value_non_lval (arg1
);
2816 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2817 arg2
= value_ptradd (arg1
, -1);
2820 struct value
*tmp
= arg1
;
2822 arg2
= value_one (value_type (arg1
), not_lval
);
2823 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2824 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2827 value_assign (arg1
, arg2
);
2833 return value_of_this (exp
->language_defn
, 1);
2836 /* The value is not supposed to be used. This is here to make it
2837 easier to accommodate expressions that contain types. */
2839 if (noside
== EVAL_SKIP
)
2841 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2843 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2845 /* If this is a typedef, then find its immediate target. We
2846 use check_typedef to resolve stubs, but we ignore its
2847 result because we do not want to dig past all
2849 check_typedef (type
);
2850 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2851 type
= TYPE_TARGET_TYPE (type
);
2852 return allocate_value (type
);
2855 error (_("Attempt to use a type name as an expression"));
2858 /* Removing this case and compiling with gcc -Wall reveals that
2859 a lot of cases are hitting this case. Some of these should
2860 probably be removed from expression.h; others are legitimate
2861 expressions which are (apparently) not fully implemented.
2863 If there are any cases landing here which mean a user error,
2864 then they should be separate cases, with more descriptive
2867 error (_("GDB does not (yet) know how to "
2868 "evaluate that kind of expression"));
2872 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2875 /* Evaluate a subexpression of EXP, at index *POS,
2876 and return the address of that subexpression.
2877 Advance *POS over the subexpression.
2878 If the subexpression isn't an lvalue, get an error.
2879 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2880 then only the type of the result need be correct. */
2882 static struct value
*
2883 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2893 op
= exp
->elts
[pc
].opcode
;
2899 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2901 /* We can't optimize out "&*" if there's a user-defined operator*. */
2902 if (unop_user_defined_p (op
, x
))
2904 x
= value_x_unop (x
, op
, noside
);
2905 goto default_case_after_eval
;
2908 return coerce_array (x
);
2912 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2913 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2916 var
= exp
->elts
[pc
+ 2].symbol
;
2918 /* C++: The "address" of a reference should yield the address
2919 * of the object pointed to. Let value_addr() deal with it. */
2920 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2924 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2927 lookup_pointer_type (SYMBOL_TYPE (var
));
2928 enum address_class sym_class
= SYMBOL_CLASS (var
);
2930 if (sym_class
== LOC_CONST
2931 || sym_class
== LOC_CONST_BYTES
2932 || sym_class
== LOC_REGISTER
)
2933 error (_("Attempt to take address of register or constant."));
2936 value_zero (type
, not_lval
);
2939 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2942 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2943 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2944 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2945 &exp
->elts
[pc
+ 3].string
,
2948 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2953 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2954 default_case_after_eval
:
2955 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2957 struct type
*type
= check_typedef (value_type (x
));
2959 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2960 return value_zero (lookup_pointer_type (value_type (x
)),
2962 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2963 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2966 error (_("Attempt to take address of "
2967 "value not located in memory."));
2969 return value_addr (x
);
2973 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2974 When used in contexts where arrays will be coerced anyway, this is
2975 equivalent to `evaluate_subexp' but much faster because it avoids
2976 actually fetching array contents (perhaps obsolete now that we have
2979 Note that we currently only do the coercion for C expressions, where
2980 arrays are zero based and the coercion is correct. For other languages,
2981 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2982 to decide if coercion is appropriate. */
2985 evaluate_subexp_with_coercion (struct expression
*exp
,
2986 int *pos
, enum noside noside
)
2995 op
= exp
->elts
[pc
].opcode
;
3000 var
= exp
->elts
[pc
+ 2].symbol
;
3001 type
= check_typedef (SYMBOL_TYPE (var
));
3002 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3003 && !TYPE_VECTOR (type
)
3004 && CAST_IS_CONVERSION (exp
->language_defn
))
3007 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3008 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3014 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3018 /* Evaluate a subexpression of EXP, at index *POS,
3019 and return a value for the size of that subexpression.
3020 Advance *POS over the subexpression. */
3022 static struct value
*
3023 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
3025 /* FIXME: This should be size_t. */
3026 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3033 op
= exp
->elts
[pc
].opcode
;
3037 /* This case is handled specially
3038 so that we avoid creating a value for the result type.
3039 If the result type is very big, it's desirable not to
3040 create a value unnecessarily. */
3043 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3044 type
= check_typedef (value_type (val
));
3045 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3046 && TYPE_CODE (type
) != TYPE_CODE_REF
3047 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3048 error (_("Attempt to take contents of a non-pointer value."));
3049 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3050 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3054 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3055 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3059 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3061 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3064 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3065 return value_from_longest (size_type
,
3066 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3070 /* Parse a type expression in the string [P..P+LENGTH). */
3073 parse_and_eval_type (char *p
, int length
)
3075 char *tmp
= (char *) alloca (length
+ 4);
3076 struct expression
*expr
;
3079 memcpy (tmp
+ 1, p
, length
);
3080 tmp
[length
+ 1] = ')';
3081 tmp
[length
+ 2] = '0';
3082 tmp
[length
+ 3] = '\0';
3083 expr
= parse_expression (tmp
);
3084 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3085 error (_("Internal error in eval_type."));
3086 return expr
->elts
[1].type
;
3090 calc_f77_array_dims (struct type
*array_type
)
3093 struct type
*tmp_type
;
3095 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3096 error (_("Can't get dimensions for a non-array type"));
3098 tmp_type
= array_type
;
3100 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3102 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)