1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2015 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 "gdbthread.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"
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 struct cleanup
*cleanups
;
69 int cleanup_temps
= 0;
71 if (*pos
== 0 && target_has_execution
72 && exp
->language_defn
->la_language
== language_cplus
73 && !thread_stack_temporaries_enabled_p (inferior_ptid
))
75 cleanups
= enable_thread_stack_temporaries (inferior_ptid
);
79 retval
= (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
80 (expect_type
, exp
, pos
, noside
);
84 if (value_in_thread_stack_temporaries (retval
, inferior_ptid
))
85 retval
= value_non_lval (retval
);
86 do_cleanups (cleanups
);
92 /* Parse the string EXP as a C expression, evaluate it,
93 and return the result as a number. */
96 parse_and_eval_address (const char *exp
)
98 struct expression
*expr
= parse_expression (exp
);
100 struct cleanup
*old_chain
=
101 make_cleanup (free_current_contents
, &expr
);
103 addr
= value_as_address (evaluate_expression (expr
));
104 do_cleanups (old_chain
);
108 /* Like parse_and_eval_address, but treats the value of the expression
109 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
111 parse_and_eval_long (const char *exp
)
113 struct expression
*expr
= parse_expression (exp
);
115 struct cleanup
*old_chain
=
116 make_cleanup (free_current_contents
, &expr
);
118 retval
= value_as_long (evaluate_expression (expr
));
119 do_cleanups (old_chain
);
124 parse_and_eval (const char *exp
)
126 struct expression
*expr
= parse_expression (exp
);
128 struct cleanup
*old_chain
=
129 make_cleanup (free_current_contents
, &expr
);
131 val
= evaluate_expression (expr
);
132 do_cleanups (old_chain
);
136 /* Parse up to a comma (or to a closeparen)
137 in the string EXPP as an expression, evaluate it, and return the value.
138 EXPP is advanced to point to the comma. */
141 parse_to_comma_and_eval (const char **expp
)
143 struct expression
*expr
= parse_exp_1 (expp
, 0, (struct block
*) 0, 1);
145 struct cleanup
*old_chain
=
146 make_cleanup (free_current_contents
, &expr
);
148 val
= evaluate_expression (expr
);
149 do_cleanups (old_chain
);
153 /* Evaluate an expression in internal prefix form
154 such as is constructed by parse.y.
156 See expression.h for info on the format of an expression. */
159 evaluate_expression (struct expression
*exp
)
163 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
166 /* Evaluate an expression, avoiding all memory references
167 and getting a value whose type alone is correct. */
170 evaluate_type (struct expression
*exp
)
174 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
177 /* Evaluate a subexpression, avoiding all memory references and
178 getting a value whose type alone is correct. */
181 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
183 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
186 /* Find the current value of a watchpoint on EXP. Return the value in
187 *VALP and *RESULTP and the chain of intermediate and final values
188 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
191 If PRESERVE_ERRORS is true, then exceptions are passed through.
192 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
193 occurs while evaluating the expression, *RESULTP will be set to
194 NULL. *RESULTP may be a lazy value, if the result could not be
195 read from memory. It is used to determine whether a value is
196 user-specified (we should watch the whole value) or intermediate
197 (we should watch only the bit used to locate the final value).
199 If the final value, or any intermediate value, could not be read
200 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
201 set to any referenced values. *VALP will never be a lazy value.
202 This is the value which we store in struct breakpoint.
204 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
205 value chain. The caller must free the values individually. If
206 VAL_CHAIN is NULL, all generated values will be left on the value
210 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
211 struct value
**resultp
, struct value
**val_chain
,
214 struct value
*mark
, *new_mark
, *result
;
222 /* Evaluate the expression. */
223 mark
= value_mark ();
228 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
230 CATCH (ex
, RETURN_MASK_ALL
)
232 /* Ignore memory errors if we want watchpoints pointing at
233 inaccessible memory to still be created; otherwise, throw the
234 error to some higher catcher. */
238 if (!preserve_errors
)
241 throw_exception (ex
);
247 new_mark
= value_mark ();
248 if (mark
== new_mark
)
253 /* Make sure it's not lazy, so that after the target stops again we
254 have a non-lazy previous value to compare with. */
257 if (!value_lazy (result
))
264 value_fetch_lazy (result
);
267 CATCH (except
, RETURN_MASK_ERROR
)
276 /* Return the chain of intermediate values. We use this to
277 decide which addresses to watch. */
278 *val_chain
= new_mark
;
279 value_release_to_mark (mark
);
283 /* Extract a field operation from an expression. If the subexpression
284 of EXP starting at *SUBEXP is not a structure dereference
285 operation, return NULL. Otherwise, return the name of the
286 dereferenced field, and advance *SUBEXP to point to the
287 subexpression of the left-hand-side of the dereference. This is
288 used when completing field names. */
291 extract_field_op (struct expression
*exp
, int *subexp
)
296 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
297 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
299 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
300 result
= &exp
->elts
[*subexp
+ 2].string
;
301 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
305 /* This function evaluates brace-initializers (in C/C++) for
308 static struct value
*
309 evaluate_struct_tuple (struct value
*struct_val
,
310 struct expression
*exp
,
311 int *pos
, enum noside noside
, int nargs
)
313 struct type
*struct_type
= check_typedef (value_type (struct_val
));
314 struct type
*field_type
;
319 struct value
*val
= NULL
;
324 /* Skip static fields. */
325 while (fieldno
< TYPE_NFIELDS (struct_type
)
326 && field_is_static (&TYPE_FIELD (struct_type
,
329 if (fieldno
>= TYPE_NFIELDS (struct_type
))
330 error (_("too many initializers"));
331 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
332 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
333 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
334 error (_("don't know which variant you want to set"));
336 /* Here, struct_type is the type of the inner struct,
337 while substruct_type is the type of the inner struct.
338 These are the same for normal structures, but a variant struct
339 contains anonymous union fields that contain substruct fields.
340 The value fieldno is the index of the top-level (normal or
341 anonymous union) field in struct_field, while the value
342 subfieldno is the index of the actual real (named inner) field
343 in substruct_type. */
345 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
347 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
349 /* Now actually set the field in struct_val. */
351 /* Assign val to field fieldno. */
352 if (value_type (val
) != field_type
)
353 val
= value_cast (field_type
, val
);
355 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
356 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
357 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
359 modify_field (struct_type
, addr
,
360 value_as_long (val
), bitpos
% 8, bitsize
);
362 memcpy (addr
, value_contents (val
),
363 TYPE_LENGTH (value_type (val
)));
369 /* Recursive helper function for setting elements of array tuples.
370 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
371 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
372 Evaluates index expresions and sets the specified element(s) of
373 ARRAY to ELEMENT. Returns last index value. */
376 init_array_element (struct value
*array
, struct value
*element
,
377 struct expression
*exp
, int *pos
,
378 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
381 int element_size
= TYPE_LENGTH (value_type (element
));
383 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
386 init_array_element (array
, element
, exp
, pos
, noside
,
387 low_bound
, high_bound
);
388 return init_array_element (array
, element
,
389 exp
, pos
, noside
, low_bound
, high_bound
);
393 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
394 if (index
< low_bound
|| index
> high_bound
)
395 error (_("tuple index out of range"));
396 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
397 value_contents (element
), element_size
);
402 static struct value
*
403 value_f90_subarray (struct value
*array
,
404 struct expression
*exp
, int *pos
, enum noside noside
)
407 LONGEST low_bound
, high_bound
;
408 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
409 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
413 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
414 low_bound
= TYPE_LOW_BOUND (range
);
416 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
418 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
419 high_bound
= TYPE_HIGH_BOUND (range
);
421 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
423 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
427 /* Promote value ARG1 as appropriate before performing a unary operation
429 If the result is not appropriate for any particular language then it
430 needs to patch this function. */
433 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
438 *arg1
= coerce_ref (*arg1
);
439 type1
= check_typedef (value_type (*arg1
));
441 if (is_integral_type (type1
))
443 switch (language
->la_language
)
446 /* Perform integral promotion for ANSI C/C++.
447 If not appropropriate for any particular language
448 it needs to modify this function. */
450 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
452 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
453 *arg1
= value_cast (builtin_int
, *arg1
);
460 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
461 operation on those two operands.
462 If the result is not appropriate for any particular language then it
463 needs to patch this function. */
466 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
467 struct value
**arg1
, struct value
**arg2
)
469 struct type
*promoted_type
= NULL
;
473 *arg1
= coerce_ref (*arg1
);
474 *arg2
= coerce_ref (*arg2
);
476 type1
= check_typedef (value_type (*arg1
));
477 type2
= check_typedef (value_type (*arg2
));
479 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
480 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
481 && !is_integral_type (type1
))
482 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
483 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
484 && !is_integral_type (type2
)))
487 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
488 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
490 /* No promotion required. */
492 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
493 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
495 switch (language
->la_language
)
501 case language_opencl
:
502 /* No promotion required. */
506 /* For other languages the result type is unchanged from gdb
507 version 6.7 for backward compatibility.
508 If either arg was long double, make sure that value is also long
509 double. Otherwise use double. */
510 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
511 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
512 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
514 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
518 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
519 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
521 /* No promotion required. */
524 /* Integral operations here. */
525 /* FIXME: Also mixed integral/booleans, with result an integer. */
527 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
528 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
529 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
530 int is_unsigned1
= TYPE_UNSIGNED (type1
);
531 int is_unsigned2
= TYPE_UNSIGNED (type2
);
532 unsigned int result_len
;
533 int unsigned_operation
;
535 /* Determine type length and signedness after promotion for
537 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
540 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
542 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
545 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
548 if (promoted_len1
> promoted_len2
)
550 unsigned_operation
= is_unsigned1
;
551 result_len
= promoted_len1
;
553 else if (promoted_len2
> promoted_len1
)
555 unsigned_operation
= is_unsigned2
;
556 result_len
= promoted_len2
;
560 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
561 result_len
= promoted_len1
;
564 switch (language
->la_language
)
570 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
572 promoted_type
= (unsigned_operation
573 ? builtin
->builtin_unsigned_int
574 : builtin
->builtin_int
);
576 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
578 promoted_type
= (unsigned_operation
579 ? builtin
->builtin_unsigned_long
580 : builtin
->builtin_long
);
584 promoted_type
= (unsigned_operation
585 ? builtin
->builtin_unsigned_long_long
586 : builtin
->builtin_long_long
);
589 case language_opencl
:
590 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
591 (language
, gdbarch
, "int")))
595 ? lookup_unsigned_typename (language
, gdbarch
, "int")
596 : lookup_signed_typename (language
, gdbarch
, "int"));
598 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
599 (language
, gdbarch
, "long")))
603 ? lookup_unsigned_typename (language
, gdbarch
, "long")
604 : lookup_signed_typename (language
, gdbarch
,"long"));
608 /* For other languages the result type is unchanged from gdb
609 version 6.7 for backward compatibility.
610 If either arg was long long, make sure that value is also long
611 long. Otherwise use long. */
612 if (unsigned_operation
)
614 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
615 promoted_type
= builtin
->builtin_unsigned_long_long
;
617 promoted_type
= builtin
->builtin_unsigned_long
;
621 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
622 promoted_type
= builtin
->builtin_long_long
;
624 promoted_type
= builtin
->builtin_long
;
632 /* Promote both operands to common type. */
633 *arg1
= value_cast (promoted_type
, *arg1
);
634 *arg2
= value_cast (promoted_type
, *arg2
);
639 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
641 type
= check_typedef (type
);
642 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
643 type
= TYPE_TARGET_TYPE (type
);
645 switch (TYPE_CODE (type
))
651 case TYPE_CODE_ARRAY
:
652 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
659 /* Constructs a fake method with the given parameter types.
660 This function is used by the parser to construct an "expected"
661 type for method overload resolution. */
664 make_params (int num_types
, struct type
**param_types
)
666 struct type
*type
= XCNEW (struct type
);
667 TYPE_MAIN_TYPE (type
) = XCNEW (struct main_type
);
668 TYPE_LENGTH (type
) = 1;
669 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
670 TYPE_CHAIN (type
) = type
;
673 if (param_types
[num_types
- 1] == NULL
)
676 TYPE_VARARGS (type
) = 1;
678 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
682 /* Caller should have ensured this. */
683 gdb_assert (num_types
== 0);
684 TYPE_PROTOTYPED (type
) = 1;
688 TYPE_NFIELDS (type
) = num_types
;
689 TYPE_FIELDS (type
) = (struct field
*)
690 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
692 while (num_types
-- > 0)
693 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
699 evaluate_subexp_standard (struct type
*expect_type
,
700 struct expression
*exp
, int *pos
,
705 int pc
, pc2
= 0, oldpos
;
706 struct value
*arg1
= NULL
;
707 struct value
*arg2
= NULL
;
711 struct value
**argvec
;
715 struct type
**arg_types
;
717 struct symbol
*function
= NULL
;
718 char *function_name
= NULL
;
721 op
= exp
->elts
[pc
].opcode
;
726 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
727 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
728 if (noside
== EVAL_SKIP
)
730 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
731 &exp
->elts
[pc
+ 3].string
,
732 expect_type
, 0, noside
);
734 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
739 return value_from_longest (exp
->elts
[pc
+ 1].type
,
740 exp
->elts
[pc
+ 2].longconst
);
744 return value_from_double (exp
->elts
[pc
+ 1].type
,
745 exp
->elts
[pc
+ 2].doubleconst
);
749 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
750 exp
->elts
[pc
+ 2].decfloatconst
);
755 if (noside
== EVAL_SKIP
)
758 /* JYG: We used to just return value_zero of the symbol type
759 if we're asked to avoid side effects. Otherwise we return
760 value_of_variable (...). However I'm not sure if
761 value_of_variable () has any side effect.
762 We need a full value object returned here for whatis_exp ()
763 to call evaluate_type () and then pass the full value to
764 value_rtti_target_type () if we are dealing with a pointer
765 or reference to a base class and print object is on. */
768 struct value
*ret
= NULL
;
772 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
773 exp
->elts
[pc
+ 1].block
);
776 CATCH (except
, RETURN_MASK_ERROR
)
778 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
779 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
782 throw_exception (except
);
789 case OP_VAR_ENTRY_VALUE
:
791 if (noside
== EVAL_SKIP
)
795 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
796 struct frame_info
*frame
;
798 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
799 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
801 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
802 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
803 error (_("Symbol \"%s\" does not have any specific entry value"),
804 SYMBOL_PRINT_NAME (sym
));
806 frame
= get_selected_frame (NULL
);
807 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
813 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
817 const char *name
= &exp
->elts
[pc
+ 2].string
;
821 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
822 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
823 name
, strlen (name
));
825 error (_("Register $%s not available."), name
);
827 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
828 a value with the appropriate register type. Unfortunately,
829 we don't have easy access to the type of user registers.
830 So for these registers, we fetch the register value regardless
831 of the evaluation mode. */
832 if (noside
== EVAL_AVOID_SIDE_EFFECTS
833 && regno
< gdbarch_num_regs (exp
->gdbarch
)
834 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
835 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
837 val
= value_of_register (regno
, get_selected_frame (NULL
));
839 error (_("Value of register %s not available."), name
);
845 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
846 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
850 return value_of_internalvar (exp
->gdbarch
,
851 exp
->elts
[pc
+ 1].internalvar
);
854 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
855 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
856 if (noside
== EVAL_SKIP
)
858 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
859 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
861 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
862 NSString constant. */
863 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
864 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
865 if (noside
== EVAL_SKIP
)
869 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
873 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
874 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
875 nargs
= tem3
- tem2
+ 1;
876 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
878 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
879 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
881 struct value
*rec
= allocate_value (expect_type
);
883 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
884 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
887 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
888 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
890 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
891 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
892 struct value
*array
= allocate_value (expect_type
);
893 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
894 LONGEST low_bound
, high_bound
, index
;
896 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
899 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
902 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
903 for (tem
= nargs
; --nargs
>= 0;)
905 struct value
*element
;
908 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
909 if (value_type (element
) != element_type
)
910 element
= value_cast (element_type
, element
);
913 int continue_pc
= *pos
;
916 index
= init_array_element (array
, element
, exp
, pos
, noside
,
917 low_bound
, high_bound
);
922 if (index
> high_bound
)
923 /* To avoid memory corruption. */
924 error (_("Too many array elements"));
925 memcpy (value_contents_raw (array
)
926 + (index
- low_bound
) * element_size
,
927 value_contents (element
),
935 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
936 && TYPE_CODE (type
) == TYPE_CODE_SET
)
938 struct value
*set
= allocate_value (expect_type
);
939 gdb_byte
*valaddr
= value_contents_raw (set
);
940 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
941 struct type
*check_type
= element_type
;
942 LONGEST low_bound
, high_bound
;
944 /* Get targettype of elementtype. */
945 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
946 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
947 check_type
= TYPE_TARGET_TYPE (check_type
);
949 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
950 error (_("(power)set type with unknown size"));
951 memset (valaddr
, '\0', TYPE_LENGTH (type
));
952 for (tem
= 0; tem
< nargs
; tem
++)
954 LONGEST range_low
, range_high
;
955 struct type
*range_low_type
, *range_high_type
;
956 struct value
*elem_val
;
958 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
959 range_low_type
= range_high_type
= value_type (elem_val
);
960 range_low
= range_high
= value_as_long (elem_val
);
962 /* Check types of elements to avoid mixture of elements from
963 different types. Also check if type of element is "compatible"
964 with element type of powerset. */
965 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
966 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
967 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
968 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
969 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
970 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
971 && (range_low_type
!= range_high_type
)))
972 /* different element modes. */
973 error (_("POWERSET tuple elements of different mode"));
974 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
975 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
976 && range_low_type
!= check_type
))
977 error (_("incompatible POWERSET tuple elements"));
978 if (range_low
> range_high
)
980 warning (_("empty POWERSET tuple range"));
983 if (range_low
< low_bound
|| range_high
> high_bound
)
984 error (_("POWERSET tuple element out of range"));
985 range_low
-= low_bound
;
986 range_high
-= low_bound
;
987 for (; range_low
<= range_high
; range_low
++)
989 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
991 if (gdbarch_bits_big_endian (exp
->gdbarch
))
992 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
993 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1000 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1001 for (tem
= 0; tem
< nargs
; tem
++)
1003 /* Ensure that array expressions are coerced into pointer
1005 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1007 if (noside
== EVAL_SKIP
)
1009 return value_array (tem2
, tem3
, argvec
);
1013 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1015 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1017 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1019 if (noside
== EVAL_SKIP
)
1021 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1025 /* Skip third and second args to evaluate the first one. */
1026 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1027 if (value_logical_not (arg1
))
1029 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1030 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1034 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1035 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1039 case OP_OBJC_SELECTOR
:
1040 { /* Objective C @selector operator. */
1041 char *sel
= &exp
->elts
[pc
+ 2].string
;
1042 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1043 struct type
*selector_type
;
1045 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1046 if (noside
== EVAL_SKIP
)
1050 sel
[len
] = 0; /* Make sure it's terminated. */
1052 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1053 return value_from_longest (selector_type
,
1054 lookup_child_selector (exp
->gdbarch
, sel
));
1057 case OP_OBJC_MSGCALL
:
1058 { /* Objective C message (method) call. */
1060 CORE_ADDR responds_selector
= 0;
1061 CORE_ADDR method_selector
= 0;
1063 CORE_ADDR selector
= 0;
1065 int struct_return
= 0;
1066 int sub_no_side
= 0;
1068 struct value
*msg_send
= NULL
;
1069 struct value
*msg_send_stret
= NULL
;
1070 int gnu_runtime
= 0;
1072 struct value
*target
= NULL
;
1073 struct value
*method
= NULL
;
1074 struct value
*called_method
= NULL
;
1076 struct type
*selector_type
= NULL
;
1077 struct type
*long_type
;
1079 struct value
*ret
= NULL
;
1082 selector
= exp
->elts
[pc
+ 1].longconst
;
1083 nargs
= exp
->elts
[pc
+ 2].longconst
;
1084 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1089 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1090 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1092 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1093 sub_no_side
= EVAL_NORMAL
;
1095 sub_no_side
= noside
;
1097 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1099 if (value_as_long (target
) == 0)
1100 return value_from_longest (long_type
, 0);
1102 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1105 /* Find the method dispatch (Apple runtime) or method lookup
1106 (GNU runtime) function for Objective-C. These will be used
1107 to lookup the symbol information for the method. If we
1108 can't find any symbol information, then we'll use these to
1109 call the method, otherwise we can call the method
1110 directly. The msg_send_stret function is used in the special
1111 case of a method that returns a structure (Apple runtime
1115 struct type
*type
= selector_type
;
1117 type
= lookup_function_type (type
);
1118 type
= lookup_pointer_type (type
);
1119 type
= lookup_function_type (type
);
1120 type
= lookup_pointer_type (type
);
1122 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1124 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1126 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1127 msg_send_stret
= value_from_pointer (type
,
1128 value_as_address (msg_send_stret
));
1132 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1133 /* Special dispatcher for methods returning structs. */
1135 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1138 /* Verify the target object responds to this method. The
1139 standard top-level 'Object' class uses a different name for
1140 the verification method than the non-standard, but more
1141 often used, 'NSObject' class. Make sure we check for both. */
1144 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1145 if (responds_selector
== 0)
1147 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1149 if (responds_selector
== 0)
1150 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1153 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1154 if (method_selector
== 0)
1156 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1158 if (method_selector
== 0)
1159 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1161 /* Call the verification method, to make sure that the target
1162 class implements the desired method. */
1164 argvec
[0] = msg_send
;
1166 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1167 argvec
[3] = value_from_longest (long_type
, selector
);
1170 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1173 /* Function objc_msg_lookup returns a pointer. */
1175 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1177 if (value_as_long (ret
) == 0)
1178 error (_("Target does not respond to this message selector."));
1180 /* Call "methodForSelector:" method, to get the address of a
1181 function method that implements this selector for this
1182 class. If we can find a symbol at that address, then we
1183 know the return type, parameter types etc. (that's a good
1186 argvec
[0] = msg_send
;
1188 argvec
[2] = value_from_longest (long_type
, method_selector
);
1189 argvec
[3] = value_from_longest (long_type
, selector
);
1192 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1196 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1199 /* ret should now be the selector. */
1201 addr
= value_as_long (ret
);
1204 struct symbol
*sym
= NULL
;
1206 /* The address might point to a function descriptor;
1207 resolve it to the actual code address instead. */
1208 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1211 /* Is it a high_level symbol? */
1212 sym
= find_pc_function (addr
);
1214 method
= value_of_variable (sym
, 0);
1217 /* If we found a method with symbol information, check to see
1218 if it returns a struct. Otherwise assume it doesn't. */
1223 struct type
*val_type
;
1225 funaddr
= find_function_addr (method
, &val_type
);
1227 block_for_pc (funaddr
);
1229 CHECK_TYPEDEF (val_type
);
1231 if ((val_type
== NULL
)
1232 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1234 if (expect_type
!= NULL
)
1235 val_type
= expect_type
;
1238 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1241 else if (expect_type
!= NULL
)
1243 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1244 check_typedef (expect_type
));
1247 /* Found a function symbol. Now we will substitute its
1248 value in place of the message dispatcher (obj_msgSend),
1249 so that we call the method directly instead of thru
1250 the dispatcher. The main reason for doing this is that
1251 we can now evaluate the return value and parameter values
1252 according to their known data types, in case we need to
1253 do things like promotion, dereferencing, special handling
1254 of structs and doubles, etc.
1256 We want to use the type signature of 'method', but still
1257 jump to objc_msgSend() or objc_msgSend_stret() to better
1258 mimic the behavior of the runtime. */
1262 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1263 error (_("method address has symbol information "
1264 "with non-function type; skipping"));
1266 /* Create a function pointer of the appropriate type, and
1267 replace its value with the value of msg_send or
1268 msg_send_stret. We must use a pointer here, as
1269 msg_send and msg_send_stret are of pointer type, and
1270 the representation may be different on systems that use
1271 function descriptors. */
1274 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1275 value_as_address (msg_send_stret
));
1278 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1279 value_as_address (msg_send
));
1284 called_method
= msg_send_stret
;
1286 called_method
= msg_send
;
1289 if (noside
== EVAL_SKIP
)
1292 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1294 /* If the return type doesn't look like a function type,
1295 call an error. This can happen if somebody tries to
1296 turn a variable into a function call. This is here
1297 because people often want to call, eg, strcmp, which
1298 gdb doesn't know is a function. If gdb isn't asked for
1299 it's opinion (ie. through "whatis"), it won't offer
1302 struct type
*type
= value_type (called_method
);
1304 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1305 type
= TYPE_TARGET_TYPE (type
);
1306 type
= TYPE_TARGET_TYPE (type
);
1310 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1311 return allocate_value (expect_type
);
1313 return allocate_value (type
);
1316 error (_("Expression of type other than "
1317 "\"method returning ...\" used as a method"));
1320 /* Now depending on whether we found a symbol for the method,
1321 we will either call the runtime dispatcher or the method
1324 argvec
[0] = called_method
;
1326 argvec
[2] = value_from_longest (long_type
, selector
);
1327 /* User-supplied arguments. */
1328 for (tem
= 0; tem
< nargs
; tem
++)
1329 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1330 argvec
[tem
+ 3] = 0;
1332 if (gnu_runtime
&& (method
!= NULL
))
1334 /* Function objc_msg_lookup returns a pointer. */
1335 deprecated_set_value_type (argvec
[0],
1336 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1338 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1341 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1348 op
= exp
->elts
[*pos
].opcode
;
1349 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1350 /* Allocate arg vector, including space for the function to be
1351 called in argvec[0], a potential `this', and a terminating NULL. */
1352 argvec
= (struct value
**)
1353 alloca (sizeof (struct value
*) * (nargs
+ 3));
1354 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1356 /* First, evaluate the structure into arg2. */
1359 if (op
== STRUCTOP_MEMBER
)
1361 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1365 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1368 /* If the function is a virtual function, then the
1369 aggregate value (providing the structure) plays
1370 its part by providing the vtable. Otherwise,
1371 it is just along for the ride: call the function
1374 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1376 type
= check_typedef (value_type (arg1
));
1377 if (noside
== EVAL_SKIP
)
1378 tem
= 1; /* Set it to the right arg index so that all arguments
1379 can also be skipped. */
1380 else if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
)
1382 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1383 arg1
= value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1385 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1387 /* Now, say which argument to start evaluating from. */
1392 else if (TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1394 struct type
*type_ptr
1395 = lookup_pointer_type (TYPE_SELF_TYPE (type
));
1396 struct type
*target_type_ptr
1397 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1399 /* Now, convert these values to an address. */
1400 arg2
= value_cast (type_ptr
, arg2
);
1402 mem_offset
= value_as_long (arg1
);
1404 arg1
= value_from_pointer (target_type_ptr
,
1405 value_as_long (arg2
) + mem_offset
);
1406 arg1
= value_ind (arg1
);
1410 error (_("Non-pointer-to-member value used in pointer-to-member "
1413 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1415 /* Hair for method invocations. */
1419 /* First, evaluate the structure into arg2. */
1421 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1422 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1424 if (op
== STRUCTOP_STRUCT
)
1426 /* If v is a variable in a register, and the user types
1427 v.method (), this will produce an error, because v has
1430 A possible way around this would be to allocate a
1431 copy of the variable on the stack, copy in the
1432 contents, call the function, and copy out the
1433 contents. I.e. convert this from call by reference
1434 to call by copy-return (or whatever it's called).
1435 However, this does not work because it is not the
1436 same: the method being called could stash a copy of
1437 the address, and then future uses through that address
1438 (after the method returns) would be expected to
1439 use the variable itself, not some copy of it. */
1440 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1444 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1446 /* Check to see if the operator '->' has been
1447 overloaded. If the operator has been overloaded
1448 replace arg2 with the value returned by the custom
1449 operator and continue evaluation. */
1450 while (unop_user_defined_p (op
, arg2
))
1452 struct value
*value
= NULL
;
1455 value
= value_x_unop (arg2
, op
, noside
);
1458 CATCH (except
, RETURN_MASK_ERROR
)
1460 if (except
.error
== NOT_FOUND_ERROR
)
1463 throw_exception (except
);
1470 /* Now, say which argument to start evaluating from. */
1473 else if (op
== OP_SCOPE
1474 && overload_resolution
1475 && (exp
->language_defn
->la_language
== language_cplus
))
1477 /* Unpack it locally so we can properly handle overload
1483 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1484 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1485 type
= exp
->elts
[pc2
+ 1].type
;
1486 name
= &exp
->elts
[pc2
+ 3].string
;
1489 function_name
= NULL
;
1490 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1492 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1494 get_selected_block (0),
1496 if (function
== NULL
)
1497 error (_("No symbol \"%s\" in namespace \"%s\"."),
1498 name
, TYPE_TAG_NAME (type
));
1501 /* arg2 is left as NULL on purpose. */
1505 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1506 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1507 function_name
= name
;
1509 /* We need a properly typed value for method lookup. For
1510 static methods arg2 is otherwise unused. */
1511 arg2
= value_zero (type
, lval_memory
);
1516 else if (op
== OP_ADL_FUNC
)
1518 /* Save the function position and move pos so that the arguments
1519 can be evaluated. */
1525 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1526 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1530 /* Non-method function call. */
1534 /* If this is a C++ function wait until overload resolution. */
1535 if (op
== OP_VAR_VALUE
1536 && overload_resolution
1537 && (exp
->language_defn
->la_language
== language_cplus
))
1539 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1544 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1545 type
= value_type (argvec
[0]);
1546 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1547 type
= TYPE_TARGET_TYPE (type
);
1548 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1550 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1552 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1560 /* Evaluate arguments (if not already done, e.g., namespace::func()
1561 and overload-resolution is off). */
1562 for (; tem
<= nargs
; tem
++)
1564 /* Ensure that array expressions are coerced into pointer
1566 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1569 /* Signal end of arglist. */
1572 if (noside
== EVAL_SKIP
)
1575 if (op
== OP_ADL_FUNC
)
1577 struct symbol
*symp
;
1580 int string_pc
= save_pos1
+ 3;
1582 /* Extract the function name. */
1583 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1584 func_name
= (char *) alloca (name_len
+ 1);
1585 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1587 find_overload_match (&argvec
[1], nargs
, func_name
,
1588 NON_METHOD
, /* not method */
1589 NULL
, NULL
, /* pass NULL symbol since
1590 symbol is unknown */
1591 NULL
, &symp
, NULL
, 0, noside
);
1593 /* Now fix the expression being evaluated. */
1594 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1595 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1598 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1599 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1601 int static_memfuncp
;
1604 /* Method invocation: stuff "this" as first parameter.
1605 If the method turns out to be static we undo this below. */
1610 /* Name of method from expression. */
1611 tstr
= &exp
->elts
[pc2
+ 2].string
;
1614 tstr
= function_name
;
1616 if (overload_resolution
&& (exp
->language_defn
->la_language
1619 /* Language is C++, do some overload resolution before
1621 struct value
*valp
= NULL
;
1623 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1624 METHOD
, /* method */
1625 &arg2
, /* the object */
1627 &static_memfuncp
, 0, noside
);
1629 if (op
== OP_SCOPE
&& !static_memfuncp
)
1631 /* For the time being, we don't handle this. */
1632 error (_("Call to overloaded function %s requires "
1636 argvec
[1] = arg2
; /* the ``this'' pointer */
1637 argvec
[0] = valp
; /* Use the method found after overload
1641 /* Non-C++ case -- or no overload resolution. */
1643 struct value
*temp
= arg2
;
1645 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1647 op
== STRUCTOP_STRUCT
1648 ? "structure" : "structure pointer");
1649 /* value_struct_elt updates temp with the correct value
1650 of the ``this'' pointer if necessary, so modify argvec[1] to
1651 reflect any ``this'' changes. */
1653 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1654 value_address (temp
)
1655 + value_embedded_offset (temp
));
1656 argvec
[1] = arg2
; /* the ``this'' pointer */
1659 /* Take out `this' if needed. */
1660 if (static_memfuncp
)
1662 argvec
[1] = argvec
[0];
1667 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1669 /* Pointer to member. argvec[1] is already set up. */
1672 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1674 /* Non-member function being called. */
1675 /* fn: This can only be done for C++ functions. A C-style function
1676 in a C++ program, for instance, does not have the fields that
1677 are expected here. */
1679 if (overload_resolution
&& (exp
->language_defn
->la_language
1682 /* Language is C++, do some overload resolution before
1684 struct symbol
*symp
;
1687 /* If a scope has been specified disable ADL. */
1691 if (op
== OP_VAR_VALUE
)
1692 function
= exp
->elts
[save_pos1
+2].symbol
;
1694 (void) find_overload_match (&argvec
[1], nargs
,
1695 NULL
, /* no need for name */
1696 NON_METHOD
, /* not method */
1697 NULL
, function
, /* the function */
1698 NULL
, &symp
, NULL
, no_adl
, noside
);
1700 if (op
== OP_VAR_VALUE
)
1702 /* Now fix the expression being evaluated. */
1703 exp
->elts
[save_pos1
+2].symbol
= symp
;
1704 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1708 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1712 /* Not C++, or no overload resolution allowed. */
1713 /* Nothing to be done; argvec already correctly set up. */
1718 /* It is probably a C-style function. */
1719 /* Nothing to be done; argvec already correctly set up. */
1724 if (argvec
[0] == NULL
)
1725 error (_("Cannot evaluate function -- may be inlined"));
1726 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1728 /* If the return type doesn't look like a function type, call an
1729 error. This can happen if somebody tries to turn a variable into
1730 a function call. This is here because people often want to
1731 call, eg, strcmp, which gdb doesn't know is a function. If
1732 gdb isn't asked for it's opinion (ie. through "whatis"),
1733 it won't offer it. */
1735 struct type
*ftype
= value_type (argvec
[0]);
1737 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1739 /* We don't know anything about what the internal
1740 function might return, but we have to return
1742 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1745 else if (TYPE_GNU_IFUNC (ftype
))
1746 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1747 else if (TYPE_TARGET_TYPE (ftype
))
1748 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1750 error (_("Expression of type other than "
1751 "\"Function returning ...\" used as function"));
1753 switch (TYPE_CODE (value_type (argvec
[0])))
1755 case TYPE_CODE_INTERNAL_FUNCTION
:
1756 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1757 argvec
[0], nargs
, argvec
+ 1);
1758 case TYPE_CODE_XMETHOD
:
1759 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
1761 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1763 /* pai: FIXME save value from call_function_by_hand, then adjust
1764 pc by adjust_fn_pc if +ve. */
1766 case OP_F77_UNDETERMINED_ARGLIST
:
1768 /* Remember that in F77, functions, substring ops and
1769 array subscript operations cannot be disambiguated
1770 at parse time. We have made all array subscript operations,
1771 substring operations as well as function calls come here
1772 and we now have to discover what the heck this thing actually was.
1773 If it is a function, we process just as if we got an OP_FUNCALL. */
1775 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1778 /* First determine the type code we are dealing with. */
1779 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1780 type
= check_typedef (value_type (arg1
));
1781 code
= TYPE_CODE (type
);
1783 if (code
== TYPE_CODE_PTR
)
1785 /* Fortran always passes variable to subroutines as pointer.
1786 So we need to look into its target type to see if it is
1787 array, string or function. If it is, we need to switch
1788 to the target value the original one points to. */
1789 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1791 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1792 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1793 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1795 arg1
= value_ind (arg1
);
1796 type
= check_typedef (value_type (arg1
));
1797 code
= TYPE_CODE (type
);
1803 case TYPE_CODE_ARRAY
:
1804 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1805 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1807 goto multi_f77_subscript
;
1809 case TYPE_CODE_STRING
:
1810 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1811 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1814 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1815 return value_subscript (arg1
, value_as_long (arg2
));
1819 case TYPE_CODE_FUNC
:
1820 /* It's a function call. */
1821 /* Allocate arg vector, including space for the function to be
1822 called in argvec[0] and a terminating NULL. */
1823 argvec
= (struct value
**)
1824 alloca (sizeof (struct value
*) * (nargs
+ 2));
1827 for (; tem
<= nargs
; tem
++)
1828 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1829 argvec
[tem
] = 0; /* signal end of arglist */
1830 if (noside
== EVAL_SKIP
)
1835 error (_("Cannot perform substring on this type"));
1839 /* We have a complex number, There should be 2 floating
1840 point numbers that compose it. */
1842 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1843 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1845 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1847 case STRUCTOP_STRUCT
:
1848 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1849 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1850 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1851 if (noside
== EVAL_SKIP
)
1853 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1855 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1856 arg3
= value_zero (value_type (arg3
), not_lval
);
1860 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1861 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1862 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1863 if (noside
== EVAL_SKIP
)
1866 /* Check to see if operator '->' has been overloaded. If so replace
1867 arg1 with the value returned by evaluating operator->(). */
1868 while (unop_user_defined_p (op
, arg1
))
1870 struct value
*value
= NULL
;
1873 value
= value_x_unop (arg1
, op
, noside
);
1876 CATCH (except
, RETURN_MASK_ERROR
)
1878 if (except
.error
== NOT_FOUND_ERROR
)
1881 throw_exception (except
);
1888 /* JYG: if print object is on we need to replace the base type
1889 with rtti type in order to continue on with successful
1890 lookup of member / method only available in the rtti type. */
1892 struct type
*type
= value_type (arg1
);
1893 struct type
*real_type
;
1894 int full
, top
, using_enc
;
1895 struct value_print_options opts
;
1897 get_user_print_options (&opts
);
1898 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1899 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
1901 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1904 arg1
= value_cast (real_type
, arg1
);
1908 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1909 NULL
, "structure pointer");
1910 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1911 arg3
= value_zero (value_type (arg3
), not_lval
);
1914 case STRUCTOP_MEMBER
:
1916 if (op
== STRUCTOP_MEMBER
)
1917 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1919 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1921 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1923 if (noside
== EVAL_SKIP
)
1926 type
= check_typedef (value_type (arg2
));
1927 switch (TYPE_CODE (type
))
1929 case TYPE_CODE_METHODPTR
:
1930 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1931 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1934 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1935 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1936 return value_ind (arg2
);
1939 case TYPE_CODE_MEMBERPTR
:
1940 /* Now, convert these values to an address. */
1941 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1944 mem_offset
= value_as_long (arg2
);
1946 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1947 value_as_long (arg1
) + mem_offset
);
1948 return value_ind (arg3
);
1951 error (_("non-pointer-to-member value used "
1952 "in pointer-to-member construct"));
1956 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1957 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1958 for (ix
= 0; ix
< nargs
; ++ix
)
1959 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1961 expect_type
= make_params (nargs
, arg_types
);
1962 *(pos
) += 3 + nargs
;
1963 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1964 xfree (TYPE_FIELDS (expect_type
));
1965 xfree (TYPE_MAIN_TYPE (expect_type
));
1966 xfree (expect_type
);
1970 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1971 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1972 if (noside
== EVAL_SKIP
)
1974 if (binop_user_defined_p (op
, arg1
, arg2
))
1975 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1977 return value_concat (arg1
, arg2
);
1980 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1981 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1983 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1985 if (binop_user_defined_p (op
, arg1
, arg2
))
1986 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1988 return value_assign (arg1
, arg2
);
1990 case BINOP_ASSIGN_MODIFY
:
1992 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1993 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1994 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1996 op
= exp
->elts
[pc
+ 1].opcode
;
1997 if (binop_user_defined_p (op
, arg1
, arg2
))
1998 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1999 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2001 && is_integral_type (value_type (arg2
)))
2002 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2003 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2005 && is_integral_type (value_type (arg2
)))
2006 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2009 struct value
*tmp
= arg1
;
2011 /* For shift and integer exponentiation operations,
2012 only promote the first argument. */
2013 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2014 && is_integral_type (value_type (arg2
)))
2015 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2017 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2019 arg2
= value_binop (tmp
, arg2
, op
);
2021 return value_assign (arg1
, arg2
);
2024 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2025 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2026 if (noside
== EVAL_SKIP
)
2028 if (binop_user_defined_p (op
, arg1
, arg2
))
2029 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
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
));
2033 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2034 && is_integral_type (value_type (arg1
)))
2035 return value_ptradd (arg2
, value_as_long (arg1
));
2038 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2039 return value_binop (arg1
, arg2
, BINOP_ADD
);
2043 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2044 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2045 if (noside
== EVAL_SKIP
)
2047 if (binop_user_defined_p (op
, arg1
, arg2
))
2048 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2049 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2050 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2052 /* FIXME -- should be ptrdiff_t */
2053 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2054 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2056 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2057 && is_integral_type (value_type (arg2
)))
2058 return value_ptradd (arg1
, - value_as_long (arg2
));
2061 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2062 return value_binop (arg1
, arg2
, BINOP_SUB
);
2073 case BINOP_BITWISE_AND
:
2074 case BINOP_BITWISE_IOR
:
2075 case BINOP_BITWISE_XOR
:
2076 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2077 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2078 if (noside
== EVAL_SKIP
)
2080 if (binop_user_defined_p (op
, arg1
, arg2
))
2081 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2084 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2085 fudge arg2 to avoid division-by-zero, the caller is
2086 (theoretically) only looking for the type of the result. */
2087 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2088 /* ??? Do we really want to test for BINOP_MOD here?
2089 The implementation of value_binop gives it a well-defined
2092 || op
== BINOP_INTDIV
2095 && value_logical_not (arg2
))
2097 struct value
*v_one
, *retval
;
2099 v_one
= value_one (value_type (arg2
));
2100 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2101 retval
= value_binop (arg1
, v_one
, op
);
2106 /* For shift and integer exponentiation operations,
2107 only promote the first argument. */
2108 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2109 && is_integral_type (value_type (arg2
)))
2110 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2112 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2114 return value_binop (arg1
, arg2
, op
);
2118 case BINOP_SUBSCRIPT
:
2119 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2120 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2121 if (noside
== EVAL_SKIP
)
2123 if (binop_user_defined_p (op
, arg1
, arg2
))
2124 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2127 /* If the user attempts to subscript something that is not an
2128 array or pointer type (like a plain int variable for example),
2129 then report this as an error. */
2131 arg1
= coerce_ref (arg1
);
2132 type
= check_typedef (value_type (arg1
));
2133 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2134 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2136 if (TYPE_NAME (type
))
2137 error (_("cannot subscript something of type `%s'"),
2140 error (_("cannot subscript requested type"));
2143 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2144 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2146 return value_subscript (arg1
, value_as_long (arg2
));
2148 case MULTI_SUBSCRIPT
:
2150 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2151 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2154 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2155 /* FIXME: EVAL_SKIP handling may not be correct. */
2156 if (noside
== EVAL_SKIP
)
2167 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2168 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2170 /* If the user attempts to subscript something that has no target
2171 type (like a plain int variable for example), then report this
2174 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2177 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2183 error (_("cannot subscript something of type `%s'"),
2184 TYPE_NAME (value_type (arg1
)));
2188 if (binop_user_defined_p (op
, arg1
, arg2
))
2190 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2194 arg1
= coerce_ref (arg1
);
2195 type
= check_typedef (value_type (arg1
));
2197 switch (TYPE_CODE (type
))
2200 case TYPE_CODE_ARRAY
:
2201 case TYPE_CODE_STRING
:
2202 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2206 if (TYPE_NAME (type
))
2207 error (_("cannot subscript something of type `%s'"),
2210 error (_("cannot subscript requested type"));
2216 multi_f77_subscript
:
2218 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2219 int ndimensions
= 1, i
;
2220 struct value
*array
= arg1
;
2222 if (nargs
> MAX_FORTRAN_DIMS
)
2223 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2225 ndimensions
= calc_f77_array_dims (type
);
2227 if (nargs
!= ndimensions
)
2228 error (_("Wrong number of subscripts"));
2230 gdb_assert (nargs
> 0);
2232 /* Now that we know we have a legal array subscript expression
2233 let us actually find out where this element exists in the array. */
2235 /* Take array indices left to right. */
2236 for (i
= 0; i
< nargs
; i
++)
2238 /* Evaluate each subscript; it must be a legal integer in F77. */
2239 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2241 /* Fill in the subscript array. */
2243 subscript_array
[i
] = value_as_long (arg2
);
2246 /* Internal type of array is arranged right to left. */
2247 for (i
= nargs
; i
> 0; i
--)
2249 struct type
*array_type
= check_typedef (value_type (array
));
2250 LONGEST index
= subscript_array
[i
- 1];
2252 array
= value_subscripted_rvalue (array
, index
,
2253 f77_get_lowerbound (array_type
));
2259 case BINOP_LOGICAL_AND
:
2260 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2261 if (noside
== EVAL_SKIP
)
2263 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2268 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2271 if (binop_user_defined_p (op
, arg1
, arg2
))
2273 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2274 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2278 tem
= value_logical_not (arg1
);
2279 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2280 (tem
? EVAL_SKIP
: noside
));
2281 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2282 return value_from_longest (type
,
2283 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2286 case BINOP_LOGICAL_OR
:
2287 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2288 if (noside
== EVAL_SKIP
)
2290 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2295 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2298 if (binop_user_defined_p (op
, arg1
, arg2
))
2300 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2301 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2305 tem
= value_logical_not (arg1
);
2306 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2307 (!tem
? EVAL_SKIP
: noside
));
2308 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2309 return value_from_longest (type
,
2310 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2314 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2315 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2316 if (noside
== EVAL_SKIP
)
2318 if (binop_user_defined_p (op
, arg1
, arg2
))
2320 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2324 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2325 tem
= value_equal (arg1
, arg2
);
2326 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2327 return value_from_longest (type
, (LONGEST
) tem
);
2330 case BINOP_NOTEQUAL
:
2331 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2332 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2333 if (noside
== EVAL_SKIP
)
2335 if (binop_user_defined_p (op
, arg1
, arg2
))
2337 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2341 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2342 tem
= value_equal (arg1
, arg2
);
2343 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2344 return value_from_longest (type
, (LONGEST
) ! tem
);
2348 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2349 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2350 if (noside
== EVAL_SKIP
)
2352 if (binop_user_defined_p (op
, arg1
, arg2
))
2354 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2358 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2359 tem
= value_less (arg1
, arg2
);
2360 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2361 return value_from_longest (type
, (LONGEST
) tem
);
2365 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2366 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2367 if (noside
== EVAL_SKIP
)
2369 if (binop_user_defined_p (op
, arg1
, arg2
))
2371 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2375 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2376 tem
= value_less (arg2
, arg1
);
2377 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2378 return value_from_longest (type
, (LONGEST
) tem
);
2382 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2383 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2384 if (noside
== EVAL_SKIP
)
2386 if (binop_user_defined_p (op
, arg1
, arg2
))
2388 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2392 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2393 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2394 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2395 return value_from_longest (type
, (LONGEST
) tem
);
2399 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2400 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2401 if (noside
== EVAL_SKIP
)
2403 if (binop_user_defined_p (op
, arg1
, arg2
))
2405 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2409 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2410 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2411 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2412 return value_from_longest (type
, (LONGEST
) tem
);
2416 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2417 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2418 if (noside
== EVAL_SKIP
)
2420 type
= check_typedef (value_type (arg2
));
2421 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2422 error (_("Non-integral right operand for \"@\" operator."));
2423 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2425 return allocate_repeat_value (value_type (arg1
),
2426 longest_to_int (value_as_long (arg2
)));
2429 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2432 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2433 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2436 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2437 if (noside
== EVAL_SKIP
)
2439 if (unop_user_defined_p (op
, arg1
))
2440 return value_x_unop (arg1
, op
, noside
);
2443 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2444 return value_pos (arg1
);
2448 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2449 if (noside
== EVAL_SKIP
)
2451 if (unop_user_defined_p (op
, arg1
))
2452 return value_x_unop (arg1
, op
, noside
);
2455 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2456 return value_neg (arg1
);
2459 case UNOP_COMPLEMENT
:
2460 /* C++: check for and handle destructor names. */
2461 op
= exp
->elts
[*pos
].opcode
;
2463 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2464 if (noside
== EVAL_SKIP
)
2466 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2467 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2470 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2471 return value_complement (arg1
);
2474 case UNOP_LOGICAL_NOT
:
2475 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2476 if (noside
== EVAL_SKIP
)
2478 if (unop_user_defined_p (op
, arg1
))
2479 return value_x_unop (arg1
, op
, noside
);
2482 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2483 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2487 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2488 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2489 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2490 type
= check_typedef (value_type (arg1
));
2491 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2492 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2493 error (_("Attempt to dereference pointer "
2494 "to member without an object"));
2495 if (noside
== EVAL_SKIP
)
2497 if (unop_user_defined_p (op
, arg1
))
2498 return value_x_unop (arg1
, op
, noside
);
2499 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2501 type
= check_typedef (value_type (arg1
));
2502 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2503 || TYPE_CODE (type
) == TYPE_CODE_REF
2504 /* In C you can dereference an array to get the 1st elt. */
2505 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2507 return value_zero (TYPE_TARGET_TYPE (type
),
2509 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2510 /* GDB allows dereferencing an int. */
2511 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2514 error (_("Attempt to take contents of a non-pointer value."));
2517 /* Allow * on an integer so we can cast it to whatever we want.
2518 This returns an int, which seems like the most C-like thing to
2519 do. "long long" variables are rare enough that
2520 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2521 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2522 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2523 (CORE_ADDR
) value_as_address (arg1
));
2524 return value_ind (arg1
);
2527 /* C++: check for and handle pointer to members. */
2529 op
= exp
->elts
[*pos
].opcode
;
2531 if (noside
== EVAL_SKIP
)
2533 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2538 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2545 if (noside
== EVAL_SKIP
)
2547 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2550 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2554 type
= exp
->elts
[pc
+ 1].type
;
2555 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2556 if (noside
== EVAL_SKIP
)
2558 if (type
!= value_type (arg1
))
2559 arg1
= value_cast (type
, arg1
);
2562 case UNOP_CAST_TYPE
:
2563 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2564 type
= value_type (arg1
);
2565 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2566 if (noside
== EVAL_SKIP
)
2568 if (type
!= value_type (arg1
))
2569 arg1
= value_cast (type
, arg1
);
2572 case UNOP_DYNAMIC_CAST
:
2573 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2574 type
= value_type (arg1
);
2575 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2576 if (noside
== EVAL_SKIP
)
2578 return value_dynamic_cast (type
, arg1
);
2580 case UNOP_REINTERPRET_CAST
:
2581 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2582 type
= value_type (arg1
);
2583 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2584 if (noside
== EVAL_SKIP
)
2586 return value_reinterpret_cast (type
, arg1
);
2590 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2591 if (noside
== EVAL_SKIP
)
2593 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2594 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2596 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2597 value_as_address (arg1
));
2599 case UNOP_MEMVAL_TYPE
:
2600 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2601 type
= value_type (arg1
);
2602 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2603 if (noside
== EVAL_SKIP
)
2605 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2606 return value_zero (type
, lval_memory
);
2608 return value_at_lazy (type
, value_as_address (arg1
));
2610 case UNOP_MEMVAL_TLS
:
2612 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2613 if (noside
== EVAL_SKIP
)
2615 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2616 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2621 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2622 value_as_address (arg1
));
2623 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2626 case UNOP_PREINCREMENT
:
2627 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2628 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2630 else if (unop_user_defined_p (op
, arg1
))
2632 return value_x_unop (arg1
, op
, noside
);
2636 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2637 arg2
= value_ptradd (arg1
, 1);
2640 struct value
*tmp
= arg1
;
2642 arg2
= value_one (value_type (arg1
));
2643 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2644 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2647 return value_assign (arg1
, arg2
);
2650 case UNOP_PREDECREMENT
:
2651 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2652 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2654 else if (unop_user_defined_p (op
, arg1
))
2656 return value_x_unop (arg1
, op
, noside
);
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_SUB
);
2671 return value_assign (arg1
, arg2
);
2674 case UNOP_POSTINCREMENT
:
2675 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2676 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2678 else if (unop_user_defined_p (op
, arg1
))
2680 return value_x_unop (arg1
, op
, noside
);
2684 arg3
= value_non_lval (arg1
);
2686 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2687 arg2
= value_ptradd (arg1
, 1);
2690 struct value
*tmp
= arg1
;
2692 arg2
= value_one (value_type (arg1
));
2693 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2694 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2697 value_assign (arg1
, arg2
);
2701 case UNOP_POSTDECREMENT
:
2702 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2703 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2705 else if (unop_user_defined_p (op
, arg1
))
2707 return value_x_unop (arg1
, op
, noside
);
2711 arg3
= value_non_lval (arg1
);
2713 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2714 arg2
= value_ptradd (arg1
, -1);
2717 struct value
*tmp
= arg1
;
2719 arg2
= value_one (value_type (arg1
));
2720 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2721 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2724 value_assign (arg1
, arg2
);
2730 return value_of_this (exp
->language_defn
);
2733 /* The value is not supposed to be used. This is here to make it
2734 easier to accommodate expressions that contain types. */
2736 if (noside
== EVAL_SKIP
)
2738 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2740 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2742 /* If this is a typedef, then find its immediate target. We
2743 use check_typedef to resolve stubs, but we ignore its
2744 result because we do not want to dig past all
2746 check_typedef (type
);
2747 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2748 type
= TYPE_TARGET_TYPE (type
);
2749 return allocate_value (type
);
2752 error (_("Attempt to use a type name as an expression"));
2756 if (noside
== EVAL_SKIP
)
2758 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2761 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2763 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2764 struct value
*result
;
2766 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2767 EVAL_AVOID_SIDE_EFFECTS
);
2769 /* 'decltype' has special semantics for lvalues. */
2770 if (op
== OP_DECLTYPE
2771 && (sub_op
== BINOP_SUBSCRIPT
2772 || sub_op
== STRUCTOP_MEMBER
2773 || sub_op
== STRUCTOP_MPTR
2774 || sub_op
== UNOP_IND
2775 || sub_op
== STRUCTOP_STRUCT
2776 || sub_op
== STRUCTOP_PTR
2777 || sub_op
== OP_SCOPE
))
2779 struct type
*type
= value_type (result
);
2781 if (TYPE_CODE (check_typedef (type
)) != TYPE_CODE_REF
)
2783 type
= lookup_reference_type (type
);
2784 result
= allocate_value (type
);
2791 error (_("Attempt to use a type as an expression"));
2795 struct value
*result
;
2796 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2798 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2799 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2800 EVAL_AVOID_SIDE_EFFECTS
);
2802 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2804 if (noside
!= EVAL_NORMAL
)
2805 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2807 return cplus_typeid (result
);
2811 /* Removing this case and compiling with gcc -Wall reveals that
2812 a lot of cases are hitting this case. Some of these should
2813 probably be removed from expression.h; others are legitimate
2814 expressions which are (apparently) not fully implemented.
2816 If there are any cases landing here which mean a user error,
2817 then they should be separate cases, with more descriptive
2820 error (_("GDB does not (yet) know how to "
2821 "evaluate that kind of expression"));
2825 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2828 /* Evaluate a subexpression of EXP, at index *POS,
2829 and return the address of that subexpression.
2830 Advance *POS over the subexpression.
2831 If the subexpression isn't an lvalue, get an error.
2832 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2833 then only the type of the result need be correct. */
2835 static struct value
*
2836 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2846 op
= exp
->elts
[pc
].opcode
;
2852 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2854 /* We can't optimize out "&*" if there's a user-defined operator*. */
2855 if (unop_user_defined_p (op
, x
))
2857 x
= value_x_unop (x
, op
, noside
);
2858 goto default_case_after_eval
;
2861 return coerce_array (x
);
2865 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2866 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2868 case UNOP_MEMVAL_TYPE
:
2873 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2874 type
= value_type (x
);
2875 return value_cast (lookup_pointer_type (type
),
2876 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2880 var
= exp
->elts
[pc
+ 2].symbol
;
2882 /* C++: The "address" of a reference should yield the address
2883 * of the object pointed to. Let value_addr() deal with it. */
2884 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2888 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2891 lookup_pointer_type (SYMBOL_TYPE (var
));
2892 enum address_class sym_class
= SYMBOL_CLASS (var
);
2894 if (sym_class
== LOC_CONST
2895 || sym_class
== LOC_CONST_BYTES
2896 || sym_class
== LOC_REGISTER
)
2897 error (_("Attempt to take address of register or constant."));
2900 value_zero (type
, not_lval
);
2903 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2906 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2907 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2908 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2909 &exp
->elts
[pc
+ 3].string
,
2912 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2917 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2918 default_case_after_eval
:
2919 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2921 struct type
*type
= check_typedef (value_type (x
));
2923 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2924 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2926 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2927 return value_zero (lookup_pointer_type (value_type (x
)),
2930 error (_("Attempt to take address of "
2931 "value not located in memory."));
2933 return value_addr (x
);
2937 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2938 When used in contexts where arrays will be coerced anyway, this is
2939 equivalent to `evaluate_subexp' but much faster because it avoids
2940 actually fetching array contents (perhaps obsolete now that we have
2943 Note that we currently only do the coercion for C expressions, where
2944 arrays are zero based and the coercion is correct. For other languages,
2945 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2946 to decide if coercion is appropriate. */
2949 evaluate_subexp_with_coercion (struct expression
*exp
,
2950 int *pos
, enum noside noside
)
2959 op
= exp
->elts
[pc
].opcode
;
2964 var
= exp
->elts
[pc
+ 2].symbol
;
2965 type
= check_typedef (SYMBOL_TYPE (var
));
2966 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2967 && !TYPE_VECTOR (type
)
2968 && CAST_IS_CONVERSION (exp
->language_defn
))
2971 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2972 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2978 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2982 /* Evaluate a subexpression of EXP, at index *POS,
2983 and return a value for the size of that subexpression.
2984 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2985 we allow side-effects on the operand if its type is a variable
2988 static struct value
*
2989 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2992 /* FIXME: This should be size_t. */
2993 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3000 op
= exp
->elts
[pc
].opcode
;
3004 /* This case is handled specially
3005 so that we avoid creating a value for the result type.
3006 If the result type is very big, it's desirable not to
3007 create a value unnecessarily. */
3010 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3011 type
= check_typedef (value_type (val
));
3012 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3013 && TYPE_CODE (type
) != TYPE_CODE_REF
3014 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3015 error (_("Attempt to take contents of a non-pointer value."));
3016 type
= TYPE_TARGET_TYPE (type
);
3017 if (is_dynamic_type (type
))
3018 type
= value_type (value_ind (val
));
3019 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3023 type
= exp
->elts
[pc
+ 1].type
;
3026 case UNOP_MEMVAL_TYPE
:
3028 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3029 type
= value_type (val
);
3033 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3034 if (is_dynamic_type (type
))
3036 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3037 type
= value_type (val
);
3043 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3044 type of the subscript is a variable length array type. In this case we
3045 must re-evaluate the right hand side of the subcription to allow
3047 case BINOP_SUBSCRIPT
:
3048 if (noside
== EVAL_NORMAL
)
3050 int pc
= (*pos
) + 1;
3052 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3053 type
= check_typedef (value_type (val
));
3054 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3056 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3057 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3059 type
= TYPE_INDEX_TYPE (type
);
3060 /* Only re-evaluate the right hand side if the resulting type
3061 is a variable length type. */
3062 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3064 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3065 return value_from_longest
3066 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3075 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3076 type
= value_type (val
);
3080 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3081 "When applied to a reference or a reference type, the result is
3082 the size of the referenced type." */
3083 CHECK_TYPEDEF (type
);
3084 if (exp
->language_defn
->la_language
== language_cplus
3085 && TYPE_CODE (type
) == TYPE_CODE_REF
)
3086 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3087 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3090 /* Parse a type expression in the string [P..P+LENGTH). */
3093 parse_and_eval_type (char *p
, int length
)
3095 char *tmp
= (char *) alloca (length
+ 4);
3096 struct expression
*expr
;
3099 memcpy (tmp
+ 1, p
, length
);
3100 tmp
[length
+ 1] = ')';
3101 tmp
[length
+ 2] = '0';
3102 tmp
[length
+ 3] = '\0';
3103 expr
= parse_expression (tmp
);
3104 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3105 error (_("Internal error in eval_type."));
3106 return expr
->elts
[1].type
;
3110 calc_f77_array_dims (struct type
*array_type
)
3113 struct type
*tmp_type
;
3115 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3116 error (_("Can't get dimensions for a non-array type"));
3118 tmp_type
= array_type
;
3120 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3122 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)