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 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
340 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
343 subfieldno
= fieldno
;
344 substruct_type
= struct_type
;
348 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
351 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
353 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
354 if ((field_name
== 0 || *field_name
== '\0')
355 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
358 for (; variantno
< TYPE_NFIELDS (field_type
);
362 = TYPE_FIELD_TYPE (field_type
, variantno
);
363 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
366 subfieldno
< TYPE_NFIELDS (substruct_type
);
369 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
380 error (_("there is no field named %s"), label
);
386 /* Unlabelled tuple element - go to next field. */
390 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
393 substruct_type
= struct_type
;
399 /* Skip static fields. */
400 while (fieldno
< TYPE_NFIELDS (struct_type
)
401 && field_is_static (&TYPE_FIELD (struct_type
,
404 subfieldno
= fieldno
;
405 if (fieldno
>= TYPE_NFIELDS (struct_type
))
406 error (_("too many initializers"));
407 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
408 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
409 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
410 error (_("don't know which variant you want to set"));
414 /* Here, struct_type is the type of the inner struct,
415 while substruct_type is the type of the inner struct.
416 These are the same for normal structures, but a variant struct
417 contains anonymous union fields that contain substruct fields.
418 The value fieldno is the index of the top-level (normal or
419 anonymous union) field in struct_field, while the value
420 subfieldno is the index of the actual real (named inner) field
421 in substruct_type. */
423 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
425 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
427 /* Now actually set the field in struct_val. */
429 /* Assign val to field fieldno. */
430 if (value_type (val
) != field_type
)
431 val
= value_cast (field_type
, val
);
433 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
434 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
436 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
437 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
439 modify_field (struct_type
, addr
,
440 value_as_long (val
), bitpos
% 8, bitsize
);
442 memcpy (addr
, value_contents (val
),
443 TYPE_LENGTH (value_type (val
)));
445 while (--nlabels
> 0);
450 /* Recursive helper function for setting elements of array tuples for
451 (the deleted) Chill. The target is ARRAY (which has bounds
452 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
453 and NOSIDE are as usual. Evaluates index expresions and sets the
454 specified element(s) of ARRAY to ELEMENT. Returns last index
458 init_array_element (struct value
*array
, struct value
*element
,
459 struct expression
*exp
, int *pos
,
460 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
463 int element_size
= TYPE_LENGTH (value_type (element
));
465 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
468 init_array_element (array
, element
, exp
, pos
, noside
,
469 low_bound
, high_bound
);
470 return init_array_element (array
, element
,
471 exp
, pos
, noside
, low_bound
, high_bound
);
473 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
478 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
479 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
480 if (low
< low_bound
|| high
> high_bound
)
481 error (_("tuple range index out of range"));
482 for (index
= low
; index
<= high
; index
++)
484 memcpy (value_contents_raw (array
)
485 + (index
- low_bound
) * element_size
,
486 value_contents (element
), element_size
);
491 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
492 if (index
< low_bound
|| index
> high_bound
)
493 error (_("tuple index out of range"));
494 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
495 value_contents (element
), element_size
);
500 static struct value
*
501 value_f90_subarray (struct value
*array
,
502 struct expression
*exp
, int *pos
, enum noside noside
)
505 LONGEST low_bound
, high_bound
;
506 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
507 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
511 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
512 low_bound
= TYPE_LOW_BOUND (range
);
514 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
516 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
517 high_bound
= TYPE_HIGH_BOUND (range
);
519 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
521 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
525 /* Promote value ARG1 as appropriate before performing a unary operation
527 If the result is not appropriate for any particular language then it
528 needs to patch this function. */
531 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
536 *arg1
= coerce_ref (*arg1
);
537 type1
= check_typedef (value_type (*arg1
));
539 if (is_integral_type (type1
))
541 switch (language
->la_language
)
544 /* Perform integral promotion for ANSI C/C++.
545 If not appropropriate for any particular language
546 it needs to modify this function. */
548 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
550 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
551 *arg1
= value_cast (builtin_int
, *arg1
);
558 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
559 operation on those two operands.
560 If the result is not appropriate for any particular language then it
561 needs to patch this function. */
564 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
565 struct value
**arg1
, struct value
**arg2
)
567 struct type
*promoted_type
= NULL
;
571 *arg1
= coerce_ref (*arg1
);
572 *arg2
= coerce_ref (*arg2
);
574 type1
= check_typedef (value_type (*arg1
));
575 type2
= check_typedef (value_type (*arg2
));
577 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
578 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
579 && !is_integral_type (type1
))
580 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
581 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
582 && !is_integral_type (type2
)))
585 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
586 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
588 /* No promotion required. */
590 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
591 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
593 switch (language
->la_language
)
599 case language_opencl
:
600 /* No promotion required. */
604 /* For other languages the result type is unchanged from gdb
605 version 6.7 for backward compatibility.
606 If either arg was long double, make sure that value is also long
607 double. Otherwise use double. */
608 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
609 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
610 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
612 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
616 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
617 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
619 /* No promotion required. */
622 /* Integral operations here. */
623 /* FIXME: Also mixed integral/booleans, with result an integer. */
625 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
626 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
627 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
628 int is_unsigned1
= TYPE_UNSIGNED (type1
);
629 int is_unsigned2
= TYPE_UNSIGNED (type2
);
630 unsigned int result_len
;
631 int unsigned_operation
;
633 /* Determine type length and signedness after promotion for
635 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
638 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
640 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
643 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
646 if (promoted_len1
> promoted_len2
)
648 unsigned_operation
= is_unsigned1
;
649 result_len
= promoted_len1
;
651 else if (promoted_len2
> promoted_len1
)
653 unsigned_operation
= is_unsigned2
;
654 result_len
= promoted_len2
;
658 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
659 result_len
= promoted_len1
;
662 switch (language
->la_language
)
668 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
670 promoted_type
= (unsigned_operation
671 ? builtin
->builtin_unsigned_int
672 : builtin
->builtin_int
);
674 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
676 promoted_type
= (unsigned_operation
677 ? builtin
->builtin_unsigned_long
678 : builtin
->builtin_long
);
682 promoted_type
= (unsigned_operation
683 ? builtin
->builtin_unsigned_long_long
684 : builtin
->builtin_long_long
);
687 case language_opencl
:
688 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
689 (language
, gdbarch
, "int")))
693 ? lookup_unsigned_typename (language
, gdbarch
, "int")
694 : lookup_signed_typename (language
, gdbarch
, "int"));
696 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
697 (language
, gdbarch
, "long")))
701 ? lookup_unsigned_typename (language
, gdbarch
, "long")
702 : lookup_signed_typename (language
, gdbarch
,"long"));
706 /* For other languages the result type is unchanged from gdb
707 version 6.7 for backward compatibility.
708 If either arg was long long, make sure that value is also long
709 long. Otherwise use long. */
710 if (unsigned_operation
)
712 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
713 promoted_type
= builtin
->builtin_unsigned_long_long
;
715 promoted_type
= builtin
->builtin_unsigned_long
;
719 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
720 promoted_type
= builtin
->builtin_long_long
;
722 promoted_type
= builtin
->builtin_long
;
730 /* Promote both operands to common type. */
731 *arg1
= value_cast (promoted_type
, *arg1
);
732 *arg2
= value_cast (promoted_type
, *arg2
);
737 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
739 type
= check_typedef (type
);
740 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
741 type
= TYPE_TARGET_TYPE (type
);
743 switch (TYPE_CODE (type
))
749 case TYPE_CODE_ARRAY
:
750 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
757 /* Constructs a fake method with the given parameter types.
758 This function is used by the parser to construct an "expected"
759 type for method overload resolution. */
762 make_params (int num_types
, struct type
**param_types
)
764 struct type
*type
= XZALLOC (struct type
);
765 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
766 TYPE_LENGTH (type
) = 1;
767 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
768 TYPE_VPTR_FIELDNO (type
) = -1;
769 TYPE_CHAIN (type
) = type
;
770 TYPE_NFIELDS (type
) = num_types
;
771 TYPE_FIELDS (type
) = (struct field
*)
772 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
774 while (num_types
-- > 0)
775 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
781 evaluate_subexp_standard (struct type
*expect_type
,
782 struct expression
*exp
, int *pos
,
787 int pc
, pc2
= 0, oldpos
;
788 struct value
*arg1
= NULL
;
789 struct value
*arg2
= NULL
;
793 struct value
**argvec
;
798 struct type
**arg_types
;
800 struct symbol
*function
= NULL
;
801 char *function_name
= NULL
;
804 op
= exp
->elts
[pc
].opcode
;
809 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
810 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
811 if (noside
== EVAL_SKIP
)
813 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
814 &exp
->elts
[pc
+ 3].string
,
815 expect_type
, 0, noside
);
817 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
822 return value_from_longest (exp
->elts
[pc
+ 1].type
,
823 exp
->elts
[pc
+ 2].longconst
);
827 return value_from_double (exp
->elts
[pc
+ 1].type
,
828 exp
->elts
[pc
+ 2].doubleconst
);
832 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
833 exp
->elts
[pc
+ 2].decfloatconst
);
838 if (noside
== EVAL_SKIP
)
841 /* JYG: We used to just return value_zero of the symbol type
842 if we're asked to avoid side effects. Otherwise we return
843 value_of_variable (...). However I'm not sure if
844 value_of_variable () has any side effect.
845 We need a full value object returned here for whatis_exp ()
846 to call evaluate_type () and then pass the full value to
847 value_rtti_target_type () if we are dealing with a pointer
848 or reference to a base class and print object is on. */
851 volatile struct gdb_exception except
;
852 struct value
*ret
= NULL
;
854 TRY_CATCH (except
, RETURN_MASK_ERROR
)
856 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
857 exp
->elts
[pc
+ 1].block
);
860 if (except
.reason
< 0)
862 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
863 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
866 throw_exception (except
);
872 case OP_VAR_ENTRY_VALUE
:
874 if (noside
== EVAL_SKIP
)
878 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
879 struct frame_info
*frame
;
881 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
882 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
884 if (SYMBOL_CLASS (sym
) != LOC_COMPUTED
885 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
886 error (_("Symbol \"%s\" does not have any specific entry value"),
887 SYMBOL_PRINT_NAME (sym
));
889 frame
= get_selected_frame (NULL
);
890 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
896 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
900 const char *name
= &exp
->elts
[pc
+ 2].string
;
904 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
905 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
906 name
, strlen (name
));
908 error (_("Register $%s not available."), name
);
910 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
911 a value with the appropriate register type. Unfortunately,
912 we don't have easy access to the type of user registers.
913 So for these registers, we fetch the register value regardless
914 of the evaluation mode. */
915 if (noside
== EVAL_AVOID_SIDE_EFFECTS
916 && regno
< gdbarch_num_regs (exp
->gdbarch
)
917 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
918 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
920 val
= value_of_register (regno
, get_selected_frame (NULL
));
922 error (_("Value of register %s not available."), name
);
928 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
929 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
933 return value_of_internalvar (exp
->gdbarch
,
934 exp
->elts
[pc
+ 1].internalvar
);
937 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
938 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
939 if (noside
== EVAL_SKIP
)
941 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
942 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
944 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
945 NSString constant. */
946 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
947 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
948 if (noside
== EVAL_SKIP
)
952 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
955 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
957 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
958 if (noside
== EVAL_SKIP
)
960 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
,
961 builtin_type (exp
->gdbarch
)->builtin_int
);
966 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
967 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
968 nargs
= tem3
- tem2
+ 1;
969 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
971 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
972 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
974 struct value
*rec
= allocate_value (expect_type
);
976 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
977 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
980 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
981 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
983 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
984 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
985 struct value
*array
= allocate_value (expect_type
);
986 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
987 LONGEST low_bound
, high_bound
, index
;
989 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
992 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
995 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
996 for (tem
= nargs
; --nargs
>= 0;)
998 struct value
*element
;
1001 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1003 index_pc
= ++(*pos
);
1004 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1006 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1007 if (value_type (element
) != element_type
)
1008 element
= value_cast (element_type
, element
);
1011 int continue_pc
= *pos
;
1014 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1015 low_bound
, high_bound
);
1020 if (index
> high_bound
)
1021 /* To avoid memory corruption. */
1022 error (_("Too many array elements"));
1023 memcpy (value_contents_raw (array
)
1024 + (index
- low_bound
) * element_size
,
1025 value_contents (element
),
1033 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1034 && TYPE_CODE (type
) == TYPE_CODE_SET
)
1036 struct value
*set
= allocate_value (expect_type
);
1037 gdb_byte
*valaddr
= value_contents_raw (set
);
1038 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
1039 struct type
*check_type
= element_type
;
1040 LONGEST low_bound
, high_bound
;
1042 /* Get targettype of elementtype. */
1043 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
1044 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
1045 check_type
= TYPE_TARGET_TYPE (check_type
);
1047 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1048 error (_("(power)set type with unknown size"));
1049 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1050 for (tem
= 0; tem
< nargs
; tem
++)
1052 LONGEST range_low
, range_high
;
1053 struct type
*range_low_type
, *range_high_type
;
1054 struct value
*elem_val
;
1056 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
1059 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1060 range_low_type
= value_type (elem_val
);
1061 range_low
= value_as_long (elem_val
);
1062 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1063 range_high_type
= value_type (elem_val
);
1064 range_high
= value_as_long (elem_val
);
1068 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1069 range_low_type
= range_high_type
= value_type (elem_val
);
1070 range_low
= range_high
= value_as_long (elem_val
);
1072 /* Check types of elements to avoid mixture of elements from
1073 different types. Also check if type of element is "compatible"
1074 with element type of powerset. */
1075 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
1076 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1077 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
1078 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1079 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
1080 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
1081 && (range_low_type
!= range_high_type
)))
1082 /* different element modes. */
1083 error (_("POWERSET tuple elements of different mode"));
1084 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
1085 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
1086 && range_low_type
!= check_type
))
1087 error (_("incompatible POWERSET tuple elements"));
1088 if (range_low
> range_high
)
1090 warning (_("empty POWERSET tuple range"));
1093 if (range_low
< low_bound
|| range_high
> high_bound
)
1094 error (_("POWERSET tuple element out of range"));
1095 range_low
-= low_bound
;
1096 range_high
-= low_bound
;
1097 for (; range_low
<= range_high
; range_low
++)
1099 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1101 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1102 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1103 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1110 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1111 for (tem
= 0; tem
< nargs
; tem
++)
1113 /* Ensure that array expressions are coerced into pointer
1115 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1117 if (noside
== EVAL_SKIP
)
1119 return value_array (tem2
, tem3
, argvec
);
1123 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1125 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1127 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1129 if (noside
== EVAL_SKIP
)
1131 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1134 case TERNOP_SLICE_COUNT
:
1136 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1138 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1140 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1142 return value_slice (array
, lowbound
, length
);
1146 /* Skip third and second args to evaluate the first one. */
1147 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1148 if (value_logical_not (arg1
))
1150 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1151 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1155 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1156 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1160 case OP_OBJC_SELECTOR
:
1161 { /* Objective C @selector operator. */
1162 char *sel
= &exp
->elts
[pc
+ 2].string
;
1163 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1164 struct type
*selector_type
;
1166 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1167 if (noside
== EVAL_SKIP
)
1171 sel
[len
] = 0; /* Make sure it's terminated. */
1173 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1174 return value_from_longest (selector_type
,
1175 lookup_child_selector (exp
->gdbarch
, sel
));
1178 case OP_OBJC_MSGCALL
:
1179 { /* Objective C message (method) call. */
1181 CORE_ADDR responds_selector
= 0;
1182 CORE_ADDR method_selector
= 0;
1184 CORE_ADDR selector
= 0;
1186 int struct_return
= 0;
1187 int sub_no_side
= 0;
1189 struct value
*msg_send
= NULL
;
1190 struct value
*msg_send_stret
= NULL
;
1191 int gnu_runtime
= 0;
1193 struct value
*target
= NULL
;
1194 struct value
*method
= NULL
;
1195 struct value
*called_method
= NULL
;
1197 struct type
*selector_type
= NULL
;
1198 struct type
*long_type
;
1200 struct value
*ret
= NULL
;
1203 selector
= exp
->elts
[pc
+ 1].longconst
;
1204 nargs
= exp
->elts
[pc
+ 2].longconst
;
1205 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1210 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1211 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1213 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1214 sub_no_side
= EVAL_NORMAL
;
1216 sub_no_side
= noside
;
1218 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1220 if (value_as_long (target
) == 0)
1221 return value_from_longest (long_type
, 0);
1223 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1226 /* Find the method dispatch (Apple runtime) or method lookup
1227 (GNU runtime) function for Objective-C. These will be used
1228 to lookup the symbol information for the method. If we
1229 can't find any symbol information, then we'll use these to
1230 call the method, otherwise we can call the method
1231 directly. The msg_send_stret function is used in the special
1232 case of a method that returns a structure (Apple runtime
1236 struct type
*type
= selector_type
;
1238 type
= lookup_function_type (type
);
1239 type
= lookup_pointer_type (type
);
1240 type
= lookup_function_type (type
);
1241 type
= lookup_pointer_type (type
);
1243 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1245 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1247 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1248 msg_send_stret
= value_from_pointer (type
,
1249 value_as_address (msg_send_stret
));
1253 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1254 /* Special dispatcher for methods returning structs. */
1256 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1259 /* Verify the target object responds to this method. The
1260 standard top-level 'Object' class uses a different name for
1261 the verification method than the non-standard, but more
1262 often used, 'NSObject' class. Make sure we check for both. */
1265 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1266 if (responds_selector
== 0)
1268 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1270 if (responds_selector
== 0)
1271 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1274 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1275 if (method_selector
== 0)
1277 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1279 if (method_selector
== 0)
1280 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1282 /* Call the verification method, to make sure that the target
1283 class implements the desired method. */
1285 argvec
[0] = msg_send
;
1287 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1288 argvec
[3] = value_from_longest (long_type
, selector
);
1291 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1294 /* Function objc_msg_lookup returns a pointer. */
1296 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1298 if (value_as_long (ret
) == 0)
1299 error (_("Target does not respond to this message selector."));
1301 /* Call "methodForSelector:" method, to get the address of a
1302 function method that implements this selector for this
1303 class. If we can find a symbol at that address, then we
1304 know the return type, parameter types etc. (that's a good
1307 argvec
[0] = msg_send
;
1309 argvec
[2] = value_from_longest (long_type
, method_selector
);
1310 argvec
[3] = value_from_longest (long_type
, selector
);
1313 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1317 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1320 /* ret should now be the selector. */
1322 addr
= value_as_long (ret
);
1325 struct symbol
*sym
= NULL
;
1327 /* The address might point to a function descriptor;
1328 resolve it to the actual code address instead. */
1329 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1332 /* Is it a high_level symbol? */
1333 sym
= find_pc_function (addr
);
1335 method
= value_of_variable (sym
, 0);
1338 /* If we found a method with symbol information, check to see
1339 if it returns a struct. Otherwise assume it doesn't. */
1344 struct type
*val_type
;
1346 funaddr
= find_function_addr (method
, &val_type
);
1348 block_for_pc (funaddr
);
1350 CHECK_TYPEDEF (val_type
);
1352 if ((val_type
== NULL
)
1353 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1355 if (expect_type
!= NULL
)
1356 val_type
= expect_type
;
1359 struct_return
= using_struct_return (exp
->gdbarch
,
1360 value_type (method
),
1363 else if (expect_type
!= NULL
)
1365 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1366 check_typedef (expect_type
));
1369 /* Found a function symbol. Now we will substitute its
1370 value in place of the message dispatcher (obj_msgSend),
1371 so that we call the method directly instead of thru
1372 the dispatcher. The main reason for doing this is that
1373 we can now evaluate the return value and parameter values
1374 according to their known data types, in case we need to
1375 do things like promotion, dereferencing, special handling
1376 of structs and doubles, etc.
1378 We want to use the type signature of 'method', but still
1379 jump to objc_msgSend() or objc_msgSend_stret() to better
1380 mimic the behavior of the runtime. */
1384 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1385 error (_("method address has symbol information "
1386 "with non-function type; skipping"));
1388 /* Create a function pointer of the appropriate type, and
1389 replace its value with the value of msg_send or
1390 msg_send_stret. We must use a pointer here, as
1391 msg_send and msg_send_stret are of pointer type, and
1392 the representation may be different on systems that use
1393 function descriptors. */
1396 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1397 value_as_address (msg_send_stret
));
1400 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1401 value_as_address (msg_send
));
1406 called_method
= msg_send_stret
;
1408 called_method
= msg_send
;
1411 if (noside
== EVAL_SKIP
)
1414 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1416 /* If the return type doesn't look like a function type,
1417 call an error. This can happen if somebody tries to
1418 turn a variable into a function call. This is here
1419 because people often want to call, eg, strcmp, which
1420 gdb doesn't know is a function. If gdb isn't asked for
1421 it's opinion (ie. through "whatis"), it won't offer
1424 struct type
*type
= value_type (called_method
);
1426 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1427 type
= TYPE_TARGET_TYPE (type
);
1428 type
= TYPE_TARGET_TYPE (type
);
1432 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1433 return allocate_value (expect_type
);
1435 return allocate_value (type
);
1438 error (_("Expression of type other than "
1439 "\"method returning ...\" used as a method"));
1442 /* Now depending on whether we found a symbol for the method,
1443 we will either call the runtime dispatcher or the method
1446 argvec
[0] = called_method
;
1448 argvec
[2] = value_from_longest (long_type
, selector
);
1449 /* User-supplied arguments. */
1450 for (tem
= 0; tem
< nargs
; tem
++)
1451 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1452 argvec
[tem
+ 3] = 0;
1454 if (gnu_runtime
&& (method
!= NULL
))
1456 /* Function objc_msg_lookup returns a pointer. */
1457 deprecated_set_value_type (argvec
[0],
1458 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1460 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1463 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1470 op
= exp
->elts
[*pos
].opcode
;
1471 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1472 /* Allocate arg vector, including space for the function to be
1473 called in argvec[0] and a terminating NULL. */
1474 argvec
= (struct value
**)
1475 alloca (sizeof (struct value
*) * (nargs
+ 3));
1476 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1479 /* First, evaluate the structure into arg2. */
1482 if (noside
== EVAL_SKIP
)
1485 if (op
== STRUCTOP_MEMBER
)
1487 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1491 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1494 /* If the function is a virtual function, then the
1495 aggregate value (providing the structure) plays
1496 its part by providing the vtable. Otherwise,
1497 it is just along for the ride: call the function
1500 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1502 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1503 != TYPE_CODE_METHODPTR
)
1504 error (_("Non-pointer-to-member value used in pointer-to-member "
1507 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1509 struct type
*method_type
= check_typedef (value_type (arg1
));
1511 arg1
= value_zero (method_type
, not_lval
);
1514 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1516 /* Now, say which argument to start evaluating from. */
1519 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1521 /* Hair for method invocations. */
1525 /* First, evaluate the structure into arg2. */
1527 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1528 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1529 if (noside
== EVAL_SKIP
)
1532 if (op
== STRUCTOP_STRUCT
)
1534 /* If v is a variable in a register, and the user types
1535 v.method (), this will produce an error, because v has
1538 A possible way around this would be to allocate a
1539 copy of the variable on the stack, copy in the
1540 contents, call the function, and copy out the
1541 contents. I.e. convert this from call by reference
1542 to call by copy-return (or whatever it's called).
1543 However, this does not work because it is not the
1544 same: the method being called could stash a copy of
1545 the address, and then future uses through that address
1546 (after the method returns) would be expected to
1547 use the variable itself, not some copy of it. */
1548 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1552 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1554 /* Check to see if the operator '->' has been
1555 overloaded. If the operator has been overloaded
1556 replace arg2 with the value returned by the custom
1557 operator and continue evaluation. */
1558 while (unop_user_defined_p (op
, arg2
))
1560 volatile struct gdb_exception except
;
1561 struct value
*value
= NULL
;
1562 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1564 value
= value_x_unop (arg2
, op
, noside
);
1567 if (except
.reason
< 0)
1569 if (except
.error
== NOT_FOUND_ERROR
)
1572 throw_exception (except
);
1577 /* Now, say which argument to start evaluating from. */
1580 else if (op
== OP_SCOPE
1581 && overload_resolution
1582 && (exp
->language_defn
->la_language
== language_cplus
))
1584 /* Unpack it locally so we can properly handle overload
1590 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1591 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1592 type
= exp
->elts
[pc2
+ 1].type
;
1593 name
= &exp
->elts
[pc2
+ 3].string
;
1596 function_name
= NULL
;
1597 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1599 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1601 get_selected_block (0),
1603 if (function
== NULL
)
1604 error (_("No symbol \"%s\" in namespace \"%s\"."),
1605 name
, TYPE_TAG_NAME (type
));
1611 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1612 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1613 function_name
= name
;
1615 arg2
= value_zero (type
, lval_memory
);
1620 else if (op
== OP_ADL_FUNC
)
1622 /* Save the function position and move pos so that the arguments
1623 can be evaluated. */
1629 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1630 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1634 /* Non-method function call. */
1638 /* If this is a C++ function wait until overload resolution. */
1639 if (op
== OP_VAR_VALUE
1640 && overload_resolution
1641 && (exp
->language_defn
->la_language
== language_cplus
))
1643 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1648 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1649 type
= value_type (argvec
[0]);
1650 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1651 type
= TYPE_TARGET_TYPE (type
);
1652 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1654 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1656 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1664 /* Evaluate arguments. */
1665 for (; tem
<= nargs
; tem
++)
1667 /* Ensure that array expressions are coerced into pointer
1669 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1672 /* Signal end of arglist. */
1674 if (op
== OP_ADL_FUNC
)
1676 struct symbol
*symp
;
1679 int string_pc
= save_pos1
+ 3;
1681 /* Extract the function name. */
1682 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1683 func_name
= (char *) alloca (name_len
+ 1);
1684 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1686 find_overload_match (&argvec
[1], nargs
, func_name
,
1687 NON_METHOD
, /* not method */
1688 0, /* strict match */
1689 NULL
, NULL
, /* pass NULL symbol since
1690 symbol is unknown */
1691 NULL
, &symp
, NULL
, 0);
1693 /* Now fix the expression being evaluated. */
1694 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1695 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1698 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1699 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1701 int static_memfuncp
;
1704 /* Method invocation : stuff "this" as first parameter. */
1709 /* Name of method from expression. */
1710 tstr
= &exp
->elts
[pc2
+ 2].string
;
1713 tstr
= function_name
;
1715 if (overload_resolution
&& (exp
->language_defn
->la_language
1718 /* Language is C++, do some overload resolution before
1720 struct value
*valp
= NULL
;
1722 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1723 METHOD
, /* method */
1724 0, /* strict match */
1725 &arg2
, /* the object */
1727 &static_memfuncp
, 0);
1729 if (op
== OP_SCOPE
&& !static_memfuncp
)
1731 /* For the time being, we don't handle this. */
1732 error (_("Call to overloaded function %s requires "
1736 argvec
[1] = arg2
; /* the ``this'' pointer */
1737 argvec
[0] = valp
; /* Use the method found after overload
1741 /* Non-C++ case -- or no overload resolution. */
1743 struct value
*temp
= arg2
;
1745 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1747 op
== STRUCTOP_STRUCT
1748 ? "structure" : "structure pointer");
1749 /* value_struct_elt updates temp with the correct value
1750 of the ``this'' pointer if necessary, so modify argvec[1] to
1751 reflect any ``this'' changes. */
1753 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1754 value_address (temp
)
1755 + value_embedded_offset (temp
));
1756 argvec
[1] = arg2
; /* the ``this'' pointer */
1759 if (static_memfuncp
)
1761 argvec
[1] = argvec
[0];
1766 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1771 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1773 /* Non-member function being called. */
1774 /* fn: This can only be done for C++ functions. A C-style function
1775 in a C++ program, for instance, does not have the fields that
1776 are expected here. */
1778 if (overload_resolution
&& (exp
->language_defn
->la_language
1781 /* Language is C++, do some overload resolution before
1783 struct symbol
*symp
;
1786 /* If a scope has been specified disable ADL. */
1790 if (op
== OP_VAR_VALUE
)
1791 function
= exp
->elts
[save_pos1
+2].symbol
;
1793 (void) find_overload_match (&argvec
[1], nargs
,
1794 NULL
, /* no need for name */
1795 NON_METHOD
, /* not method */
1796 0, /* strict match */
1797 NULL
, function
, /* the function */
1798 NULL
, &symp
, NULL
, no_adl
);
1800 if (op
== OP_VAR_VALUE
)
1802 /* Now fix the expression being evaluated. */
1803 exp
->elts
[save_pos1
+2].symbol
= symp
;
1804 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1808 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1812 /* Not C++, or no overload resolution allowed. */
1813 /* Nothing to be done; argvec already correctly set up. */
1818 /* It is probably a C-style function. */
1819 /* Nothing to be done; argvec already correctly set up. */
1824 if (noside
== EVAL_SKIP
)
1826 if (argvec
[0] == NULL
)
1827 error (_("Cannot evaluate function -- may be inlined"));
1828 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1830 /* If the return type doesn't look like a function type, call an
1831 error. This can happen if somebody tries to turn a variable into
1832 a function call. This is here because people often want to
1833 call, eg, strcmp, which gdb doesn't know is a function. If
1834 gdb isn't asked for it's opinion (ie. through "whatis"),
1835 it won't offer it. */
1837 struct type
*ftype
= value_type (argvec
[0]);
1839 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1841 /* We don't know anything about what the internal
1842 function might return, but we have to return
1844 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1847 else if (TYPE_GNU_IFUNC (ftype
))
1848 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1849 else if (TYPE_TARGET_TYPE (ftype
))
1850 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1852 error (_("Expression of type other than "
1853 "\"Function returning ...\" used as function"));
1855 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1856 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1857 argvec
[0], nargs
, argvec
+ 1);
1859 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1860 /* pai: FIXME save value from call_function_by_hand, then adjust
1861 pc by adjust_fn_pc if +ve. */
1863 case OP_F77_UNDETERMINED_ARGLIST
:
1865 /* Remember that in F77, functions, substring ops and
1866 array subscript operations cannot be disambiguated
1867 at parse time. We have made all array subscript operations,
1868 substring operations as well as function calls come here
1869 and we now have to discover what the heck this thing actually was.
1870 If it is a function, we process just as if we got an OP_FUNCALL. */
1872 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1875 /* First determine the type code we are dealing with. */
1876 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1877 type
= check_typedef (value_type (arg1
));
1878 code
= TYPE_CODE (type
);
1880 if (code
== TYPE_CODE_PTR
)
1882 /* Fortran always passes variable to subroutines as pointer.
1883 So we need to look into its target type to see if it is
1884 array, string or function. If it is, we need to switch
1885 to the target value the original one points to. */
1886 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1888 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1889 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1890 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1892 arg1
= value_ind (arg1
);
1893 type
= check_typedef (value_type (arg1
));
1894 code
= TYPE_CODE (type
);
1900 case TYPE_CODE_ARRAY
:
1901 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1902 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1904 goto multi_f77_subscript
;
1906 case TYPE_CODE_STRING
:
1907 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1908 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1911 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1912 return value_subscript (arg1
, value_as_long (arg2
));
1916 case TYPE_CODE_FUNC
:
1917 /* It's a function call. */
1918 /* Allocate arg vector, including space for the function to be
1919 called in argvec[0] and a terminating NULL. */
1920 argvec
= (struct value
**)
1921 alloca (sizeof (struct value
*) * (nargs
+ 2));
1924 for (; tem
<= nargs
; tem
++)
1925 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1926 argvec
[tem
] = 0; /* signal end of arglist */
1930 error (_("Cannot perform substring on this type"));
1934 /* We have a complex number, There should be 2 floating
1935 point numbers that compose it. */
1937 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1938 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1940 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1942 case STRUCTOP_STRUCT
:
1943 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1944 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1945 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1946 if (noside
== EVAL_SKIP
)
1948 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1949 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1950 &exp
->elts
[pc
+ 2].string
,
1955 struct value
*temp
= arg1
;
1957 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1962 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1963 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1964 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1965 if (noside
== EVAL_SKIP
)
1968 /* Check to see if operator '->' has been overloaded. If so replace
1969 arg1 with the value returned by evaluating operator->(). */
1970 while (unop_user_defined_p (op
, arg1
))
1972 volatile struct gdb_exception except
;
1973 struct value
*value
= NULL
;
1974 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1976 value
= value_x_unop (arg1
, op
, noside
);
1979 if (except
.reason
< 0)
1981 if (except
.error
== NOT_FOUND_ERROR
)
1984 throw_exception (except
);
1989 /* JYG: if print object is on we need to replace the base type
1990 with rtti type in order to continue on with successful
1991 lookup of member / method only available in the rtti type. */
1993 struct type
*type
= value_type (arg1
);
1994 struct type
*real_type
;
1995 int full
, top
, using_enc
;
1996 struct value_print_options opts
;
1998 get_user_print_options (&opts
);
1999 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
2000 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
2002 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
2005 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
2006 real_type
= lookup_pointer_type (real_type
);
2008 real_type
= lookup_reference_type (real_type
);
2010 arg1
= value_cast (real_type
, arg1
);
2015 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2016 return value_zero (lookup_struct_elt_type (value_type (arg1
),
2017 &exp
->elts
[pc
+ 2].string
,
2022 struct value
*temp
= arg1
;
2024 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
2025 NULL
, "structure pointer");
2028 case STRUCTOP_MEMBER
:
2030 if (op
== STRUCTOP_MEMBER
)
2031 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2033 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2035 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2037 if (noside
== EVAL_SKIP
)
2040 type
= check_typedef (value_type (arg2
));
2041 switch (TYPE_CODE (type
))
2043 case TYPE_CODE_METHODPTR
:
2044 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2045 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2048 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2049 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
2050 return value_ind (arg2
);
2053 case TYPE_CODE_MEMBERPTR
:
2054 /* Now, convert these values to an address. */
2055 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
2058 mem_offset
= value_as_long (arg2
);
2060 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2061 value_as_long (arg1
) + mem_offset
);
2062 return value_ind (arg3
);
2065 error (_("non-pointer-to-member value used "
2066 "in pointer-to-member construct"));
2070 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2071 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2072 for (ix
= 0; ix
< nargs
; ++ix
)
2073 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
2075 expect_type
= make_params (nargs
, arg_types
);
2076 *(pos
) += 3 + nargs
;
2077 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
2078 xfree (TYPE_FIELDS (expect_type
));
2079 xfree (TYPE_MAIN_TYPE (expect_type
));
2080 xfree (expect_type
);
2084 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2085 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2086 if (noside
== EVAL_SKIP
)
2088 if (binop_user_defined_p (op
, arg1
, arg2
))
2089 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2091 return value_concat (arg1
, arg2
);
2094 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2095 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2097 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2099 if (binop_user_defined_p (op
, arg1
, arg2
))
2100 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2102 return value_assign (arg1
, arg2
);
2104 case BINOP_ASSIGN_MODIFY
:
2106 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2107 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2108 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2110 op
= exp
->elts
[pc
+ 1].opcode
;
2111 if (binop_user_defined_p (op
, arg1
, arg2
))
2112 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2113 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2115 && is_integral_type (value_type (arg2
)))
2116 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2117 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2119 && is_integral_type (value_type (arg2
)))
2120 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2123 struct value
*tmp
= arg1
;
2125 /* For shift and integer exponentiation operations,
2126 only promote the first argument. */
2127 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2128 && is_integral_type (value_type (arg2
)))
2129 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2131 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2133 arg2
= value_binop (tmp
, arg2
, op
);
2135 return value_assign (arg1
, arg2
);
2138 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2139 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2140 if (noside
== EVAL_SKIP
)
2142 if (binop_user_defined_p (op
, arg1
, arg2
))
2143 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2144 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2145 && is_integral_type (value_type (arg2
)))
2146 return value_ptradd (arg1
, value_as_long (arg2
));
2147 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2148 && is_integral_type (value_type (arg1
)))
2149 return value_ptradd (arg2
, value_as_long (arg1
));
2152 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2153 return value_binop (arg1
, arg2
, BINOP_ADD
);
2157 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2158 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2159 if (noside
== EVAL_SKIP
)
2161 if (binop_user_defined_p (op
, arg1
, arg2
))
2162 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2163 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2164 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2166 /* FIXME -- should be ptrdiff_t */
2167 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2168 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2170 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2171 && is_integral_type (value_type (arg2
)))
2172 return value_ptradd (arg1
, - value_as_long (arg2
));
2175 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2176 return value_binop (arg1
, arg2
, BINOP_SUB
);
2187 case BINOP_BITWISE_AND
:
2188 case BINOP_BITWISE_IOR
:
2189 case BINOP_BITWISE_XOR
:
2190 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2191 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2192 if (noside
== EVAL_SKIP
)
2194 if (binop_user_defined_p (op
, arg1
, arg2
))
2195 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2198 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2199 fudge arg2 to avoid division-by-zero, the caller is
2200 (theoretically) only looking for the type of the result. */
2201 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2202 /* ??? Do we really want to test for BINOP_MOD here?
2203 The implementation of value_binop gives it a well-defined
2206 || op
== BINOP_INTDIV
2209 && value_logical_not (arg2
))
2211 struct value
*v_one
, *retval
;
2213 v_one
= value_one (value_type (arg2
));
2214 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2215 retval
= value_binop (arg1
, v_one
, op
);
2220 /* For shift and integer exponentiation operations,
2221 only promote the first argument. */
2222 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2223 && is_integral_type (value_type (arg2
)))
2224 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2226 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2228 return value_binop (arg1
, arg2
, op
);
2233 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2234 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2235 if (noside
== EVAL_SKIP
)
2237 error (_("':' operator used in invalid context"));
2239 case BINOP_SUBSCRIPT
:
2240 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2241 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2242 if (noside
== EVAL_SKIP
)
2244 if (binop_user_defined_p (op
, arg1
, arg2
))
2245 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2248 /* If the user attempts to subscript something that is not an
2249 array or pointer type (like a plain int variable for example),
2250 then report this as an error. */
2252 arg1
= coerce_ref (arg1
);
2253 type
= check_typedef (value_type (arg1
));
2254 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2255 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2257 if (TYPE_NAME (type
))
2258 error (_("cannot subscript something of type `%s'"),
2261 error (_("cannot subscript requested type"));
2264 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2265 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2267 return value_subscript (arg1
, value_as_long (arg2
));
2271 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2272 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2273 if (noside
== EVAL_SKIP
)
2275 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2276 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2278 case MULTI_SUBSCRIPT
:
2280 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2281 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2284 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2285 /* FIXME: EVAL_SKIP handling may not be correct. */
2286 if (noside
== EVAL_SKIP
)
2297 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2298 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2300 /* If the user attempts to subscript something that has no target
2301 type (like a plain int variable for example), then report this
2304 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2307 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2313 error (_("cannot subscript something of type `%s'"),
2314 TYPE_NAME (value_type (arg1
)));
2318 if (binop_user_defined_p (op
, arg1
, arg2
))
2320 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2324 arg1
= coerce_ref (arg1
);
2325 type
= check_typedef (value_type (arg1
));
2327 switch (TYPE_CODE (type
))
2330 case TYPE_CODE_ARRAY
:
2331 case TYPE_CODE_STRING
:
2332 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2335 case TYPE_CODE_BITSTRING
:
2336 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2337 arg1
= value_bitstring_subscript (type
, arg1
,
2338 value_as_long (arg2
));
2342 if (TYPE_NAME (type
))
2343 error (_("cannot subscript something of type `%s'"),
2346 error (_("cannot subscript requested type"));
2352 multi_f77_subscript
:
2354 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2355 int ndimensions
= 1, i
;
2356 struct value
*array
= arg1
;
2358 if (nargs
> MAX_FORTRAN_DIMS
)
2359 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2361 ndimensions
= calc_f77_array_dims (type
);
2363 if (nargs
!= ndimensions
)
2364 error (_("Wrong number of subscripts"));
2366 gdb_assert (nargs
> 0);
2368 /* Now that we know we have a legal array subscript expression
2369 let us actually find out where this element exists in the array. */
2371 /* Take array indices left to right. */
2372 for (i
= 0; i
< nargs
; i
++)
2374 /* Evaluate each subscript; it must be a legal integer in F77. */
2375 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2377 /* Fill in the subscript array. */
2379 subscript_array
[i
] = value_as_long (arg2
);
2382 /* Internal type of array is arranged right to left. */
2383 for (i
= nargs
; i
> 0; i
--)
2385 struct type
*array_type
= check_typedef (value_type (array
));
2386 LONGEST index
= subscript_array
[i
- 1];
2388 lower
= f77_get_lowerbound (array_type
);
2389 array
= value_subscripted_rvalue (array
, index
, lower
);
2395 case BINOP_LOGICAL_AND
:
2396 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2397 if (noside
== EVAL_SKIP
)
2399 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2404 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2407 if (binop_user_defined_p (op
, arg1
, arg2
))
2409 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2410 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2414 tem
= value_logical_not (arg1
);
2415 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2416 (tem
? EVAL_SKIP
: noside
));
2417 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2418 return value_from_longest (type
,
2419 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2422 case BINOP_LOGICAL_OR
:
2423 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2424 if (noside
== EVAL_SKIP
)
2426 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2431 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2434 if (binop_user_defined_p (op
, arg1
, arg2
))
2436 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2437 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2441 tem
= value_logical_not (arg1
);
2442 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2443 (!tem
? EVAL_SKIP
: noside
));
2444 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2445 return value_from_longest (type
,
2446 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2450 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2451 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2452 if (noside
== EVAL_SKIP
)
2454 if (binop_user_defined_p (op
, arg1
, arg2
))
2456 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2460 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2461 tem
= value_equal (arg1
, arg2
);
2462 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2463 return value_from_longest (type
, (LONGEST
) tem
);
2466 case BINOP_NOTEQUAL
:
2467 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2468 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2469 if (noside
== EVAL_SKIP
)
2471 if (binop_user_defined_p (op
, arg1
, arg2
))
2473 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2477 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2478 tem
= value_equal (arg1
, arg2
);
2479 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2480 return value_from_longest (type
, (LONGEST
) ! tem
);
2484 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2485 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2486 if (noside
== EVAL_SKIP
)
2488 if (binop_user_defined_p (op
, arg1
, arg2
))
2490 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2494 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2495 tem
= value_less (arg1
, arg2
);
2496 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2497 return value_from_longest (type
, (LONGEST
) tem
);
2501 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2502 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2503 if (noside
== EVAL_SKIP
)
2505 if (binop_user_defined_p (op
, arg1
, arg2
))
2507 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2511 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2512 tem
= value_less (arg2
, arg1
);
2513 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2514 return value_from_longest (type
, (LONGEST
) tem
);
2518 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2519 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2520 if (noside
== EVAL_SKIP
)
2522 if (binop_user_defined_p (op
, arg1
, arg2
))
2524 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2528 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2529 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2530 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2531 return value_from_longest (type
, (LONGEST
) tem
);
2535 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2536 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2537 if (noside
== EVAL_SKIP
)
2539 if (binop_user_defined_p (op
, arg1
, arg2
))
2541 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2545 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2546 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2547 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2548 return value_from_longest (type
, (LONGEST
) tem
);
2552 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2553 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2554 if (noside
== EVAL_SKIP
)
2556 type
= check_typedef (value_type (arg2
));
2557 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2558 error (_("Non-integral right operand for \"@\" operator."));
2559 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2561 return allocate_repeat_value (value_type (arg1
),
2562 longest_to_int (value_as_long (arg2
)));
2565 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2568 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2569 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2572 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2573 if (noside
== EVAL_SKIP
)
2575 if (unop_user_defined_p (op
, arg1
))
2576 return value_x_unop (arg1
, op
, noside
);
2579 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2580 return value_pos (arg1
);
2584 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2585 if (noside
== EVAL_SKIP
)
2587 if (unop_user_defined_p (op
, arg1
))
2588 return value_x_unop (arg1
, op
, noside
);
2591 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2592 return value_neg (arg1
);
2595 case UNOP_COMPLEMENT
:
2596 /* C++: check for and handle destructor names. */
2597 op
= exp
->elts
[*pos
].opcode
;
2599 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2600 if (noside
== EVAL_SKIP
)
2602 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2603 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2606 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2607 return value_complement (arg1
);
2610 case UNOP_LOGICAL_NOT
:
2611 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2612 if (noside
== EVAL_SKIP
)
2614 if (unop_user_defined_p (op
, arg1
))
2615 return value_x_unop (arg1
, op
, noside
);
2618 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2619 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2623 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2624 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2625 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2626 type
= check_typedef (value_type (arg1
));
2627 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2628 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2629 error (_("Attempt to dereference pointer "
2630 "to member without an object"));
2631 if (noside
== EVAL_SKIP
)
2633 if (unop_user_defined_p (op
, arg1
))
2634 return value_x_unop (arg1
, op
, noside
);
2635 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2637 type
= check_typedef (value_type (arg1
));
2638 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2639 || TYPE_CODE (type
) == TYPE_CODE_REF
2640 /* In C you can dereference an array to get the 1st elt. */
2641 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2643 return value_zero (TYPE_TARGET_TYPE (type
),
2645 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2646 /* GDB allows dereferencing an int. */
2647 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2650 error (_("Attempt to take contents of a non-pointer value."));
2653 /* Allow * on an integer so we can cast it to whatever we want.
2654 This returns an int, which seems like the most C-like thing to
2655 do. "long long" variables are rare enough that
2656 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2657 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2658 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2659 (CORE_ADDR
) value_as_address (arg1
));
2660 return value_ind (arg1
);
2663 /* C++: check for and handle pointer to members. */
2665 op
= exp
->elts
[*pos
].opcode
;
2667 if (noside
== EVAL_SKIP
)
2669 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2674 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2681 if (noside
== EVAL_SKIP
)
2683 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2686 return evaluate_subexp_for_sizeof (exp
, pos
);
2690 type
= exp
->elts
[pc
+ 1].type
;
2691 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2692 if (noside
== EVAL_SKIP
)
2694 if (type
!= value_type (arg1
))
2695 arg1
= value_cast (type
, arg1
);
2698 case UNOP_DYNAMIC_CAST
:
2700 type
= exp
->elts
[pc
+ 1].type
;
2701 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2702 if (noside
== EVAL_SKIP
)
2704 return value_dynamic_cast (type
, arg1
);
2706 case UNOP_REINTERPRET_CAST
:
2708 type
= exp
->elts
[pc
+ 1].type
;
2709 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2710 if (noside
== EVAL_SKIP
)
2712 return value_reinterpret_cast (type
, arg1
);
2716 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2717 if (noside
== EVAL_SKIP
)
2719 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2720 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2722 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2723 value_as_address (arg1
));
2725 case UNOP_MEMVAL_TLS
:
2727 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2728 if (noside
== EVAL_SKIP
)
2730 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2731 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2736 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2737 value_as_address (arg1
));
2738 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2741 case UNOP_PREINCREMENT
:
2742 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2743 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2745 else if (unop_user_defined_p (op
, arg1
))
2747 return value_x_unop (arg1
, op
, noside
);
2751 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2752 arg2
= value_ptradd (arg1
, 1);
2755 struct value
*tmp
= arg1
;
2757 arg2
= value_one (value_type (arg1
));
2758 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2759 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2762 return value_assign (arg1
, arg2
);
2765 case UNOP_PREDECREMENT
:
2766 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2767 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2769 else if (unop_user_defined_p (op
, arg1
))
2771 return value_x_unop (arg1
, op
, noside
);
2775 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2776 arg2
= value_ptradd (arg1
, -1);
2779 struct value
*tmp
= arg1
;
2781 arg2
= value_one (value_type (arg1
));
2782 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2783 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2786 return value_assign (arg1
, arg2
);
2789 case UNOP_POSTINCREMENT
:
2790 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2791 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2793 else if (unop_user_defined_p (op
, arg1
))
2795 return value_x_unop (arg1
, op
, noside
);
2799 arg3
= value_non_lval (arg1
);
2801 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2802 arg2
= value_ptradd (arg1
, 1);
2805 struct value
*tmp
= arg1
;
2807 arg2
= value_one (value_type (arg1
));
2808 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2809 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2812 value_assign (arg1
, arg2
);
2816 case UNOP_POSTDECREMENT
:
2817 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2818 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2820 else if (unop_user_defined_p (op
, arg1
))
2822 return value_x_unop (arg1
, op
, noside
);
2826 arg3
= value_non_lval (arg1
);
2828 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2829 arg2
= value_ptradd (arg1
, -1);
2832 struct value
*tmp
= arg1
;
2834 arg2
= value_one (value_type (arg1
));
2835 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2836 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2839 value_assign (arg1
, arg2
);
2845 return value_of_this (exp
->language_defn
);
2848 /* The value is not supposed to be used. This is here to make it
2849 easier to accommodate expressions that contain types. */
2851 if (noside
== EVAL_SKIP
)
2853 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2855 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2857 /* If this is a typedef, then find its immediate target. We
2858 use check_typedef to resolve stubs, but we ignore its
2859 result because we do not want to dig past all
2861 check_typedef (type
);
2862 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2863 type
= TYPE_TARGET_TYPE (type
);
2864 return allocate_value (type
);
2867 error (_("Attempt to use a type name as an expression"));
2870 /* Removing this case and compiling with gcc -Wall reveals that
2871 a lot of cases are hitting this case. Some of these should
2872 probably be removed from expression.h; others are legitimate
2873 expressions which are (apparently) not fully implemented.
2875 If there are any cases landing here which mean a user error,
2876 then they should be separate cases, with more descriptive
2879 error (_("GDB does not (yet) know how to "
2880 "evaluate that kind of expression"));
2884 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2887 /* Evaluate a subexpression of EXP, at index *POS,
2888 and return the address of that subexpression.
2889 Advance *POS over the subexpression.
2890 If the subexpression isn't an lvalue, get an error.
2891 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2892 then only the type of the result need be correct. */
2894 static struct value
*
2895 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2905 op
= exp
->elts
[pc
].opcode
;
2911 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2913 /* We can't optimize out "&*" if there's a user-defined operator*. */
2914 if (unop_user_defined_p (op
, x
))
2916 x
= value_x_unop (x
, op
, noside
);
2917 goto default_case_after_eval
;
2920 return coerce_array (x
);
2924 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2925 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2928 var
= exp
->elts
[pc
+ 2].symbol
;
2930 /* C++: The "address" of a reference should yield the address
2931 * of the object pointed to. Let value_addr() deal with it. */
2932 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2936 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2939 lookup_pointer_type (SYMBOL_TYPE (var
));
2940 enum address_class sym_class
= SYMBOL_CLASS (var
);
2942 if (sym_class
== LOC_CONST
2943 || sym_class
== LOC_CONST_BYTES
2944 || sym_class
== LOC_REGISTER
)
2945 error (_("Attempt to take address of register or constant."));
2948 value_zero (type
, not_lval
);
2951 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2954 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2955 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2956 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2957 &exp
->elts
[pc
+ 3].string
,
2960 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2965 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2966 default_case_after_eval
:
2967 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2969 struct type
*type
= check_typedef (value_type (x
));
2971 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2972 return value_zero (lookup_pointer_type (value_type (x
)),
2974 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2975 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2978 error (_("Attempt to take address of "
2979 "value not located in memory."));
2981 return value_addr (x
);
2985 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2986 When used in contexts where arrays will be coerced anyway, this is
2987 equivalent to `evaluate_subexp' but much faster because it avoids
2988 actually fetching array contents (perhaps obsolete now that we have
2991 Note that we currently only do the coercion for C expressions, where
2992 arrays are zero based and the coercion is correct. For other languages,
2993 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2994 to decide if coercion is appropriate. */
2997 evaluate_subexp_with_coercion (struct expression
*exp
,
2998 int *pos
, enum noside noside
)
3007 op
= exp
->elts
[pc
].opcode
;
3012 var
= exp
->elts
[pc
+ 2].symbol
;
3013 type
= check_typedef (SYMBOL_TYPE (var
));
3014 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
3015 && !TYPE_VECTOR (type
)
3016 && CAST_IS_CONVERSION (exp
->language_defn
))
3019 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3020 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3026 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3030 /* Evaluate a subexpression of EXP, at index *POS,
3031 and return a value for the size of that subexpression.
3032 Advance *POS over the subexpression. */
3034 static struct value
*
3035 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
3037 /* FIXME: This should be size_t. */
3038 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3045 op
= exp
->elts
[pc
].opcode
;
3049 /* This case is handled specially
3050 so that we avoid creating a value for the result type.
3051 If the result type is very big, it's desirable not to
3052 create a value unnecessarily. */
3055 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3056 type
= check_typedef (value_type (val
));
3057 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3058 && TYPE_CODE (type
) != TYPE_CODE_REF
3059 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3060 error (_("Attempt to take contents of a non-pointer value."));
3061 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3062 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3066 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3067 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3071 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3073 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3076 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3077 return value_from_longest (size_type
,
3078 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3082 /* Parse a type expression in the string [P..P+LENGTH). */
3085 parse_and_eval_type (char *p
, int length
)
3087 char *tmp
= (char *) alloca (length
+ 4);
3088 struct expression
*expr
;
3091 memcpy (tmp
+ 1, p
, length
);
3092 tmp
[length
+ 1] = ')';
3093 tmp
[length
+ 2] = '0';
3094 tmp
[length
+ 3] = '\0';
3095 expr
= parse_expression (tmp
);
3096 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3097 error (_("Internal error in eval_type."));
3098 return expr
->elts
[1].type
;
3102 calc_f77_array_dims (struct type
*array_type
)
3105 struct type
*tmp_type
;
3107 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3108 error (_("Can't get dimensions for a non-array type"));
3110 tmp_type
= array_type
;
3112 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3114 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)