1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2003, 2005-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_string.h"
25 #include "expression.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
29 #include "f-lang.h" /* For array bound stuff. */
32 #include "objc-lang.h"
34 #include "parser-defs.h"
35 #include "cp-support.h"
37 #include "exceptions.h"
39 #include "user-regs.h"
41 #include "gdb_obstack.h"
43 #include "python/python.h"
45 #include "gdb_assert.h"
49 /* This is defined in valops.c */
50 extern int overload_resolution
;
52 /* Prototypes for local functions. */
54 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
56 static struct value
*evaluate_subexp_for_address (struct expression
*,
59 static char *get_label (struct expression
*, int *);
61 static struct value
*evaluate_struct_tuple (struct value
*,
62 struct expression
*, int *,
65 static LONGEST
init_array_element (struct value
*, struct value
*,
66 struct expression
*, int *, enum noside
,
70 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
71 int *pos
, enum noside noside
)
73 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
74 (expect_type
, exp
, pos
, noside
);
77 /* Parse the string EXP as a C expression, evaluate it,
78 and return the result as a number. */
81 parse_and_eval_address (char *exp
)
83 struct expression
*expr
= parse_expression (exp
);
85 struct cleanup
*old_chain
=
86 make_cleanup (free_current_contents
, &expr
);
88 addr
= value_as_address (evaluate_expression (expr
));
89 do_cleanups (old_chain
);
93 /* Like parse_and_eval_address, but treats the value of the expression
94 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
96 parse_and_eval_long (char *exp
)
98 struct expression
*expr
= parse_expression (exp
);
100 struct cleanup
*old_chain
=
101 make_cleanup (free_current_contents
, &expr
);
103 retval
= value_as_long (evaluate_expression (expr
));
104 do_cleanups (old_chain
);
109 parse_and_eval (char *exp
)
111 struct expression
*expr
= parse_expression (exp
);
113 struct cleanup
*old_chain
=
114 make_cleanup (free_current_contents
, &expr
);
116 val
= evaluate_expression (expr
);
117 do_cleanups (old_chain
);
121 /* Parse up to a comma (or to a closeparen)
122 in the string EXPP as an expression, evaluate it, and return the value.
123 EXPP is advanced to point to the comma. */
126 parse_to_comma_and_eval (char **expp
)
128 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
130 struct cleanup
*old_chain
=
131 make_cleanup (free_current_contents
, &expr
);
133 val
= evaluate_expression (expr
);
134 do_cleanups (old_chain
);
138 /* Evaluate an expression in internal prefix form
139 such as is constructed by parse.y.
141 See expression.h for info on the format of an expression. */
144 evaluate_expression (struct expression
*exp
)
148 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
151 /* Evaluate an expression, avoiding all memory references
152 and getting a value whose type alone is correct. */
155 evaluate_type (struct expression
*exp
)
159 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
162 /* Evaluate a subexpression, avoiding all memory references and
163 getting a value whose type alone is correct. */
166 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
168 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
171 /* Find the current value of a watchpoint on EXP. Return the value in
172 *VALP and *RESULTP and the chain of intermediate and final values
173 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
176 If a memory error occurs while evaluating the expression, *RESULTP will
177 be set to NULL. *RESULTP may be a lazy value, if the result could
178 not be read from memory. It is used to determine whether a value
179 is user-specified (we should watch the whole value) or intermediate
180 (we should watch only the bit used to locate the final value).
182 If the final value, or any intermediate value, could not be read
183 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
184 set to any referenced values. *VALP will never be a lazy value.
185 This is the value which we store in struct breakpoint.
187 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
188 value chain. The caller must free the values individually. If
189 VAL_CHAIN is NULL, all generated values will be left on the value
193 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
194 struct value
**resultp
, struct value
**val_chain
)
196 struct value
*mark
, *new_mark
, *result
;
197 volatile struct gdb_exception ex
;
205 /* Evaluate the expression. */
206 mark
= value_mark ();
209 TRY_CATCH (ex
, RETURN_MASK_ALL
)
211 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
215 /* Ignore memory errors, we want watchpoints pointing at
216 inaccessible memory to still be created; otherwise, throw the
217 error to some higher catcher. */
223 throw_exception (ex
);
228 new_mark
= value_mark ();
229 if (mark
== new_mark
)
234 /* Make sure it's not lazy, so that after the target stops again we
235 have a non-lazy previous value to compare with. */
238 if (!value_lazy (result
))
242 volatile struct gdb_exception except
;
244 TRY_CATCH (except
, RETURN_MASK_ERROR
)
246 value_fetch_lazy (result
);
254 /* Return the chain of intermediate values. We use this to
255 decide which addresses to watch. */
256 *val_chain
= new_mark
;
257 value_release_to_mark (mark
);
261 /* Extract a field operation from an expression. If the subexpression
262 of EXP starting at *SUBEXP is not a structure dereference
263 operation, return NULL. Otherwise, return the name of the
264 dereferenced field, and advance *SUBEXP to point to the
265 subexpression of the left-hand-side of the dereference. This is
266 used when completing field names. */
269 extract_field_op (struct expression
*exp
, int *subexp
)
274 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
275 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
277 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
278 result
= &exp
->elts
[*subexp
+ 2].string
;
279 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
283 /* If the next expression is an OP_LABELED, skips past it,
284 returning the label. Otherwise, does nothing and returns NULL. */
287 get_label (struct expression
*exp
, int *pos
)
289 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
292 char *name
= &exp
->elts
[pc
+ 2].string
;
293 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
295 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
302 /* This function evaluates tuples (in (the deleted) Chill) or
303 brace-initializers (in C/C++) for structure types. */
305 static struct value
*
306 evaluate_struct_tuple (struct value
*struct_val
,
307 struct expression
*exp
,
308 int *pos
, enum noside noside
, int nargs
)
310 struct type
*struct_type
= check_typedef (value_type (struct_val
));
311 struct type
*substruct_type
= struct_type
;
312 struct type
*field_type
;
320 struct value
*val
= NULL
;
325 /* Skip past the labels, and count them. */
326 while (get_label (exp
, pos
) != NULL
)
331 char *label
= get_label (exp
, &pc
);
335 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
338 const char *field_name
=
339 TYPE_FIELD_NAME (struct_type
, fieldno
);
341 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
344 subfieldno
= fieldno
;
345 substruct_type
= struct_type
;
349 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
352 const char *field_name
=
353 TYPE_FIELD_NAME (struct_type
, fieldno
);
355 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
356 if ((field_name
== 0 || *field_name
== '\0')
357 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
360 for (; variantno
< TYPE_NFIELDS (field_type
);
364 = TYPE_FIELD_TYPE (field_type
, variantno
);
365 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
368 subfieldno
< TYPE_NFIELDS (substruct_type
);
371 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
382 error (_("there is no field named %s"), label
);
388 /* Unlabelled tuple element - go to next field. */
392 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
395 substruct_type
= struct_type
;
401 /* Skip static fields. */
402 while (fieldno
< TYPE_NFIELDS (struct_type
)
403 && field_is_static (&TYPE_FIELD (struct_type
,
406 subfieldno
= fieldno
;
407 if (fieldno
>= TYPE_NFIELDS (struct_type
))
408 error (_("too many initializers"));
409 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
410 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
411 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
412 error (_("don't know which variant you want to set"));
416 /* Here, struct_type is the type of the inner struct,
417 while substruct_type is the type of the inner struct.
418 These are the same for normal structures, but a variant struct
419 contains anonymous union fields that contain substruct fields.
420 The value fieldno is the index of the top-level (normal or
421 anonymous union) field in struct_field, while the value
422 subfieldno is the index of the actual real (named inner) field
423 in substruct_type. */
425 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
427 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
429 /* Now actually set the field in struct_val. */
431 /* Assign val to field fieldno. */
432 if (value_type (val
) != field_type
)
433 val
= value_cast (field_type
, val
);
435 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
436 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
438 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
439 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
441 modify_field (struct_type
, addr
,
442 value_as_long (val
), bitpos
% 8, bitsize
);
444 memcpy (addr
, value_contents (val
),
445 TYPE_LENGTH (value_type (val
)));
447 while (--nlabels
> 0);
452 /* Recursive helper function for setting elements of array tuples for
453 (the deleted) Chill. The target is ARRAY (which has bounds
454 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
455 and NOSIDE are as usual. Evaluates index expresions and sets the
456 specified element(s) of ARRAY to ELEMENT. Returns last index
460 init_array_element (struct value
*array
, struct value
*element
,
461 struct expression
*exp
, int *pos
,
462 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
465 int element_size
= TYPE_LENGTH (value_type (element
));
467 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
470 init_array_element (array
, element
, exp
, pos
, noside
,
471 low_bound
, high_bound
);
472 return init_array_element (array
, element
,
473 exp
, pos
, noside
, low_bound
, high_bound
);
475 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
480 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
481 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
482 if (low
< low_bound
|| high
> high_bound
)
483 error (_("tuple range index out of range"));
484 for (index
= low
; index
<= high
; index
++)
486 memcpy (value_contents_raw (array
)
487 + (index
- low_bound
) * element_size
,
488 value_contents (element
), element_size
);
493 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
494 if (index
< low_bound
|| index
> high_bound
)
495 error (_("tuple index out of range"));
496 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
497 value_contents (element
), element_size
);
502 static struct value
*
503 value_f90_subarray (struct value
*array
,
504 struct expression
*exp
, int *pos
, enum noside noside
)
507 LONGEST low_bound
, high_bound
;
508 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
509 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
513 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
514 low_bound
= TYPE_LOW_BOUND (range
);
516 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
518 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
519 high_bound
= TYPE_HIGH_BOUND (range
);
521 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
523 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
527 /* Promote value ARG1 as appropriate before performing a unary operation
529 If the result is not appropriate for any particular language then it
530 needs to patch this function. */
533 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
538 *arg1
= coerce_ref (*arg1
);
539 type1
= check_typedef (value_type (*arg1
));
541 if (is_integral_type (type1
))
543 switch (language
->la_language
)
546 /* Perform integral promotion for ANSI C/C++.
547 If not appropropriate for any particular language
548 it needs to modify this function. */
550 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
552 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
553 *arg1
= value_cast (builtin_int
, *arg1
);
560 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
561 operation on those two operands.
562 If the result is not appropriate for any particular language then it
563 needs to patch this function. */
566 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
567 struct value
**arg1
, struct value
**arg2
)
569 struct type
*promoted_type
= NULL
;
573 *arg1
= coerce_ref (*arg1
);
574 *arg2
= coerce_ref (*arg2
);
576 type1
= check_typedef (value_type (*arg1
));
577 type2
= check_typedef (value_type (*arg2
));
579 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
580 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
581 && !is_integral_type (type1
))
582 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
583 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
584 && !is_integral_type (type2
)))
587 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
588 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
590 /* No promotion required. */
592 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
593 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
595 switch (language
->la_language
)
601 case language_opencl
:
602 /* No promotion required. */
606 /* For other languages the result type is unchanged from gdb
607 version 6.7 for backward compatibility.
608 If either arg was long double, make sure that value is also long
609 double. Otherwise use double. */
610 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
611 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
612 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
614 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
618 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
619 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
621 /* No promotion required. */
624 /* Integral operations here. */
625 /* FIXME: Also mixed integral/booleans, with result an integer. */
627 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
628 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
629 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
630 int is_unsigned1
= TYPE_UNSIGNED (type1
);
631 int is_unsigned2
= TYPE_UNSIGNED (type2
);
632 unsigned int result_len
;
633 int unsigned_operation
;
635 /* Determine type length and signedness after promotion for
637 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
640 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
642 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
645 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
648 if (promoted_len1
> promoted_len2
)
650 unsigned_operation
= is_unsigned1
;
651 result_len
= promoted_len1
;
653 else if (promoted_len2
> promoted_len1
)
655 unsigned_operation
= is_unsigned2
;
656 result_len
= promoted_len2
;
660 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
661 result_len
= promoted_len1
;
664 switch (language
->la_language
)
670 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
672 promoted_type
= (unsigned_operation
673 ? builtin
->builtin_unsigned_int
674 : builtin
->builtin_int
);
676 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
678 promoted_type
= (unsigned_operation
679 ? builtin
->builtin_unsigned_long
680 : builtin
->builtin_long
);
684 promoted_type
= (unsigned_operation
685 ? builtin
->builtin_unsigned_long_long
686 : builtin
->builtin_long_long
);
689 case language_opencl
:
690 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
691 (language
, gdbarch
, "int")))
695 ? lookup_unsigned_typename (language
, gdbarch
, "int")
696 : lookup_signed_typename (language
, gdbarch
, "int"));
698 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
699 (language
, gdbarch
, "long")))
703 ? lookup_unsigned_typename (language
, gdbarch
, "long")
704 : lookup_signed_typename (language
, gdbarch
,"long"));
708 /* For other languages the result type is unchanged from gdb
709 version 6.7 for backward compatibility.
710 If either arg was long long, make sure that value is also long
711 long. Otherwise use long. */
712 if (unsigned_operation
)
714 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
715 promoted_type
= builtin
->builtin_unsigned_long_long
;
717 promoted_type
= builtin
->builtin_unsigned_long
;
721 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
722 promoted_type
= builtin
->builtin_long_long
;
724 promoted_type
= builtin
->builtin_long
;
732 /* Promote both operands to common type. */
733 *arg1
= value_cast (promoted_type
, *arg1
);
734 *arg2
= value_cast (promoted_type
, *arg2
);
739 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
741 type
= check_typedef (type
);
742 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
743 type
= TYPE_TARGET_TYPE (type
);
745 switch (TYPE_CODE (type
))
751 case TYPE_CODE_ARRAY
:
752 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
759 /* Constructs a fake method with the given parameter types.
760 This function is used by the parser to construct an "expected"
761 type for method overload resolution. */
764 make_params (int num_types
, struct type
**param_types
)
766 struct type
*type
= XZALLOC (struct type
);
767 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
768 TYPE_LENGTH (type
) = 1;
769 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
770 TYPE_VPTR_FIELDNO (type
) = -1;
771 TYPE_CHAIN (type
) = type
;
772 TYPE_NFIELDS (type
) = num_types
;
773 TYPE_FIELDS (type
) = (struct field
*)
774 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
776 while (num_types
-- > 0)
777 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
783 evaluate_subexp_standard (struct type
*expect_type
,
784 struct expression
*exp
, int *pos
,
789 int pc
, pc2
= 0, oldpos
;
790 struct value
*arg1
= NULL
;
791 struct value
*arg2
= NULL
;
795 struct value
**argvec
;
800 struct type
**arg_types
;
802 struct symbol
*function
= NULL
;
803 char *function_name
= NULL
;
806 op
= exp
->elts
[pc
].opcode
;
811 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
812 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
813 if (noside
== EVAL_SKIP
)
815 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
816 &exp
->elts
[pc
+ 3].string
,
817 expect_type
, 0, noside
);
819 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
824 return value_from_longest (exp
->elts
[pc
+ 1].type
,
825 exp
->elts
[pc
+ 2].longconst
);
829 return value_from_double (exp
->elts
[pc
+ 1].type
,
830 exp
->elts
[pc
+ 2].doubleconst
);
834 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
835 exp
->elts
[pc
+ 2].decfloatconst
);
840 if (noside
== EVAL_SKIP
)
843 /* JYG: We used to just return value_zero of the symbol type
844 if we're asked to avoid side effects. Otherwise we return
845 value_of_variable (...). However I'm not sure if
846 value_of_variable () has any side effect.
847 We need a full value object returned here for whatis_exp ()
848 to call evaluate_type () and then pass the full value to
849 value_rtti_target_type () if we are dealing with a pointer
850 or reference to a base class and print object is on. */
853 volatile struct gdb_exception except
;
854 struct value
*ret
= NULL
;
856 TRY_CATCH (except
, RETURN_MASK_ERROR
)
858 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
859 exp
->elts
[pc
+ 1].block
);
862 if (except
.reason
< 0)
864 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
865 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
868 throw_exception (except
);
874 case OP_VAR_ENTRY_VALUE
:
876 if (noside
== EVAL_SKIP
)
880 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
881 struct frame_info
*frame
;
883 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
884 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
886 if (SYMBOL_CLASS (sym
) != LOC_COMPUTED
887 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
888 error (_("Symbol \"%s\" does not have any specific entry value"),
889 SYMBOL_PRINT_NAME (sym
));
891 frame
= get_selected_frame (NULL
);
892 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
898 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
902 const char *name
= &exp
->elts
[pc
+ 2].string
;
906 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
907 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
908 name
, strlen (name
));
910 error (_("Register $%s not available."), name
);
912 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
913 a value with the appropriate register type. Unfortunately,
914 we don't have easy access to the type of user registers.
915 So for these registers, we fetch the register value regardless
916 of the evaluation mode. */
917 if (noside
== EVAL_AVOID_SIDE_EFFECTS
918 && regno
< gdbarch_num_regs (exp
->gdbarch
)
919 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
920 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
922 val
= value_of_register (regno
, get_selected_frame (NULL
));
924 error (_("Value of register %s not available."), name
);
930 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
931 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
935 return value_of_internalvar (exp
->gdbarch
,
936 exp
->elts
[pc
+ 1].internalvar
);
939 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
940 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
941 if (noside
== EVAL_SKIP
)
943 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
944 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
946 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
947 NSString constant. */
948 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
949 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
950 if (noside
== EVAL_SKIP
)
954 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
957 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
959 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
960 if (noside
== EVAL_SKIP
)
962 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
,
963 builtin_type (exp
->gdbarch
)->builtin_int
);
968 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
969 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
970 nargs
= tem3
- tem2
+ 1;
971 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
973 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
974 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
976 struct value
*rec
= allocate_value (expect_type
);
978 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
979 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
982 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
983 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
985 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
986 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
987 struct value
*array
= allocate_value (expect_type
);
988 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
989 LONGEST low_bound
, high_bound
, index
;
991 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
994 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
997 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
998 for (tem
= nargs
; --nargs
>= 0;)
1000 struct value
*element
;
1003 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1005 index_pc
= ++(*pos
);
1006 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1008 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1009 if (value_type (element
) != element_type
)
1010 element
= value_cast (element_type
, element
);
1013 int continue_pc
= *pos
;
1016 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1017 low_bound
, high_bound
);
1022 if (index
> high_bound
)
1023 /* To avoid memory corruption. */
1024 error (_("Too many array elements"));
1025 memcpy (value_contents_raw (array
)
1026 + (index
- low_bound
) * element_size
,
1027 value_contents (element
),
1035 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1036 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1038 struct value
*set
= allocate_value (expect_type
);
1039 gdb_byte
*valaddr
= value_contents_raw (set
);
1040 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1041 struct type
*check_type
= element_type
;
1042 LONGEST low_bound
, high_bound
;
1044 /* Get targettype of elementtype. */
1045 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1046 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1047 check_type
= TYPE_TARGET_TYPE (check_type
);
1049 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1050 error (_("(power)set type with unknown size"));
1051 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1052 for (tem
= 0; tem
< nargs
; tem
++)
1054 LONGEST range_low
, range_high
;
1055 struct type
*range_low_type
, *range_high_type
;
1056 struct value
*elem_val
;
1058 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1061 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1062 range_low_type
= value_type (elem_val
);
1063 range_low
= value_as_long (elem_val
);
1064 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1065 range_high_type
= value_type (elem_val
);
1066 range_high
= value_as_long (elem_val
);
1070 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1071 range_low_type
= range_high_type
= value_type (elem_val
);
1072 range_low
= range_high
= value_as_long (elem_val
);
1074 /* Check types of elements to avoid mixture of elements from
1075 different types. Also check if type of element is "compatible"
1076 with element type of powerset. */
1077 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1078 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1079 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1080 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1081 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1082 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1083 && (range_low_type
!= range_high_type
)))
1084 /* different element modes. */
1085 error (_("POWERSET tuple elements of different mode"));
1086 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1087 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1088 && range_low_type
!= check_type
))
1089 error (_("incompatible POWERSET tuple elements"));
1090 if (range_low
> range_high
)
1092 warning (_("empty POWERSET tuple range"));
1095 if (range_low
< low_bound
|| range_high
> high_bound
)
1096 error (_("POWERSET tuple element out of range"));
1097 range_low
-= low_bound
;
1098 range_high
-= low_bound
;
1099 for (; range_low
<= range_high
; range_low
++)
1101 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1103 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1104 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1105 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1112 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1113 for (tem
= 0; tem
< nargs
; tem
++)
1115 /* Ensure that array expressions are coerced into pointer
1117 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1119 if (noside
== EVAL_SKIP
)
1121 return value_array (tem2
, tem3
, argvec
);
1125 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1127 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1129 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1131 if (noside
== EVAL_SKIP
)
1133 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1136 case TERNOP_SLICE_COUNT
:
1138 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1140 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1142 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1144 return value_slice (array
, lowbound
, length
);
1148 /* Skip third and second args to evaluate the first one. */
1149 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1150 if (value_logical_not (arg1
))
1152 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1153 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1157 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1158 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1162 case OP_OBJC_SELECTOR
:
1163 { /* Objective C @selector operator. */
1164 char *sel
= &exp
->elts
[pc
+ 2].string
;
1165 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1166 struct type
*selector_type
;
1168 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1169 if (noside
== EVAL_SKIP
)
1173 sel
[len
] = 0; /* Make sure it's terminated. */
1175 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1176 return value_from_longest (selector_type
,
1177 lookup_child_selector (exp
->gdbarch
, sel
));
1180 case OP_OBJC_MSGCALL
:
1181 { /* Objective C message (method) call. */
1183 CORE_ADDR responds_selector
= 0;
1184 CORE_ADDR method_selector
= 0;
1186 CORE_ADDR selector
= 0;
1188 int struct_return
= 0;
1189 int sub_no_side
= 0;
1191 struct value
*msg_send
= NULL
;
1192 struct value
*msg_send_stret
= NULL
;
1193 int gnu_runtime
= 0;
1195 struct value
*target
= NULL
;
1196 struct value
*method
= NULL
;
1197 struct value
*called_method
= NULL
;
1199 struct type
*selector_type
= NULL
;
1200 struct type
*long_type
;
1202 struct value
*ret
= NULL
;
1205 selector
= exp
->elts
[pc
+ 1].longconst
;
1206 nargs
= exp
->elts
[pc
+ 2].longconst
;
1207 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1212 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1213 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1215 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1216 sub_no_side
= EVAL_NORMAL
;
1218 sub_no_side
= noside
;
1220 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1222 if (value_as_long (target
) == 0)
1223 return value_from_longest (long_type
, 0);
1225 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1228 /* Find the method dispatch (Apple runtime) or method lookup
1229 (GNU runtime) function for Objective-C. These will be used
1230 to lookup the symbol information for the method. If we
1231 can't find any symbol information, then we'll use these to
1232 call the method, otherwise we can call the method
1233 directly. The msg_send_stret function is used in the special
1234 case of a method that returns a structure (Apple runtime
1238 struct type
*type
= selector_type
;
1240 type
= lookup_function_type (type
);
1241 type
= lookup_pointer_type (type
);
1242 type
= lookup_function_type (type
);
1243 type
= lookup_pointer_type (type
);
1245 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1247 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1249 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1250 msg_send_stret
= value_from_pointer (type
,
1251 value_as_address (msg_send_stret
));
1255 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1256 /* Special dispatcher for methods returning structs. */
1258 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1261 /* Verify the target object responds to this method. The
1262 standard top-level 'Object' class uses a different name for
1263 the verification method than the non-standard, but more
1264 often used, 'NSObject' class. Make sure we check for both. */
1267 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1268 if (responds_selector
== 0)
1270 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1272 if (responds_selector
== 0)
1273 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1276 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1277 if (method_selector
== 0)
1279 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1281 if (method_selector
== 0)
1282 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1284 /* Call the verification method, to make sure that the target
1285 class implements the desired method. */
1287 argvec
[0] = msg_send
;
1289 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1290 argvec
[3] = value_from_longest (long_type
, selector
);
1293 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1296 /* Function objc_msg_lookup returns a pointer. */
1298 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1300 if (value_as_long (ret
) == 0)
1301 error (_("Target does not respond to this message selector."));
1303 /* Call "methodForSelector:" method, to get the address of a
1304 function method that implements this selector for this
1305 class. If we can find a symbol at that address, then we
1306 know the return type, parameter types etc. (that's a good
1309 argvec
[0] = msg_send
;
1311 argvec
[2] = value_from_longest (long_type
, method_selector
);
1312 argvec
[3] = value_from_longest (long_type
, selector
);
1315 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1319 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1322 /* ret should now be the selector. */
1324 addr
= value_as_long (ret
);
1327 struct symbol
*sym
= NULL
;
1329 /* The address might point to a function descriptor;
1330 resolve it to the actual code address instead. */
1331 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1334 /* Is it a high_level symbol? */
1335 sym
= find_pc_function (addr
);
1337 method
= value_of_variable (sym
, 0);
1340 /* If we found a method with symbol information, check to see
1341 if it returns a struct. Otherwise assume it doesn't. */
1346 struct type
*val_type
;
1348 funaddr
= find_function_addr (method
, &val_type
);
1350 block_for_pc (funaddr
);
1352 CHECK_TYPEDEF (val_type
);
1354 if ((val_type
== NULL
)
1355 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1357 if (expect_type
!= NULL
)
1358 val_type
= expect_type
;
1361 struct_return
= using_struct_return (exp
->gdbarch
,
1362 value_type (method
),
1365 else if (expect_type
!= NULL
)
1367 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1368 check_typedef (expect_type
));
1371 /* Found a function symbol. Now we will substitute its
1372 value in place of the message dispatcher (obj_msgSend),
1373 so that we call the method directly instead of thru
1374 the dispatcher. The main reason for doing this is that
1375 we can now evaluate the return value and parameter values
1376 according to their known data types, in case we need to
1377 do things like promotion, dereferencing, special handling
1378 of structs and doubles, etc.
1380 We want to use the type signature of 'method', but still
1381 jump to objc_msgSend() or objc_msgSend_stret() to better
1382 mimic the behavior of the runtime. */
1386 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1387 error (_("method address has symbol information "
1388 "with non-function type; skipping"));
1390 /* Create a function pointer of the appropriate type, and
1391 replace its value with the value of msg_send or
1392 msg_send_stret. We must use a pointer here, as
1393 msg_send and msg_send_stret are of pointer type, and
1394 the representation may be different on systems that use
1395 function descriptors. */
1398 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1399 value_as_address (msg_send_stret
));
1402 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1403 value_as_address (msg_send
));
1408 called_method
= msg_send_stret
;
1410 called_method
= msg_send
;
1413 if (noside
== EVAL_SKIP
)
1416 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1418 /* If the return type doesn't look like a function type,
1419 call an error. This can happen if somebody tries to
1420 turn a variable into a function call. This is here
1421 because people often want to call, eg, strcmp, which
1422 gdb doesn't know is a function. If gdb isn't asked for
1423 it's opinion (ie. through "whatis"), it won't offer
1426 struct type
*type
= value_type (called_method
);
1428 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1429 type
= TYPE_TARGET_TYPE (type
);
1430 type
= TYPE_TARGET_TYPE (type
);
1434 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1435 return allocate_value (expect_type
);
1437 return allocate_value (type
);
1440 error (_("Expression of type other than "
1441 "\"method returning ...\" used as a method"));
1444 /* Now depending on whether we found a symbol for the method,
1445 we will either call the runtime dispatcher or the method
1448 argvec
[0] = called_method
;
1450 argvec
[2] = value_from_longest (long_type
, selector
);
1451 /* User-supplied arguments. */
1452 for (tem
= 0; tem
< nargs
; tem
++)
1453 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1454 argvec
[tem
+ 3] = 0;
1456 if (gnu_runtime
&& (method
!= NULL
))
1458 /* Function objc_msg_lookup returns a pointer. */
1459 deprecated_set_value_type (argvec
[0],
1460 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1462 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1465 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1472 op
= exp
->elts
[*pos
].opcode
;
1473 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1474 /* Allocate arg vector, including space for the function to be
1475 called in argvec[0] and a terminating NULL. */
1476 argvec
= (struct value
**)
1477 alloca (sizeof (struct value
*) * (nargs
+ 3));
1478 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1481 /* First, evaluate the structure into arg2. */
1484 if (noside
== EVAL_SKIP
)
1487 if (op
== STRUCTOP_MEMBER
)
1489 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1493 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1496 /* If the function is a virtual function, then the
1497 aggregate value (providing the structure) plays
1498 its part by providing the vtable. Otherwise,
1499 it is just along for the ride: call the function
1502 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1504 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1505 != TYPE_CODE_METHODPTR
)
1506 error (_("Non-pointer-to-member value used in pointer-to-member "
1509 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1511 struct type
*method_type
= check_typedef (value_type (arg1
));
1513 arg1
= value_zero (method_type
, not_lval
);
1516 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1518 /* Now, say which argument to start evaluating from. */
1521 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1523 /* Hair for method invocations. */
1527 /* First, evaluate the structure into arg2. */
1529 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1530 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1531 if (noside
== EVAL_SKIP
)
1534 if (op
== STRUCTOP_STRUCT
)
1536 /* If v is a variable in a register, and the user types
1537 v.method (), this will produce an error, because v has
1540 A possible way around this would be to allocate a
1541 copy of the variable on the stack, copy in the
1542 contents, call the function, and copy out the
1543 contents. I.e. convert this from call by reference
1544 to call by copy-return (or whatever it's called).
1545 However, this does not work because it is not the
1546 same: the method being called could stash a copy of
1547 the address, and then future uses through that address
1548 (after the method returns) would be expected to
1549 use the variable itself, not some copy of it. */
1550 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1554 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1556 /* Check to see if the operator '->' has been
1557 overloaded. If the operator has been overloaded
1558 replace arg2 with the value returned by the custom
1559 operator and continue evaluation. */
1560 while (unop_user_defined_p (op
, arg2
))
1562 volatile struct gdb_exception except
;
1563 struct value
*value
= NULL
;
1564 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1566 value
= value_x_unop (arg2
, op
, noside
);
1569 if (except
.reason
< 0)
1571 if (except
.error
== NOT_FOUND_ERROR
)
1574 throw_exception (except
);
1579 /* Now, say which argument to start evaluating from. */
1582 else if (op
== OP_SCOPE
1583 && overload_resolution
1584 && (exp
->language_defn
->la_language
== language_cplus
))
1586 /* Unpack it locally so we can properly handle overload
1592 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1593 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1594 type
= exp
->elts
[pc2
+ 1].type
;
1595 name
= &exp
->elts
[pc2
+ 3].string
;
1598 function_name
= NULL
;
1599 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1601 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1603 get_selected_block (0),
1605 if (function
== NULL
)
1606 error (_("No symbol \"%s\" in namespace \"%s\"."),
1607 name
, TYPE_TAG_NAME (type
));
1613 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1614 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1615 function_name
= name
;
1617 arg2
= value_zero (type
, lval_memory
);
1622 else if (op
== OP_ADL_FUNC
)
1624 /* Save the function position and move pos so that the arguments
1625 can be evaluated. */
1631 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1632 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1636 /* Non-method function call. */
1640 /* If this is a C++ function wait until overload resolution. */
1641 if (op
== OP_VAR_VALUE
1642 && overload_resolution
1643 && (exp
->language_defn
->la_language
== language_cplus
))
1645 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1650 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1651 type
= value_type (argvec
[0]);
1652 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1653 type
= TYPE_TARGET_TYPE (type
);
1654 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1656 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1658 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1666 /* Evaluate arguments. */
1667 for (; tem
<= nargs
; tem
++)
1669 /* Ensure that array expressions are coerced into pointer
1671 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1674 /* Signal end of arglist. */
1676 if (op
== OP_ADL_FUNC
)
1678 struct symbol
*symp
;
1681 int string_pc
= save_pos1
+ 3;
1683 /* Extract the function name. */
1684 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1685 func_name
= (char *) alloca (name_len
+ 1);
1686 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1688 find_overload_match (&argvec
[1], nargs
, func_name
,
1689 NON_METHOD
, /* not method */
1690 0, /* strict match */
1691 NULL
, NULL
, /* pass NULL symbol since
1692 symbol is unknown */
1693 NULL
, &symp
, NULL
, 0);
1695 /* Now fix the expression being evaluated. */
1696 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1697 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1700 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1701 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1703 int static_memfuncp
;
1706 /* Method invocation : stuff "this" as first parameter. */
1711 /* Name of method from expression. */
1712 tstr
= &exp
->elts
[pc2
+ 2].string
;
1715 tstr
= function_name
;
1717 if (overload_resolution
&& (exp
->language_defn
->la_language
1720 /* Language is C++, do some overload resolution before
1722 struct value
*valp
= NULL
;
1724 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1725 METHOD
, /* method */
1726 0, /* strict match */
1727 &arg2
, /* the object */
1729 &static_memfuncp
, 0);
1731 if (op
== OP_SCOPE
&& !static_memfuncp
)
1733 /* For the time being, we don't handle this. */
1734 error (_("Call to overloaded function %s requires "
1738 argvec
[1] = arg2
; /* the ``this'' pointer */
1739 argvec
[0] = valp
; /* Use the method found after overload
1743 /* Non-C++ case -- or no overload resolution. */
1745 struct value
*temp
= arg2
;
1747 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1749 op
== STRUCTOP_STRUCT
1750 ? "structure" : "structure pointer");
1751 /* value_struct_elt updates temp with the correct value
1752 of the ``this'' pointer if necessary, so modify argvec[1] to
1753 reflect any ``this'' changes. */
1755 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1756 value_address (temp
)
1757 + value_embedded_offset (temp
));
1758 argvec
[1] = arg2
; /* the ``this'' pointer */
1761 if (static_memfuncp
)
1763 argvec
[1] = argvec
[0];
1768 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1773 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1775 /* Non-member function being called. */
1776 /* fn: This can only be done for C++ functions. A C-style function
1777 in a C++ program, for instance, does not have the fields that
1778 are expected here. */
1780 if (overload_resolution
&& (exp
->language_defn
->la_language
1783 /* Language is C++, do some overload resolution before
1785 struct symbol
*symp
;
1788 /* If a scope has been specified disable ADL. */
1792 if (op
== OP_VAR_VALUE
)
1793 function
= exp
->elts
[save_pos1
+2].symbol
;
1795 (void) find_overload_match (&argvec
[1], nargs
,
1796 NULL
, /* no need for name */
1797 NON_METHOD
, /* not method */
1798 0, /* strict match */
1799 NULL
, function
, /* the function */
1800 NULL
, &symp
, NULL
, no_adl
);
1802 if (op
== OP_VAR_VALUE
)
1804 /* Now fix the expression being evaluated. */
1805 exp
->elts
[save_pos1
+2].symbol
= symp
;
1806 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1810 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1814 /* Not C++, or no overload resolution allowed. */
1815 /* Nothing to be done; argvec already correctly set up. */
1820 /* It is probably a C-style function. */
1821 /* Nothing to be done; argvec already correctly set up. */
1826 if (noside
== EVAL_SKIP
)
1828 if (argvec
[0] == NULL
)
1829 error (_("Cannot evaluate function -- may be inlined"));
1830 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1832 /* If the return type doesn't look like a function type, call an
1833 error. This can happen if somebody tries to turn a variable into
1834 a function call. This is here because people often want to
1835 call, eg, strcmp, which gdb doesn't know is a function. If
1836 gdb isn't asked for it's opinion (ie. through "whatis"),
1837 it won't offer it. */
1839 struct type
*ftype
= value_type (argvec
[0]);
1841 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1843 /* We don't know anything about what the internal
1844 function might return, but we have to return
1846 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1849 else if (TYPE_GNU_IFUNC (ftype
))
1850 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1851 else if (TYPE_TARGET_TYPE (ftype
))
1852 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1854 error (_("Expression of type other than "
1855 "\"Function returning ...\" used as function"));
1857 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1858 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1859 argvec
[0], nargs
, argvec
+ 1);
1861 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1862 /* pai: FIXME save value from call_function_by_hand, then adjust
1863 pc by adjust_fn_pc if +ve. */
1865 case OP_F77_UNDETERMINED_ARGLIST
:
1867 /* Remember that in F77, functions, substring ops and
1868 array subscript operations cannot be disambiguated
1869 at parse time. We have made all array subscript operations,
1870 substring operations as well as function calls come here
1871 and we now have to discover what the heck this thing actually was.
1872 If it is a function, we process just as if we got an OP_FUNCALL. */
1874 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1877 /* First determine the type code we are dealing with. */
1878 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1879 type
= check_typedef (value_type (arg1
));
1880 code
= TYPE_CODE (type
);
1882 if (code
== TYPE_CODE_PTR
)
1884 /* Fortran always passes variable to subroutines as pointer.
1885 So we need to look into its target type to see if it is
1886 array, string or function. If it is, we need to switch
1887 to the target value the original one points to. */
1888 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1890 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1891 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1892 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1894 arg1
= value_ind (arg1
);
1895 type
= check_typedef (value_type (arg1
));
1896 code
= TYPE_CODE (type
);
1902 case TYPE_CODE_ARRAY
:
1903 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1904 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1906 goto multi_f77_subscript
;
1908 case TYPE_CODE_STRING
:
1909 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1910 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1913 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1914 return value_subscript (arg1
, value_as_long (arg2
));
1918 case TYPE_CODE_FUNC
:
1919 /* It's a function call. */
1920 /* Allocate arg vector, including space for the function to be
1921 called in argvec[0] and a terminating NULL. */
1922 argvec
= (struct value
**)
1923 alloca (sizeof (struct value
*) * (nargs
+ 2));
1926 for (; tem
<= nargs
; tem
++)
1927 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1928 argvec
[tem
] = 0; /* signal end of arglist */
1932 error (_("Cannot perform substring on this type"));
1936 /* We have a complex number, There should be 2 floating
1937 point numbers that compose it. */
1939 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1940 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1942 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1944 case STRUCTOP_STRUCT
:
1945 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1946 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1947 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1948 if (noside
== EVAL_SKIP
)
1950 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1951 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1952 &exp
->elts
[pc
+ 2].string
,
1957 struct value
*temp
= arg1
;
1959 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1964 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1965 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1966 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1967 if (noside
== EVAL_SKIP
)
1970 /* Check to see if operator '->' has been overloaded. If so replace
1971 arg1 with the value returned by evaluating operator->(). */
1972 while (unop_user_defined_p (op
, arg1
))
1974 volatile struct gdb_exception except
;
1975 struct value
*value
= NULL
;
1976 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1978 value
= value_x_unop (arg1
, op
, noside
);
1981 if (except
.reason
< 0)
1983 if (except
.error
== NOT_FOUND_ERROR
)
1986 throw_exception (except
);
1991 /* JYG: if print object is on we need to replace the base type
1992 with rtti type in order to continue on with successful
1993 lookup of member / method only available in the rtti type. */
1995 struct type
*type
= value_type (arg1
);
1996 struct type
*real_type
;
1997 int full
, top
, using_enc
;
1998 struct value_print_options opts
;
2000 get_user_print_options (&opts
);
2001 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
2002 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
2004 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
2007 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
2008 real_type
= lookup_pointer_type (real_type
);
2010 real_type
= lookup_reference_type (real_type
);
2012 arg1
= value_cast (real_type
, arg1
);
2017 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2018 return value_zero (lookup_struct_elt_type (value_type (arg1
),
2019 &exp
->elts
[pc
+ 2].string
,
2024 struct value
*temp
= arg1
;
2026 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
2027 NULL
, "structure pointer");
2030 case STRUCTOP_MEMBER
:
2032 if (op
== STRUCTOP_MEMBER
)
2033 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2035 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2037 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2039 if (noside
== EVAL_SKIP
)
2042 type
= check_typedef (value_type (arg2
));
2043 switch (TYPE_CODE (type
))
2045 case TYPE_CODE_METHODPTR
:
2046 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2047 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2050 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2051 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2052 return value_ind (arg2
);
2055 case TYPE_CODE_MEMBERPTR
:
2056 /* Now, convert these values to an address. */
2057 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
2060 mem_offset
= value_as_long (arg2
);
2062 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2063 value_as_long (arg1
) + mem_offset
);
2064 return value_ind (arg3
);
2067 error (_("non-pointer-to-member value used "
2068 "in pointer-to-member construct"));
2072 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2073 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2074 for (ix
= 0; ix
< nargs
; ++ix
)
2075 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
2077 expect_type
= make_params (nargs
, arg_types
);
2078 *(pos
) += 3 + nargs
;
2079 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
2080 xfree (TYPE_FIELDS (expect_type
));
2081 xfree (TYPE_MAIN_TYPE (expect_type
));
2082 xfree (expect_type
);
2086 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2087 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2088 if (noside
== EVAL_SKIP
)
2090 if (binop_user_defined_p (op
, arg1
, arg2
))
2091 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2093 return value_concat (arg1
, arg2
);
2096 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2097 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2099 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2101 if (binop_user_defined_p (op
, arg1
, arg2
))
2102 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2104 return value_assign (arg1
, arg2
);
2106 case BINOP_ASSIGN_MODIFY
:
2108 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2109 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2110 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2112 op
= exp
->elts
[pc
+ 1].opcode
;
2113 if (binop_user_defined_p (op
, arg1
, arg2
))
2114 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2115 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2117 && is_integral_type (value_type (arg2
)))
2118 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2119 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2121 && is_integral_type (value_type (arg2
)))
2122 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2125 struct value
*tmp
= arg1
;
2127 /* For shift and integer exponentiation operations,
2128 only promote the first argument. */
2129 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2130 && is_integral_type (value_type (arg2
)))
2131 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2133 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2135 arg2
= value_binop (tmp
, arg2
, op
);
2137 return value_assign (arg1
, arg2
);
2140 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2141 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2142 if (noside
== EVAL_SKIP
)
2144 if (binop_user_defined_p (op
, arg1
, arg2
))
2145 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2146 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2147 && is_integral_type (value_type (arg2
)))
2148 return value_ptradd (arg1
, value_as_long (arg2
));
2149 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2150 && is_integral_type (value_type (arg1
)))
2151 return value_ptradd (arg2
, value_as_long (arg1
));
2154 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2155 return value_binop (arg1
, arg2
, BINOP_ADD
);
2159 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2160 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2161 if (noside
== EVAL_SKIP
)
2163 if (binop_user_defined_p (op
, arg1
, arg2
))
2164 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2165 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2166 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2168 /* FIXME -- should be ptrdiff_t */
2169 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2170 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2172 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2173 && is_integral_type (value_type (arg2
)))
2174 return value_ptradd (arg1
, - value_as_long (arg2
));
2177 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2178 return value_binop (arg1
, arg2
, BINOP_SUB
);
2189 case BINOP_BITWISE_AND
:
2190 case BINOP_BITWISE_IOR
:
2191 case BINOP_BITWISE_XOR
:
2192 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2193 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2194 if (noside
== EVAL_SKIP
)
2196 if (binop_user_defined_p (op
, arg1
, arg2
))
2197 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2200 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2201 fudge arg2 to avoid division-by-zero, the caller is
2202 (theoretically) only looking for the type of the result. */
2203 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2204 /* ??? Do we really want to test for BINOP_MOD here?
2205 The implementation of value_binop gives it a well-defined
2208 || op
== BINOP_INTDIV
2211 && value_logical_not (arg2
))
2213 struct value
*v_one
, *retval
;
2215 v_one
= value_one (value_type (arg2
));
2216 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2217 retval
= value_binop (arg1
, v_one
, op
);
2222 /* For shift and integer exponentiation operations,
2223 only promote the first argument. */
2224 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2225 && is_integral_type (value_type (arg2
)))
2226 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2228 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2230 return value_binop (arg1
, arg2
, op
);
2235 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2236 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2237 if (noside
== EVAL_SKIP
)
2239 error (_("':' operator used in invalid context"));
2241 case BINOP_SUBSCRIPT
:
2242 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2243 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2244 if (noside
== EVAL_SKIP
)
2246 if (binop_user_defined_p (op
, arg1
, arg2
))
2247 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2250 /* If the user attempts to subscript something that is not an
2251 array or pointer type (like a plain int variable for example),
2252 then report this as an error. */
2254 arg1
= coerce_ref (arg1
);
2255 type
= check_typedef (value_type (arg1
));
2256 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2257 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2259 if (TYPE_NAME (type
))
2260 error (_("cannot subscript something of type `%s'"),
2263 error (_("cannot subscript requested type"));
2266 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2267 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2269 return value_subscript (arg1
, value_as_long (arg2
));
2273 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2274 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2275 if (noside
== EVAL_SKIP
)
2277 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2278 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2280 case MULTI_SUBSCRIPT
:
2282 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2283 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2286 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2287 /* FIXME: EVAL_SKIP handling may not be correct. */
2288 if (noside
== EVAL_SKIP
)
2299 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2300 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2302 /* If the user attempts to subscript something that has no target
2303 type (like a plain int variable for example), then report this
2306 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2309 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2315 error (_("cannot subscript something of type `%s'"),
2316 TYPE_NAME (value_type (arg1
)));
2320 if (binop_user_defined_p (op
, arg1
, arg2
))
2322 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2326 arg1
= coerce_ref (arg1
);
2327 type
= check_typedef (value_type (arg1
));
2329 switch (TYPE_CODE (type
))
2332 case TYPE_CODE_ARRAY
:
2333 case TYPE_CODE_STRING
:
2334 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2337 case TYPE_CODE_BITSTRING
:
2338 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2339 arg1
= value_bitstring_subscript (type
, arg1
,
2340 value_as_long (arg2
));
2344 if (TYPE_NAME (type
))
2345 error (_("cannot subscript something of type `%s'"),
2348 error (_("cannot subscript requested type"));
2354 multi_f77_subscript
:
2356 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2357 int ndimensions
= 1, i
;
2358 struct value
*array
= arg1
;
2360 if (nargs
> MAX_FORTRAN_DIMS
)
2361 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2363 ndimensions
= calc_f77_array_dims (type
);
2365 if (nargs
!= ndimensions
)
2366 error (_("Wrong number of subscripts"));
2368 gdb_assert (nargs
> 0);
2370 /* Now that we know we have a legal array subscript expression
2371 let us actually find out where this element exists in the array. */
2373 /* Take array indices left to right. */
2374 for (i
= 0; i
< nargs
; i
++)
2376 /* Evaluate each subscript; it must be a legal integer in F77. */
2377 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2379 /* Fill in the subscript array. */
2381 subscript_array
[i
] = value_as_long (arg2
);
2384 /* Internal type of array is arranged right to left. */
2385 for (i
= nargs
; i
> 0; i
--)
2387 struct type
*array_type
= check_typedef (value_type (array
));
2388 LONGEST index
= subscript_array
[i
- 1];
2390 lower
= f77_get_lowerbound (array_type
);
2391 array
= value_subscripted_rvalue (array
, index
, lower
);
2397 case BINOP_LOGICAL_AND
:
2398 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2399 if (noside
== EVAL_SKIP
)
2401 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2406 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2409 if (binop_user_defined_p (op
, arg1
, arg2
))
2411 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2412 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2416 tem
= value_logical_not (arg1
);
2417 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2418 (tem
? EVAL_SKIP
: noside
));
2419 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2420 return value_from_longest (type
,
2421 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2424 case BINOP_LOGICAL_OR
:
2425 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2426 if (noside
== EVAL_SKIP
)
2428 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2433 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2436 if (binop_user_defined_p (op
, arg1
, arg2
))
2438 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2439 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2443 tem
= value_logical_not (arg1
);
2444 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2445 (!tem
? EVAL_SKIP
: noside
));
2446 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2447 return value_from_longest (type
,
2448 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2452 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2453 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2454 if (noside
== EVAL_SKIP
)
2456 if (binop_user_defined_p (op
, arg1
, arg2
))
2458 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2462 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2463 tem
= value_equal (arg1
, arg2
);
2464 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2465 return value_from_longest (type
, (LONGEST
) tem
);
2468 case BINOP_NOTEQUAL
:
2469 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2470 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2471 if (noside
== EVAL_SKIP
)
2473 if (binop_user_defined_p (op
, arg1
, arg2
))
2475 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2479 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2480 tem
= value_equal (arg1
, arg2
);
2481 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2482 return value_from_longest (type
, (LONGEST
) ! tem
);
2486 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2487 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2488 if (noside
== EVAL_SKIP
)
2490 if (binop_user_defined_p (op
, arg1
, arg2
))
2492 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2496 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2497 tem
= value_less (arg1
, arg2
);
2498 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2499 return value_from_longest (type
, (LONGEST
) tem
);
2503 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2504 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2505 if (noside
== EVAL_SKIP
)
2507 if (binop_user_defined_p (op
, arg1
, arg2
))
2509 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2513 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2514 tem
= value_less (arg2
, arg1
);
2515 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2516 return value_from_longest (type
, (LONGEST
) tem
);
2520 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2521 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2522 if (noside
== EVAL_SKIP
)
2524 if (binop_user_defined_p (op
, arg1
, arg2
))
2526 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2530 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2531 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2532 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2533 return value_from_longest (type
, (LONGEST
) tem
);
2537 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2538 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2539 if (noside
== EVAL_SKIP
)
2541 if (binop_user_defined_p (op
, arg1
, arg2
))
2543 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2547 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2548 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2549 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2550 return value_from_longest (type
, (LONGEST
) tem
);
2554 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2555 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2556 if (noside
== EVAL_SKIP
)
2558 type
= check_typedef (value_type (arg2
));
2559 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2560 error (_("Non-integral right operand for \"@\" operator."));
2561 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2563 return allocate_repeat_value (value_type (arg1
),
2564 longest_to_int (value_as_long (arg2
)));
2567 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2570 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2571 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2574 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2575 if (noside
== EVAL_SKIP
)
2577 if (unop_user_defined_p (op
, arg1
))
2578 return value_x_unop (arg1
, op
, noside
);
2581 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2582 return value_pos (arg1
);
2586 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2587 if (noside
== EVAL_SKIP
)
2589 if (unop_user_defined_p (op
, arg1
))
2590 return value_x_unop (arg1
, op
, noside
);
2593 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2594 return value_neg (arg1
);
2597 case UNOP_COMPLEMENT
:
2598 /* C++: check for and handle destructor names. */
2599 op
= exp
->elts
[*pos
].opcode
;
2601 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2602 if (noside
== EVAL_SKIP
)
2604 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2605 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2608 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2609 return value_complement (arg1
);
2612 case UNOP_LOGICAL_NOT
:
2613 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2614 if (noside
== EVAL_SKIP
)
2616 if (unop_user_defined_p (op
, arg1
))
2617 return value_x_unop (arg1
, op
, noside
);
2620 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2621 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2625 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2626 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2627 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2628 type
= check_typedef (value_type (arg1
));
2629 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2630 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2631 error (_("Attempt to dereference pointer "
2632 "to member without an object"));
2633 if (noside
== EVAL_SKIP
)
2635 if (unop_user_defined_p (op
, arg1
))
2636 return value_x_unop (arg1
, op
, noside
);
2637 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2639 type
= check_typedef (value_type (arg1
));
2640 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2641 || TYPE_CODE (type
) == TYPE_CODE_REF
2642 /* In C you can dereference an array to get the 1st elt. */
2643 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2645 return value_zero (TYPE_TARGET_TYPE (type
),
2647 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2648 /* GDB allows dereferencing an int. */
2649 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2652 error (_("Attempt to take contents of a non-pointer value."));
2655 /* Allow * on an integer so we can cast it to whatever we want.
2656 This returns an int, which seems like the most C-like thing to
2657 do. "long long" variables are rare enough that
2658 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2659 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2660 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2661 (CORE_ADDR
) value_as_address (arg1
));
2662 return value_ind (arg1
);
2665 /* C++: check for and handle pointer to members. */
2667 op
= exp
->elts
[*pos
].opcode
;
2669 if (noside
== EVAL_SKIP
)
2671 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2676 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2683 if (noside
== EVAL_SKIP
)
2685 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2688 return evaluate_subexp_for_sizeof (exp
, pos
);
2692 type
= exp
->elts
[pc
+ 1].type
;
2693 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2694 if (noside
== EVAL_SKIP
)
2696 if (type
!= value_type (arg1
))
2697 arg1
= value_cast (type
, arg1
);
2700 case UNOP_DYNAMIC_CAST
:
2702 type
= exp
->elts
[pc
+ 1].type
;
2703 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2704 if (noside
== EVAL_SKIP
)
2706 return value_dynamic_cast (type
, arg1
);
2708 case UNOP_REINTERPRET_CAST
:
2710 type
= exp
->elts
[pc
+ 1].type
;
2711 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2712 if (noside
== EVAL_SKIP
)
2714 return value_reinterpret_cast (type
, arg1
);
2718 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2719 if (noside
== EVAL_SKIP
)
2721 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2722 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2724 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2725 value_as_address (arg1
));
2727 case UNOP_MEMVAL_TLS
:
2729 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2730 if (noside
== EVAL_SKIP
)
2732 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2733 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2738 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2739 value_as_address (arg1
));
2740 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2743 case UNOP_PREINCREMENT
:
2744 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2745 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2747 else if (unop_user_defined_p (op
, arg1
))
2749 return value_x_unop (arg1
, op
, noside
);
2753 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2754 arg2
= value_ptradd (arg1
, 1);
2757 struct value
*tmp
= arg1
;
2759 arg2
= value_one (value_type (arg1
));
2760 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2761 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2764 return value_assign (arg1
, arg2
);
2767 case UNOP_PREDECREMENT
:
2768 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2769 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2771 else if (unop_user_defined_p (op
, arg1
))
2773 return value_x_unop (arg1
, op
, noside
);
2777 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2778 arg2
= value_ptradd (arg1
, -1);
2781 struct value
*tmp
= arg1
;
2783 arg2
= value_one (value_type (arg1
));
2784 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2785 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2788 return value_assign (arg1
, arg2
);
2791 case UNOP_POSTINCREMENT
:
2792 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2793 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2795 else if (unop_user_defined_p (op
, arg1
))
2797 return value_x_unop (arg1
, op
, noside
);
2801 arg3
= value_non_lval (arg1
);
2803 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2804 arg2
= value_ptradd (arg1
, 1);
2807 struct value
*tmp
= arg1
;
2809 arg2
= value_one (value_type (arg1
));
2810 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2811 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2814 value_assign (arg1
, arg2
);
2818 case UNOP_POSTDECREMENT
:
2819 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2820 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2822 else if (unop_user_defined_p (op
, arg1
))
2824 return value_x_unop (arg1
, op
, noside
);
2828 arg3
= value_non_lval (arg1
);
2830 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2831 arg2
= value_ptradd (arg1
, -1);
2834 struct value
*tmp
= arg1
;
2836 arg2
= value_one (value_type (arg1
));
2837 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2838 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2841 value_assign (arg1
, arg2
);
2847 return value_of_this (exp
->language_defn
);
2850 /* The value is not supposed to be used. This is here to make it
2851 easier to accommodate expressions that contain types. */
2853 if (noside
== EVAL_SKIP
)
2855 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2857 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2859 /* If this is a typedef, then find its immediate target. We
2860 use check_typedef to resolve stubs, but we ignore its
2861 result because we do not want to dig past all
2863 check_typedef (type
);
2864 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2865 type
= TYPE_TARGET_TYPE (type
);
2866 return allocate_value (type
);
2869 error (_("Attempt to use a type name as an expression"));
2872 /* Removing this case and compiling with gcc -Wall reveals that
2873 a lot of cases are hitting this case. Some of these should
2874 probably be removed from expression.h; others are legitimate
2875 expressions which are (apparently) not fully implemented.
2877 If there are any cases landing here which mean a user error,
2878 then they should be separate cases, with more descriptive
2881 error (_("GDB does not (yet) know how to "
2882 "evaluate that kind of expression"));
2886 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2889 /* Evaluate a subexpression of EXP, at index *POS,
2890 and return the address of that subexpression.
2891 Advance *POS over the subexpression.
2892 If the subexpression isn't an lvalue, get an error.
2893 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2894 then only the type of the result need be correct. */
2896 static struct value
*
2897 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2907 op
= exp
->elts
[pc
].opcode
;
2913 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2915 /* We can't optimize out "&*" if there's a user-defined operator*. */
2916 if (unop_user_defined_p (op
, x
))
2918 x
= value_x_unop (x
, op
, noside
);
2919 goto default_case_after_eval
;
2922 return coerce_array (x
);
2926 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2927 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2930 var
= exp
->elts
[pc
+ 2].symbol
;
2932 /* C++: The "address" of a reference should yield the address
2933 * of the object pointed to. Let value_addr() deal with it. */
2934 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2938 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2941 lookup_pointer_type (SYMBOL_TYPE (var
));
2942 enum address_class sym_class
= SYMBOL_CLASS (var
);
2944 if (sym_class
== LOC_CONST
2945 || sym_class
== LOC_CONST_BYTES
2946 || sym_class
== LOC_REGISTER
)
2947 error (_("Attempt to take address of register or constant."));
2950 value_zero (type
, not_lval
);
2953 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2956 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2957 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2958 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2959 &exp
->elts
[pc
+ 3].string
,
2962 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2967 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2968 default_case_after_eval
:
2969 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2971 struct type
*type
= check_typedef (value_type (x
));
2973 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2974 return value_zero (lookup_pointer_type (value_type (x
)),
2976 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2977 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2980 error (_("Attempt to take address of "
2981 "value not located in memory."));
2983 return value_addr (x
);
2987 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2988 When used in contexts where arrays will be coerced anyway, this is
2989 equivalent to `evaluate_subexp' but much faster because it avoids
2990 actually fetching array contents (perhaps obsolete now that we have
2993 Note that we currently only do the coercion for C expressions, where
2994 arrays are zero based and the coercion is correct. For other languages,
2995 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2996 to decide if coercion is appropriate. */
2999 evaluate_subexp_with_coercion (struct expression
*exp
,
3000 int *pos
, enum noside noside
)
3009 op
= exp
->elts
[pc
].opcode
;
3014 var
= exp
->elts
[pc
+ 2].symbol
;
3015 type
= check_typedef (SYMBOL_TYPE (var
));
3016 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3017 && !TYPE_VECTOR (type
)
3018 && CAST_IS_CONVERSION (exp
->language_defn
))
3021 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3022 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3028 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3032 /* Evaluate a subexpression of EXP, at index *POS,
3033 and return a value for the size of that subexpression.
3034 Advance *POS over the subexpression. */
3036 static struct value
*
3037 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
3039 /* FIXME: This should be size_t. */
3040 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3047 op
= exp
->elts
[pc
].opcode
;
3051 /* This case is handled specially
3052 so that we avoid creating a value for the result type.
3053 If the result type is very big, it's desirable not to
3054 create a value unnecessarily. */
3057 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3058 type
= check_typedef (value_type (val
));
3059 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3060 && TYPE_CODE (type
) != TYPE_CODE_REF
3061 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3062 error (_("Attempt to take contents of a non-pointer value."));
3063 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3064 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3068 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3069 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3073 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3075 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3078 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3079 return value_from_longest (size_type
,
3080 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3084 /* Parse a type expression in the string [P..P+LENGTH). */
3087 parse_and_eval_type (char *p
, int length
)
3089 char *tmp
= (char *) alloca (length
+ 4);
3090 struct expression
*expr
;
3093 memcpy (tmp
+ 1, p
, length
);
3094 tmp
[length
+ 1] = ')';
3095 tmp
[length
+ 2] = '0';
3096 tmp
[length
+ 3] = '\0';
3097 expr
= parse_expression (tmp
);
3098 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3099 error (_("Internal error in eval_type."));
3100 return expr
->elts
[1].type
;
3104 calc_f77_array_dims (struct type
*array_type
)
3107 struct type
*tmp_type
;
3109 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3110 error (_("Can't get dimensions for a non-array type"));
3112 tmp_type
= array_type
;
3114 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3116 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)