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
);
863 case OP_VAR_ENTRY_VALUE
:
865 if (noside
== EVAL_SKIP
)
869 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
870 struct frame_info
*frame
;
872 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
873 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
875 if (SYMBOL_CLASS (sym
) != LOC_COMPUTED
876 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
877 error (_("Symbol \"%s\" does not have any specific entry value"),
878 SYMBOL_PRINT_NAME (sym
));
880 frame
= get_selected_frame (NULL
);
881 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
887 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
891 const char *name
= &exp
->elts
[pc
+ 2].string
;
895 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
896 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
897 name
, strlen (name
));
899 error (_("Register $%s not available."), name
);
901 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
902 a value with the appropriate register type. Unfortunately,
903 we don't have easy access to the type of user registers.
904 So for these registers, we fetch the register value regardless
905 of the evaluation mode. */
906 if (noside
== EVAL_AVOID_SIDE_EFFECTS
907 && regno
< gdbarch_num_regs (exp
->gdbarch
)
908 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
909 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
911 val
= value_of_register (regno
, get_selected_frame (NULL
));
913 error (_("Value of register %s not available."), name
);
919 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
920 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
924 return value_of_internalvar (exp
->gdbarch
,
925 exp
->elts
[pc
+ 1].internalvar
);
928 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
929 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
930 if (noside
== EVAL_SKIP
)
932 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
933 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
935 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
936 NSString constant. */
937 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
938 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
939 if (noside
== EVAL_SKIP
)
943 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
946 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
948 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
949 if (noside
== EVAL_SKIP
)
951 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
,
952 builtin_type (exp
->gdbarch
)->builtin_int
);
957 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
958 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
959 nargs
= tem3
- tem2
+ 1;
960 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
962 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
963 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
965 struct value
*rec
= allocate_value (expect_type
);
967 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
968 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
971 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
972 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
974 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
975 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
976 struct value
*array
= allocate_value (expect_type
);
977 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
978 LONGEST low_bound
, high_bound
, index
;
980 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
983 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
986 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
987 for (tem
= nargs
; --nargs
>= 0;)
989 struct value
*element
;
992 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
995 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
997 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
998 if (value_type (element
) != element_type
)
999 element
= value_cast (element_type
, element
);
1002 int continue_pc
= *pos
;
1005 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1006 low_bound
, high_bound
);
1011 if (index
> high_bound
)
1012 /* To avoid memory corruption. */
1013 error (_("Too many array elements"));
1014 memcpy (value_contents_raw (array
)
1015 + (index
- low_bound
) * element_size
,
1016 value_contents (element
),
1024 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1025 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1027 struct value
*set
= allocate_value (expect_type
);
1028 gdb_byte
*valaddr
= value_contents_raw (set
);
1029 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1030 struct type
*check_type
= element_type
;
1031 LONGEST low_bound
, high_bound
;
1033 /* Get targettype of elementtype. */
1034 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1035 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1036 check_type
= TYPE_TARGET_TYPE (check_type
);
1038 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1039 error (_("(power)set type with unknown size"));
1040 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1041 for (tem
= 0; tem
< nargs
; tem
++)
1043 LONGEST range_low
, range_high
;
1044 struct type
*range_low_type
, *range_high_type
;
1045 struct value
*elem_val
;
1047 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1050 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1051 range_low_type
= value_type (elem_val
);
1052 range_low
= value_as_long (elem_val
);
1053 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1054 range_high_type
= value_type (elem_val
);
1055 range_high
= value_as_long (elem_val
);
1059 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1060 range_low_type
= range_high_type
= value_type (elem_val
);
1061 range_low
= range_high
= value_as_long (elem_val
);
1063 /* Check types of elements to avoid mixture of elements from
1064 different types. Also check if type of element is "compatible"
1065 with element type of powerset. */
1066 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1067 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1068 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1069 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1070 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1071 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1072 && (range_low_type
!= range_high_type
)))
1073 /* different element modes. */
1074 error (_("POWERSET tuple elements of different mode"));
1075 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1076 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1077 && range_low_type
!= check_type
))
1078 error (_("incompatible POWERSET tuple elements"));
1079 if (range_low
> range_high
)
1081 warning (_("empty POWERSET tuple range"));
1084 if (range_low
< low_bound
|| range_high
> high_bound
)
1085 error (_("POWERSET tuple element out of range"));
1086 range_low
-= low_bound
;
1087 range_high
-= low_bound
;
1088 for (; range_low
<= range_high
; range_low
++)
1090 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1092 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1093 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1094 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1101 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1102 for (tem
= 0; tem
< nargs
; tem
++)
1104 /* Ensure that array expressions are coerced into pointer
1106 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1108 if (noside
== EVAL_SKIP
)
1110 return value_array (tem2
, tem3
, argvec
);
1114 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1116 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1118 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1120 if (noside
== EVAL_SKIP
)
1122 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1125 case TERNOP_SLICE_COUNT
:
1127 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1129 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1131 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1133 return value_slice (array
, lowbound
, length
);
1137 /* Skip third and second args to evaluate the first one. */
1138 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1139 if (value_logical_not (arg1
))
1141 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1142 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1146 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1147 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1151 case OP_OBJC_SELECTOR
:
1152 { /* Objective C @selector operator. */
1153 char *sel
= &exp
->elts
[pc
+ 2].string
;
1154 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1155 struct type
*selector_type
;
1157 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1158 if (noside
== EVAL_SKIP
)
1162 sel
[len
] = 0; /* Make sure it's terminated. */
1164 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1165 return value_from_longest (selector_type
,
1166 lookup_child_selector (exp
->gdbarch
, sel
));
1169 case OP_OBJC_MSGCALL
:
1170 { /* Objective C message (method) call. */
1172 CORE_ADDR responds_selector
= 0;
1173 CORE_ADDR method_selector
= 0;
1175 CORE_ADDR selector
= 0;
1177 int struct_return
= 0;
1178 int sub_no_side
= 0;
1180 struct value
*msg_send
= NULL
;
1181 struct value
*msg_send_stret
= NULL
;
1182 int gnu_runtime
= 0;
1184 struct value
*target
= NULL
;
1185 struct value
*method
= NULL
;
1186 struct value
*called_method
= NULL
;
1188 struct type
*selector_type
= NULL
;
1189 struct type
*long_type
;
1191 struct value
*ret
= NULL
;
1194 selector
= exp
->elts
[pc
+ 1].longconst
;
1195 nargs
= exp
->elts
[pc
+ 2].longconst
;
1196 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1201 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1202 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1204 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1205 sub_no_side
= EVAL_NORMAL
;
1207 sub_no_side
= noside
;
1209 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1211 if (value_as_long (target
) == 0)
1212 return value_from_longest (long_type
, 0);
1214 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1217 /* Find the method dispatch (Apple runtime) or method lookup
1218 (GNU runtime) function for Objective-C. These will be used
1219 to lookup the symbol information for the method. If we
1220 can't find any symbol information, then we'll use these to
1221 call the method, otherwise we can call the method
1222 directly. The msg_send_stret function is used in the special
1223 case of a method that returns a structure (Apple runtime
1227 struct type
*type
= selector_type
;
1229 type
= lookup_function_type (type
);
1230 type
= lookup_pointer_type (type
);
1231 type
= lookup_function_type (type
);
1232 type
= lookup_pointer_type (type
);
1234 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1236 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1238 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1239 msg_send_stret
= value_from_pointer (type
,
1240 value_as_address (msg_send_stret
));
1244 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1245 /* Special dispatcher for methods returning structs. */
1247 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1250 /* Verify the target object responds to this method. The
1251 standard top-level 'Object' class uses a different name for
1252 the verification method than the non-standard, but more
1253 often used, 'NSObject' class. Make sure we check for both. */
1256 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1257 if (responds_selector
== 0)
1259 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1261 if (responds_selector
== 0)
1262 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1265 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1266 if (method_selector
== 0)
1268 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1270 if (method_selector
== 0)
1271 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1273 /* Call the verification method, to make sure that the target
1274 class implements the desired method. */
1276 argvec
[0] = msg_send
;
1278 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1279 argvec
[3] = value_from_longest (long_type
, selector
);
1282 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1285 /* Function objc_msg_lookup returns a pointer. */
1287 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1289 if (value_as_long (ret
) == 0)
1290 error (_("Target does not respond to this message selector."));
1292 /* Call "methodForSelector:" method, to get the address of a
1293 function method that implements this selector for this
1294 class. If we can find a symbol at that address, then we
1295 know the return type, parameter types etc. (that's a good
1298 argvec
[0] = msg_send
;
1300 argvec
[2] = value_from_longest (long_type
, method_selector
);
1301 argvec
[3] = value_from_longest (long_type
, selector
);
1304 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1308 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1311 /* ret should now be the selector. */
1313 addr
= value_as_long (ret
);
1316 struct symbol
*sym
= NULL
;
1318 /* The address might point to a function descriptor;
1319 resolve it to the actual code address instead. */
1320 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1323 /* Is it a high_level symbol? */
1324 sym
= find_pc_function (addr
);
1326 method
= value_of_variable (sym
, 0);
1329 /* If we found a method with symbol information, check to see
1330 if it returns a struct. Otherwise assume it doesn't. */
1335 struct type
*val_type
;
1337 funaddr
= find_function_addr (method
, &val_type
);
1339 block_for_pc (funaddr
);
1341 CHECK_TYPEDEF (val_type
);
1343 if ((val_type
== NULL
)
1344 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1346 if (expect_type
!= NULL
)
1347 val_type
= expect_type
;
1350 struct_return
= using_struct_return (exp
->gdbarch
,
1351 value_type (method
),
1354 else if (expect_type
!= NULL
)
1356 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1357 check_typedef (expect_type
));
1360 /* Found a function symbol. Now we will substitute its
1361 value in place of the message dispatcher (obj_msgSend),
1362 so that we call the method directly instead of thru
1363 the dispatcher. The main reason for doing this is that
1364 we can now evaluate the return value and parameter values
1365 according to their known data types, in case we need to
1366 do things like promotion, dereferencing, special handling
1367 of structs and doubles, etc.
1369 We want to use the type signature of 'method', but still
1370 jump to objc_msgSend() or objc_msgSend_stret() to better
1371 mimic the behavior of the runtime. */
1375 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1376 error (_("method address has symbol information "
1377 "with non-function type; skipping"));
1379 /* Create a function pointer of the appropriate type, and
1380 replace its value with the value of msg_send or
1381 msg_send_stret. We must use a pointer here, as
1382 msg_send and msg_send_stret are of pointer type, and
1383 the representation may be different on systems that use
1384 function descriptors. */
1387 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1388 value_as_address (msg_send_stret
));
1391 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1392 value_as_address (msg_send
));
1397 called_method
= msg_send_stret
;
1399 called_method
= msg_send
;
1402 if (noside
== EVAL_SKIP
)
1405 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1407 /* If the return type doesn't look like a function type,
1408 call an error. This can happen if somebody tries to
1409 turn a variable into a function call. This is here
1410 because people often want to call, eg, strcmp, which
1411 gdb doesn't know is a function. If gdb isn't asked for
1412 it's opinion (ie. through "whatis"), it won't offer
1415 struct type
*type
= value_type (called_method
);
1417 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1418 type
= TYPE_TARGET_TYPE (type
);
1419 type
= TYPE_TARGET_TYPE (type
);
1423 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1424 return allocate_value (expect_type
);
1426 return allocate_value (type
);
1429 error (_("Expression of type other than "
1430 "\"method returning ...\" used as a method"));
1433 /* Now depending on whether we found a symbol for the method,
1434 we will either call the runtime dispatcher or the method
1437 argvec
[0] = called_method
;
1439 argvec
[2] = value_from_longest (long_type
, selector
);
1440 /* User-supplied arguments. */
1441 for (tem
= 0; tem
< nargs
; tem
++)
1442 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1443 argvec
[tem
+ 3] = 0;
1445 if (gnu_runtime
&& (method
!= NULL
))
1447 /* Function objc_msg_lookup returns a pointer. */
1448 deprecated_set_value_type (argvec
[0],
1449 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1451 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1454 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1461 op
= exp
->elts
[*pos
].opcode
;
1462 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1463 /* Allocate arg vector, including space for the function to be
1464 called in argvec[0] and a terminating NULL. */
1465 argvec
= (struct value
**)
1466 alloca (sizeof (struct value
*) * (nargs
+ 3));
1467 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1470 /* First, evaluate the structure into arg2. */
1473 if (noside
== EVAL_SKIP
)
1476 if (op
== STRUCTOP_MEMBER
)
1478 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1482 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1485 /* If the function is a virtual function, then the
1486 aggregate value (providing the structure) plays
1487 its part by providing the vtable. Otherwise,
1488 it is just along for the ride: call the function
1491 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1493 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1494 != TYPE_CODE_METHODPTR
)
1495 error (_("Non-pointer-to-member value used in pointer-to-member "
1498 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1500 struct type
*method_type
= check_typedef (value_type (arg1
));
1502 arg1
= value_zero (method_type
, not_lval
);
1505 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1507 /* Now, say which argument to start evaluating from. */
1510 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1512 /* Hair for method invocations. */
1516 /* First, evaluate the structure into arg2. */
1518 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1519 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1520 if (noside
== EVAL_SKIP
)
1523 if (op
== STRUCTOP_STRUCT
)
1525 /* If v is a variable in a register, and the user types
1526 v.method (), this will produce an error, because v has
1529 A possible way around this would be to allocate a
1530 copy of the variable on the stack, copy in the
1531 contents, call the function, and copy out the
1532 contents. I.e. convert this from call by reference
1533 to call by copy-return (or whatever it's called).
1534 However, this does not work because it is not the
1535 same: the method being called could stash a copy of
1536 the address, and then future uses through that address
1537 (after the method returns) would be expected to
1538 use the variable itself, not some copy of it. */
1539 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1543 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1545 /* Check to see if the operator '->' has been
1546 overloaded. If the operator has been overloaded
1547 replace arg2 with the value returned by the custom
1548 operator and continue evaluation. */
1549 while (unop_user_defined_p (op
, arg2
))
1551 volatile struct gdb_exception except
;
1552 struct value
*value
= NULL
;
1553 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1555 value
= value_x_unop (arg2
, op
, noside
);
1558 if (except
.reason
< 0)
1560 if (except
.error
== NOT_FOUND_ERROR
)
1563 throw_exception (except
);
1568 /* Now, say which argument to start evaluating from. */
1571 else if (op
== OP_SCOPE
1572 && overload_resolution
1573 && (exp
->language_defn
->la_language
== language_cplus
))
1575 /* Unpack it locally so we can properly handle overload
1581 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1582 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1583 type
= exp
->elts
[pc2
+ 1].type
;
1584 name
= &exp
->elts
[pc2
+ 3].string
;
1587 function_name
= NULL
;
1588 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1590 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1592 get_selected_block (0),
1594 if (function
== NULL
)
1595 error (_("No symbol \"%s\" in namespace \"%s\"."),
1596 name
, TYPE_TAG_NAME (type
));
1602 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1603 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1604 function_name
= name
;
1606 arg2
= value_zero (type
, lval_memory
);
1611 else if (op
== OP_ADL_FUNC
)
1613 /* Save the function position and move pos so that the arguments
1614 can be evaluated. */
1620 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1621 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1625 /* Non-method function call. */
1629 /* If this is a C++ function wait until overload resolution. */
1630 if (op
== OP_VAR_VALUE
1631 && overload_resolution
1632 && (exp
->language_defn
->la_language
== language_cplus
))
1634 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1639 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1640 type
= value_type (argvec
[0]);
1641 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1642 type
= TYPE_TARGET_TYPE (type
);
1643 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1645 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1647 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1655 /* Evaluate arguments. */
1656 for (; tem
<= nargs
; tem
++)
1658 /* Ensure that array expressions are coerced into pointer
1660 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1663 /* Signal end of arglist. */
1665 if (op
== OP_ADL_FUNC
)
1667 struct symbol
*symp
;
1670 int string_pc
= save_pos1
+ 3;
1672 /* Extract the function name. */
1673 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1674 func_name
= (char *) alloca (name_len
+ 1);
1675 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1677 /* Prepare list of argument types for overload resolution. */
1678 arg_types
= (struct type
**)
1679 alloca (nargs
* (sizeof (struct type
*)));
1680 for (ix
= 1; ix
<= nargs
; ix
++)
1681 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1683 find_overload_match (arg_types
, nargs
, func_name
,
1684 NON_METHOD
, /* not method */
1685 0, /* strict match */
1686 NULL
, NULL
, /* pass NULL symbol since
1687 symbol is unknown */
1688 NULL
, &symp
, NULL
, 0);
1690 /* Now fix the expression being evaluated. */
1691 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1692 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1695 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1696 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1698 int static_memfuncp
;
1701 /* Method invocation : stuff "this" as first parameter. */
1706 /* Name of method from expression. */
1707 tstr
= &exp
->elts
[pc2
+ 2].string
;
1710 tstr
= function_name
;
1712 if (overload_resolution
&& (exp
->language_defn
->la_language
1715 /* Language is C++, do some overload resolution before
1717 struct value
*valp
= NULL
;
1719 /* Prepare list of argument types for overload resolution. */
1720 arg_types
= (struct type
**)
1721 alloca (nargs
* (sizeof (struct type
*)));
1722 for (ix
= 1; ix
<= nargs
; ix
++)
1723 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1725 (void) find_overload_match (arg_types
, nargs
, tstr
,
1726 METHOD
, /* method */
1727 0, /* strict match */
1728 &arg2
, /* the object */
1730 &static_memfuncp
, 0);
1732 if (op
== OP_SCOPE
&& !static_memfuncp
)
1734 /* For the time being, we don't handle this. */
1735 error (_("Call to overloaded function %s requires "
1739 argvec
[1] = arg2
; /* the ``this'' pointer */
1740 argvec
[0] = valp
; /* Use the method found after overload
1744 /* Non-C++ case -- or no overload resolution. */
1746 struct value
*temp
= arg2
;
1748 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1750 op
== STRUCTOP_STRUCT
1751 ? "structure" : "structure pointer");
1752 /* value_struct_elt updates temp with the correct value
1753 of the ``this'' pointer if necessary, so modify argvec[1] to
1754 reflect any ``this'' changes. */
1756 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1757 value_address (temp
)
1758 + value_embedded_offset (temp
));
1759 argvec
[1] = arg2
; /* the ``this'' pointer */
1762 if (static_memfuncp
)
1764 argvec
[1] = argvec
[0];
1769 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1774 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1776 /* Non-member function being called. */
1777 /* fn: This can only be done for C++ functions. A C-style function
1778 in a C++ program, for instance, does not have the fields that
1779 are expected here. */
1781 if (overload_resolution
&& (exp
->language_defn
->la_language
1784 /* Language is C++, do some overload resolution before
1786 struct symbol
*symp
;
1789 /* If a scope has been specified disable ADL. */
1793 if (op
== OP_VAR_VALUE
)
1794 function
= exp
->elts
[save_pos1
+2].symbol
;
1796 /* Prepare list of argument types for overload resolution. */
1797 arg_types
= (struct type
**)
1798 alloca (nargs
* (sizeof (struct type
*)));
1799 for (ix
= 1; ix
<= nargs
; ix
++)
1800 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1802 (void) find_overload_match (arg_types
, nargs
,
1803 NULL
, /* no need for name */
1804 NON_METHOD
, /* not method */
1805 0, /* strict match */
1806 NULL
, function
, /* the function */
1807 NULL
, &symp
, NULL
, no_adl
);
1809 if (op
== OP_VAR_VALUE
)
1811 /* Now fix the expression being evaluated. */
1812 exp
->elts
[save_pos1
+2].symbol
= symp
;
1813 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1817 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1821 /* Not C++, or no overload resolution allowed. */
1822 /* Nothing to be done; argvec already correctly set up. */
1827 /* It is probably a C-style function. */
1828 /* Nothing to be done; argvec already correctly set up. */
1833 if (noside
== EVAL_SKIP
)
1835 if (argvec
[0] == NULL
)
1836 error (_("Cannot evaluate function -- may be inlined"));
1837 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1839 /* If the return type doesn't look like a function type, call an
1840 error. This can happen if somebody tries to turn a variable into
1841 a function call. This is here because people often want to
1842 call, eg, strcmp, which gdb doesn't know is a function. If
1843 gdb isn't asked for it's opinion (ie. through "whatis"),
1844 it won't offer it. */
1846 struct type
*ftype
= value_type (argvec
[0]);
1848 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1850 /* We don't know anything about what the internal
1851 function might return, but we have to return
1853 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1856 else if (TYPE_GNU_IFUNC (ftype
))
1857 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1858 else if (TYPE_TARGET_TYPE (ftype
))
1859 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1861 error (_("Expression of type other than "
1862 "\"Function returning ...\" used as function"));
1864 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1865 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1866 argvec
[0], nargs
, argvec
+ 1);
1868 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1869 /* pai: FIXME save value from call_function_by_hand, then adjust
1870 pc by adjust_fn_pc if +ve. */
1872 case OP_F77_UNDETERMINED_ARGLIST
:
1874 /* Remember that in F77, functions, substring ops and
1875 array subscript operations cannot be disambiguated
1876 at parse time. We have made all array subscript operations,
1877 substring operations as well as function calls come here
1878 and we now have to discover what the heck this thing actually was.
1879 If it is a function, we process just as if we got an OP_FUNCALL. */
1881 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1884 /* First determine the type code we are dealing with. */
1885 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1886 type
= check_typedef (value_type (arg1
));
1887 code
= TYPE_CODE (type
);
1889 if (code
== TYPE_CODE_PTR
)
1891 /* Fortran always passes variable to subroutines as pointer.
1892 So we need to look into its target type to see if it is
1893 array, string or function. If it is, we need to switch
1894 to the target value the original one points to. */
1895 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1897 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1898 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1899 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1901 arg1
= value_ind (arg1
);
1902 type
= check_typedef (value_type (arg1
));
1903 code
= TYPE_CODE (type
);
1909 case TYPE_CODE_ARRAY
:
1910 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1911 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1913 goto multi_f77_subscript
;
1915 case TYPE_CODE_STRING
:
1916 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1917 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1920 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1921 return value_subscript (arg1
, value_as_long (arg2
));
1925 case TYPE_CODE_FUNC
:
1926 /* It's a function call. */
1927 /* Allocate arg vector, including space for the function to be
1928 called in argvec[0] and a terminating NULL. */
1929 argvec
= (struct value
**)
1930 alloca (sizeof (struct value
*) * (nargs
+ 2));
1933 for (; tem
<= nargs
; tem
++)
1934 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1935 argvec
[tem
] = 0; /* signal end of arglist */
1939 error (_("Cannot perform substring on this type"));
1943 /* We have a complex number, There should be 2 floating
1944 point numbers that compose it. */
1946 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1947 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1949 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1951 case STRUCTOP_STRUCT
:
1952 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1953 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1954 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1955 if (noside
== EVAL_SKIP
)
1957 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1958 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1959 &exp
->elts
[pc
+ 2].string
,
1964 struct value
*temp
= arg1
;
1966 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1971 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1972 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1973 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1974 if (noside
== EVAL_SKIP
)
1977 /* Check to see if operator '->' has been overloaded. If so replace
1978 arg1 with the value returned by evaluating operator->(). */
1979 while (unop_user_defined_p (op
, arg1
))
1981 volatile struct gdb_exception except
;
1982 struct value
*value
= NULL
;
1983 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1985 value
= value_x_unop (arg1
, op
, noside
);
1988 if (except
.reason
< 0)
1990 if (except
.error
== NOT_FOUND_ERROR
)
1993 throw_exception (except
);
1998 /* JYG: if print object is on we need to replace the base type
1999 with rtti type in order to continue on with successful
2000 lookup of member / method only available in the rtti type. */
2002 struct type
*type
= value_type (arg1
);
2003 struct type
*real_type
;
2004 int full
, top
, using_enc
;
2005 struct value_print_options opts
;
2007 get_user_print_options (&opts
);
2008 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
2009 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
2011 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
2014 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
2015 real_type
= lookup_pointer_type (real_type
);
2017 real_type
= lookup_reference_type (real_type
);
2019 arg1
= value_cast (real_type
, arg1
);
2024 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2025 return value_zero (lookup_struct_elt_type (value_type (arg1
),
2026 &exp
->elts
[pc
+ 2].string
,
2031 struct value
*temp
= arg1
;
2033 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
2034 NULL
, "structure pointer");
2037 case STRUCTOP_MEMBER
:
2039 if (op
== STRUCTOP_MEMBER
)
2040 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2042 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2044 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2046 if (noside
== EVAL_SKIP
)
2049 type
= check_typedef (value_type (arg2
));
2050 switch (TYPE_CODE (type
))
2052 case TYPE_CODE_METHODPTR
:
2053 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2054 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2057 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2058 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2059 return value_ind (arg2
);
2062 case TYPE_CODE_MEMBERPTR
:
2063 /* Now, convert these values to an address. */
2064 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
2067 mem_offset
= value_as_long (arg2
);
2069 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2070 value_as_long (arg1
) + mem_offset
);
2071 return value_ind (arg3
);
2074 error (_("non-pointer-to-member value used "
2075 "in pointer-to-member construct"));
2079 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2080 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2081 for (ix
= 0; ix
< nargs
; ++ix
)
2082 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
2084 expect_type
= make_params (nargs
, arg_types
);
2085 *(pos
) += 3 + nargs
;
2086 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
2087 xfree (TYPE_FIELDS (expect_type
));
2088 xfree (TYPE_MAIN_TYPE (expect_type
));
2089 xfree (expect_type
);
2093 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2094 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2095 if (noside
== EVAL_SKIP
)
2097 if (binop_user_defined_p (op
, arg1
, arg2
))
2098 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2100 return value_concat (arg1
, arg2
);
2103 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2104 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2106 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2108 if (binop_user_defined_p (op
, arg1
, arg2
))
2109 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2111 return value_assign (arg1
, arg2
);
2113 case BINOP_ASSIGN_MODIFY
:
2115 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2116 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2117 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2119 op
= exp
->elts
[pc
+ 1].opcode
;
2120 if (binop_user_defined_p (op
, arg1
, arg2
))
2121 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2122 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2124 && is_integral_type (value_type (arg2
)))
2125 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2126 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2128 && is_integral_type (value_type (arg2
)))
2129 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2132 struct value
*tmp
= arg1
;
2134 /* For shift and integer exponentiation operations,
2135 only promote the first argument. */
2136 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2137 && is_integral_type (value_type (arg2
)))
2138 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2140 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2142 arg2
= value_binop (tmp
, arg2
, op
);
2144 return value_assign (arg1
, arg2
);
2147 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2148 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2149 if (noside
== EVAL_SKIP
)
2151 if (binop_user_defined_p (op
, arg1
, arg2
))
2152 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2153 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2154 && is_integral_type (value_type (arg2
)))
2155 return value_ptradd (arg1
, value_as_long (arg2
));
2156 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2157 && is_integral_type (value_type (arg1
)))
2158 return value_ptradd (arg2
, value_as_long (arg1
));
2161 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2162 return value_binop (arg1
, arg2
, BINOP_ADD
);
2166 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2167 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2168 if (noside
== EVAL_SKIP
)
2170 if (binop_user_defined_p (op
, arg1
, arg2
))
2171 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2172 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2173 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2175 /* FIXME -- should be ptrdiff_t */
2176 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2177 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2179 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2180 && is_integral_type (value_type (arg2
)))
2181 return value_ptradd (arg1
, - value_as_long (arg2
));
2184 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2185 return value_binop (arg1
, arg2
, BINOP_SUB
);
2196 case BINOP_BITWISE_AND
:
2197 case BINOP_BITWISE_IOR
:
2198 case BINOP_BITWISE_XOR
:
2199 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2200 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2201 if (noside
== EVAL_SKIP
)
2203 if (binop_user_defined_p (op
, arg1
, arg2
))
2204 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2207 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2208 fudge arg2 to avoid division-by-zero, the caller is
2209 (theoretically) only looking for the type of the result. */
2210 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2211 /* ??? Do we really want to test for BINOP_MOD here?
2212 The implementation of value_binop gives it a well-defined
2215 || op
== BINOP_INTDIV
2218 && value_logical_not (arg2
))
2220 struct value
*v_one
, *retval
;
2222 v_one
= value_one (value_type (arg2
));
2223 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2224 retval
= value_binop (arg1
, v_one
, op
);
2229 /* For shift and integer exponentiation operations,
2230 only promote the first argument. */
2231 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2232 && is_integral_type (value_type (arg2
)))
2233 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2235 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2237 return value_binop (arg1
, arg2
, op
);
2242 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2243 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2244 if (noside
== EVAL_SKIP
)
2246 error (_("':' operator used in invalid context"));
2248 case BINOP_SUBSCRIPT
:
2249 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2250 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2251 if (noside
== EVAL_SKIP
)
2253 if (binop_user_defined_p (op
, arg1
, arg2
))
2254 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2257 /* If the user attempts to subscript something that is not an
2258 array or pointer type (like a plain int variable for example),
2259 then report this as an error. */
2261 arg1
= coerce_ref (arg1
);
2262 type
= check_typedef (value_type (arg1
));
2263 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2264 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2266 if (TYPE_NAME (type
))
2267 error (_("cannot subscript something of type `%s'"),
2270 error (_("cannot subscript requested type"));
2273 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2274 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2276 return value_subscript (arg1
, value_as_long (arg2
));
2280 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2281 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2282 if (noside
== EVAL_SKIP
)
2284 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2285 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2287 case MULTI_SUBSCRIPT
:
2289 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2290 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2293 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2294 /* FIXME: EVAL_SKIP handling may not be correct. */
2295 if (noside
== EVAL_SKIP
)
2306 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2307 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2309 /* If the user attempts to subscript something that has no target
2310 type (like a plain int variable for example), then report this
2313 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2316 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2322 error (_("cannot subscript something of type `%s'"),
2323 TYPE_NAME (value_type (arg1
)));
2327 if (binop_user_defined_p (op
, arg1
, arg2
))
2329 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2333 arg1
= coerce_ref (arg1
);
2334 type
= check_typedef (value_type (arg1
));
2336 switch (TYPE_CODE (type
))
2339 case TYPE_CODE_ARRAY
:
2340 case TYPE_CODE_STRING
:
2341 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2344 case TYPE_CODE_BITSTRING
:
2345 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2346 arg1
= value_bitstring_subscript (type
, arg1
,
2347 value_as_long (arg2
));
2351 if (TYPE_NAME (type
))
2352 error (_("cannot subscript something of type `%s'"),
2355 error (_("cannot subscript requested type"));
2361 multi_f77_subscript
:
2363 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2364 int ndimensions
= 1, i
;
2365 struct value
*array
= arg1
;
2367 if (nargs
> MAX_FORTRAN_DIMS
)
2368 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2370 ndimensions
= calc_f77_array_dims (type
);
2372 if (nargs
!= ndimensions
)
2373 error (_("Wrong number of subscripts"));
2375 gdb_assert (nargs
> 0);
2377 /* Now that we know we have a legal array subscript expression
2378 let us actually find out where this element exists in the array. */
2380 /* Take array indices left to right. */
2381 for (i
= 0; i
< nargs
; i
++)
2383 /* Evaluate each subscript; it must be a legal integer in F77. */
2384 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2386 /* Fill in the subscript array. */
2388 subscript_array
[i
] = value_as_long (arg2
);
2391 /* Internal type of array is arranged right to left. */
2392 for (i
= nargs
; i
> 0; i
--)
2394 struct type
*array_type
= check_typedef (value_type (array
));
2395 LONGEST index
= subscript_array
[i
- 1];
2397 lower
= f77_get_lowerbound (array_type
);
2398 array
= value_subscripted_rvalue (array
, index
, lower
);
2404 case BINOP_LOGICAL_AND
:
2405 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2406 if (noside
== EVAL_SKIP
)
2408 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2413 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2416 if (binop_user_defined_p (op
, arg1
, arg2
))
2418 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2419 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2423 tem
= value_logical_not (arg1
);
2424 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2425 (tem
? EVAL_SKIP
: noside
));
2426 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2427 return value_from_longest (type
,
2428 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2431 case BINOP_LOGICAL_OR
:
2432 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2433 if (noside
== EVAL_SKIP
)
2435 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2440 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2443 if (binop_user_defined_p (op
, arg1
, arg2
))
2445 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2446 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2450 tem
= value_logical_not (arg1
);
2451 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2452 (!tem
? EVAL_SKIP
: noside
));
2453 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2454 return value_from_longest (type
,
2455 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2459 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2460 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2461 if (noside
== EVAL_SKIP
)
2463 if (binop_user_defined_p (op
, arg1
, arg2
))
2465 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2469 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2470 tem
= value_equal (arg1
, arg2
);
2471 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2472 return value_from_longest (type
, (LONGEST
) tem
);
2475 case BINOP_NOTEQUAL
:
2476 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2477 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2478 if (noside
== EVAL_SKIP
)
2480 if (binop_user_defined_p (op
, arg1
, arg2
))
2482 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2486 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2487 tem
= value_equal (arg1
, arg2
);
2488 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2489 return value_from_longest (type
, (LONGEST
) ! tem
);
2493 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2494 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2495 if (noside
== EVAL_SKIP
)
2497 if (binop_user_defined_p (op
, arg1
, arg2
))
2499 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2503 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2504 tem
= value_less (arg1
, arg2
);
2505 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2506 return value_from_longest (type
, (LONGEST
) tem
);
2510 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2511 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2512 if (noside
== EVAL_SKIP
)
2514 if (binop_user_defined_p (op
, arg1
, arg2
))
2516 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2520 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2521 tem
= value_less (arg2
, arg1
);
2522 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2523 return value_from_longest (type
, (LONGEST
) tem
);
2527 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2528 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2529 if (noside
== EVAL_SKIP
)
2531 if (binop_user_defined_p (op
, arg1
, arg2
))
2533 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2537 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2538 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2539 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2540 return value_from_longest (type
, (LONGEST
) tem
);
2544 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2545 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2546 if (noside
== EVAL_SKIP
)
2548 if (binop_user_defined_p (op
, arg1
, arg2
))
2550 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2554 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2555 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2556 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2557 return value_from_longest (type
, (LONGEST
) tem
);
2561 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2562 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2563 if (noside
== EVAL_SKIP
)
2565 type
= check_typedef (value_type (arg2
));
2566 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2567 error (_("Non-integral right operand for \"@\" operator."));
2568 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2570 return allocate_repeat_value (value_type (arg1
),
2571 longest_to_int (value_as_long (arg2
)));
2574 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2577 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2578 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2581 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2582 if (noside
== EVAL_SKIP
)
2584 if (unop_user_defined_p (op
, arg1
))
2585 return value_x_unop (arg1
, op
, noside
);
2588 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2589 return value_pos (arg1
);
2593 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2594 if (noside
== EVAL_SKIP
)
2596 if (unop_user_defined_p (op
, arg1
))
2597 return value_x_unop (arg1
, op
, noside
);
2600 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2601 return value_neg (arg1
);
2604 case UNOP_COMPLEMENT
:
2605 /* C++: check for and handle destructor names. */
2606 op
= exp
->elts
[*pos
].opcode
;
2608 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2609 if (noside
== EVAL_SKIP
)
2611 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2612 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2615 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2616 return value_complement (arg1
);
2619 case UNOP_LOGICAL_NOT
:
2620 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2621 if (noside
== EVAL_SKIP
)
2623 if (unop_user_defined_p (op
, arg1
))
2624 return value_x_unop (arg1
, op
, noside
);
2627 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2628 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2632 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2633 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2634 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2635 type
= check_typedef (value_type (arg1
));
2636 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2637 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2638 error (_("Attempt to dereference pointer "
2639 "to member without an object"));
2640 if (noside
== EVAL_SKIP
)
2642 if (unop_user_defined_p (op
, arg1
))
2643 return value_x_unop (arg1
, op
, noside
);
2644 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2646 type
= check_typedef (value_type (arg1
));
2647 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2648 || TYPE_CODE (type
) == TYPE_CODE_REF
2649 /* In C you can dereference an array to get the 1st elt. */
2650 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2652 return value_zero (TYPE_TARGET_TYPE (type
),
2654 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2655 /* GDB allows dereferencing an int. */
2656 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2659 error (_("Attempt to take contents of a non-pointer value."));
2662 /* Allow * on an integer so we can cast it to whatever we want.
2663 This returns an int, which seems like the most C-like thing to
2664 do. "long long" variables are rare enough that
2665 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2666 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2667 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2668 (CORE_ADDR
) value_as_address (arg1
));
2669 return value_ind (arg1
);
2672 /* C++: check for and handle pointer to members. */
2674 op
= exp
->elts
[*pos
].opcode
;
2676 if (noside
== EVAL_SKIP
)
2678 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2683 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2690 if (noside
== EVAL_SKIP
)
2692 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2695 return evaluate_subexp_for_sizeof (exp
, pos
);
2699 type
= exp
->elts
[pc
+ 1].type
;
2700 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2701 if (noside
== EVAL_SKIP
)
2703 if (type
!= value_type (arg1
))
2704 arg1
= value_cast (type
, arg1
);
2707 case UNOP_DYNAMIC_CAST
:
2709 type
= exp
->elts
[pc
+ 1].type
;
2710 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2711 if (noside
== EVAL_SKIP
)
2713 return value_dynamic_cast (type
, arg1
);
2715 case UNOP_REINTERPRET_CAST
:
2717 type
= exp
->elts
[pc
+ 1].type
;
2718 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2719 if (noside
== EVAL_SKIP
)
2721 return value_reinterpret_cast (type
, arg1
);
2725 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2726 if (noside
== EVAL_SKIP
)
2728 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2729 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2731 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2732 value_as_address (arg1
));
2734 case UNOP_MEMVAL_TLS
:
2736 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2737 if (noside
== EVAL_SKIP
)
2739 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2740 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2745 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2746 value_as_address (arg1
));
2747 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2750 case UNOP_PREINCREMENT
:
2751 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2752 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2754 else if (unop_user_defined_p (op
, arg1
))
2756 return value_x_unop (arg1
, op
, noside
);
2760 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2761 arg2
= value_ptradd (arg1
, 1);
2764 struct value
*tmp
= arg1
;
2766 arg2
= value_one (value_type (arg1
));
2767 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2768 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2771 return value_assign (arg1
, arg2
);
2774 case UNOP_PREDECREMENT
:
2775 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2776 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2778 else if (unop_user_defined_p (op
, arg1
))
2780 return value_x_unop (arg1
, op
, noside
);
2784 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2785 arg2
= value_ptradd (arg1
, -1);
2788 struct value
*tmp
= arg1
;
2790 arg2
= value_one (value_type (arg1
));
2791 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2792 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2795 return value_assign (arg1
, arg2
);
2798 case UNOP_POSTINCREMENT
:
2799 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2800 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2802 else if (unop_user_defined_p (op
, arg1
))
2804 return value_x_unop (arg1
, op
, noside
);
2808 arg3
= value_non_lval (arg1
);
2810 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2811 arg2
= value_ptradd (arg1
, 1);
2814 struct value
*tmp
= arg1
;
2816 arg2
= value_one (value_type (arg1
));
2817 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2818 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2821 value_assign (arg1
, arg2
);
2825 case UNOP_POSTDECREMENT
:
2826 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2827 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2829 else if (unop_user_defined_p (op
, arg1
))
2831 return value_x_unop (arg1
, op
, noside
);
2835 arg3
= value_non_lval (arg1
);
2837 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2838 arg2
= value_ptradd (arg1
, -1);
2841 struct value
*tmp
= arg1
;
2843 arg2
= value_one (value_type (arg1
));
2844 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2845 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2848 value_assign (arg1
, arg2
);
2854 return value_of_this (exp
->language_defn
);
2857 /* The value is not supposed to be used. This is here to make it
2858 easier to accommodate expressions that contain types. */
2860 if (noside
== EVAL_SKIP
)
2862 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2864 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2866 /* If this is a typedef, then find its immediate target. We
2867 use check_typedef to resolve stubs, but we ignore its
2868 result because we do not want to dig past all
2870 check_typedef (type
);
2871 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2872 type
= TYPE_TARGET_TYPE (type
);
2873 return allocate_value (type
);
2876 error (_("Attempt to use a type name as an expression"));
2879 /* Removing this case and compiling with gcc -Wall reveals that
2880 a lot of cases are hitting this case. Some of these should
2881 probably be removed from expression.h; others are legitimate
2882 expressions which are (apparently) not fully implemented.
2884 If there are any cases landing here which mean a user error,
2885 then they should be separate cases, with more descriptive
2888 error (_("GDB does not (yet) know how to "
2889 "evaluate that kind of expression"));
2893 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2896 /* Evaluate a subexpression of EXP, at index *POS,
2897 and return the address of that subexpression.
2898 Advance *POS over the subexpression.
2899 If the subexpression isn't an lvalue, get an error.
2900 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2901 then only the type of the result need be correct. */
2903 static struct value
*
2904 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2914 op
= exp
->elts
[pc
].opcode
;
2920 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2922 /* We can't optimize out "&*" if there's a user-defined operator*. */
2923 if (unop_user_defined_p (op
, x
))
2925 x
= value_x_unop (x
, op
, noside
);
2926 goto default_case_after_eval
;
2929 return coerce_array (x
);
2933 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2934 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2937 var
= exp
->elts
[pc
+ 2].symbol
;
2939 /* C++: The "address" of a reference should yield the address
2940 * of the object pointed to. Let value_addr() deal with it. */
2941 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2945 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2948 lookup_pointer_type (SYMBOL_TYPE (var
));
2949 enum address_class sym_class
= SYMBOL_CLASS (var
);
2951 if (sym_class
== LOC_CONST
2952 || sym_class
== LOC_CONST_BYTES
2953 || sym_class
== LOC_REGISTER
)
2954 error (_("Attempt to take address of register or constant."));
2957 value_zero (type
, not_lval
);
2960 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2963 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2964 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2965 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2966 &exp
->elts
[pc
+ 3].string
,
2969 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2974 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2975 default_case_after_eval
:
2976 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2978 struct type
*type
= check_typedef (value_type (x
));
2980 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2981 return value_zero (lookup_pointer_type (value_type (x
)),
2983 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2984 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2987 error (_("Attempt to take address of "
2988 "value not located in memory."));
2990 return value_addr (x
);
2994 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2995 When used in contexts where arrays will be coerced anyway, this is
2996 equivalent to `evaluate_subexp' but much faster because it avoids
2997 actually fetching array contents (perhaps obsolete now that we have
3000 Note that we currently only do the coercion for C expressions, where
3001 arrays are zero based and the coercion is correct. For other languages,
3002 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3003 to decide if coercion is appropriate. */
3006 evaluate_subexp_with_coercion (struct expression
*exp
,
3007 int *pos
, enum noside noside
)
3016 op
= exp
->elts
[pc
].opcode
;
3021 var
= exp
->elts
[pc
+ 2].symbol
;
3022 type
= check_typedef (SYMBOL_TYPE (var
));
3023 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3024 && !TYPE_VECTOR (type
)
3025 && CAST_IS_CONVERSION (exp
->language_defn
))
3028 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3029 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3035 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3039 /* Evaluate a subexpression of EXP, at index *POS,
3040 and return a value for the size of that subexpression.
3041 Advance *POS over the subexpression. */
3043 static struct value
*
3044 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
3046 /* FIXME: This should be size_t. */
3047 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3054 op
= exp
->elts
[pc
].opcode
;
3058 /* This case is handled specially
3059 so that we avoid creating a value for the result type.
3060 If the result type is very big, it's desirable not to
3061 create a value unnecessarily. */
3064 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3065 type
= check_typedef (value_type (val
));
3066 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3067 && TYPE_CODE (type
) != TYPE_CODE_REF
3068 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3069 error (_("Attempt to take contents of a non-pointer value."));
3070 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3071 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3075 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3076 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3080 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3082 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3085 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3086 return value_from_longest (size_type
,
3087 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3091 /* Parse a type expression in the string [P..P+LENGTH). */
3094 parse_and_eval_type (char *p
, int length
)
3096 char *tmp
= (char *) alloca (length
+ 4);
3097 struct expression
*expr
;
3100 memcpy (tmp
+ 1, p
, length
);
3101 tmp
[length
+ 1] = ')';
3102 tmp
[length
+ 2] = '0';
3103 tmp
[length
+ 3] = '\0';
3104 expr
= parse_expression (tmp
);
3105 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3106 error (_("Internal error in eval_type."));
3107 return expr
->elts
[1].type
;
3111 calc_f77_array_dims (struct type
*array_type
)
3114 struct type
*tmp_type
;
3116 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3117 error (_("Can't get dimensions for a non-array type"));
3119 tmp_type
= array_type
;
3121 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3123 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)