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/>. */
24 #include "expression.h"
27 #include "language.h" /* For CAST_IS_CONVERSION. */
28 #include "f-lang.h" /* For array bound stuff. */
31 #include "objc-lang.h"
33 #include "parser-defs.h"
34 #include "cp-support.h"
36 #include "exceptions.h"
38 #include "user-regs.h"
40 #include "gdb_obstack.h"
44 /* This is defined in valops.c */
45 extern int overload_resolution
;
47 /* Prototypes for local functions. */
49 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
52 static struct value
*evaluate_subexp_for_address (struct expression
*,
55 static struct value
*evaluate_struct_tuple (struct value
*,
56 struct expression
*, int *,
59 static LONGEST
init_array_element (struct value
*, struct value
*,
60 struct expression
*, int *, enum noside
,
64 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
65 int *pos
, enum noside noside
)
67 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
68 (expect_type
, exp
, pos
, noside
);
71 /* Parse the string EXP as a C expression, evaluate it,
72 and return the result as a number. */
75 parse_and_eval_address (const char *exp
)
77 struct expression
*expr
= parse_expression (exp
);
79 struct cleanup
*old_chain
=
80 make_cleanup (free_current_contents
, &expr
);
82 addr
= value_as_address (evaluate_expression (expr
));
83 do_cleanups (old_chain
);
87 /* Like parse_and_eval_address, but treats the value of the expression
88 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
90 parse_and_eval_long (const char *exp
)
92 struct expression
*expr
= parse_expression (exp
);
94 struct cleanup
*old_chain
=
95 make_cleanup (free_current_contents
, &expr
);
97 retval
= value_as_long (evaluate_expression (expr
));
98 do_cleanups (old_chain
);
103 parse_and_eval (const char *exp
)
105 struct expression
*expr
= parse_expression (exp
);
107 struct cleanup
*old_chain
=
108 make_cleanup (free_current_contents
, &expr
);
110 val
= evaluate_expression (expr
);
111 do_cleanups (old_chain
);
115 /* Parse up to a comma (or to a closeparen)
116 in the string EXPP as an expression, evaluate it, and return the value.
117 EXPP is advanced to point to the comma. */
120 parse_to_comma_and_eval (const char **expp
)
122 struct expression
*expr
= parse_exp_1 (expp
, 0, (struct block
*) 0, 1);
124 struct cleanup
*old_chain
=
125 make_cleanup (free_current_contents
, &expr
);
127 val
= evaluate_expression (expr
);
128 do_cleanups (old_chain
);
132 /* Evaluate an expression in internal prefix form
133 such as is constructed by parse.y.
135 See expression.h for info on the format of an expression. */
138 evaluate_expression (struct expression
*exp
)
142 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
145 /* Evaluate an expression, avoiding all memory references
146 and getting a value whose type alone is correct. */
149 evaluate_type (struct expression
*exp
)
153 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
156 /* Evaluate a subexpression, avoiding all memory references and
157 getting a value whose type alone is correct. */
160 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
162 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
165 /* Find the current value of a watchpoint on EXP. Return the value in
166 *VALP and *RESULTP and the chain of intermediate and final values
167 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
170 If PRESERVE_ERRORS is true, then exceptions are passed through.
171 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
172 occurs while evaluating the expression, *RESULTP will be set to
173 NULL. *RESULTP may be a lazy value, if the result could not be
174 read from memory. It is used to determine whether a value is
175 user-specified (we should watch the whole value) or intermediate
176 (we should watch only the bit used to locate the final value).
178 If the final value, or any intermediate value, could not be read
179 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
180 set to any referenced values. *VALP will never be a lazy value.
181 This is the value which we store in struct breakpoint.
183 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
184 value chain. The caller must free the values individually. If
185 VAL_CHAIN is NULL, all generated values will be left on the value
189 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
190 struct value
**resultp
, struct value
**val_chain
,
193 struct value
*mark
, *new_mark
, *result
;
194 volatile struct gdb_exception ex
;
202 /* Evaluate the expression. */
203 mark
= value_mark ();
206 TRY_CATCH (ex
, RETURN_MASK_ALL
)
208 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
212 /* Ignore memory errors if we want watchpoints pointing at
213 inaccessible memory to still be created; otherwise, throw the
214 error to some higher catcher. */
218 if (!preserve_errors
)
221 throw_exception (ex
);
226 new_mark
= value_mark ();
227 if (mark
== new_mark
)
232 /* Make sure it's not lazy, so that after the target stops again we
233 have a non-lazy previous value to compare with. */
236 if (!value_lazy (result
))
240 volatile struct gdb_exception except
;
242 TRY_CATCH (except
, RETURN_MASK_ERROR
)
244 value_fetch_lazy (result
);
252 /* Return the chain of intermediate values. We use this to
253 decide which addresses to watch. */
254 *val_chain
= new_mark
;
255 value_release_to_mark (mark
);
259 /* Extract a field operation from an expression. If the subexpression
260 of EXP starting at *SUBEXP is not a structure dereference
261 operation, return NULL. Otherwise, return the name of the
262 dereferenced field, and advance *SUBEXP to point to the
263 subexpression of the left-hand-side of the dereference. This is
264 used when completing field names. */
267 extract_field_op (struct expression
*exp
, int *subexp
)
272 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
273 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
275 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
276 result
= &exp
->elts
[*subexp
+ 2].string
;
277 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
281 /* This function evaluates brace-initializers (in C/C++) for
284 static struct value
*
285 evaluate_struct_tuple (struct value
*struct_val
,
286 struct expression
*exp
,
287 int *pos
, enum noside noside
, int nargs
)
289 struct type
*struct_type
= check_typedef (value_type (struct_val
));
290 struct type
*field_type
;
295 struct value
*val
= NULL
;
300 /* Skip static fields. */
301 while (fieldno
< TYPE_NFIELDS (struct_type
)
302 && field_is_static (&TYPE_FIELD (struct_type
,
305 if (fieldno
>= TYPE_NFIELDS (struct_type
))
306 error (_("too many initializers"));
307 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
308 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
309 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
310 error (_("don't know which variant you want to set"));
312 /* Here, struct_type is the type of the inner struct,
313 while substruct_type is the type of the inner struct.
314 These are the same for normal structures, but a variant struct
315 contains anonymous union fields that contain substruct fields.
316 The value fieldno is the index of the top-level (normal or
317 anonymous union) field in struct_field, while the value
318 subfieldno is the index of the actual real (named inner) field
319 in substruct_type. */
321 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
323 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
325 /* Now actually set the field in struct_val. */
327 /* Assign val to field fieldno. */
328 if (value_type (val
) != field_type
)
329 val
= value_cast (field_type
, val
);
331 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
332 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
333 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
335 modify_field (struct_type
, addr
,
336 value_as_long (val
), bitpos
% 8, bitsize
);
338 memcpy (addr
, value_contents (val
),
339 TYPE_LENGTH (value_type (val
)));
345 /* Recursive helper function for setting elements of array tuples.
346 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
347 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
348 Evaluates index expresions and sets the specified element(s) of
349 ARRAY to ELEMENT. Returns last index value. */
352 init_array_element (struct value
*array
, struct value
*element
,
353 struct expression
*exp
, int *pos
,
354 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
357 int element_size
= TYPE_LENGTH (value_type (element
));
359 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
362 init_array_element (array
, element
, exp
, pos
, noside
,
363 low_bound
, high_bound
);
364 return init_array_element (array
, element
,
365 exp
, pos
, noside
, low_bound
, high_bound
);
369 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
370 if (index
< low_bound
|| index
> high_bound
)
371 error (_("tuple index out of range"));
372 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
373 value_contents (element
), element_size
);
378 static struct value
*
379 value_f90_subarray (struct value
*array
,
380 struct expression
*exp
, int *pos
, enum noside noside
)
383 LONGEST low_bound
, high_bound
;
384 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
385 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
389 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
390 low_bound
= TYPE_LOW_BOUND (range
);
392 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
394 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
395 high_bound
= TYPE_HIGH_BOUND (range
);
397 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
399 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
403 /* Promote value ARG1 as appropriate before performing a unary operation
405 If the result is not appropriate for any particular language then it
406 needs to patch this function. */
409 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
414 *arg1
= coerce_ref (*arg1
);
415 type1
= check_typedef (value_type (*arg1
));
417 if (is_integral_type (type1
))
419 switch (language
->la_language
)
422 /* Perform integral promotion for ANSI C/C++.
423 If not appropropriate for any particular language
424 it needs to modify this function. */
426 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
428 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
429 *arg1
= value_cast (builtin_int
, *arg1
);
436 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
437 operation on those two operands.
438 If the result is not appropriate for any particular language then it
439 needs to patch this function. */
442 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
443 struct value
**arg1
, struct value
**arg2
)
445 struct type
*promoted_type
= NULL
;
449 *arg1
= coerce_ref (*arg1
);
450 *arg2
= coerce_ref (*arg2
);
452 type1
= check_typedef (value_type (*arg1
));
453 type2
= check_typedef (value_type (*arg2
));
455 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
456 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
457 && !is_integral_type (type1
))
458 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
459 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
460 && !is_integral_type (type2
)))
463 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
464 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
466 /* No promotion required. */
468 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
469 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
471 switch (language
->la_language
)
477 case language_opencl
:
478 /* No promotion required. */
482 /* For other languages the result type is unchanged from gdb
483 version 6.7 for backward compatibility.
484 If either arg was long double, make sure that value is also long
485 double. Otherwise use double. */
486 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
487 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
488 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
490 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
494 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
495 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
497 /* No promotion required. */
500 /* Integral operations here. */
501 /* FIXME: Also mixed integral/booleans, with result an integer. */
503 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
504 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
505 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
506 int is_unsigned1
= TYPE_UNSIGNED (type1
);
507 int is_unsigned2
= TYPE_UNSIGNED (type2
);
508 unsigned int result_len
;
509 int unsigned_operation
;
511 /* Determine type length and signedness after promotion for
513 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
516 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
518 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
521 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
524 if (promoted_len1
> promoted_len2
)
526 unsigned_operation
= is_unsigned1
;
527 result_len
= promoted_len1
;
529 else if (promoted_len2
> promoted_len1
)
531 unsigned_operation
= is_unsigned2
;
532 result_len
= promoted_len2
;
536 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
537 result_len
= promoted_len1
;
540 switch (language
->la_language
)
546 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
548 promoted_type
= (unsigned_operation
549 ? builtin
->builtin_unsigned_int
550 : builtin
->builtin_int
);
552 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
554 promoted_type
= (unsigned_operation
555 ? builtin
->builtin_unsigned_long
556 : builtin
->builtin_long
);
560 promoted_type
= (unsigned_operation
561 ? builtin
->builtin_unsigned_long_long
562 : builtin
->builtin_long_long
);
565 case language_opencl
:
566 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
567 (language
, gdbarch
, "int")))
571 ? lookup_unsigned_typename (language
, gdbarch
, "int")
572 : lookup_signed_typename (language
, gdbarch
, "int"));
574 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
575 (language
, gdbarch
, "long")))
579 ? lookup_unsigned_typename (language
, gdbarch
, "long")
580 : lookup_signed_typename (language
, gdbarch
,"long"));
584 /* For other languages the result type is unchanged from gdb
585 version 6.7 for backward compatibility.
586 If either arg was long long, make sure that value is also long
587 long. Otherwise use long. */
588 if (unsigned_operation
)
590 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
591 promoted_type
= builtin
->builtin_unsigned_long_long
;
593 promoted_type
= builtin
->builtin_unsigned_long
;
597 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
598 promoted_type
= builtin
->builtin_long_long
;
600 promoted_type
= builtin
->builtin_long
;
608 /* Promote both operands to common type. */
609 *arg1
= value_cast (promoted_type
, *arg1
);
610 *arg2
= value_cast (promoted_type
, *arg2
);
615 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
617 type
= check_typedef (type
);
618 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
619 type
= TYPE_TARGET_TYPE (type
);
621 switch (TYPE_CODE (type
))
627 case TYPE_CODE_ARRAY
:
628 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
635 /* Constructs a fake method with the given parameter types.
636 This function is used by the parser to construct an "expected"
637 type for method overload resolution. */
640 make_params (int num_types
, struct type
**param_types
)
642 struct type
*type
= XCNEW (struct type
);
643 TYPE_MAIN_TYPE (type
) = XCNEW (struct main_type
);
644 TYPE_LENGTH (type
) = 1;
645 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
646 TYPE_VPTR_FIELDNO (type
) = -1;
647 TYPE_CHAIN (type
) = type
;
650 if (param_types
[num_types
- 1] == NULL
)
653 TYPE_VARARGS (type
) = 1;
655 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
659 /* Caller should have ensured this. */
660 gdb_assert (num_types
== 0);
661 TYPE_PROTOTYPED (type
) = 1;
665 TYPE_NFIELDS (type
) = num_types
;
666 TYPE_FIELDS (type
) = (struct field
*)
667 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
669 while (num_types
-- > 0)
670 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
676 evaluate_subexp_standard (struct type
*expect_type
,
677 struct expression
*exp
, int *pos
,
682 int pc
, pc2
= 0, oldpos
;
683 struct value
*arg1
= NULL
;
684 struct value
*arg2
= NULL
;
688 struct value
**argvec
;
692 struct type
**arg_types
;
694 struct symbol
*function
= NULL
;
695 char *function_name
= NULL
;
698 op
= exp
->elts
[pc
].opcode
;
703 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
704 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
705 if (noside
== EVAL_SKIP
)
707 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
708 &exp
->elts
[pc
+ 3].string
,
709 expect_type
, 0, noside
);
711 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
716 return value_from_longest (exp
->elts
[pc
+ 1].type
,
717 exp
->elts
[pc
+ 2].longconst
);
721 return value_from_double (exp
->elts
[pc
+ 1].type
,
722 exp
->elts
[pc
+ 2].doubleconst
);
726 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
727 exp
->elts
[pc
+ 2].decfloatconst
);
732 if (noside
== EVAL_SKIP
)
735 /* JYG: We used to just return value_zero of the symbol type
736 if we're asked to avoid side effects. Otherwise we return
737 value_of_variable (...). However I'm not sure if
738 value_of_variable () has any side effect.
739 We need a full value object returned here for whatis_exp ()
740 to call evaluate_type () and then pass the full value to
741 value_rtti_target_type () if we are dealing with a pointer
742 or reference to a base class and print object is on. */
745 volatile struct gdb_exception except
;
746 struct value
*ret
= NULL
;
748 TRY_CATCH (except
, RETURN_MASK_ERROR
)
750 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
751 exp
->elts
[pc
+ 1].block
);
754 if (except
.reason
< 0)
756 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
757 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
760 throw_exception (except
);
766 case OP_VAR_ENTRY_VALUE
:
768 if (noside
== EVAL_SKIP
)
772 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
773 struct frame_info
*frame
;
775 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
776 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
778 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
779 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
780 error (_("Symbol \"%s\" does not have any specific entry value"),
781 SYMBOL_PRINT_NAME (sym
));
783 frame
= get_selected_frame (NULL
);
784 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
790 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
794 const char *name
= &exp
->elts
[pc
+ 2].string
;
798 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
799 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
800 name
, strlen (name
));
802 error (_("Register $%s not available."), name
);
804 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
805 a value with the appropriate register type. Unfortunately,
806 we don't have easy access to the type of user registers.
807 So for these registers, we fetch the register value regardless
808 of the evaluation mode. */
809 if (noside
== EVAL_AVOID_SIDE_EFFECTS
810 && regno
< gdbarch_num_regs (exp
->gdbarch
)
811 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
812 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
814 val
= value_of_register (regno
, get_selected_frame (NULL
));
816 error (_("Value of register %s not available."), name
);
822 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
823 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
827 return value_of_internalvar (exp
->gdbarch
,
828 exp
->elts
[pc
+ 1].internalvar
);
831 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
832 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
833 if (noside
== EVAL_SKIP
)
835 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
836 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
838 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
839 NSString constant. */
840 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
841 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
842 if (noside
== EVAL_SKIP
)
846 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
850 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
851 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
852 nargs
= tem3
- tem2
+ 1;
853 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
855 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
856 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
858 struct value
*rec
= allocate_value (expect_type
);
860 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
861 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
864 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
865 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
867 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
868 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
869 struct value
*array
= allocate_value (expect_type
);
870 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
871 LONGEST low_bound
, high_bound
, index
;
873 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
876 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
879 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
880 for (tem
= nargs
; --nargs
>= 0;)
882 struct value
*element
;
885 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
886 if (value_type (element
) != element_type
)
887 element
= value_cast (element_type
, element
);
890 int continue_pc
= *pos
;
893 index
= init_array_element (array
, element
, exp
, pos
, noside
,
894 low_bound
, high_bound
);
899 if (index
> high_bound
)
900 /* To avoid memory corruption. */
901 error (_("Too many array elements"));
902 memcpy (value_contents_raw (array
)
903 + (index
- low_bound
) * element_size
,
904 value_contents (element
),
912 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
913 && TYPE_CODE (type
) == TYPE_CODE_SET
)
915 struct value
*set
= allocate_value (expect_type
);
916 gdb_byte
*valaddr
= value_contents_raw (set
);
917 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
918 struct type
*check_type
= element_type
;
919 LONGEST low_bound
, high_bound
;
921 /* Get targettype of elementtype. */
922 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
923 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
924 check_type
= TYPE_TARGET_TYPE (check_type
);
926 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
927 error (_("(power)set type with unknown size"));
928 memset (valaddr
, '\0', TYPE_LENGTH (type
));
929 for (tem
= 0; tem
< nargs
; tem
++)
931 LONGEST range_low
, range_high
;
932 struct type
*range_low_type
, *range_high_type
;
933 struct value
*elem_val
;
935 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
936 range_low_type
= range_high_type
= value_type (elem_val
);
937 range_low
= range_high
= value_as_long (elem_val
);
939 /* Check types of elements to avoid mixture of elements from
940 different types. Also check if type of element is "compatible"
941 with element type of powerset. */
942 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
943 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
944 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
945 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
946 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
947 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
948 && (range_low_type
!= range_high_type
)))
949 /* different element modes. */
950 error (_("POWERSET tuple elements of different mode"));
951 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
952 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
953 && range_low_type
!= check_type
))
954 error (_("incompatible POWERSET tuple elements"));
955 if (range_low
> range_high
)
957 warning (_("empty POWERSET tuple range"));
960 if (range_low
< low_bound
|| range_high
> high_bound
)
961 error (_("POWERSET tuple element out of range"));
962 range_low
-= low_bound
;
963 range_high
-= low_bound
;
964 for (; range_low
<= range_high
; range_low
++)
966 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
968 if (gdbarch_bits_big_endian (exp
->gdbarch
))
969 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
970 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
977 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
978 for (tem
= 0; tem
< nargs
; tem
++)
980 /* Ensure that array expressions are coerced into pointer
982 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
984 if (noside
== EVAL_SKIP
)
986 return value_array (tem2
, tem3
, argvec
);
990 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
992 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
994 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
996 if (noside
== EVAL_SKIP
)
998 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1002 /* Skip third and second args to evaluate the first one. */
1003 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1004 if (value_logical_not (arg1
))
1006 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1007 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1011 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1012 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1016 case OP_OBJC_SELECTOR
:
1017 { /* Objective C @selector operator. */
1018 char *sel
= &exp
->elts
[pc
+ 2].string
;
1019 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1020 struct type
*selector_type
;
1022 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1023 if (noside
== EVAL_SKIP
)
1027 sel
[len
] = 0; /* Make sure it's terminated. */
1029 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1030 return value_from_longest (selector_type
,
1031 lookup_child_selector (exp
->gdbarch
, sel
));
1034 case OP_OBJC_MSGCALL
:
1035 { /* Objective C message (method) call. */
1037 CORE_ADDR responds_selector
= 0;
1038 CORE_ADDR method_selector
= 0;
1040 CORE_ADDR selector
= 0;
1042 int struct_return
= 0;
1043 int sub_no_side
= 0;
1045 struct value
*msg_send
= NULL
;
1046 struct value
*msg_send_stret
= NULL
;
1047 int gnu_runtime
= 0;
1049 struct value
*target
= NULL
;
1050 struct value
*method
= NULL
;
1051 struct value
*called_method
= NULL
;
1053 struct type
*selector_type
= NULL
;
1054 struct type
*long_type
;
1056 struct value
*ret
= NULL
;
1059 selector
= exp
->elts
[pc
+ 1].longconst
;
1060 nargs
= exp
->elts
[pc
+ 2].longconst
;
1061 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1066 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1067 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1069 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1070 sub_no_side
= EVAL_NORMAL
;
1072 sub_no_side
= noside
;
1074 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1076 if (value_as_long (target
) == 0)
1077 return value_from_longest (long_type
, 0);
1079 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1082 /* Find the method dispatch (Apple runtime) or method lookup
1083 (GNU runtime) function for Objective-C. These will be used
1084 to lookup the symbol information for the method. If we
1085 can't find any symbol information, then we'll use these to
1086 call the method, otherwise we can call the method
1087 directly. The msg_send_stret function is used in the special
1088 case of a method that returns a structure (Apple runtime
1092 struct type
*type
= selector_type
;
1094 type
= lookup_function_type (type
);
1095 type
= lookup_pointer_type (type
);
1096 type
= lookup_function_type (type
);
1097 type
= lookup_pointer_type (type
);
1099 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1101 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1103 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1104 msg_send_stret
= value_from_pointer (type
,
1105 value_as_address (msg_send_stret
));
1109 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1110 /* Special dispatcher for methods returning structs. */
1112 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1115 /* Verify the target object responds to this method. The
1116 standard top-level 'Object' class uses a different name for
1117 the verification method than the non-standard, but more
1118 often used, 'NSObject' class. Make sure we check for both. */
1121 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1122 if (responds_selector
== 0)
1124 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1126 if (responds_selector
== 0)
1127 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1130 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1131 if (method_selector
== 0)
1133 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1135 if (method_selector
== 0)
1136 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1138 /* Call the verification method, to make sure that the target
1139 class implements the desired method. */
1141 argvec
[0] = msg_send
;
1143 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1144 argvec
[3] = value_from_longest (long_type
, selector
);
1147 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1150 /* Function objc_msg_lookup returns a pointer. */
1152 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1154 if (value_as_long (ret
) == 0)
1155 error (_("Target does not respond to this message selector."));
1157 /* Call "methodForSelector:" method, to get the address of a
1158 function method that implements this selector for this
1159 class. If we can find a symbol at that address, then we
1160 know the return type, parameter types etc. (that's a good
1163 argvec
[0] = msg_send
;
1165 argvec
[2] = value_from_longest (long_type
, method_selector
);
1166 argvec
[3] = value_from_longest (long_type
, selector
);
1169 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1173 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1176 /* ret should now be the selector. */
1178 addr
= value_as_long (ret
);
1181 struct symbol
*sym
= NULL
;
1183 /* The address might point to a function descriptor;
1184 resolve it to the actual code address instead. */
1185 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1188 /* Is it a high_level symbol? */
1189 sym
= find_pc_function (addr
);
1191 method
= value_of_variable (sym
, 0);
1194 /* If we found a method with symbol information, check to see
1195 if it returns a struct. Otherwise assume it doesn't. */
1200 struct type
*val_type
;
1202 funaddr
= find_function_addr (method
, &val_type
);
1204 block_for_pc (funaddr
);
1206 CHECK_TYPEDEF (val_type
);
1208 if ((val_type
== NULL
)
1209 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1211 if (expect_type
!= NULL
)
1212 val_type
= expect_type
;
1215 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1218 else if (expect_type
!= NULL
)
1220 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1221 check_typedef (expect_type
));
1224 /* Found a function symbol. Now we will substitute its
1225 value in place of the message dispatcher (obj_msgSend),
1226 so that we call the method directly instead of thru
1227 the dispatcher. The main reason for doing this is that
1228 we can now evaluate the return value and parameter values
1229 according to their known data types, in case we need to
1230 do things like promotion, dereferencing, special handling
1231 of structs and doubles, etc.
1233 We want to use the type signature of 'method', but still
1234 jump to objc_msgSend() or objc_msgSend_stret() to better
1235 mimic the behavior of the runtime. */
1239 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1240 error (_("method address has symbol information "
1241 "with non-function type; skipping"));
1243 /* Create a function pointer of the appropriate type, and
1244 replace its value with the value of msg_send or
1245 msg_send_stret. We must use a pointer here, as
1246 msg_send and msg_send_stret are of pointer type, and
1247 the representation may be different on systems that use
1248 function descriptors. */
1251 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1252 value_as_address (msg_send_stret
));
1255 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1256 value_as_address (msg_send
));
1261 called_method
= msg_send_stret
;
1263 called_method
= msg_send
;
1266 if (noside
== EVAL_SKIP
)
1269 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1271 /* If the return type doesn't look like a function type,
1272 call an error. This can happen if somebody tries to
1273 turn a variable into a function call. This is here
1274 because people often want to call, eg, strcmp, which
1275 gdb doesn't know is a function. If gdb isn't asked for
1276 it's opinion (ie. through "whatis"), it won't offer
1279 struct type
*type
= value_type (called_method
);
1281 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1282 type
= TYPE_TARGET_TYPE (type
);
1283 type
= TYPE_TARGET_TYPE (type
);
1287 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1288 return allocate_value (expect_type
);
1290 return allocate_value (type
);
1293 error (_("Expression of type other than "
1294 "\"method returning ...\" used as a method"));
1297 /* Now depending on whether we found a symbol for the method,
1298 we will either call the runtime dispatcher or the method
1301 argvec
[0] = called_method
;
1303 argvec
[2] = value_from_longest (long_type
, selector
);
1304 /* User-supplied arguments. */
1305 for (tem
= 0; tem
< nargs
; tem
++)
1306 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1307 argvec
[tem
+ 3] = 0;
1309 if (gnu_runtime
&& (method
!= NULL
))
1311 /* Function objc_msg_lookup returns a pointer. */
1312 deprecated_set_value_type (argvec
[0],
1313 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1315 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1318 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1325 op
= exp
->elts
[*pos
].opcode
;
1326 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1327 /* Allocate arg vector, including space for the function to be
1328 called in argvec[0], a potential `this', and a terminating NULL. */
1329 argvec
= (struct value
**)
1330 alloca (sizeof (struct value
*) * (nargs
+ 3));
1331 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1333 /* First, evaluate the structure into arg2. */
1336 if (noside
== EVAL_SKIP
)
1339 if (op
== STRUCTOP_MEMBER
)
1341 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1345 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1348 /* If the function is a virtual function, then the
1349 aggregate value (providing the structure) plays
1350 its part by providing the vtable. Otherwise,
1351 it is just along for the ride: call the function
1354 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1356 type
= check_typedef (value_type (arg1
));
1357 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
)
1359 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1360 arg1
= value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1362 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1364 /* Now, say which argument to start evaluating from. */
1369 else if (TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1371 struct type
*type_ptr
1372 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type
));
1373 struct type
*target_type_ptr
1374 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1376 /* Now, convert these values to an address. */
1377 arg2
= value_cast (type_ptr
, arg2
);
1379 mem_offset
= value_as_long (arg1
);
1381 arg1
= value_from_pointer (target_type_ptr
,
1382 value_as_long (arg2
) + mem_offset
);
1383 arg1
= value_ind (arg1
);
1387 error (_("Non-pointer-to-member value used in pointer-to-member "
1390 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1392 /* Hair for method invocations. */
1396 /* First, evaluate the structure into arg2. */
1398 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1399 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1400 if (noside
== EVAL_SKIP
)
1403 if (op
== STRUCTOP_STRUCT
)
1405 /* If v is a variable in a register, and the user types
1406 v.method (), this will produce an error, because v has
1409 A possible way around this would be to allocate a
1410 copy of the variable on the stack, copy in the
1411 contents, call the function, and copy out the
1412 contents. I.e. convert this from call by reference
1413 to call by copy-return (or whatever it's called).
1414 However, this does not work because it is not the
1415 same: the method being called could stash a copy of
1416 the address, and then future uses through that address
1417 (after the method returns) would be expected to
1418 use the variable itself, not some copy of it. */
1419 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1423 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1425 /* Check to see if the operator '->' has been
1426 overloaded. If the operator has been overloaded
1427 replace arg2 with the value returned by the custom
1428 operator and continue evaluation. */
1429 while (unop_user_defined_p (op
, arg2
))
1431 volatile struct gdb_exception except
;
1432 struct value
*value
= NULL
;
1433 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1435 value
= value_x_unop (arg2
, op
, noside
);
1438 if (except
.reason
< 0)
1440 if (except
.error
== NOT_FOUND_ERROR
)
1443 throw_exception (except
);
1448 /* Now, say which argument to start evaluating from. */
1451 else if (op
== OP_SCOPE
1452 && overload_resolution
1453 && (exp
->language_defn
->la_language
== language_cplus
))
1455 /* Unpack it locally so we can properly handle overload
1461 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1462 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1463 type
= exp
->elts
[pc2
+ 1].type
;
1464 name
= &exp
->elts
[pc2
+ 3].string
;
1467 function_name
= NULL
;
1468 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1470 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1472 get_selected_block (0),
1474 if (function
== NULL
)
1475 error (_("No symbol \"%s\" in namespace \"%s\"."),
1476 name
, TYPE_TAG_NAME (type
));
1479 /* arg2 is left as NULL on purpose. */
1483 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1484 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1485 function_name
= name
;
1487 /* We need a properly typed value for method lookup. For
1488 static methods arg2 is otherwise unused. */
1489 arg2
= value_zero (type
, lval_memory
);
1494 else if (op
== OP_ADL_FUNC
)
1496 /* Save the function position and move pos so that the arguments
1497 can be evaluated. */
1503 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1504 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1508 /* Non-method function call. */
1512 /* If this is a C++ function wait until overload resolution. */
1513 if (op
== OP_VAR_VALUE
1514 && overload_resolution
1515 && (exp
->language_defn
->la_language
== language_cplus
))
1517 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1522 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1523 type
= value_type (argvec
[0]);
1524 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1525 type
= TYPE_TARGET_TYPE (type
);
1526 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1528 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1530 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1538 /* Evaluate arguments (if not already done, e.g., namespace::func()
1539 and overload-resolution is off). */
1540 for (; tem
<= nargs
; tem
++)
1542 /* Ensure that array expressions are coerced into pointer
1544 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1547 /* Signal end of arglist. */
1550 if (op
== OP_ADL_FUNC
)
1552 struct symbol
*symp
;
1555 int string_pc
= save_pos1
+ 3;
1557 /* Extract the function name. */
1558 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1559 func_name
= (char *) alloca (name_len
+ 1);
1560 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1562 find_overload_match (&argvec
[1], nargs
, func_name
,
1563 NON_METHOD
, /* not method */
1564 NULL
, NULL
, /* pass NULL symbol since
1565 symbol is unknown */
1566 NULL
, &symp
, NULL
, 0);
1568 /* Now fix the expression being evaluated. */
1569 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1570 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1573 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1574 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1576 int static_memfuncp
;
1579 /* Method invocation: stuff "this" as first parameter.
1580 If the method turns out to be static we undo this below. */
1585 /* Name of method from expression. */
1586 tstr
= &exp
->elts
[pc2
+ 2].string
;
1589 tstr
= function_name
;
1591 if (overload_resolution
&& (exp
->language_defn
->la_language
1594 /* Language is C++, do some overload resolution before
1596 struct value
*valp
= NULL
;
1598 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1599 METHOD
, /* method */
1600 &arg2
, /* the object */
1602 &static_memfuncp
, 0);
1604 if (op
== OP_SCOPE
&& !static_memfuncp
)
1606 /* For the time being, we don't handle this. */
1607 error (_("Call to overloaded function %s requires "
1611 argvec
[1] = arg2
; /* the ``this'' pointer */
1612 argvec
[0] = valp
; /* Use the method found after overload
1616 /* Non-C++ case -- or no overload resolution. */
1618 struct value
*temp
= arg2
;
1620 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1622 op
== STRUCTOP_STRUCT
1623 ? "structure" : "structure pointer");
1624 /* value_struct_elt updates temp with the correct value
1625 of the ``this'' pointer if necessary, so modify argvec[1] to
1626 reflect any ``this'' changes. */
1628 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1629 value_address (temp
)
1630 + value_embedded_offset (temp
));
1631 argvec
[1] = arg2
; /* the ``this'' pointer */
1634 /* Take out `this' if needed. */
1635 if (static_memfuncp
)
1637 argvec
[1] = argvec
[0];
1642 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1644 /* Pointer to member. argvec[1] is already set up. */
1647 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1649 /* Non-member function being called. */
1650 /* fn: This can only be done for C++ functions. A C-style function
1651 in a C++ program, for instance, does not have the fields that
1652 are expected here. */
1654 if (overload_resolution
&& (exp
->language_defn
->la_language
1657 /* Language is C++, do some overload resolution before
1659 struct symbol
*symp
;
1662 /* If a scope has been specified disable ADL. */
1666 if (op
== OP_VAR_VALUE
)
1667 function
= exp
->elts
[save_pos1
+2].symbol
;
1669 (void) find_overload_match (&argvec
[1], nargs
,
1670 NULL
, /* no need for name */
1671 NON_METHOD
, /* not method */
1672 NULL
, function
, /* the function */
1673 NULL
, &symp
, NULL
, no_adl
);
1675 if (op
== OP_VAR_VALUE
)
1677 /* Now fix the expression being evaluated. */
1678 exp
->elts
[save_pos1
+2].symbol
= symp
;
1679 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1683 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1687 /* Not C++, or no overload resolution allowed. */
1688 /* Nothing to be done; argvec already correctly set up. */
1693 /* It is probably a C-style function. */
1694 /* Nothing to be done; argvec already correctly set up. */
1699 if (noside
== EVAL_SKIP
)
1701 if (argvec
[0] == NULL
)
1702 error (_("Cannot evaluate function -- may be inlined"));
1703 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1705 /* If the return type doesn't look like a function type, call an
1706 error. This can happen if somebody tries to turn a variable into
1707 a function call. This is here because people often want to
1708 call, eg, strcmp, which gdb doesn't know is a function. If
1709 gdb isn't asked for it's opinion (ie. through "whatis"),
1710 it won't offer it. */
1712 struct type
*ftype
= value_type (argvec
[0]);
1714 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1716 /* We don't know anything about what the internal
1717 function might return, but we have to return
1719 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1722 else if (TYPE_GNU_IFUNC (ftype
))
1723 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1724 else if (TYPE_TARGET_TYPE (ftype
))
1725 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1727 error (_("Expression of type other than "
1728 "\"Function returning ...\" used as function"));
1730 switch (TYPE_CODE (value_type (argvec
[0])))
1732 case TYPE_CODE_INTERNAL_FUNCTION
:
1733 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1734 argvec
[0], nargs
, argvec
+ 1);
1735 case TYPE_CODE_XMETHOD
:
1736 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
1738 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1740 /* pai: FIXME save value from call_function_by_hand, then adjust
1741 pc by adjust_fn_pc if +ve. */
1743 case OP_F77_UNDETERMINED_ARGLIST
:
1745 /* Remember that in F77, functions, substring ops and
1746 array subscript operations cannot be disambiguated
1747 at parse time. We have made all array subscript operations,
1748 substring operations as well as function calls come here
1749 and we now have to discover what the heck this thing actually was.
1750 If it is a function, we process just as if we got an OP_FUNCALL. */
1752 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1755 /* First determine the type code we are dealing with. */
1756 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1757 type
= check_typedef (value_type (arg1
));
1758 code
= TYPE_CODE (type
);
1760 if (code
== TYPE_CODE_PTR
)
1762 /* Fortran always passes variable to subroutines as pointer.
1763 So we need to look into its target type to see if it is
1764 array, string or function. If it is, we need to switch
1765 to the target value the original one points to. */
1766 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1768 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1769 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1770 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1772 arg1
= value_ind (arg1
);
1773 type
= check_typedef (value_type (arg1
));
1774 code
= TYPE_CODE (type
);
1780 case TYPE_CODE_ARRAY
:
1781 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1782 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1784 goto multi_f77_subscript
;
1786 case TYPE_CODE_STRING
:
1787 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1788 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1791 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1792 return value_subscript (arg1
, value_as_long (arg2
));
1796 case TYPE_CODE_FUNC
:
1797 /* It's a function call. */
1798 /* Allocate arg vector, including space for the function to be
1799 called in argvec[0] and a terminating NULL. */
1800 argvec
= (struct value
**)
1801 alloca (sizeof (struct value
*) * (nargs
+ 2));
1804 for (; tem
<= nargs
; tem
++)
1805 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1806 argvec
[tem
] = 0; /* signal end of arglist */
1810 error (_("Cannot perform substring on this type"));
1814 /* We have a complex number, There should be 2 floating
1815 point numbers that compose it. */
1817 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1818 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1820 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1822 case STRUCTOP_STRUCT
:
1823 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1824 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1825 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1826 if (noside
== EVAL_SKIP
)
1828 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1830 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1831 arg3
= value_zero (value_type (arg3
), not_lval
);
1835 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1836 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1837 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1838 if (noside
== EVAL_SKIP
)
1841 /* Check to see if operator '->' has been overloaded. If so replace
1842 arg1 with the value returned by evaluating operator->(). */
1843 while (unop_user_defined_p (op
, arg1
))
1845 volatile struct gdb_exception except
;
1846 struct value
*value
= NULL
;
1847 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1849 value
= value_x_unop (arg1
, op
, noside
);
1852 if (except
.reason
< 0)
1854 if (except
.error
== NOT_FOUND_ERROR
)
1857 throw_exception (except
);
1862 /* JYG: if print object is on we need to replace the base type
1863 with rtti type in order to continue on with successful
1864 lookup of member / method only available in the rtti type. */
1866 struct type
*type
= value_type (arg1
);
1867 struct type
*real_type
;
1868 int full
, top
, using_enc
;
1869 struct value_print_options opts
;
1871 get_user_print_options (&opts
);
1872 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1873 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1875 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1878 arg1
= value_cast (real_type
, arg1
);
1882 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1883 NULL
, "structure pointer");
1884 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1885 arg3
= value_zero (value_type (arg3
), not_lval
);
1888 case STRUCTOP_MEMBER
:
1890 if (op
== STRUCTOP_MEMBER
)
1891 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1893 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1895 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1897 if (noside
== EVAL_SKIP
)
1900 type
= check_typedef (value_type (arg2
));
1901 switch (TYPE_CODE (type
))
1903 case TYPE_CODE_METHODPTR
:
1904 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1905 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1908 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1909 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1910 return value_ind (arg2
);
1913 case TYPE_CODE_MEMBERPTR
:
1914 /* Now, convert these values to an address. */
1915 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1918 mem_offset
= value_as_long (arg2
);
1920 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1921 value_as_long (arg1
) + mem_offset
);
1922 return value_ind (arg3
);
1925 error (_("non-pointer-to-member value used "
1926 "in pointer-to-member construct"));
1930 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1931 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1932 for (ix
= 0; ix
< nargs
; ++ix
)
1933 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1935 expect_type
= make_params (nargs
, arg_types
);
1936 *(pos
) += 3 + nargs
;
1937 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1938 xfree (TYPE_FIELDS (expect_type
));
1939 xfree (TYPE_MAIN_TYPE (expect_type
));
1940 xfree (expect_type
);
1944 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1945 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1946 if (noside
== EVAL_SKIP
)
1948 if (binop_user_defined_p (op
, arg1
, arg2
))
1949 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1951 return value_concat (arg1
, arg2
);
1954 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1955 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1957 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1959 if (binop_user_defined_p (op
, arg1
, arg2
))
1960 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1962 return value_assign (arg1
, arg2
);
1964 case BINOP_ASSIGN_MODIFY
:
1966 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1967 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1968 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1970 op
= exp
->elts
[pc
+ 1].opcode
;
1971 if (binop_user_defined_p (op
, arg1
, arg2
))
1972 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1973 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
1975 && is_integral_type (value_type (arg2
)))
1976 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
1977 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
1979 && is_integral_type (value_type (arg2
)))
1980 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
1983 struct value
*tmp
= arg1
;
1985 /* For shift and integer exponentiation operations,
1986 only promote the first argument. */
1987 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1988 && is_integral_type (value_type (arg2
)))
1989 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1991 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1993 arg2
= value_binop (tmp
, arg2
, op
);
1995 return value_assign (arg1
, arg2
);
1998 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1999 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2000 if (noside
== EVAL_SKIP
)
2002 if (binop_user_defined_p (op
, arg1
, arg2
))
2003 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2004 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2005 && is_integral_type (value_type (arg2
)))
2006 return value_ptradd (arg1
, value_as_long (arg2
));
2007 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2008 && is_integral_type (value_type (arg1
)))
2009 return value_ptradd (arg2
, value_as_long (arg1
));
2012 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2013 return value_binop (arg1
, arg2
, BINOP_ADD
);
2017 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2018 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2019 if (noside
== EVAL_SKIP
)
2021 if (binop_user_defined_p (op
, arg1
, arg2
))
2022 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2023 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2024 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2026 /* FIXME -- should be ptrdiff_t */
2027 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2028 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2030 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2031 && is_integral_type (value_type (arg2
)))
2032 return value_ptradd (arg1
, - value_as_long (arg2
));
2035 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2036 return value_binop (arg1
, arg2
, BINOP_SUB
);
2047 case BINOP_BITWISE_AND
:
2048 case BINOP_BITWISE_IOR
:
2049 case BINOP_BITWISE_XOR
:
2050 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2051 arg2
= evaluate_subexp (NULL_TYPE
, 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
);
2058 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2059 fudge arg2 to avoid division-by-zero, the caller is
2060 (theoretically) only looking for the type of the result. */
2061 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2062 /* ??? Do we really want to test for BINOP_MOD here?
2063 The implementation of value_binop gives it a well-defined
2066 || op
== BINOP_INTDIV
2069 && value_logical_not (arg2
))
2071 struct value
*v_one
, *retval
;
2073 v_one
= value_one (value_type (arg2
));
2074 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2075 retval
= value_binop (arg1
, v_one
, op
);
2080 /* For shift and integer exponentiation operations,
2081 only promote the first argument. */
2082 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2083 && is_integral_type (value_type (arg2
)))
2084 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2086 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2088 return value_binop (arg1
, arg2
, op
);
2092 case BINOP_SUBSCRIPT
:
2093 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2094 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2095 if (noside
== EVAL_SKIP
)
2097 if (binop_user_defined_p (op
, arg1
, arg2
))
2098 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2101 /* If the user attempts to subscript something that is not an
2102 array or pointer type (like a plain int variable for example),
2103 then report this as an error. */
2105 arg1
= coerce_ref (arg1
);
2106 type
= check_typedef (value_type (arg1
));
2107 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2108 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2110 if (TYPE_NAME (type
))
2111 error (_("cannot subscript something of type `%s'"),
2114 error (_("cannot subscript requested type"));
2117 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2118 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2120 return value_subscript (arg1
, value_as_long (arg2
));
2122 case MULTI_SUBSCRIPT
:
2124 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2125 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2128 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2129 /* FIXME: EVAL_SKIP handling may not be correct. */
2130 if (noside
== EVAL_SKIP
)
2141 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2142 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2144 /* If the user attempts to subscript something that has no target
2145 type (like a plain int variable for example), then report this
2148 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2151 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2157 error (_("cannot subscript something of type `%s'"),
2158 TYPE_NAME (value_type (arg1
)));
2162 if (binop_user_defined_p (op
, arg1
, arg2
))
2164 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2168 arg1
= coerce_ref (arg1
);
2169 type
= check_typedef (value_type (arg1
));
2171 switch (TYPE_CODE (type
))
2174 case TYPE_CODE_ARRAY
:
2175 case TYPE_CODE_STRING
:
2176 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2180 if (TYPE_NAME (type
))
2181 error (_("cannot subscript something of type `%s'"),
2184 error (_("cannot subscript requested type"));
2190 multi_f77_subscript
:
2192 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2193 int ndimensions
= 1, i
;
2194 struct value
*array
= arg1
;
2196 if (nargs
> MAX_FORTRAN_DIMS
)
2197 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2199 ndimensions
= calc_f77_array_dims (type
);
2201 if (nargs
!= ndimensions
)
2202 error (_("Wrong number of subscripts"));
2204 gdb_assert (nargs
> 0);
2206 /* Now that we know we have a legal array subscript expression
2207 let us actually find out where this element exists in the array. */
2209 /* Take array indices left to right. */
2210 for (i
= 0; i
< nargs
; i
++)
2212 /* Evaluate each subscript; it must be a legal integer in F77. */
2213 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2215 /* Fill in the subscript array. */
2217 subscript_array
[i
] = value_as_long (arg2
);
2220 /* Internal type of array is arranged right to left. */
2221 for (i
= nargs
; i
> 0; i
--)
2223 struct type
*array_type
= check_typedef (value_type (array
));
2224 LONGEST index
= subscript_array
[i
- 1];
2226 array
= value_subscripted_rvalue (array
, index
,
2227 f77_get_lowerbound (array_type
));
2233 case BINOP_LOGICAL_AND
:
2234 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2235 if (noside
== EVAL_SKIP
)
2237 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2242 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2245 if (binop_user_defined_p (op
, arg1
, arg2
))
2247 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2248 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2252 tem
= value_logical_not (arg1
);
2253 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2254 (tem
? EVAL_SKIP
: noside
));
2255 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2256 return value_from_longest (type
,
2257 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2260 case BINOP_LOGICAL_OR
:
2261 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2262 if (noside
== EVAL_SKIP
)
2264 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2269 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2272 if (binop_user_defined_p (op
, arg1
, arg2
))
2274 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2275 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2279 tem
= value_logical_not (arg1
);
2280 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2281 (!tem
? EVAL_SKIP
: noside
));
2282 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2283 return value_from_longest (type
,
2284 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2288 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2289 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2290 if (noside
== EVAL_SKIP
)
2292 if (binop_user_defined_p (op
, arg1
, arg2
))
2294 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2298 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2299 tem
= value_equal (arg1
, arg2
);
2300 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2301 return value_from_longest (type
, (LONGEST
) tem
);
2304 case BINOP_NOTEQUAL
:
2305 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2306 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2307 if (noside
== EVAL_SKIP
)
2309 if (binop_user_defined_p (op
, arg1
, arg2
))
2311 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2315 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2316 tem
= value_equal (arg1
, arg2
);
2317 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2318 return value_from_longest (type
, (LONGEST
) ! tem
);
2322 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2323 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2324 if (noside
== EVAL_SKIP
)
2326 if (binop_user_defined_p (op
, arg1
, arg2
))
2328 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2332 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2333 tem
= value_less (arg1
, arg2
);
2334 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2335 return value_from_longest (type
, (LONGEST
) tem
);
2339 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2340 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2341 if (noside
== EVAL_SKIP
)
2343 if (binop_user_defined_p (op
, arg1
, arg2
))
2345 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2349 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2350 tem
= value_less (arg2
, arg1
);
2351 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2352 return value_from_longest (type
, (LONGEST
) tem
);
2356 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2357 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2358 if (noside
== EVAL_SKIP
)
2360 if (binop_user_defined_p (op
, arg1
, arg2
))
2362 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2366 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2367 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2368 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2369 return value_from_longest (type
, (LONGEST
) tem
);
2373 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2374 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2375 if (noside
== EVAL_SKIP
)
2377 if (binop_user_defined_p (op
, arg1
, arg2
))
2379 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2383 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2384 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2385 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2386 return value_from_longest (type
, (LONGEST
) tem
);
2390 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2391 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2392 if (noside
== EVAL_SKIP
)
2394 type
= check_typedef (value_type (arg2
));
2395 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2396 error (_("Non-integral right operand for \"@\" operator."));
2397 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2399 return allocate_repeat_value (value_type (arg1
),
2400 longest_to_int (value_as_long (arg2
)));
2403 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2406 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2407 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2410 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2411 if (noside
== EVAL_SKIP
)
2413 if (unop_user_defined_p (op
, arg1
))
2414 return value_x_unop (arg1
, op
, noside
);
2417 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2418 return value_pos (arg1
);
2422 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2423 if (noside
== EVAL_SKIP
)
2425 if (unop_user_defined_p (op
, arg1
))
2426 return value_x_unop (arg1
, op
, noside
);
2429 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2430 return value_neg (arg1
);
2433 case UNOP_COMPLEMENT
:
2434 /* C++: check for and handle destructor names. */
2435 op
= exp
->elts
[*pos
].opcode
;
2437 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2438 if (noside
== EVAL_SKIP
)
2440 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2441 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2444 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2445 return value_complement (arg1
);
2448 case UNOP_LOGICAL_NOT
:
2449 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2450 if (noside
== EVAL_SKIP
)
2452 if (unop_user_defined_p (op
, arg1
))
2453 return value_x_unop (arg1
, op
, noside
);
2456 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2457 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2461 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2462 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2463 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2464 type
= check_typedef (value_type (arg1
));
2465 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2466 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2467 error (_("Attempt to dereference pointer "
2468 "to member without an object"));
2469 if (noside
== EVAL_SKIP
)
2471 if (unop_user_defined_p (op
, arg1
))
2472 return value_x_unop (arg1
, op
, noside
);
2473 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2475 type
= check_typedef (value_type (arg1
));
2476 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2477 || TYPE_CODE (type
) == TYPE_CODE_REF
2478 /* In C you can dereference an array to get the 1st elt. */
2479 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2481 return value_zero (TYPE_TARGET_TYPE (type
),
2483 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2484 /* GDB allows dereferencing an int. */
2485 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2488 error (_("Attempt to take contents of a non-pointer value."));
2491 /* Allow * on an integer so we can cast it to whatever we want.
2492 This returns an int, which seems like the most C-like thing to
2493 do. "long long" variables are rare enough that
2494 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2495 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2496 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2497 (CORE_ADDR
) value_as_address (arg1
));
2498 return value_ind (arg1
);
2501 /* C++: check for and handle pointer to members. */
2503 op
= exp
->elts
[*pos
].opcode
;
2505 if (noside
== EVAL_SKIP
)
2507 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2512 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2519 if (noside
== EVAL_SKIP
)
2521 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2524 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2528 type
= exp
->elts
[pc
+ 1].type
;
2529 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2530 if (noside
== EVAL_SKIP
)
2532 if (type
!= value_type (arg1
))
2533 arg1
= value_cast (type
, arg1
);
2536 case UNOP_CAST_TYPE
:
2537 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2538 type
= value_type (arg1
);
2539 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2540 if (noside
== EVAL_SKIP
)
2542 if (type
!= value_type (arg1
))
2543 arg1
= value_cast (type
, arg1
);
2546 case UNOP_DYNAMIC_CAST
:
2547 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2548 type
= value_type (arg1
);
2549 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2550 if (noside
== EVAL_SKIP
)
2552 return value_dynamic_cast (type
, arg1
);
2554 case UNOP_REINTERPRET_CAST
:
2555 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2556 type
= value_type (arg1
);
2557 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2558 if (noside
== EVAL_SKIP
)
2560 return value_reinterpret_cast (type
, arg1
);
2564 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2565 if (noside
== EVAL_SKIP
)
2567 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2568 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2570 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2571 value_as_address (arg1
));
2573 case UNOP_MEMVAL_TYPE
:
2574 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2575 type
= value_type (arg1
);
2576 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2577 if (noside
== EVAL_SKIP
)
2579 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2580 return value_zero (type
, lval_memory
);
2582 return value_at_lazy (type
, value_as_address (arg1
));
2584 case UNOP_MEMVAL_TLS
:
2586 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2587 if (noside
== EVAL_SKIP
)
2589 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2590 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2595 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2596 value_as_address (arg1
));
2597 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2600 case UNOP_PREINCREMENT
:
2601 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2602 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2604 else if (unop_user_defined_p (op
, arg1
))
2606 return value_x_unop (arg1
, op
, noside
);
2610 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2611 arg2
= value_ptradd (arg1
, 1);
2614 struct value
*tmp
= arg1
;
2616 arg2
= value_one (value_type (arg1
));
2617 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2618 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2621 return value_assign (arg1
, arg2
);
2624 case UNOP_PREDECREMENT
:
2625 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2626 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2628 else if (unop_user_defined_p (op
, arg1
))
2630 return value_x_unop (arg1
, op
, noside
);
2634 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2635 arg2
= value_ptradd (arg1
, -1);
2638 struct value
*tmp
= arg1
;
2640 arg2
= value_one (value_type (arg1
));
2641 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2642 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2645 return value_assign (arg1
, arg2
);
2648 case UNOP_POSTINCREMENT
:
2649 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2650 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2652 else if (unop_user_defined_p (op
, arg1
))
2654 return value_x_unop (arg1
, op
, noside
);
2658 arg3
= value_non_lval (arg1
);
2660 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2661 arg2
= value_ptradd (arg1
, 1);
2664 struct value
*tmp
= arg1
;
2666 arg2
= value_one (value_type (arg1
));
2667 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2668 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2671 value_assign (arg1
, arg2
);
2675 case UNOP_POSTDECREMENT
:
2676 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2677 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2679 else if (unop_user_defined_p (op
, arg1
))
2681 return value_x_unop (arg1
, op
, noside
);
2685 arg3
= value_non_lval (arg1
);
2687 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2688 arg2
= value_ptradd (arg1
, -1);
2691 struct value
*tmp
= arg1
;
2693 arg2
= value_one (value_type (arg1
));
2694 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2695 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2698 value_assign (arg1
, arg2
);
2704 return value_of_this (exp
->language_defn
);
2707 /* The value is not supposed to be used. This is here to make it
2708 easier to accommodate expressions that contain types. */
2710 if (noside
== EVAL_SKIP
)
2712 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2714 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2716 /* If this is a typedef, then find its immediate target. We
2717 use check_typedef to resolve stubs, but we ignore its
2718 result because we do not want to dig past all
2720 check_typedef (type
);
2721 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2722 type
= TYPE_TARGET_TYPE (type
);
2723 return allocate_value (type
);
2726 error (_("Attempt to use a type name as an expression"));
2730 if (noside
== EVAL_SKIP
)
2732 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2735 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2737 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2738 struct value
*result
;
2740 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2741 EVAL_AVOID_SIDE_EFFECTS
);
2743 /* 'decltype' has special semantics for lvalues. */
2744 if (op
== OP_DECLTYPE
2745 && (sub_op
== BINOP_SUBSCRIPT
2746 || sub_op
== STRUCTOP_MEMBER
2747 || sub_op
== STRUCTOP_MPTR
2748 || sub_op
== UNOP_IND
2749 || sub_op
== STRUCTOP_STRUCT
2750 || sub_op
== STRUCTOP_PTR
2751 || sub_op
== OP_SCOPE
))
2753 struct type
*type
= value_type (result
);
2755 if (TYPE_CODE (check_typedef (type
)) != TYPE_CODE_REF
)
2757 type
= lookup_reference_type (type
);
2758 result
= allocate_value (type
);
2765 error (_("Attempt to use a type as an expression"));
2769 struct value
*result
;
2770 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2772 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2773 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2774 EVAL_AVOID_SIDE_EFFECTS
);
2776 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2778 if (noside
!= EVAL_NORMAL
)
2779 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2781 return cplus_typeid (result
);
2785 /* Removing this case and compiling with gcc -Wall reveals that
2786 a lot of cases are hitting this case. Some of these should
2787 probably be removed from expression.h; others are legitimate
2788 expressions which are (apparently) not fully implemented.
2790 If there are any cases landing here which mean a user error,
2791 then they should be separate cases, with more descriptive
2794 error (_("GDB does not (yet) know how to "
2795 "evaluate that kind of expression"));
2799 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2802 /* Evaluate a subexpression of EXP, at index *POS,
2803 and return the address of that subexpression.
2804 Advance *POS over the subexpression.
2805 If the subexpression isn't an lvalue, get an error.
2806 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2807 then only the type of the result need be correct. */
2809 static struct value
*
2810 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2820 op
= exp
->elts
[pc
].opcode
;
2826 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2828 /* We can't optimize out "&*" if there's a user-defined operator*. */
2829 if (unop_user_defined_p (op
, x
))
2831 x
= value_x_unop (x
, op
, noside
);
2832 goto default_case_after_eval
;
2835 return coerce_array (x
);
2839 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2840 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2842 case UNOP_MEMVAL_TYPE
:
2847 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2848 type
= value_type (x
);
2849 return value_cast (lookup_pointer_type (type
),
2850 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2854 var
= exp
->elts
[pc
+ 2].symbol
;
2856 /* C++: The "address" of a reference should yield the address
2857 * of the object pointed to. Let value_addr() deal with it. */
2858 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2862 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2865 lookup_pointer_type (SYMBOL_TYPE (var
));
2866 enum address_class sym_class
= SYMBOL_CLASS (var
);
2868 if (sym_class
== LOC_CONST
2869 || sym_class
== LOC_CONST_BYTES
2870 || sym_class
== LOC_REGISTER
)
2871 error (_("Attempt to take address of register or constant."));
2874 value_zero (type
, not_lval
);
2877 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2880 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2881 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2882 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2883 &exp
->elts
[pc
+ 3].string
,
2886 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2891 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2892 default_case_after_eval
:
2893 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2895 struct type
*type
= check_typedef (value_type (x
));
2897 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2898 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2900 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2901 return value_zero (lookup_pointer_type (value_type (x
)),
2904 error (_("Attempt to take address of "
2905 "value not located in memory."));
2907 return value_addr (x
);
2911 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2912 When used in contexts where arrays will be coerced anyway, this is
2913 equivalent to `evaluate_subexp' but much faster because it avoids
2914 actually fetching array contents (perhaps obsolete now that we have
2917 Note that we currently only do the coercion for C expressions, where
2918 arrays are zero based and the coercion is correct. For other languages,
2919 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2920 to decide if coercion is appropriate. */
2923 evaluate_subexp_with_coercion (struct expression
*exp
,
2924 int *pos
, enum noside noside
)
2933 op
= exp
->elts
[pc
].opcode
;
2938 var
= exp
->elts
[pc
+ 2].symbol
;
2939 type
= check_typedef (SYMBOL_TYPE (var
));
2940 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2941 && !TYPE_VECTOR (type
)
2942 && CAST_IS_CONVERSION (exp
->language_defn
))
2945 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2946 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2952 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2956 /* Evaluate a subexpression of EXP, at index *POS,
2957 and return a value for the size of that subexpression.
2958 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2959 we allow side-effects on the operand if its type is a variable
2962 static struct value
*
2963 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2966 /* FIXME: This should be size_t. */
2967 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2974 op
= exp
->elts
[pc
].opcode
;
2978 /* This case is handled specially
2979 so that we avoid creating a value for the result type.
2980 If the result type is very big, it's desirable not to
2981 create a value unnecessarily. */
2984 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2985 type
= check_typedef (value_type (val
));
2986 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2987 && TYPE_CODE (type
) != TYPE_CODE_REF
2988 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2989 error (_("Attempt to take contents of a non-pointer value."));
2990 type
= TYPE_TARGET_TYPE (type
);
2991 if (is_dynamic_type (type
))
2992 type
= value_type (value_ind (val
));
2993 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
2997 type
= exp
->elts
[pc
+ 1].type
;
3000 case UNOP_MEMVAL_TYPE
:
3002 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3003 type
= value_type (val
);
3007 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3008 if (is_dynamic_type (type
))
3010 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3011 type
= value_type (val
);
3017 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3018 type of the subscript is a variable length array type. In this case we
3019 must re-evaluate the right hand side of the subcription to allow
3021 case BINOP_SUBSCRIPT
:
3022 if (noside
== EVAL_NORMAL
)
3024 int pc
= (*pos
) + 1;
3026 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3027 type
= check_typedef (value_type (val
));
3028 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3030 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3031 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3033 type
= TYPE_INDEX_TYPE (type
);
3034 /* Only re-evaluate the right hand side if the resulting type
3035 is a variable length type. */
3036 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3038 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3039 return value_from_longest
3040 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3049 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3050 type
= value_type (val
);
3054 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3055 "When applied to a reference or a reference type, the result is
3056 the size of the referenced type." */
3057 CHECK_TYPEDEF (type
);
3058 if (exp
->language_defn
->la_language
== language_cplus
3059 && TYPE_CODE (type
) == TYPE_CODE_REF
)
3060 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3061 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3064 /* Parse a type expression in the string [P..P+LENGTH). */
3067 parse_and_eval_type (char *p
, int length
)
3069 char *tmp
= (char *) alloca (length
+ 4);
3070 struct expression
*expr
;
3073 memcpy (tmp
+ 1, p
, length
);
3074 tmp
[length
+ 1] = ')';
3075 tmp
[length
+ 2] = '0';
3076 tmp
[length
+ 3] = '\0';
3077 expr
= parse_expression (tmp
);
3078 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3079 error (_("Internal error in eval_type."));
3080 return expr
->elts
[1].type
;
3084 calc_f77_array_dims (struct type
*array_type
)
3087 struct type
*tmp_type
;
3089 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3090 error (_("Can't get dimensions for a non-array type"));
3092 tmp_type
= array_type
;
3094 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3096 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)