1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2014 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/>. */
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"
44 #include "gdb_assert.h"
48 /* This is defined in valops.c */
49 extern int overload_resolution
;
51 /* Prototypes for local functions. */
53 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
56 static struct value
*evaluate_subexp_for_address (struct expression
*,
59 static struct value
*evaluate_struct_tuple (struct value
*,
60 struct expression
*, int *,
63 static LONGEST
init_array_element (struct value
*, struct value
*,
64 struct expression
*, int *, enum noside
,
68 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
69 int *pos
, enum noside noside
)
71 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
72 (expect_type
, exp
, pos
, noside
);
75 /* Parse the string EXP as a C expression, evaluate it,
76 and return the result as a number. */
79 parse_and_eval_address (const char *exp
)
81 struct expression
*expr
= parse_expression (exp
);
83 struct cleanup
*old_chain
=
84 make_cleanup (free_current_contents
, &expr
);
86 addr
= value_as_address (evaluate_expression (expr
));
87 do_cleanups (old_chain
);
91 /* Like parse_and_eval_address, but treats the value of the expression
92 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
94 parse_and_eval_long (const char *exp
)
96 struct expression
*expr
= parse_expression (exp
);
98 struct cleanup
*old_chain
=
99 make_cleanup (free_current_contents
, &expr
);
101 retval
= value_as_long (evaluate_expression (expr
));
102 do_cleanups (old_chain
);
107 parse_and_eval (const char *exp
)
109 struct expression
*expr
= parse_expression (exp
);
111 struct cleanup
*old_chain
=
112 make_cleanup (free_current_contents
, &expr
);
114 val
= evaluate_expression (expr
);
115 do_cleanups (old_chain
);
119 /* Parse up to a comma (or to a closeparen)
120 in the string EXPP as an expression, evaluate it, and return the value.
121 EXPP is advanced to point to the comma. */
124 parse_to_comma_and_eval (const char **expp
)
126 struct expression
*expr
= parse_exp_1 (expp
, 0, (struct block
*) 0, 1);
128 struct cleanup
*old_chain
=
129 make_cleanup (free_current_contents
, &expr
);
131 val
= evaluate_expression (expr
);
132 do_cleanups (old_chain
);
136 /* Evaluate an expression in internal prefix form
137 such as is constructed by parse.y.
139 See expression.h for info on the format of an expression. */
142 evaluate_expression (struct expression
*exp
)
146 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
149 /* Evaluate an expression, avoiding all memory references
150 and getting a value whose type alone is correct. */
153 evaluate_type (struct expression
*exp
)
157 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
160 /* Evaluate a subexpression, avoiding all memory references and
161 getting a value whose type alone is correct. */
164 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
166 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
169 /* Find the current value of a watchpoint on EXP. Return the value in
170 *VALP and *RESULTP and the chain of intermediate and final values
171 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
174 If PRESERVE_ERRORS is true, then exceptions are passed through.
175 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
176 occurs while evaluating the expression, *RESULTP will be set to
177 NULL. *RESULTP may be a lazy value, if the result could not be
178 read from memory. It is used to determine whether a value is
179 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
,
197 struct value
*mark
, *new_mark
, *result
;
198 volatile struct gdb_exception ex
;
206 /* Evaluate the expression. */
207 mark
= value_mark ();
210 TRY_CATCH (ex
, RETURN_MASK_ALL
)
212 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
216 /* Ignore memory errors if we want watchpoints pointing at
217 inaccessible memory to still be created; otherwise, throw the
218 error to some higher catcher. */
222 if (!preserve_errors
)
225 throw_exception (ex
);
230 new_mark
= value_mark ();
231 if (mark
== new_mark
)
236 /* Make sure it's not lazy, so that after the target stops again we
237 have a non-lazy previous value to compare with. */
240 if (!value_lazy (result
))
244 volatile struct gdb_exception except
;
246 TRY_CATCH (except
, RETURN_MASK_ERROR
)
248 value_fetch_lazy (result
);
256 /* Return the chain of intermediate values. We use this to
257 decide which addresses to watch. */
258 *val_chain
= new_mark
;
259 value_release_to_mark (mark
);
263 /* Extract a field operation from an expression. If the subexpression
264 of EXP starting at *SUBEXP is not a structure dereference
265 operation, return NULL. Otherwise, return the name of the
266 dereferenced field, and advance *SUBEXP to point to the
267 subexpression of the left-hand-side of the dereference. This is
268 used when completing field names. */
271 extract_field_op (struct expression
*exp
, int *subexp
)
276 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
277 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
279 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
280 result
= &exp
->elts
[*subexp
+ 2].string
;
281 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
285 /* This function evaluates brace-initializers (in C/C++) for
288 static struct value
*
289 evaluate_struct_tuple (struct value
*struct_val
,
290 struct expression
*exp
,
291 int *pos
, enum noside noside
, int nargs
)
293 struct type
*struct_type
= check_typedef (value_type (struct_val
));
294 struct type
*field_type
;
299 struct value
*val
= NULL
;
304 /* Skip static fields. */
305 while (fieldno
< TYPE_NFIELDS (struct_type
)
306 && field_is_static (&TYPE_FIELD (struct_type
,
309 if (fieldno
>= TYPE_NFIELDS (struct_type
))
310 error (_("too many initializers"));
311 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
312 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
313 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
314 error (_("don't know which variant you want to set"));
316 /* Here, struct_type is the type of the inner struct,
317 while substruct_type is the type of the inner struct.
318 These are the same for normal structures, but a variant struct
319 contains anonymous union fields that contain substruct fields.
320 The value fieldno is the index of the top-level (normal or
321 anonymous union) field in struct_field, while the value
322 subfieldno is the index of the actual real (named inner) field
323 in substruct_type. */
325 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
327 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
329 /* Now actually set the field in struct_val. */
331 /* Assign val to field fieldno. */
332 if (value_type (val
) != field_type
)
333 val
= value_cast (field_type
, val
);
335 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
336 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
337 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
339 modify_field (struct_type
, addr
,
340 value_as_long (val
), bitpos
% 8, bitsize
);
342 memcpy (addr
, value_contents (val
),
343 TYPE_LENGTH (value_type (val
)));
349 /* Recursive helper function for setting elements of array tuples for
350 (the deleted) Chill. The target is ARRAY (which has bounds
351 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
352 and NOSIDE are as usual. Evaluates index expresions and sets the
353 specified element(s) of ARRAY to ELEMENT. Returns last index
357 init_array_element (struct value
*array
, struct value
*element
,
358 struct expression
*exp
, int *pos
,
359 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
362 int element_size
= TYPE_LENGTH (value_type (element
));
364 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
367 init_array_element (array
, element
, exp
, pos
, noside
,
368 low_bound
, high_bound
);
369 return init_array_element (array
, element
,
370 exp
, pos
, noside
, low_bound
, high_bound
);
372 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
377 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
378 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
379 if (low
< low_bound
|| high
> high_bound
)
380 error (_("tuple range index out of range"));
381 for (index
= low
; index
<= high
; index
++)
383 memcpy (value_contents_raw (array
)
384 + (index
- low_bound
) * element_size
,
385 value_contents (element
), element_size
);
390 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
391 if (index
< low_bound
|| index
> high_bound
)
392 error (_("tuple index out of range"));
393 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
394 value_contents (element
), element_size
);
399 static struct value
*
400 value_f90_subarray (struct value
*array
,
401 struct expression
*exp
, int *pos
, enum noside noside
)
404 LONGEST low_bound
, high_bound
;
405 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
406 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
410 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
411 low_bound
= TYPE_LOW_BOUND (range
);
413 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
415 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
416 high_bound
= TYPE_HIGH_BOUND (range
);
418 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
420 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
424 /* Promote value ARG1 as appropriate before performing a unary operation
426 If the result is not appropriate for any particular language then it
427 needs to patch this function. */
430 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
435 *arg1
= coerce_ref (*arg1
);
436 type1
= check_typedef (value_type (*arg1
));
438 if (is_integral_type (type1
))
440 switch (language
->la_language
)
443 /* Perform integral promotion for ANSI C/C++.
444 If not appropropriate for any particular language
445 it needs to modify this function. */
447 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
449 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
450 *arg1
= value_cast (builtin_int
, *arg1
);
457 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
458 operation on those two operands.
459 If the result is not appropriate for any particular language then it
460 needs to patch this function. */
463 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
464 struct value
**arg1
, struct value
**arg2
)
466 struct type
*promoted_type
= NULL
;
470 *arg1
= coerce_ref (*arg1
);
471 *arg2
= coerce_ref (*arg2
);
473 type1
= check_typedef (value_type (*arg1
));
474 type2
= check_typedef (value_type (*arg2
));
476 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
477 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
478 && !is_integral_type (type1
))
479 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
480 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
481 && !is_integral_type (type2
)))
484 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
485 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
487 /* No promotion required. */
489 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
490 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
492 switch (language
->la_language
)
498 case language_opencl
:
499 /* No promotion required. */
503 /* For other languages the result type is unchanged from gdb
504 version 6.7 for backward compatibility.
505 If either arg was long double, make sure that value is also long
506 double. Otherwise use double. */
507 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
508 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
509 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
511 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
515 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
516 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
518 /* No promotion required. */
521 /* Integral operations here. */
522 /* FIXME: Also mixed integral/booleans, with result an integer. */
524 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
525 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
526 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
527 int is_unsigned1
= TYPE_UNSIGNED (type1
);
528 int is_unsigned2
= TYPE_UNSIGNED (type2
);
529 unsigned int result_len
;
530 int unsigned_operation
;
532 /* Determine type length and signedness after promotion for
534 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
537 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
539 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
542 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
545 if (promoted_len1
> promoted_len2
)
547 unsigned_operation
= is_unsigned1
;
548 result_len
= promoted_len1
;
550 else if (promoted_len2
> promoted_len1
)
552 unsigned_operation
= is_unsigned2
;
553 result_len
= promoted_len2
;
557 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
558 result_len
= promoted_len1
;
561 switch (language
->la_language
)
567 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
569 promoted_type
= (unsigned_operation
570 ? builtin
->builtin_unsigned_int
571 : builtin
->builtin_int
);
573 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
575 promoted_type
= (unsigned_operation
576 ? builtin
->builtin_unsigned_long
577 : builtin
->builtin_long
);
581 promoted_type
= (unsigned_operation
582 ? builtin
->builtin_unsigned_long_long
583 : builtin
->builtin_long_long
);
586 case language_opencl
:
587 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
588 (language
, gdbarch
, "int")))
592 ? lookup_unsigned_typename (language
, gdbarch
, "int")
593 : lookup_signed_typename (language
, gdbarch
, "int"));
595 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
596 (language
, gdbarch
, "long")))
600 ? lookup_unsigned_typename (language
, gdbarch
, "long")
601 : lookup_signed_typename (language
, gdbarch
,"long"));
605 /* For other languages the result type is unchanged from gdb
606 version 6.7 for backward compatibility.
607 If either arg was long long, make sure that value is also long
608 long. Otherwise use long. */
609 if (unsigned_operation
)
611 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
612 promoted_type
= builtin
->builtin_unsigned_long_long
;
614 promoted_type
= builtin
->builtin_unsigned_long
;
618 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
619 promoted_type
= builtin
->builtin_long_long
;
621 promoted_type
= builtin
->builtin_long
;
629 /* Promote both operands to common type. */
630 *arg1
= value_cast (promoted_type
, *arg1
);
631 *arg2
= value_cast (promoted_type
, *arg2
);
636 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
638 type
= check_typedef (type
);
639 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
640 type
= TYPE_TARGET_TYPE (type
);
642 switch (TYPE_CODE (type
))
648 case TYPE_CODE_ARRAY
:
649 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
656 /* Constructs a fake method with the given parameter types.
657 This function is used by the parser to construct an "expected"
658 type for method overload resolution. */
661 make_params (int num_types
, struct type
**param_types
)
663 struct type
*type
= XCNEW (struct type
);
664 TYPE_MAIN_TYPE (type
) = XCNEW (struct main_type
);
665 TYPE_LENGTH (type
) = 1;
666 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
667 TYPE_VPTR_FIELDNO (type
) = -1;
668 TYPE_CHAIN (type
) = type
;
671 if (param_types
[num_types
- 1] == NULL
)
674 TYPE_VARARGS (type
) = 1;
676 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
680 /* Caller should have ensured this. */
681 gdb_assert (num_types
== 0);
682 TYPE_PROTOTYPED (type
) = 1;
686 TYPE_NFIELDS (type
) = num_types
;
687 TYPE_FIELDS (type
) = (struct field
*)
688 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
690 while (num_types
-- > 0)
691 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
697 evaluate_subexp_standard (struct type
*expect_type
,
698 struct expression
*exp
, int *pos
,
703 int pc
, pc2
= 0, oldpos
;
704 struct value
*arg1
= NULL
;
705 struct value
*arg2
= NULL
;
709 struct value
**argvec
;
713 struct type
**arg_types
;
715 struct symbol
*function
= NULL
;
716 char *function_name
= NULL
;
719 op
= exp
->elts
[pc
].opcode
;
724 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
725 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
726 if (noside
== EVAL_SKIP
)
728 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
729 &exp
->elts
[pc
+ 3].string
,
730 expect_type
, 0, noside
);
732 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
737 return value_from_longest (exp
->elts
[pc
+ 1].type
,
738 exp
->elts
[pc
+ 2].longconst
);
742 return value_from_double (exp
->elts
[pc
+ 1].type
,
743 exp
->elts
[pc
+ 2].doubleconst
);
747 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
748 exp
->elts
[pc
+ 2].decfloatconst
);
753 if (noside
== EVAL_SKIP
)
756 /* JYG: We used to just return value_zero of the symbol type
757 if we're asked to avoid side effects. Otherwise we return
758 value_of_variable (...). However I'm not sure if
759 value_of_variable () has any side effect.
760 We need a full value object returned here for whatis_exp ()
761 to call evaluate_type () and then pass the full value to
762 value_rtti_target_type () if we are dealing with a pointer
763 or reference to a base class and print object is on. */
766 volatile struct gdb_exception except
;
767 struct value
*ret
= NULL
;
769 TRY_CATCH (except
, RETURN_MASK_ERROR
)
771 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
772 exp
->elts
[pc
+ 1].block
);
775 if (except
.reason
< 0)
777 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
778 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
781 throw_exception (except
);
787 case OP_VAR_ENTRY_VALUE
:
789 if (noside
== EVAL_SKIP
)
793 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
794 struct frame_info
*frame
;
796 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
797 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
799 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
800 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
801 error (_("Symbol \"%s\" does not have any specific entry value"),
802 SYMBOL_PRINT_NAME (sym
));
804 frame
= get_selected_frame (NULL
);
805 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
811 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
815 const char *name
= &exp
->elts
[pc
+ 2].string
;
819 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
820 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
821 name
, strlen (name
));
823 error (_("Register $%s not available."), name
);
825 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
826 a value with the appropriate register type. Unfortunately,
827 we don't have easy access to the type of user registers.
828 So for these registers, we fetch the register value regardless
829 of the evaluation mode. */
830 if (noside
== EVAL_AVOID_SIDE_EFFECTS
831 && regno
< gdbarch_num_regs (exp
->gdbarch
)
832 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
833 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
835 val
= value_of_register (regno
, get_selected_frame (NULL
));
837 error (_("Value of register %s not available."), name
);
843 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
844 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
848 return value_of_internalvar (exp
->gdbarch
,
849 exp
->elts
[pc
+ 1].internalvar
);
852 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
853 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
854 if (noside
== EVAL_SKIP
)
856 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
857 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
859 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
860 NSString constant. */
861 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
862 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
863 if (noside
== EVAL_SKIP
)
867 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
871 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
872 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
873 nargs
= tem3
- tem2
+ 1;
874 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
876 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
877 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
879 struct value
*rec
= allocate_value (expect_type
);
881 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
882 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
885 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
886 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
888 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
889 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
890 struct value
*array
= allocate_value (expect_type
);
891 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
892 LONGEST low_bound
, high_bound
, index
;
894 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
897 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
900 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
901 for (tem
= nargs
; --nargs
>= 0;)
903 struct value
*element
;
906 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
909 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
911 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
912 if (value_type (element
) != element_type
)
913 element
= value_cast (element_type
, element
);
916 int continue_pc
= *pos
;
919 index
= init_array_element (array
, element
, exp
, pos
, noside
,
920 low_bound
, high_bound
);
925 if (index
> high_bound
)
926 /* To avoid memory corruption. */
927 error (_("Too many array elements"));
928 memcpy (value_contents_raw (array
)
929 + (index
- low_bound
) * element_size
,
930 value_contents (element
),
938 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
939 && TYPE_CODE (type
) == TYPE_CODE_SET
)
941 struct value
*set
= allocate_value (expect_type
);
942 gdb_byte
*valaddr
= value_contents_raw (set
);
943 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
944 struct type
*check_type
= element_type
;
945 LONGEST low_bound
, high_bound
;
947 /* Get targettype of elementtype. */
948 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
949 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
950 check_type
= TYPE_TARGET_TYPE (check_type
);
952 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
953 error (_("(power)set type with unknown size"));
954 memset (valaddr
, '\0', TYPE_LENGTH (type
));
955 for (tem
= 0; tem
< nargs
; tem
++)
957 LONGEST range_low
, range_high
;
958 struct type
*range_low_type
, *range_high_type
;
959 struct value
*elem_val
;
961 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
964 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
965 range_low_type
= value_type (elem_val
);
966 range_low
= value_as_long (elem_val
);
967 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
968 range_high_type
= value_type (elem_val
);
969 range_high
= value_as_long (elem_val
);
973 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
974 range_low_type
= range_high_type
= value_type (elem_val
);
975 range_low
= range_high
= value_as_long (elem_val
);
977 /* Check types of elements to avoid mixture of elements from
978 different types. Also check if type of element is "compatible"
979 with element type of powerset. */
980 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
981 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
982 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
983 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
984 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
985 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
986 && (range_low_type
!= range_high_type
)))
987 /* different element modes. */
988 error (_("POWERSET tuple elements of different mode"));
989 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
990 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
991 && range_low_type
!= check_type
))
992 error (_("incompatible POWERSET tuple elements"));
993 if (range_low
> range_high
)
995 warning (_("empty POWERSET tuple range"));
998 if (range_low
< low_bound
|| range_high
> high_bound
)
999 error (_("POWERSET tuple element out of range"));
1000 range_low
-= low_bound
;
1001 range_high
-= low_bound
;
1002 for (; range_low
<= range_high
; range_low
++)
1004 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1006 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1007 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1008 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1015 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1016 for (tem
= 0; tem
< nargs
; tem
++)
1018 /* Ensure that array expressions are coerced into pointer
1020 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1022 if (noside
== EVAL_SKIP
)
1024 return value_array (tem2
, tem3
, argvec
);
1028 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1030 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1032 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1034 if (noside
== EVAL_SKIP
)
1036 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1040 /* Skip third and second args to evaluate the first one. */
1041 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1042 if (value_logical_not (arg1
))
1044 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1045 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1049 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1050 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1054 case OP_OBJC_SELECTOR
:
1055 { /* Objective C @selector operator. */
1056 char *sel
= &exp
->elts
[pc
+ 2].string
;
1057 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1058 struct type
*selector_type
;
1060 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1061 if (noside
== EVAL_SKIP
)
1065 sel
[len
] = 0; /* Make sure it's terminated. */
1067 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1068 return value_from_longest (selector_type
,
1069 lookup_child_selector (exp
->gdbarch
, sel
));
1072 case OP_OBJC_MSGCALL
:
1073 { /* Objective C message (method) call. */
1075 CORE_ADDR responds_selector
= 0;
1076 CORE_ADDR method_selector
= 0;
1078 CORE_ADDR selector
= 0;
1080 int struct_return
= 0;
1081 int sub_no_side
= 0;
1083 struct value
*msg_send
= NULL
;
1084 struct value
*msg_send_stret
= NULL
;
1085 int gnu_runtime
= 0;
1087 struct value
*target
= NULL
;
1088 struct value
*method
= NULL
;
1089 struct value
*called_method
= NULL
;
1091 struct type
*selector_type
= NULL
;
1092 struct type
*long_type
;
1094 struct value
*ret
= NULL
;
1097 selector
= exp
->elts
[pc
+ 1].longconst
;
1098 nargs
= exp
->elts
[pc
+ 2].longconst
;
1099 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1104 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1105 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1107 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1108 sub_no_side
= EVAL_NORMAL
;
1110 sub_no_side
= noside
;
1112 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1114 if (value_as_long (target
) == 0)
1115 return value_from_longest (long_type
, 0);
1117 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1120 /* Find the method dispatch (Apple runtime) or method lookup
1121 (GNU runtime) function for Objective-C. These will be used
1122 to lookup the symbol information for the method. If we
1123 can't find any symbol information, then we'll use these to
1124 call the method, otherwise we can call the method
1125 directly. The msg_send_stret function is used in the special
1126 case of a method that returns a structure (Apple runtime
1130 struct type
*type
= selector_type
;
1132 type
= lookup_function_type (type
);
1133 type
= lookup_pointer_type (type
);
1134 type
= lookup_function_type (type
);
1135 type
= lookup_pointer_type (type
);
1137 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1139 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1141 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1142 msg_send_stret
= value_from_pointer (type
,
1143 value_as_address (msg_send_stret
));
1147 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1148 /* Special dispatcher for methods returning structs. */
1150 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1153 /* Verify the target object responds to this method. The
1154 standard top-level 'Object' class uses a different name for
1155 the verification method than the non-standard, but more
1156 often used, 'NSObject' class. Make sure we check for both. */
1159 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1160 if (responds_selector
== 0)
1162 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1164 if (responds_selector
== 0)
1165 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1168 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1169 if (method_selector
== 0)
1171 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1173 if (method_selector
== 0)
1174 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1176 /* Call the verification method, to make sure that the target
1177 class implements the desired method. */
1179 argvec
[0] = msg_send
;
1181 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1182 argvec
[3] = value_from_longest (long_type
, selector
);
1185 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1188 /* Function objc_msg_lookup returns a pointer. */
1190 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1192 if (value_as_long (ret
) == 0)
1193 error (_("Target does not respond to this message selector."));
1195 /* Call "methodForSelector:" method, to get the address of a
1196 function method that implements this selector for this
1197 class. If we can find a symbol at that address, then we
1198 know the return type, parameter types etc. (that's a good
1201 argvec
[0] = msg_send
;
1203 argvec
[2] = value_from_longest (long_type
, method_selector
);
1204 argvec
[3] = value_from_longest (long_type
, selector
);
1207 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1211 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1214 /* ret should now be the selector. */
1216 addr
= value_as_long (ret
);
1219 struct symbol
*sym
= NULL
;
1221 /* The address might point to a function descriptor;
1222 resolve it to the actual code address instead. */
1223 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1226 /* Is it a high_level symbol? */
1227 sym
= find_pc_function (addr
);
1229 method
= value_of_variable (sym
, 0);
1232 /* If we found a method with symbol information, check to see
1233 if it returns a struct. Otherwise assume it doesn't. */
1238 struct type
*val_type
;
1240 funaddr
= find_function_addr (method
, &val_type
);
1242 block_for_pc (funaddr
);
1244 CHECK_TYPEDEF (val_type
);
1246 if ((val_type
== NULL
)
1247 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1249 if (expect_type
!= NULL
)
1250 val_type
= expect_type
;
1253 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1256 else if (expect_type
!= NULL
)
1258 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1259 check_typedef (expect_type
));
1262 /* Found a function symbol. Now we will substitute its
1263 value in place of the message dispatcher (obj_msgSend),
1264 so that we call the method directly instead of thru
1265 the dispatcher. The main reason for doing this is that
1266 we can now evaluate the return value and parameter values
1267 according to their known data types, in case we need to
1268 do things like promotion, dereferencing, special handling
1269 of structs and doubles, etc.
1271 We want to use the type signature of 'method', but still
1272 jump to objc_msgSend() or objc_msgSend_stret() to better
1273 mimic the behavior of the runtime. */
1277 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1278 error (_("method address has symbol information "
1279 "with non-function type; skipping"));
1281 /* Create a function pointer of the appropriate type, and
1282 replace its value with the value of msg_send or
1283 msg_send_stret. We must use a pointer here, as
1284 msg_send and msg_send_stret are of pointer type, and
1285 the representation may be different on systems that use
1286 function descriptors. */
1289 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1290 value_as_address (msg_send_stret
));
1293 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1294 value_as_address (msg_send
));
1299 called_method
= msg_send_stret
;
1301 called_method
= msg_send
;
1304 if (noside
== EVAL_SKIP
)
1307 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1309 /* If the return type doesn't look like a function type,
1310 call an error. This can happen if somebody tries to
1311 turn a variable into a function call. This is here
1312 because people often want to call, eg, strcmp, which
1313 gdb doesn't know is a function. If gdb isn't asked for
1314 it's opinion (ie. through "whatis"), it won't offer
1317 struct type
*type
= value_type (called_method
);
1319 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1320 type
= TYPE_TARGET_TYPE (type
);
1321 type
= TYPE_TARGET_TYPE (type
);
1325 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1326 return allocate_value (expect_type
);
1328 return allocate_value (type
);
1331 error (_("Expression of type other than "
1332 "\"method returning ...\" used as a method"));
1335 /* Now depending on whether we found a symbol for the method,
1336 we will either call the runtime dispatcher or the method
1339 argvec
[0] = called_method
;
1341 argvec
[2] = value_from_longest (long_type
, selector
);
1342 /* User-supplied arguments. */
1343 for (tem
= 0; tem
< nargs
; tem
++)
1344 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1345 argvec
[tem
+ 3] = 0;
1347 if (gnu_runtime
&& (method
!= NULL
))
1349 /* Function objc_msg_lookup returns a pointer. */
1350 deprecated_set_value_type (argvec
[0],
1351 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1353 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1356 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1363 op
= exp
->elts
[*pos
].opcode
;
1364 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1365 /* Allocate arg vector, including space for the function to be
1366 called in argvec[0], a potential `this', and a terminating NULL. */
1367 argvec
= (struct value
**)
1368 alloca (sizeof (struct value
*) * (nargs
+ 3));
1369 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1371 /* First, evaluate the structure into arg2. */
1374 if (noside
== EVAL_SKIP
)
1377 if (op
== STRUCTOP_MEMBER
)
1379 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1383 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1386 /* If the function is a virtual function, then the
1387 aggregate value (providing the structure) plays
1388 its part by providing the vtable. Otherwise,
1389 it is just along for the ride: call the function
1392 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1394 type
= check_typedef (value_type (arg1
));
1395 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
)
1397 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1398 arg1
= value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1400 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1402 /* Now, say which argument to start evaluating from. */
1407 else if (TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1409 struct type
*type_ptr
1410 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type
));
1411 struct type
*target_type_ptr
1412 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1414 /* Now, convert these values to an address. */
1415 arg2
= value_cast (type_ptr
, arg2
);
1417 mem_offset
= value_as_long (arg1
);
1419 arg1
= value_from_pointer (target_type_ptr
,
1420 value_as_long (arg2
) + mem_offset
);
1421 arg1
= value_ind (arg1
);
1425 error (_("Non-pointer-to-member value used in pointer-to-member "
1428 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1430 /* Hair for method invocations. */
1434 /* First, evaluate the structure into arg2. */
1436 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1437 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1438 if (noside
== EVAL_SKIP
)
1441 if (op
== STRUCTOP_STRUCT
)
1443 /* If v is a variable in a register, and the user types
1444 v.method (), this will produce an error, because v has
1447 A possible way around this would be to allocate a
1448 copy of the variable on the stack, copy in the
1449 contents, call the function, and copy out the
1450 contents. I.e. convert this from call by reference
1451 to call by copy-return (or whatever it's called).
1452 However, this does not work because it is not the
1453 same: the method being called could stash a copy of
1454 the address, and then future uses through that address
1455 (after the method returns) would be expected to
1456 use the variable itself, not some copy of it. */
1457 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1461 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1463 /* Check to see if the operator '->' has been
1464 overloaded. If the operator has been overloaded
1465 replace arg2 with the value returned by the custom
1466 operator and continue evaluation. */
1467 while (unop_user_defined_p (op
, arg2
))
1469 volatile struct gdb_exception except
;
1470 struct value
*value
= NULL
;
1471 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1473 value
= value_x_unop (arg2
, op
, noside
);
1476 if (except
.reason
< 0)
1478 if (except
.error
== NOT_FOUND_ERROR
)
1481 throw_exception (except
);
1486 /* Now, say which argument to start evaluating from. */
1489 else if (op
== OP_SCOPE
1490 && overload_resolution
1491 && (exp
->language_defn
->la_language
== language_cplus
))
1493 /* Unpack it locally so we can properly handle overload
1499 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1500 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1501 type
= exp
->elts
[pc2
+ 1].type
;
1502 name
= &exp
->elts
[pc2
+ 3].string
;
1505 function_name
= NULL
;
1506 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1508 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1510 get_selected_block (0),
1512 if (function
== NULL
)
1513 error (_("No symbol \"%s\" in namespace \"%s\"."),
1514 name
, TYPE_TAG_NAME (type
));
1517 /* arg2 is left as NULL on purpose. */
1521 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1522 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1523 function_name
= name
;
1525 /* We need a properly typed value for method lookup. For
1526 static methods arg2 is otherwise unused. */
1527 arg2
= value_zero (type
, lval_memory
);
1532 else if (op
== OP_ADL_FUNC
)
1534 /* Save the function position and move pos so that the arguments
1535 can be evaluated. */
1541 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1542 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1546 /* Non-method function call. */
1550 /* If this is a C++ function wait until overload resolution. */
1551 if (op
== OP_VAR_VALUE
1552 && overload_resolution
1553 && (exp
->language_defn
->la_language
== language_cplus
))
1555 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1560 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1561 type
= value_type (argvec
[0]);
1562 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1563 type
= TYPE_TARGET_TYPE (type
);
1564 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1566 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1568 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1576 /* Evaluate arguments (if not already done, e.g., namespace::func()
1577 and overload-resolution is off). */
1578 for (; tem
<= nargs
; tem
++)
1580 /* Ensure that array expressions are coerced into pointer
1582 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1585 /* Signal end of arglist. */
1588 if (op
== OP_ADL_FUNC
)
1590 struct symbol
*symp
;
1593 int string_pc
= save_pos1
+ 3;
1595 /* Extract the function name. */
1596 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1597 func_name
= (char *) alloca (name_len
+ 1);
1598 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1600 find_overload_match (&argvec
[1], nargs
, func_name
,
1601 NON_METHOD
, /* not method */
1602 NULL
, NULL
, /* pass NULL symbol since
1603 symbol is unknown */
1604 NULL
, &symp
, NULL
, 0);
1606 /* Now fix the expression being evaluated. */
1607 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1608 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1611 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1612 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1614 int static_memfuncp
;
1617 /* Method invocation: stuff "this" as first parameter.
1618 If the method turns out to be static we undo this below. */
1623 /* Name of method from expression. */
1624 tstr
= &exp
->elts
[pc2
+ 2].string
;
1627 tstr
= function_name
;
1629 if (overload_resolution
&& (exp
->language_defn
->la_language
1632 /* Language is C++, do some overload resolution before
1634 struct value
*valp
= NULL
;
1636 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1637 METHOD
, /* method */
1638 &arg2
, /* the object */
1640 &static_memfuncp
, 0);
1642 if (op
== OP_SCOPE
&& !static_memfuncp
)
1644 /* For the time being, we don't handle this. */
1645 error (_("Call to overloaded function %s requires "
1649 argvec
[1] = arg2
; /* the ``this'' pointer */
1650 argvec
[0] = valp
; /* Use the method found after overload
1654 /* Non-C++ case -- or no overload resolution. */
1656 struct value
*temp
= arg2
;
1658 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1660 op
== STRUCTOP_STRUCT
1661 ? "structure" : "structure pointer");
1662 /* value_struct_elt updates temp with the correct value
1663 of the ``this'' pointer if necessary, so modify argvec[1] to
1664 reflect any ``this'' changes. */
1666 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1667 value_address (temp
)
1668 + value_embedded_offset (temp
));
1669 argvec
[1] = arg2
; /* the ``this'' pointer */
1672 /* Take out `this' if needed. */
1673 if (static_memfuncp
)
1675 argvec
[1] = argvec
[0];
1680 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1682 /* Pointer to member. argvec[1] is already set up. */
1685 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1687 /* Non-member function being called. */
1688 /* fn: This can only be done for C++ functions. A C-style function
1689 in a C++ program, for instance, does not have the fields that
1690 are expected here. */
1692 if (overload_resolution
&& (exp
->language_defn
->la_language
1695 /* Language is C++, do some overload resolution before
1697 struct symbol
*symp
;
1700 /* If a scope has been specified disable ADL. */
1704 if (op
== OP_VAR_VALUE
)
1705 function
= exp
->elts
[save_pos1
+2].symbol
;
1707 (void) find_overload_match (&argvec
[1], nargs
,
1708 NULL
, /* no need for name */
1709 NON_METHOD
, /* not method */
1710 NULL
, function
, /* the function */
1711 NULL
, &symp
, NULL
, no_adl
);
1713 if (op
== OP_VAR_VALUE
)
1715 /* Now fix the expression being evaluated. */
1716 exp
->elts
[save_pos1
+2].symbol
= symp
;
1717 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1721 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1725 /* Not C++, or no overload resolution allowed. */
1726 /* Nothing to be done; argvec already correctly set up. */
1731 /* It is probably a C-style function. */
1732 /* Nothing to be done; argvec already correctly set up. */
1737 if (noside
== EVAL_SKIP
)
1739 if (argvec
[0] == NULL
)
1740 error (_("Cannot evaluate function -- may be inlined"));
1741 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1743 /* If the return type doesn't look like a function type, call an
1744 error. This can happen if somebody tries to turn a variable into
1745 a function call. This is here because people often want to
1746 call, eg, strcmp, which gdb doesn't know is a function. If
1747 gdb isn't asked for it's opinion (ie. through "whatis"),
1748 it won't offer it. */
1750 struct type
*ftype
= value_type (argvec
[0]);
1752 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1754 /* We don't know anything about what the internal
1755 function might return, but we have to return
1757 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1760 else if (TYPE_GNU_IFUNC (ftype
))
1761 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1762 else if (TYPE_TARGET_TYPE (ftype
))
1763 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1765 error (_("Expression of type other than "
1766 "\"Function returning ...\" used as function"));
1768 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1769 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1770 argvec
[0], nargs
, argvec
+ 1);
1772 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1773 /* pai: FIXME save value from call_function_by_hand, then adjust
1774 pc by adjust_fn_pc if +ve. */
1776 case OP_F77_UNDETERMINED_ARGLIST
:
1778 /* Remember that in F77, functions, substring ops and
1779 array subscript operations cannot be disambiguated
1780 at parse time. We have made all array subscript operations,
1781 substring operations as well as function calls come here
1782 and we now have to discover what the heck this thing actually was.
1783 If it is a function, we process just as if we got an OP_FUNCALL. */
1785 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1788 /* First determine the type code we are dealing with. */
1789 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1790 type
= check_typedef (value_type (arg1
));
1791 code
= TYPE_CODE (type
);
1793 if (code
== TYPE_CODE_PTR
)
1795 /* Fortran always passes variable to subroutines as pointer.
1796 So we need to look into its target type to see if it is
1797 array, string or function. If it is, we need to switch
1798 to the target value the original one points to. */
1799 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1801 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1802 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1803 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1805 arg1
= value_ind (arg1
);
1806 type
= check_typedef (value_type (arg1
));
1807 code
= TYPE_CODE (type
);
1813 case TYPE_CODE_ARRAY
:
1814 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1815 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1817 goto multi_f77_subscript
;
1819 case TYPE_CODE_STRING
:
1820 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1821 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1824 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1825 return value_subscript (arg1
, value_as_long (arg2
));
1829 case TYPE_CODE_FUNC
:
1830 /* It's a function call. */
1831 /* Allocate arg vector, including space for the function to be
1832 called in argvec[0] and a terminating NULL. */
1833 argvec
= (struct value
**)
1834 alloca (sizeof (struct value
*) * (nargs
+ 2));
1837 for (; tem
<= nargs
; tem
++)
1838 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1839 argvec
[tem
] = 0; /* signal end of arglist */
1843 error (_("Cannot perform substring on this type"));
1847 /* We have a complex number, There should be 2 floating
1848 point numbers that compose it. */
1850 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1851 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1853 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1855 case STRUCTOP_STRUCT
:
1856 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1857 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1858 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1859 if (noside
== EVAL_SKIP
)
1861 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1863 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1864 arg3
= value_zero (value_type (arg3
), not_lval
);
1868 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1869 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1870 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1871 if (noside
== EVAL_SKIP
)
1874 /* Check to see if operator '->' has been overloaded. If so replace
1875 arg1 with the value returned by evaluating operator->(). */
1876 while (unop_user_defined_p (op
, arg1
))
1878 volatile struct gdb_exception except
;
1879 struct value
*value
= NULL
;
1880 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1882 value
= value_x_unop (arg1
, op
, noside
);
1885 if (except
.reason
< 0)
1887 if (except
.error
== NOT_FOUND_ERROR
)
1890 throw_exception (except
);
1895 /* JYG: if print object is on we need to replace the base type
1896 with rtti type in order to continue on with successful
1897 lookup of member / method only available in the rtti type. */
1899 struct type
*type
= value_type (arg1
);
1900 struct type
*real_type
;
1901 int full
, top
, using_enc
;
1902 struct value_print_options opts
;
1904 get_user_print_options (&opts
);
1905 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1906 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1908 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1911 arg1
= value_cast (real_type
, arg1
);
1915 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1916 NULL
, "structure pointer");
1917 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1918 arg3
= value_zero (value_type (arg3
), not_lval
);
1921 case STRUCTOP_MEMBER
:
1923 if (op
== STRUCTOP_MEMBER
)
1924 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1926 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1928 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1930 if (noside
== EVAL_SKIP
)
1933 type
= check_typedef (value_type (arg2
));
1934 switch (TYPE_CODE (type
))
1936 case TYPE_CODE_METHODPTR
:
1937 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1938 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1941 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1942 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1943 return value_ind (arg2
);
1946 case TYPE_CODE_MEMBERPTR
:
1947 /* Now, convert these values to an address. */
1948 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1951 mem_offset
= value_as_long (arg2
);
1953 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1954 value_as_long (arg1
) + mem_offset
);
1955 return value_ind (arg3
);
1958 error (_("non-pointer-to-member value used "
1959 "in pointer-to-member construct"));
1963 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1964 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1965 for (ix
= 0; ix
< nargs
; ++ix
)
1966 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1968 expect_type
= make_params (nargs
, arg_types
);
1969 *(pos
) += 3 + nargs
;
1970 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1971 xfree (TYPE_FIELDS (expect_type
));
1972 xfree (TYPE_MAIN_TYPE (expect_type
));
1973 xfree (expect_type
);
1977 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1978 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1979 if (noside
== EVAL_SKIP
)
1981 if (binop_user_defined_p (op
, arg1
, arg2
))
1982 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1984 return value_concat (arg1
, arg2
);
1987 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1988 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1990 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1992 if (binop_user_defined_p (op
, arg1
, arg2
))
1993 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1995 return value_assign (arg1
, arg2
);
1997 case BINOP_ASSIGN_MODIFY
:
1999 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2000 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2001 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2003 op
= exp
->elts
[pc
+ 1].opcode
;
2004 if (binop_user_defined_p (op
, arg1
, arg2
))
2005 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2006 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2008 && is_integral_type (value_type (arg2
)))
2009 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2010 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2012 && is_integral_type (value_type (arg2
)))
2013 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2016 struct value
*tmp
= arg1
;
2018 /* For shift and integer exponentiation operations,
2019 only promote the first argument. */
2020 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2021 && is_integral_type (value_type (arg2
)))
2022 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2024 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2026 arg2
= value_binop (tmp
, arg2
, op
);
2028 return value_assign (arg1
, arg2
);
2031 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2032 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2033 if (noside
== EVAL_SKIP
)
2035 if (binop_user_defined_p (op
, arg1
, arg2
))
2036 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2037 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2038 && is_integral_type (value_type (arg2
)))
2039 return value_ptradd (arg1
, value_as_long (arg2
));
2040 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2041 && is_integral_type (value_type (arg1
)))
2042 return value_ptradd (arg2
, value_as_long (arg1
));
2045 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2046 return value_binop (arg1
, arg2
, BINOP_ADD
);
2050 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2051 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2052 if (noside
== EVAL_SKIP
)
2054 if (binop_user_defined_p (op
, arg1
, arg2
))
2055 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2056 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2057 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2059 /* FIXME -- should be ptrdiff_t */
2060 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2061 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2063 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2064 && is_integral_type (value_type (arg2
)))
2065 return value_ptradd (arg1
, - value_as_long (arg2
));
2068 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2069 return value_binop (arg1
, arg2
, BINOP_SUB
);
2080 case BINOP_BITWISE_AND
:
2081 case BINOP_BITWISE_IOR
:
2082 case BINOP_BITWISE_XOR
:
2083 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2084 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2085 if (noside
== EVAL_SKIP
)
2087 if (binop_user_defined_p (op
, arg1
, arg2
))
2088 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2091 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2092 fudge arg2 to avoid division-by-zero, the caller is
2093 (theoretically) only looking for the type of the result. */
2094 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2095 /* ??? Do we really want to test for BINOP_MOD here?
2096 The implementation of value_binop gives it a well-defined
2099 || op
== BINOP_INTDIV
2102 && value_logical_not (arg2
))
2104 struct value
*v_one
, *retval
;
2106 v_one
= value_one (value_type (arg2
));
2107 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2108 retval
= value_binop (arg1
, v_one
, op
);
2113 /* For shift and integer exponentiation operations,
2114 only promote the first argument. */
2115 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2116 && is_integral_type (value_type (arg2
)))
2117 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2119 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2121 return value_binop (arg1
, arg2
, op
);
2126 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2127 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2128 if (noside
== EVAL_SKIP
)
2130 error (_("':' operator used in invalid context"));
2132 case BINOP_SUBSCRIPT
:
2133 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2134 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2135 if (noside
== EVAL_SKIP
)
2137 if (binop_user_defined_p (op
, arg1
, arg2
))
2138 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2141 /* If the user attempts to subscript something that is not an
2142 array or pointer type (like a plain int variable for example),
2143 then report this as an error. */
2145 arg1
= coerce_ref (arg1
);
2146 type
= check_typedef (value_type (arg1
));
2147 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2148 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2150 if (TYPE_NAME (type
))
2151 error (_("cannot subscript something of type `%s'"),
2154 error (_("cannot subscript requested type"));
2157 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2158 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2160 return value_subscript (arg1
, value_as_long (arg2
));
2164 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2165 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2166 if (noside
== EVAL_SKIP
)
2168 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2169 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2171 case MULTI_SUBSCRIPT
:
2173 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2174 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2177 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2178 /* FIXME: EVAL_SKIP handling may not be correct. */
2179 if (noside
== EVAL_SKIP
)
2190 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2191 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2193 /* If the user attempts to subscript something that has no target
2194 type (like a plain int variable for example), then report this
2197 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2200 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2206 error (_("cannot subscript something of type `%s'"),
2207 TYPE_NAME (value_type (arg1
)));
2211 if (binop_user_defined_p (op
, arg1
, arg2
))
2213 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2217 arg1
= coerce_ref (arg1
);
2218 type
= check_typedef (value_type (arg1
));
2220 switch (TYPE_CODE (type
))
2223 case TYPE_CODE_ARRAY
:
2224 case TYPE_CODE_STRING
:
2225 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2229 if (TYPE_NAME (type
))
2230 error (_("cannot subscript something of type `%s'"),
2233 error (_("cannot subscript requested type"));
2239 multi_f77_subscript
:
2241 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2242 int ndimensions
= 1, i
;
2243 struct value
*array
= arg1
;
2245 if (nargs
> MAX_FORTRAN_DIMS
)
2246 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2248 ndimensions
= calc_f77_array_dims (type
);
2250 if (nargs
!= ndimensions
)
2251 error (_("Wrong number of subscripts"));
2253 gdb_assert (nargs
> 0);
2255 /* Now that we know we have a legal array subscript expression
2256 let us actually find out where this element exists in the array. */
2258 /* Take array indices left to right. */
2259 for (i
= 0; i
< nargs
; i
++)
2261 /* Evaluate each subscript; it must be a legal integer in F77. */
2262 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2264 /* Fill in the subscript array. */
2266 subscript_array
[i
] = value_as_long (arg2
);
2269 /* Internal type of array is arranged right to left. */
2270 for (i
= nargs
; i
> 0; i
--)
2272 struct type
*array_type
= check_typedef (value_type (array
));
2273 LONGEST index
= subscript_array
[i
- 1];
2275 array
= value_subscripted_rvalue (array
, index
,
2276 f77_get_lowerbound (array_type
));
2282 case BINOP_LOGICAL_AND
:
2283 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2284 if (noside
== EVAL_SKIP
)
2286 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2291 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2294 if (binop_user_defined_p (op
, arg1
, arg2
))
2296 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2297 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2301 tem
= value_logical_not (arg1
);
2302 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2303 (tem
? EVAL_SKIP
: noside
));
2304 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2305 return value_from_longest (type
,
2306 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2309 case BINOP_LOGICAL_OR
:
2310 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2311 if (noside
== EVAL_SKIP
)
2313 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2318 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2321 if (binop_user_defined_p (op
, arg1
, arg2
))
2323 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2324 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2328 tem
= value_logical_not (arg1
);
2329 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2330 (!tem
? EVAL_SKIP
: noside
));
2331 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2332 return value_from_longest (type
,
2333 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2337 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2338 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2339 if (noside
== EVAL_SKIP
)
2341 if (binop_user_defined_p (op
, arg1
, arg2
))
2343 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2347 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2348 tem
= value_equal (arg1
, arg2
);
2349 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2350 return value_from_longest (type
, (LONGEST
) tem
);
2353 case BINOP_NOTEQUAL
:
2354 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2355 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2356 if (noside
== EVAL_SKIP
)
2358 if (binop_user_defined_p (op
, arg1
, arg2
))
2360 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2364 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2365 tem
= value_equal (arg1
, arg2
);
2366 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2367 return value_from_longest (type
, (LONGEST
) ! tem
);
2371 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2372 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2373 if (noside
== EVAL_SKIP
)
2375 if (binop_user_defined_p (op
, arg1
, arg2
))
2377 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2381 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2382 tem
= value_less (arg1
, arg2
);
2383 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2384 return value_from_longest (type
, (LONGEST
) tem
);
2388 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2389 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2390 if (noside
== EVAL_SKIP
)
2392 if (binop_user_defined_p (op
, arg1
, arg2
))
2394 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2398 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2399 tem
= value_less (arg2
, arg1
);
2400 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2401 return value_from_longest (type
, (LONGEST
) tem
);
2405 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2406 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2407 if (noside
== EVAL_SKIP
)
2409 if (binop_user_defined_p (op
, arg1
, arg2
))
2411 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2415 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2416 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2417 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2418 return value_from_longest (type
, (LONGEST
) tem
);
2422 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2423 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2424 if (noside
== EVAL_SKIP
)
2426 if (binop_user_defined_p (op
, arg1
, arg2
))
2428 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2432 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2433 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2434 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2435 return value_from_longest (type
, (LONGEST
) tem
);
2439 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2440 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2441 if (noside
== EVAL_SKIP
)
2443 type
= check_typedef (value_type (arg2
));
2444 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2445 error (_("Non-integral right operand for \"@\" operator."));
2446 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2448 return allocate_repeat_value (value_type (arg1
),
2449 longest_to_int (value_as_long (arg2
)));
2452 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2455 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2456 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2459 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2460 if (noside
== EVAL_SKIP
)
2462 if (unop_user_defined_p (op
, arg1
))
2463 return value_x_unop (arg1
, op
, noside
);
2466 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2467 return value_pos (arg1
);
2471 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2472 if (noside
== EVAL_SKIP
)
2474 if (unop_user_defined_p (op
, arg1
))
2475 return value_x_unop (arg1
, op
, noside
);
2478 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2479 return value_neg (arg1
);
2482 case UNOP_COMPLEMENT
:
2483 /* C++: check for and handle destructor names. */
2484 op
= exp
->elts
[*pos
].opcode
;
2486 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2487 if (noside
== EVAL_SKIP
)
2489 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2490 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2493 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2494 return value_complement (arg1
);
2497 case UNOP_LOGICAL_NOT
:
2498 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2499 if (noside
== EVAL_SKIP
)
2501 if (unop_user_defined_p (op
, arg1
))
2502 return value_x_unop (arg1
, op
, noside
);
2505 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2506 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2510 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2511 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2512 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2513 type
= check_typedef (value_type (arg1
));
2514 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2515 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2516 error (_("Attempt to dereference pointer "
2517 "to member without an object"));
2518 if (noside
== EVAL_SKIP
)
2520 if (unop_user_defined_p (op
, arg1
))
2521 return value_x_unop (arg1
, op
, noside
);
2522 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2524 type
= check_typedef (value_type (arg1
));
2525 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2526 || TYPE_CODE (type
) == TYPE_CODE_REF
2527 /* In C you can dereference an array to get the 1st elt. */
2528 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2530 return value_zero (TYPE_TARGET_TYPE (type
),
2532 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2533 /* GDB allows dereferencing an int. */
2534 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2537 error (_("Attempt to take contents of a non-pointer value."));
2540 /* Allow * on an integer so we can cast it to whatever we want.
2541 This returns an int, which seems like the most C-like thing to
2542 do. "long long" variables are rare enough that
2543 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2544 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2545 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2546 (CORE_ADDR
) value_as_address (arg1
));
2547 return value_ind (arg1
);
2550 /* C++: check for and handle pointer to members. */
2552 op
= exp
->elts
[*pos
].opcode
;
2554 if (noside
== EVAL_SKIP
)
2556 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2561 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2568 if (noside
== EVAL_SKIP
)
2570 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2573 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2577 type
= exp
->elts
[pc
+ 1].type
;
2578 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2579 if (noside
== EVAL_SKIP
)
2581 if (type
!= value_type (arg1
))
2582 arg1
= value_cast (type
, arg1
);
2585 case UNOP_CAST_TYPE
:
2586 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2587 type
= value_type (arg1
);
2588 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2589 if (noside
== EVAL_SKIP
)
2591 if (type
!= value_type (arg1
))
2592 arg1
= value_cast (type
, arg1
);
2595 case UNOP_DYNAMIC_CAST
:
2596 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2597 type
= value_type (arg1
);
2598 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2599 if (noside
== EVAL_SKIP
)
2601 return value_dynamic_cast (type
, arg1
);
2603 case UNOP_REINTERPRET_CAST
:
2604 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2605 type
= value_type (arg1
);
2606 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2607 if (noside
== EVAL_SKIP
)
2609 return value_reinterpret_cast (type
, arg1
);
2613 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2614 if (noside
== EVAL_SKIP
)
2616 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2617 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2619 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2620 value_as_address (arg1
));
2622 case UNOP_MEMVAL_TYPE
:
2623 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2624 type
= value_type (arg1
);
2625 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2626 if (noside
== EVAL_SKIP
)
2628 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2629 return value_zero (type
, lval_memory
);
2631 return value_at_lazy (type
, value_as_address (arg1
));
2633 case UNOP_MEMVAL_TLS
:
2635 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2636 if (noside
== EVAL_SKIP
)
2638 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2639 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2644 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2645 value_as_address (arg1
));
2646 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2649 case UNOP_PREINCREMENT
:
2650 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2651 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2653 else if (unop_user_defined_p (op
, arg1
))
2655 return value_x_unop (arg1
, op
, noside
);
2659 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2660 arg2
= value_ptradd (arg1
, 1);
2663 struct value
*tmp
= arg1
;
2665 arg2
= value_one (value_type (arg1
));
2666 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2667 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2670 return value_assign (arg1
, arg2
);
2673 case UNOP_PREDECREMENT
:
2674 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2675 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2677 else if (unop_user_defined_p (op
, arg1
))
2679 return value_x_unop (arg1
, op
, noside
);
2683 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2684 arg2
= value_ptradd (arg1
, -1);
2687 struct value
*tmp
= arg1
;
2689 arg2
= value_one (value_type (arg1
));
2690 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2691 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2694 return value_assign (arg1
, arg2
);
2697 case UNOP_POSTINCREMENT
:
2698 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2699 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2701 else if (unop_user_defined_p (op
, arg1
))
2703 return value_x_unop (arg1
, op
, noside
);
2707 arg3
= value_non_lval (arg1
);
2709 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2710 arg2
= value_ptradd (arg1
, 1);
2713 struct value
*tmp
= arg1
;
2715 arg2
= value_one (value_type (arg1
));
2716 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2717 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2720 value_assign (arg1
, arg2
);
2724 case UNOP_POSTDECREMENT
:
2725 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2726 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2728 else if (unop_user_defined_p (op
, arg1
))
2730 return value_x_unop (arg1
, op
, noside
);
2734 arg3
= value_non_lval (arg1
);
2736 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2737 arg2
= value_ptradd (arg1
, -1);
2740 struct value
*tmp
= arg1
;
2742 arg2
= value_one (value_type (arg1
));
2743 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2744 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2747 value_assign (arg1
, arg2
);
2753 return value_of_this (exp
->language_defn
);
2756 /* The value is not supposed to be used. This is here to make it
2757 easier to accommodate expressions that contain types. */
2759 if (noside
== EVAL_SKIP
)
2761 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2763 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2765 /* If this is a typedef, then find its immediate target. We
2766 use check_typedef to resolve stubs, but we ignore its
2767 result because we do not want to dig past all
2769 check_typedef (type
);
2770 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2771 type
= TYPE_TARGET_TYPE (type
);
2772 return allocate_value (type
);
2775 error (_("Attempt to use a type name as an expression"));
2779 if (noside
== EVAL_SKIP
)
2781 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2784 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2786 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2787 struct value
*result
;
2789 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2790 EVAL_AVOID_SIDE_EFFECTS
);
2792 /* 'decltype' has special semantics for lvalues. */
2793 if (op
== OP_DECLTYPE
2794 && (sub_op
== BINOP_SUBSCRIPT
2795 || sub_op
== STRUCTOP_MEMBER
2796 || sub_op
== STRUCTOP_MPTR
2797 || sub_op
== UNOP_IND
2798 || sub_op
== STRUCTOP_STRUCT
2799 || sub_op
== STRUCTOP_PTR
2800 || sub_op
== OP_SCOPE
))
2802 struct type
*type
= value_type (result
);
2804 if (TYPE_CODE (check_typedef (type
)) != TYPE_CODE_REF
)
2806 type
= lookup_reference_type (type
);
2807 result
= allocate_value (type
);
2814 error (_("Attempt to use a type as an expression"));
2818 struct value
*result
;
2819 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2821 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2822 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2823 EVAL_AVOID_SIDE_EFFECTS
);
2825 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2827 if (noside
!= EVAL_NORMAL
)
2828 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2830 return cplus_typeid (result
);
2834 /* Removing this case and compiling with gcc -Wall reveals that
2835 a lot of cases are hitting this case. Some of these should
2836 probably be removed from expression.h; others are legitimate
2837 expressions which are (apparently) not fully implemented.
2839 If there are any cases landing here which mean a user error,
2840 then they should be separate cases, with more descriptive
2843 error (_("GDB does not (yet) know how to "
2844 "evaluate that kind of expression"));
2848 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2851 /* Evaluate a subexpression of EXP, at index *POS,
2852 and return the address of that subexpression.
2853 Advance *POS over the subexpression.
2854 If the subexpression isn't an lvalue, get an error.
2855 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2856 then only the type of the result need be correct. */
2858 static struct value
*
2859 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2869 op
= exp
->elts
[pc
].opcode
;
2875 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2877 /* We can't optimize out "&*" if there's a user-defined operator*. */
2878 if (unop_user_defined_p (op
, x
))
2880 x
= value_x_unop (x
, op
, noside
);
2881 goto default_case_after_eval
;
2884 return coerce_array (x
);
2888 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2889 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2891 case UNOP_MEMVAL_TYPE
:
2896 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2897 type
= value_type (x
);
2898 return value_cast (lookup_pointer_type (type
),
2899 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2903 var
= exp
->elts
[pc
+ 2].symbol
;
2905 /* C++: The "address" of a reference should yield the address
2906 * of the object pointed to. Let value_addr() deal with it. */
2907 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2911 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2914 lookup_pointer_type (SYMBOL_TYPE (var
));
2915 enum address_class sym_class
= SYMBOL_CLASS (var
);
2917 if (sym_class
== LOC_CONST
2918 || sym_class
== LOC_CONST_BYTES
2919 || sym_class
== LOC_REGISTER
)
2920 error (_("Attempt to take address of register or constant."));
2923 value_zero (type
, not_lval
);
2926 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2929 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2930 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2931 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2932 &exp
->elts
[pc
+ 3].string
,
2935 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2940 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2941 default_case_after_eval
:
2942 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2944 struct type
*type
= check_typedef (value_type (x
));
2946 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2947 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2949 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2950 return value_zero (lookup_pointer_type (value_type (x
)),
2953 error (_("Attempt to take address of "
2954 "value not located in memory."));
2956 return value_addr (x
);
2960 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2961 When used in contexts where arrays will be coerced anyway, this is
2962 equivalent to `evaluate_subexp' but much faster because it avoids
2963 actually fetching array contents (perhaps obsolete now that we have
2966 Note that we currently only do the coercion for C expressions, where
2967 arrays are zero based and the coercion is correct. For other languages,
2968 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2969 to decide if coercion is appropriate. */
2972 evaluate_subexp_with_coercion (struct expression
*exp
,
2973 int *pos
, enum noside noside
)
2982 op
= exp
->elts
[pc
].opcode
;
2987 var
= exp
->elts
[pc
+ 2].symbol
;
2988 type
= check_typedef (SYMBOL_TYPE (var
));
2989 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2990 && !TYPE_VECTOR (type
)
2991 && CAST_IS_CONVERSION (exp
->language_defn
))
2994 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2995 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3001 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3005 /* Evaluate a subexpression of EXP, at index *POS,
3006 and return a value for the size of that subexpression.
3007 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3008 we allow side-effects on the operand if its type is a variable
3011 static struct value
*
3012 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3015 /* FIXME: This should be size_t. */
3016 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3023 op
= exp
->elts
[pc
].opcode
;
3027 /* This case is handled specially
3028 so that we avoid creating a value for the result type.
3029 If the result type is very big, it's desirable not to
3030 create a value unnecessarily. */
3033 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3034 type
= check_typedef (value_type (val
));
3035 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3036 && TYPE_CODE (type
) != TYPE_CODE_REF
3037 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3038 error (_("Attempt to take contents of a non-pointer value."));
3039 type
= TYPE_TARGET_TYPE (type
);
3040 if (is_dynamic_type (type
))
3041 type
= value_type (value_ind (val
));
3042 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3046 type
= exp
->elts
[pc
+ 1].type
;
3049 case UNOP_MEMVAL_TYPE
:
3051 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3052 type
= value_type (val
);
3056 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3057 if (is_dynamic_type (type
))
3059 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3060 type
= value_type (val
);
3066 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3067 type of the subscript is a variable length array type. In this case we
3068 must re-evaluate the right hand side of the subcription to allow
3070 case BINOP_SUBSCRIPT
:
3071 if (noside
== EVAL_NORMAL
)
3073 int pc
= (*pos
) + 1;
3075 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3076 type
= check_typedef (value_type (val
));
3077 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3079 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3080 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3082 type
= TYPE_INDEX_TYPE (type
);
3083 /* Only re-evaluate the right hand side if the resulting type
3084 is a variable length type. */
3085 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3087 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3088 return value_from_longest
3089 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3098 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3099 type
= value_type (val
);
3103 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3104 "When applied to a reference or a reference type, the result is
3105 the size of the referenced type." */
3106 CHECK_TYPEDEF (type
);
3107 if (exp
->language_defn
->la_language
== language_cplus
3108 && TYPE_CODE (type
) == TYPE_CODE_REF
)
3109 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3110 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3113 /* Parse a type expression in the string [P..P+LENGTH). */
3116 parse_and_eval_type (char *p
, int length
)
3118 char *tmp
= (char *) alloca (length
+ 4);
3119 struct expression
*expr
;
3122 memcpy (tmp
+ 1, p
, length
);
3123 tmp
[length
+ 1] = ')';
3124 tmp
[length
+ 2] = '0';
3125 tmp
[length
+ 3] = '\0';
3126 expr
= parse_expression (tmp
);
3127 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3128 error (_("Internal error in eval_type."));
3129 return expr
->elts
[1].type
;
3133 calc_f77_array_dims (struct type
*array_type
)
3136 struct type
*tmp_type
;
3138 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3139 error (_("Can't get dimensions for a non-array type"));
3141 tmp_type
= array_type
;
3143 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3145 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)