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
410 = (enum f90_range_type
) longest_to_int (exp
->elts
[pc
].longconst
);
414 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
415 low_bound
= TYPE_LOW_BOUND (range
);
417 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
419 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
420 high_bound
= TYPE_HIGH_BOUND (range
);
422 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
424 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
428 /* Promote value ARG1 as appropriate before performing a unary operation
430 If the result is not appropriate for any particular language then it
431 needs to patch this function. */
434 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
439 *arg1
= coerce_ref (*arg1
);
440 type1
= check_typedef (value_type (*arg1
));
442 if (is_integral_type (type1
))
444 switch (language
->la_language
)
447 /* Perform integral promotion for ANSI C/C++.
448 If not appropropriate for any particular language
449 it needs to modify this function. */
451 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
453 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
454 *arg1
= value_cast (builtin_int
, *arg1
);
461 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
462 operation on those two operands.
463 If the result is not appropriate for any particular language then it
464 needs to patch this function. */
467 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
468 struct value
**arg1
, struct value
**arg2
)
470 struct type
*promoted_type
= NULL
;
474 *arg1
= coerce_ref (*arg1
);
475 *arg2
= coerce_ref (*arg2
);
477 type1
= check_typedef (value_type (*arg1
));
478 type2
= check_typedef (value_type (*arg2
));
480 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
481 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
482 && !is_integral_type (type1
))
483 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
484 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
485 && !is_integral_type (type2
)))
488 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
489 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
491 /* No promotion required. */
493 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
494 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
496 switch (language
->la_language
)
502 case language_opencl
:
503 /* No promotion required. */
507 /* For other languages the result type is unchanged from gdb
508 version 6.7 for backward compatibility.
509 If either arg was long double, make sure that value is also long
510 double. Otherwise use double. */
511 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
512 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
513 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
515 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
519 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
520 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
522 /* No promotion required. */
525 /* Integral operations here. */
526 /* FIXME: Also mixed integral/booleans, with result an integer. */
528 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
529 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
530 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
531 int is_unsigned1
= TYPE_UNSIGNED (type1
);
532 int is_unsigned2
= TYPE_UNSIGNED (type2
);
533 unsigned int result_len
;
534 int unsigned_operation
;
536 /* Determine type length and signedness after promotion for
538 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
541 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
543 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
546 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
549 if (promoted_len1
> promoted_len2
)
551 unsigned_operation
= is_unsigned1
;
552 result_len
= promoted_len1
;
554 else if (promoted_len2
> promoted_len1
)
556 unsigned_operation
= is_unsigned2
;
557 result_len
= promoted_len2
;
561 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
562 result_len
= promoted_len1
;
565 switch (language
->la_language
)
571 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
573 promoted_type
= (unsigned_operation
574 ? builtin
->builtin_unsigned_int
575 : builtin
->builtin_int
);
577 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
579 promoted_type
= (unsigned_operation
580 ? builtin
->builtin_unsigned_long
581 : builtin
->builtin_long
);
585 promoted_type
= (unsigned_operation
586 ? builtin
->builtin_unsigned_long_long
587 : builtin
->builtin_long_long
);
590 case language_opencl
:
591 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
592 (language
, gdbarch
, "int")))
596 ? lookup_unsigned_typename (language
, gdbarch
, "int")
597 : lookup_signed_typename (language
, gdbarch
, "int"));
599 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
600 (language
, gdbarch
, "long")))
604 ? lookup_unsigned_typename (language
, gdbarch
, "long")
605 : lookup_signed_typename (language
, gdbarch
,"long"));
609 /* For other languages the result type is unchanged from gdb
610 version 6.7 for backward compatibility.
611 If either arg was long long, make sure that value is also long
612 long. Otherwise use long. */
613 if (unsigned_operation
)
615 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
616 promoted_type
= builtin
->builtin_unsigned_long_long
;
618 promoted_type
= builtin
->builtin_unsigned_long
;
622 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
623 promoted_type
= builtin
->builtin_long_long
;
625 promoted_type
= builtin
->builtin_long
;
633 /* Promote both operands to common type. */
634 *arg1
= value_cast (promoted_type
, *arg1
);
635 *arg2
= value_cast (promoted_type
, *arg2
);
640 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
642 type
= check_typedef (type
);
643 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
644 type
= TYPE_TARGET_TYPE (type
);
646 switch (TYPE_CODE (type
))
652 case TYPE_CODE_ARRAY
:
653 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
660 /* Constructs a fake method with the given parameter types.
661 This function is used by the parser to construct an "expected"
662 type for method overload resolution. */
665 make_params (int num_types
, struct type
**param_types
)
667 struct type
*type
= XCNEW (struct type
);
668 TYPE_MAIN_TYPE (type
) = XCNEW (struct main_type
);
669 TYPE_LENGTH (type
) = 1;
670 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
671 TYPE_CHAIN (type
) = type
;
674 if (param_types
[num_types
- 1] == NULL
)
677 TYPE_VARARGS (type
) = 1;
679 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
683 /* Caller should have ensured this. */
684 gdb_assert (num_types
== 0);
685 TYPE_PROTOTYPED (type
) = 1;
689 TYPE_NFIELDS (type
) = num_types
;
690 TYPE_FIELDS (type
) = (struct field
*)
691 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
693 while (num_types
-- > 0)
694 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
700 evaluate_subexp_standard (struct type
*expect_type
,
701 struct expression
*exp
, int *pos
,
706 int pc
, pc2
= 0, oldpos
;
707 struct value
*arg1
= NULL
;
708 struct value
*arg2
= NULL
;
712 struct value
**argvec
;
716 struct type
**arg_types
;
718 struct symbol
*function
= NULL
;
719 char *function_name
= NULL
;
722 op
= exp
->elts
[pc
].opcode
;
727 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
728 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
729 if (noside
== EVAL_SKIP
)
731 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
732 &exp
->elts
[pc
+ 3].string
,
733 expect_type
, 0, noside
);
735 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
740 return value_from_longest (exp
->elts
[pc
+ 1].type
,
741 exp
->elts
[pc
+ 2].longconst
);
745 return value_from_double (exp
->elts
[pc
+ 1].type
,
746 exp
->elts
[pc
+ 2].doubleconst
);
750 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
751 exp
->elts
[pc
+ 2].decfloatconst
);
756 if (noside
== EVAL_SKIP
)
759 /* JYG: We used to just return value_zero of the symbol type
760 if we're asked to avoid side effects. Otherwise we return
761 value_of_variable (...). However I'm not sure if
762 value_of_variable () has any side effect.
763 We need a full value object returned here for whatis_exp ()
764 to call evaluate_type () and then pass the full value to
765 value_rtti_target_type () if we are dealing with a pointer
766 or reference to a base class and print object is on. */
769 struct value
*ret
= NULL
;
773 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
774 exp
->elts
[pc
+ 1].block
);
777 CATCH (except
, RETURN_MASK_ERROR
)
779 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
780 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
783 throw_exception (except
);
790 case OP_VAR_ENTRY_VALUE
:
792 if (noside
== EVAL_SKIP
)
796 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
797 struct frame_info
*frame
;
799 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
800 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
802 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
803 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
804 error (_("Symbol \"%s\" does not have any specific entry value"),
805 SYMBOL_PRINT_NAME (sym
));
807 frame
= get_selected_frame (NULL
);
808 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
814 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
818 const char *name
= &exp
->elts
[pc
+ 2].string
;
822 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
823 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
824 name
, strlen (name
));
826 error (_("Register $%s not available."), name
);
828 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
829 a value with the appropriate register type. Unfortunately,
830 we don't have easy access to the type of user registers.
831 So for these registers, we fetch the register value regardless
832 of the evaluation mode. */
833 if (noside
== EVAL_AVOID_SIDE_EFFECTS
834 && regno
< gdbarch_num_regs (exp
->gdbarch
)
835 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
836 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
838 val
= value_of_register (regno
, get_selected_frame (NULL
));
840 error (_("Value of register %s not available."), name
);
846 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
847 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
851 return value_of_internalvar (exp
->gdbarch
,
852 exp
->elts
[pc
+ 1].internalvar
);
855 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
856 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
857 if (noside
== EVAL_SKIP
)
859 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
860 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
862 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
863 NSString constant. */
864 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
865 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
866 if (noside
== EVAL_SKIP
)
870 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
874 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
875 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
876 nargs
= tem3
- tem2
+ 1;
877 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
879 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
880 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
882 struct value
*rec
= allocate_value (expect_type
);
884 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
885 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
888 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
889 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
891 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
892 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
893 struct value
*array
= allocate_value (expect_type
);
894 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
895 LONGEST low_bound
, high_bound
, index
;
897 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
900 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
903 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
904 for (tem
= nargs
; --nargs
>= 0;)
906 struct value
*element
;
909 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
910 if (value_type (element
) != element_type
)
911 element
= value_cast (element_type
, element
);
914 int continue_pc
= *pos
;
917 index
= init_array_element (array
, element
, exp
, pos
, noside
,
918 low_bound
, high_bound
);
923 if (index
> high_bound
)
924 /* To avoid memory corruption. */
925 error (_("Too many array elements"));
926 memcpy (value_contents_raw (array
)
927 + (index
- low_bound
) * element_size
,
928 value_contents (element
),
936 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
937 && TYPE_CODE (type
) == TYPE_CODE_SET
)
939 struct value
*set
= allocate_value (expect_type
);
940 gdb_byte
*valaddr
= value_contents_raw (set
);
941 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
942 struct type
*check_type
= element_type
;
943 LONGEST low_bound
, high_bound
;
945 /* Get targettype of elementtype. */
946 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
947 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
948 check_type
= TYPE_TARGET_TYPE (check_type
);
950 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
951 error (_("(power)set type with unknown size"));
952 memset (valaddr
, '\0', TYPE_LENGTH (type
));
953 for (tem
= 0; tem
< nargs
; tem
++)
955 LONGEST range_low
, range_high
;
956 struct type
*range_low_type
, *range_high_type
;
957 struct value
*elem_val
;
959 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
960 range_low_type
= range_high_type
= value_type (elem_val
);
961 range_low
= range_high
= value_as_long (elem_val
);
963 /* Check types of elements to avoid mixture of elements from
964 different types. Also check if type of element is "compatible"
965 with element type of powerset. */
966 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
967 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
968 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
969 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
970 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
971 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
972 && (range_low_type
!= range_high_type
)))
973 /* different element modes. */
974 error (_("POWERSET tuple elements of different mode"));
975 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
976 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
977 && range_low_type
!= check_type
))
978 error (_("incompatible POWERSET tuple elements"));
979 if (range_low
> range_high
)
981 warning (_("empty POWERSET tuple range"));
984 if (range_low
< low_bound
|| range_high
> high_bound
)
985 error (_("POWERSET tuple element out of range"));
986 range_low
-= low_bound
;
987 range_high
-= low_bound
;
988 for (; range_low
<= range_high
; range_low
++)
990 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
992 if (gdbarch_bits_big_endian (exp
->gdbarch
))
993 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
994 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1001 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1002 for (tem
= 0; tem
< nargs
; tem
++)
1004 /* Ensure that array expressions are coerced into pointer
1006 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1008 if (noside
== EVAL_SKIP
)
1010 return value_array (tem2
, tem3
, argvec
);
1014 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1016 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1018 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1020 if (noside
== EVAL_SKIP
)
1022 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1026 /* Skip third and second args to evaluate the first one. */
1027 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1028 if (value_logical_not (arg1
))
1030 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1031 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1035 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1036 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1040 case OP_OBJC_SELECTOR
:
1041 { /* Objective C @selector operator. */
1042 char *sel
= &exp
->elts
[pc
+ 2].string
;
1043 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1044 struct type
*selector_type
;
1046 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1047 if (noside
== EVAL_SKIP
)
1051 sel
[len
] = 0; /* Make sure it's terminated. */
1053 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1054 return value_from_longest (selector_type
,
1055 lookup_child_selector (exp
->gdbarch
, sel
));
1058 case OP_OBJC_MSGCALL
:
1059 { /* Objective C message (method) call. */
1061 CORE_ADDR responds_selector
= 0;
1062 CORE_ADDR method_selector
= 0;
1064 CORE_ADDR selector
= 0;
1066 int struct_return
= 0;
1067 enum noside sub_no_side
= EVAL_NORMAL
;
1069 struct value
*msg_send
= NULL
;
1070 struct value
*msg_send_stret
= NULL
;
1071 int gnu_runtime
= 0;
1073 struct value
*target
= NULL
;
1074 struct value
*method
= NULL
;
1075 struct value
*called_method
= NULL
;
1077 struct type
*selector_type
= NULL
;
1078 struct type
*long_type
;
1080 struct value
*ret
= NULL
;
1083 selector
= exp
->elts
[pc
+ 1].longconst
;
1084 nargs
= exp
->elts
[pc
+ 2].longconst
;
1085 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1090 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1091 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1093 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1094 sub_no_side
= EVAL_NORMAL
;
1096 sub_no_side
= noside
;
1098 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1100 if (value_as_long (target
) == 0)
1101 return value_from_longest (long_type
, 0);
1103 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1106 /* Find the method dispatch (Apple runtime) or method lookup
1107 (GNU runtime) function for Objective-C. These will be used
1108 to lookup the symbol information for the method. If we
1109 can't find any symbol information, then we'll use these to
1110 call the method, otherwise we can call the method
1111 directly. The msg_send_stret function is used in the special
1112 case of a method that returns a structure (Apple runtime
1116 struct type
*type
= selector_type
;
1118 type
= lookup_function_type (type
);
1119 type
= lookup_pointer_type (type
);
1120 type
= lookup_function_type (type
);
1121 type
= lookup_pointer_type (type
);
1123 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1125 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1127 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1128 msg_send_stret
= value_from_pointer (type
,
1129 value_as_address (msg_send_stret
));
1133 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1134 /* Special dispatcher for methods returning structs. */
1136 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1139 /* Verify the target object responds to this method. The
1140 standard top-level 'Object' class uses a different name for
1141 the verification method than the non-standard, but more
1142 often used, 'NSObject' class. Make sure we check for both. */
1145 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1146 if (responds_selector
== 0)
1148 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1150 if (responds_selector
== 0)
1151 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1154 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1155 if (method_selector
== 0)
1157 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1159 if (method_selector
== 0)
1160 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1162 /* Call the verification method, to make sure that the target
1163 class implements the desired method. */
1165 argvec
[0] = msg_send
;
1167 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1168 argvec
[3] = value_from_longest (long_type
, selector
);
1171 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1174 /* Function objc_msg_lookup returns a pointer. */
1176 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1178 if (value_as_long (ret
) == 0)
1179 error (_("Target does not respond to this message selector."));
1181 /* Call "methodForSelector:" method, to get the address of a
1182 function method that implements this selector for this
1183 class. If we can find a symbol at that address, then we
1184 know the return type, parameter types etc. (that's a good
1187 argvec
[0] = msg_send
;
1189 argvec
[2] = value_from_longest (long_type
, method_selector
);
1190 argvec
[3] = value_from_longest (long_type
, selector
);
1193 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1197 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1200 /* ret should now be the selector. */
1202 addr
= value_as_long (ret
);
1205 struct symbol
*sym
= NULL
;
1207 /* The address might point to a function descriptor;
1208 resolve it to the actual code address instead. */
1209 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1212 /* Is it a high_level symbol? */
1213 sym
= find_pc_function (addr
);
1215 method
= value_of_variable (sym
, 0);
1218 /* If we found a method with symbol information, check to see
1219 if it returns a struct. Otherwise assume it doesn't. */
1224 struct type
*val_type
;
1226 funaddr
= find_function_addr (method
, &val_type
);
1228 block_for_pc (funaddr
);
1230 val_type
= check_typedef (val_type
);
1232 if ((val_type
== NULL
)
1233 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1235 if (expect_type
!= NULL
)
1236 val_type
= expect_type
;
1239 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1242 else if (expect_type
!= NULL
)
1244 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1245 check_typedef (expect_type
));
1248 /* Found a function symbol. Now we will substitute its
1249 value in place of the message dispatcher (obj_msgSend),
1250 so that we call the method directly instead of thru
1251 the dispatcher. The main reason for doing this is that
1252 we can now evaluate the return value and parameter values
1253 according to their known data types, in case we need to
1254 do things like promotion, dereferencing, special handling
1255 of structs and doubles, etc.
1257 We want to use the type signature of 'method', but still
1258 jump to objc_msgSend() or objc_msgSend_stret() to better
1259 mimic the behavior of the runtime. */
1263 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1264 error (_("method address has symbol information "
1265 "with non-function type; skipping"));
1267 /* Create a function pointer of the appropriate type, and
1268 replace its value with the value of msg_send or
1269 msg_send_stret. We must use a pointer here, as
1270 msg_send and msg_send_stret are of pointer type, and
1271 the representation may be different on systems that use
1272 function descriptors. */
1275 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1276 value_as_address (msg_send_stret
));
1279 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1280 value_as_address (msg_send
));
1285 called_method
= msg_send_stret
;
1287 called_method
= msg_send
;
1290 if (noside
== EVAL_SKIP
)
1293 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1295 /* If the return type doesn't look like a function type,
1296 call an error. This can happen if somebody tries to
1297 turn a variable into a function call. This is here
1298 because people often want to call, eg, strcmp, which
1299 gdb doesn't know is a function. If gdb isn't asked for
1300 it's opinion (ie. through "whatis"), it won't offer
1303 struct type
*type
= value_type (called_method
);
1305 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1306 type
= TYPE_TARGET_TYPE (type
);
1307 type
= TYPE_TARGET_TYPE (type
);
1311 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1312 return allocate_value (expect_type
);
1314 return allocate_value (type
);
1317 error (_("Expression of type other than "
1318 "\"method returning ...\" used as a method"));
1321 /* Now depending on whether we found a symbol for the method,
1322 we will either call the runtime dispatcher or the method
1325 argvec
[0] = called_method
;
1327 argvec
[2] = value_from_longest (long_type
, selector
);
1328 /* User-supplied arguments. */
1329 for (tem
= 0; tem
< nargs
; tem
++)
1330 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1331 argvec
[tem
+ 3] = 0;
1333 if (gnu_runtime
&& (method
!= NULL
))
1335 /* Function objc_msg_lookup returns a pointer. */
1336 deprecated_set_value_type (argvec
[0],
1337 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1339 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1342 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1349 op
= exp
->elts
[*pos
].opcode
;
1350 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1351 /* Allocate arg vector, including space for the function to be
1352 called in argvec[0], a potential `this', and a terminating NULL. */
1353 argvec
= (struct value
**)
1354 alloca (sizeof (struct value
*) * (nargs
+ 3));
1355 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1357 /* First, evaluate the structure into arg2. */
1360 if (op
== STRUCTOP_MEMBER
)
1362 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1366 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1369 /* If the function is a virtual function, then the
1370 aggregate value (providing the structure) plays
1371 its part by providing the vtable. Otherwise,
1372 it is just along for the ride: call the function
1375 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1377 type
= check_typedef (value_type (arg1
));
1378 if (noside
== EVAL_SKIP
)
1379 tem
= 1; /* Set it to the right arg index so that all arguments
1380 can also be skipped. */
1381 else if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
)
1383 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1384 arg1
= value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1386 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1388 /* Now, say which argument to start evaluating from. */
1393 else if (TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1395 struct type
*type_ptr
1396 = lookup_pointer_type (TYPE_SELF_TYPE (type
));
1397 struct type
*target_type_ptr
1398 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1400 /* Now, convert these values to an address. */
1401 arg2
= value_cast (type_ptr
, arg2
);
1403 mem_offset
= value_as_long (arg1
);
1405 arg1
= value_from_pointer (target_type_ptr
,
1406 value_as_long (arg2
) + mem_offset
);
1407 arg1
= value_ind (arg1
);
1411 error (_("Non-pointer-to-member value used in pointer-to-member "
1414 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1416 /* Hair for method invocations. */
1420 /* First, evaluate the structure into arg2. */
1422 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1423 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1425 if (op
== STRUCTOP_STRUCT
)
1427 /* If v is a variable in a register, and the user types
1428 v.method (), this will produce an error, because v has
1431 A possible way around this would be to allocate a
1432 copy of the variable on the stack, copy in the
1433 contents, call the function, and copy out the
1434 contents. I.e. convert this from call by reference
1435 to call by copy-return (or whatever it's called).
1436 However, this does not work because it is not the
1437 same: the method being called could stash a copy of
1438 the address, and then future uses through that address
1439 (after the method returns) would be expected to
1440 use the variable itself, not some copy of it. */
1441 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1445 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1447 /* Check to see if the operator '->' has been
1448 overloaded. If the operator has been overloaded
1449 replace arg2 with the value returned by the custom
1450 operator and continue evaluation. */
1451 while (unop_user_defined_p (op
, arg2
))
1453 struct value
*value
= NULL
;
1456 value
= value_x_unop (arg2
, op
, noside
);
1459 CATCH (except
, RETURN_MASK_ERROR
)
1461 if (except
.error
== NOT_FOUND_ERROR
)
1464 throw_exception (except
);
1471 /* Now, say which argument to start evaluating from. */
1474 else if (op
== OP_SCOPE
1475 && overload_resolution
1476 && (exp
->language_defn
->la_language
== language_cplus
))
1478 /* Unpack it locally so we can properly handle overload
1484 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1485 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1486 type
= exp
->elts
[pc2
+ 1].type
;
1487 name
= &exp
->elts
[pc2
+ 3].string
;
1490 function_name
= NULL
;
1491 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1493 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1495 get_selected_block (0),
1497 if (function
== NULL
)
1498 error (_("No symbol \"%s\" in namespace \"%s\"."),
1499 name
, TYPE_TAG_NAME (type
));
1502 /* arg2 is left as NULL on purpose. */
1506 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1507 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1508 function_name
= name
;
1510 /* We need a properly typed value for method lookup. For
1511 static methods arg2 is otherwise unused. */
1512 arg2
= value_zero (type
, lval_memory
);
1517 else if (op
== OP_ADL_FUNC
)
1519 /* Save the function position and move pos so that the arguments
1520 can be evaluated. */
1526 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1527 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1531 /* Non-method function call. */
1535 /* If this is a C++ function wait until overload resolution. */
1536 if (op
== OP_VAR_VALUE
1537 && overload_resolution
1538 && (exp
->language_defn
->la_language
== language_cplus
))
1540 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1545 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1546 type
= value_type (argvec
[0]);
1547 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1548 type
= TYPE_TARGET_TYPE (type
);
1549 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1551 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1553 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1561 /* Evaluate arguments (if not already done, e.g., namespace::func()
1562 and overload-resolution is off). */
1563 for (; tem
<= nargs
; tem
++)
1565 /* Ensure that array expressions are coerced into pointer
1567 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1570 /* Signal end of arglist. */
1573 if (noside
== EVAL_SKIP
)
1576 if (op
== OP_ADL_FUNC
)
1578 struct symbol
*symp
;
1581 int string_pc
= save_pos1
+ 3;
1583 /* Extract the function name. */
1584 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1585 func_name
= (char *) alloca (name_len
+ 1);
1586 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1588 find_overload_match (&argvec
[1], nargs
, func_name
,
1589 NON_METHOD
, /* not method */
1590 NULL
, NULL
, /* pass NULL symbol since
1591 symbol is unknown */
1592 NULL
, &symp
, NULL
, 0, noside
);
1594 /* Now fix the expression being evaluated. */
1595 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1596 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1599 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1600 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1602 int static_memfuncp
;
1605 /* Method invocation: stuff "this" as first parameter.
1606 If the method turns out to be static we undo this below. */
1611 /* Name of method from expression. */
1612 tstr
= &exp
->elts
[pc2
+ 2].string
;
1615 tstr
= function_name
;
1617 if (overload_resolution
&& (exp
->language_defn
->la_language
1620 /* Language is C++, do some overload resolution before
1622 struct value
*valp
= NULL
;
1624 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1625 METHOD
, /* method */
1626 &arg2
, /* the object */
1628 &static_memfuncp
, 0, noside
);
1630 if (op
== OP_SCOPE
&& !static_memfuncp
)
1632 /* For the time being, we don't handle this. */
1633 error (_("Call to overloaded function %s requires "
1637 argvec
[1] = arg2
; /* the ``this'' pointer */
1638 argvec
[0] = valp
; /* Use the method found after overload
1642 /* Non-C++ case -- or no overload resolution. */
1644 struct value
*temp
= arg2
;
1646 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1648 op
== STRUCTOP_STRUCT
1649 ? "structure" : "structure pointer");
1650 /* value_struct_elt updates temp with the correct value
1651 of the ``this'' pointer if necessary, so modify argvec[1] to
1652 reflect any ``this'' changes. */
1654 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1655 value_address (temp
)
1656 + value_embedded_offset (temp
));
1657 argvec
[1] = arg2
; /* the ``this'' pointer */
1660 /* Take out `this' if needed. */
1661 if (static_memfuncp
)
1663 argvec
[1] = argvec
[0];
1668 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1670 /* Pointer to member. argvec[1] is already set up. */
1673 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1675 /* Non-member function being called. */
1676 /* fn: This can only be done for C++ functions. A C-style function
1677 in a C++ program, for instance, does not have the fields that
1678 are expected here. */
1680 if (overload_resolution
&& (exp
->language_defn
->la_language
1683 /* Language is C++, do some overload resolution before
1685 struct symbol
*symp
;
1688 /* If a scope has been specified disable ADL. */
1692 if (op
== OP_VAR_VALUE
)
1693 function
= exp
->elts
[save_pos1
+2].symbol
;
1695 (void) find_overload_match (&argvec
[1], nargs
,
1696 NULL
, /* no need for name */
1697 NON_METHOD
, /* not method */
1698 NULL
, function
, /* the function */
1699 NULL
, &symp
, NULL
, no_adl
, noside
);
1701 if (op
== OP_VAR_VALUE
)
1703 /* Now fix the expression being evaluated. */
1704 exp
->elts
[save_pos1
+2].symbol
= symp
;
1705 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1709 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1713 /* Not C++, or no overload resolution allowed. */
1714 /* Nothing to be done; argvec already correctly set up. */
1719 /* It is probably a C-style function. */
1720 /* Nothing to be done; argvec already correctly set up. */
1725 if (argvec
[0] == NULL
)
1726 error (_("Cannot evaluate function -- may be inlined"));
1727 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1729 /* If the return type doesn't look like a function type, call an
1730 error. This can happen if somebody tries to turn a variable into
1731 a function call. This is here because people often want to
1732 call, eg, strcmp, which gdb doesn't know is a function. If
1733 gdb isn't asked for it's opinion (ie. through "whatis"),
1734 it won't offer it. */
1736 struct type
*ftype
= value_type (argvec
[0]);
1738 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1740 /* We don't know anything about what the internal
1741 function might return, but we have to return
1743 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1746 else if (TYPE_CODE (ftype
) == TYPE_CODE_XMETHOD
)
1748 struct type
*return_type
1749 = result_type_of_xmethod (argvec
[0], nargs
, argvec
+ 1);
1751 if (return_type
== NULL
)
1752 error (_("Xmethod is missing return type."));
1753 return value_zero (return_type
, not_lval
);
1755 else if (TYPE_GNU_IFUNC (ftype
))
1756 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1757 else if (TYPE_TARGET_TYPE (ftype
))
1758 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1760 error (_("Expression of type other than "
1761 "\"Function returning ...\" used as function"));
1763 switch (TYPE_CODE (value_type (argvec
[0])))
1765 case TYPE_CODE_INTERNAL_FUNCTION
:
1766 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1767 argvec
[0], nargs
, argvec
+ 1);
1768 case TYPE_CODE_XMETHOD
:
1769 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
1771 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1773 /* pai: FIXME save value from call_function_by_hand, then adjust
1774 pc by adjust_fn_pc if +ve. */
1776 case OP_F77_UNDETERMINED_ARGLIST
:
1778 /* Remember that in F77, functions, substring ops and
1779 array subscript operations cannot be disambiguated
1780 at parse time. We have made all array subscript operations,
1781 substring operations as well as function calls come here
1782 and we now have to discover what the heck this thing actually was.
1783 If it is a function, we process just as if we got an OP_FUNCALL. */
1785 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1788 /* First determine the type code we are dealing with. */
1789 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1790 type
= check_typedef (value_type (arg1
));
1791 code
= TYPE_CODE (type
);
1793 if (code
== TYPE_CODE_PTR
)
1795 /* Fortran always passes variable to subroutines as pointer.
1796 So we need to look into its target type to see if it is
1797 array, string or function. If it is, we need to switch
1798 to the target value the original one points to. */
1799 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1801 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1802 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1803 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1805 arg1
= value_ind (arg1
);
1806 type
= check_typedef (value_type (arg1
));
1807 code
= TYPE_CODE (type
);
1813 case TYPE_CODE_ARRAY
:
1814 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1815 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1817 goto multi_f77_subscript
;
1819 case TYPE_CODE_STRING
:
1820 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1821 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1824 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1825 return value_subscript (arg1
, value_as_long (arg2
));
1829 case TYPE_CODE_FUNC
:
1830 /* It's a function call. */
1831 /* Allocate arg vector, including space for the function to be
1832 called in argvec[0] and a terminating NULL. */
1833 argvec
= (struct value
**)
1834 alloca (sizeof (struct value
*) * (nargs
+ 2));
1837 for (; tem
<= nargs
; tem
++)
1838 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1839 argvec
[tem
] = 0; /* signal end of arglist */
1840 if (noside
== EVAL_SKIP
)
1845 error (_("Cannot perform substring on this type"));
1849 /* We have a complex number, There should be 2 floating
1850 point numbers that compose it. */
1852 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1853 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1855 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1857 case STRUCTOP_STRUCT
:
1858 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1859 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1860 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1861 if (noside
== EVAL_SKIP
)
1863 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1865 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1866 arg3
= value_zero (value_type (arg3
), not_lval
);
1870 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1871 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1872 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1873 if (noside
== EVAL_SKIP
)
1876 /* Check to see if operator '->' has been overloaded. If so replace
1877 arg1 with the value returned by evaluating operator->(). */
1878 while (unop_user_defined_p (op
, arg1
))
1880 struct value
*value
= NULL
;
1883 value
= value_x_unop (arg1
, op
, noside
);
1886 CATCH (except
, RETURN_MASK_ERROR
)
1888 if (except
.error
== NOT_FOUND_ERROR
)
1891 throw_exception (except
);
1898 /* JYG: if print object is on we need to replace the base type
1899 with rtti type in order to continue on with successful
1900 lookup of member / method only available in the rtti type. */
1902 struct type
*type
= value_type (arg1
);
1903 struct type
*real_type
;
1904 int full
, top
, using_enc
;
1905 struct value_print_options opts
;
1907 get_user_print_options (&opts
);
1908 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1909 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
1911 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1914 arg1
= value_cast (real_type
, arg1
);
1918 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1919 NULL
, "structure pointer");
1920 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1921 arg3
= value_zero (value_type (arg3
), not_lval
);
1924 case STRUCTOP_MEMBER
:
1926 if (op
== STRUCTOP_MEMBER
)
1927 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1929 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1931 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1933 if (noside
== EVAL_SKIP
)
1936 type
= check_typedef (value_type (arg2
));
1937 switch (TYPE_CODE (type
))
1939 case TYPE_CODE_METHODPTR
:
1940 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1941 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1944 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1945 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1946 return value_ind (arg2
);
1949 case TYPE_CODE_MEMBERPTR
:
1950 /* Now, convert these values to an address. */
1951 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1954 mem_offset
= value_as_long (arg2
);
1956 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1957 value_as_long (arg1
) + mem_offset
);
1958 return value_ind (arg3
);
1961 error (_("non-pointer-to-member value used "
1962 "in pointer-to-member construct"));
1966 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1967 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1968 for (ix
= 0; ix
< nargs
; ++ix
)
1969 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1971 expect_type
= make_params (nargs
, arg_types
);
1972 *(pos
) += 3 + nargs
;
1973 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1974 xfree (TYPE_FIELDS (expect_type
));
1975 xfree (TYPE_MAIN_TYPE (expect_type
));
1976 xfree (expect_type
);
1980 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1981 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1982 if (noside
== EVAL_SKIP
)
1984 if (binop_user_defined_p (op
, arg1
, arg2
))
1985 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1987 return value_concat (arg1
, arg2
);
1990 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1991 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1993 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1995 if (binop_user_defined_p (op
, arg1
, arg2
))
1996 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1998 return value_assign (arg1
, arg2
);
2000 case BINOP_ASSIGN_MODIFY
:
2002 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2003 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2004 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2006 op
= exp
->elts
[pc
+ 1].opcode
;
2007 if (binop_user_defined_p (op
, arg1
, arg2
))
2008 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2009 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2011 && is_integral_type (value_type (arg2
)))
2012 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2013 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2015 && is_integral_type (value_type (arg2
)))
2016 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2019 struct value
*tmp
= arg1
;
2021 /* For shift and integer exponentiation operations,
2022 only promote the first argument. */
2023 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2024 && is_integral_type (value_type (arg2
)))
2025 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2027 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2029 arg2
= value_binop (tmp
, arg2
, op
);
2031 return value_assign (arg1
, arg2
);
2034 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2035 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2036 if (noside
== EVAL_SKIP
)
2038 if (binop_user_defined_p (op
, arg1
, arg2
))
2039 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2040 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2041 && is_integral_type (value_type (arg2
)))
2042 return value_ptradd (arg1
, value_as_long (arg2
));
2043 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2044 && is_integral_type (value_type (arg1
)))
2045 return value_ptradd (arg2
, value_as_long (arg1
));
2048 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2049 return value_binop (arg1
, arg2
, BINOP_ADD
);
2053 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2054 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2055 if (noside
== EVAL_SKIP
)
2057 if (binop_user_defined_p (op
, arg1
, arg2
))
2058 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2059 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2060 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2062 /* FIXME -- should be ptrdiff_t */
2063 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2064 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2066 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2067 && is_integral_type (value_type (arg2
)))
2068 return value_ptradd (arg1
, - value_as_long (arg2
));
2071 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2072 return value_binop (arg1
, arg2
, BINOP_SUB
);
2083 case BINOP_BITWISE_AND
:
2084 case BINOP_BITWISE_IOR
:
2085 case BINOP_BITWISE_XOR
:
2086 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2087 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2088 if (noside
== EVAL_SKIP
)
2090 if (binop_user_defined_p (op
, arg1
, arg2
))
2091 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2094 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2095 fudge arg2 to avoid division-by-zero, the caller is
2096 (theoretically) only looking for the type of the result. */
2097 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2098 /* ??? Do we really want to test for BINOP_MOD here?
2099 The implementation of value_binop gives it a well-defined
2102 || op
== BINOP_INTDIV
2105 && value_logical_not (arg2
))
2107 struct value
*v_one
, *retval
;
2109 v_one
= value_one (value_type (arg2
));
2110 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2111 retval
= value_binop (arg1
, v_one
, op
);
2116 /* For shift and integer exponentiation operations,
2117 only promote the first argument. */
2118 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2119 && is_integral_type (value_type (arg2
)))
2120 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2122 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2124 return value_binop (arg1
, arg2
, op
);
2128 case BINOP_SUBSCRIPT
:
2129 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2130 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2131 if (noside
== EVAL_SKIP
)
2133 if (binop_user_defined_p (op
, arg1
, arg2
))
2134 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2137 /* If the user attempts to subscript something that is not an
2138 array or pointer type (like a plain int variable for example),
2139 then report this as an error. */
2141 arg1
= coerce_ref (arg1
);
2142 type
= check_typedef (value_type (arg1
));
2143 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2144 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2146 if (TYPE_NAME (type
))
2147 error (_("cannot subscript something of type `%s'"),
2150 error (_("cannot subscript requested type"));
2153 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2154 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2156 return value_subscript (arg1
, value_as_long (arg2
));
2158 case MULTI_SUBSCRIPT
:
2160 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2161 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2164 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2165 /* FIXME: EVAL_SKIP handling may not be correct. */
2166 if (noside
== EVAL_SKIP
)
2177 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2178 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2180 /* If the user attempts to subscript something that has no target
2181 type (like a plain int variable for example), then report this
2184 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2187 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2193 error (_("cannot subscript something of type `%s'"),
2194 TYPE_NAME (value_type (arg1
)));
2198 if (binop_user_defined_p (op
, arg1
, arg2
))
2200 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2204 arg1
= coerce_ref (arg1
);
2205 type
= check_typedef (value_type (arg1
));
2207 switch (TYPE_CODE (type
))
2210 case TYPE_CODE_ARRAY
:
2211 case TYPE_CODE_STRING
:
2212 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2216 if (TYPE_NAME (type
))
2217 error (_("cannot subscript something of type `%s'"),
2220 error (_("cannot subscript requested type"));
2226 multi_f77_subscript
:
2228 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2229 int ndimensions
= 1, i
;
2230 struct value
*array
= arg1
;
2232 if (nargs
> MAX_FORTRAN_DIMS
)
2233 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2235 ndimensions
= calc_f77_array_dims (type
);
2237 if (nargs
!= ndimensions
)
2238 error (_("Wrong number of subscripts"));
2240 gdb_assert (nargs
> 0);
2242 /* Now that we know we have a legal array subscript expression
2243 let us actually find out where this element exists in the array. */
2245 /* Take array indices left to right. */
2246 for (i
= 0; i
< nargs
; i
++)
2248 /* Evaluate each subscript; it must be a legal integer in F77. */
2249 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2251 /* Fill in the subscript array. */
2253 subscript_array
[i
] = value_as_long (arg2
);
2256 /* Internal type of array is arranged right to left. */
2257 for (i
= nargs
; i
> 0; i
--)
2259 struct type
*array_type
= check_typedef (value_type (array
));
2260 LONGEST index
= subscript_array
[i
- 1];
2262 array
= value_subscripted_rvalue (array
, index
,
2263 f77_get_lowerbound (array_type
));
2269 case BINOP_LOGICAL_AND
:
2270 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2271 if (noside
== EVAL_SKIP
)
2273 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2278 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2281 if (binop_user_defined_p (op
, arg1
, arg2
))
2283 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2284 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2288 tem
= value_logical_not (arg1
);
2289 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2290 (tem
? EVAL_SKIP
: noside
));
2291 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2292 return value_from_longest (type
,
2293 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2296 case BINOP_LOGICAL_OR
:
2297 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2298 if (noside
== EVAL_SKIP
)
2300 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2305 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2308 if (binop_user_defined_p (op
, arg1
, arg2
))
2310 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2311 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2315 tem
= value_logical_not (arg1
);
2316 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2317 (!tem
? EVAL_SKIP
: noside
));
2318 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2319 return value_from_longest (type
,
2320 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2324 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2325 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2326 if (noside
== EVAL_SKIP
)
2328 if (binop_user_defined_p (op
, arg1
, arg2
))
2330 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2334 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2335 tem
= value_equal (arg1
, arg2
);
2336 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2337 return value_from_longest (type
, (LONGEST
) tem
);
2340 case BINOP_NOTEQUAL
:
2341 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2342 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2343 if (noside
== EVAL_SKIP
)
2345 if (binop_user_defined_p (op
, arg1
, arg2
))
2347 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2351 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2352 tem
= value_equal (arg1
, arg2
);
2353 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2354 return value_from_longest (type
, (LONGEST
) ! tem
);
2358 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2359 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2360 if (noside
== EVAL_SKIP
)
2362 if (binop_user_defined_p (op
, arg1
, arg2
))
2364 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2368 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2369 tem
= value_less (arg1
, arg2
);
2370 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2371 return value_from_longest (type
, (LONGEST
) tem
);
2375 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2376 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2377 if (noside
== EVAL_SKIP
)
2379 if (binop_user_defined_p (op
, arg1
, arg2
))
2381 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2385 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2386 tem
= value_less (arg2
, arg1
);
2387 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2388 return value_from_longest (type
, (LONGEST
) tem
);
2392 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2393 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2394 if (noside
== EVAL_SKIP
)
2396 if (binop_user_defined_p (op
, arg1
, arg2
))
2398 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2402 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2403 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2404 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2405 return value_from_longest (type
, (LONGEST
) tem
);
2409 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2410 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2411 if (noside
== EVAL_SKIP
)
2413 if (binop_user_defined_p (op
, arg1
, arg2
))
2415 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2419 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2420 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2421 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2422 return value_from_longest (type
, (LONGEST
) tem
);
2426 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2427 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2428 if (noside
== EVAL_SKIP
)
2430 type
= check_typedef (value_type (arg2
));
2431 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2432 error (_("Non-integral right operand for \"@\" operator."));
2433 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2435 return allocate_repeat_value (value_type (arg1
),
2436 longest_to_int (value_as_long (arg2
)));
2439 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2442 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2443 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2446 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2447 if (noside
== EVAL_SKIP
)
2449 if (unop_user_defined_p (op
, arg1
))
2450 return value_x_unop (arg1
, op
, noside
);
2453 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2454 return value_pos (arg1
);
2458 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2459 if (noside
== EVAL_SKIP
)
2461 if (unop_user_defined_p (op
, arg1
))
2462 return value_x_unop (arg1
, op
, noside
);
2465 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2466 return value_neg (arg1
);
2469 case UNOP_COMPLEMENT
:
2470 /* C++: check for and handle destructor names. */
2471 op
= exp
->elts
[*pos
].opcode
;
2473 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2474 if (noside
== EVAL_SKIP
)
2476 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2477 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2480 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2481 return value_complement (arg1
);
2484 case UNOP_LOGICAL_NOT
:
2485 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2486 if (noside
== EVAL_SKIP
)
2488 if (unop_user_defined_p (op
, arg1
))
2489 return value_x_unop (arg1
, op
, noside
);
2492 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2493 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2497 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2498 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2499 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2500 type
= check_typedef (value_type (arg1
));
2501 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2502 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2503 error (_("Attempt to dereference pointer "
2504 "to member without an object"));
2505 if (noside
== EVAL_SKIP
)
2507 if (unop_user_defined_p (op
, arg1
))
2508 return value_x_unop (arg1
, op
, noside
);
2509 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2511 type
= check_typedef (value_type (arg1
));
2512 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2513 || TYPE_CODE (type
) == TYPE_CODE_REF
2514 /* In C you can dereference an array to get the 1st elt. */
2515 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2517 return value_zero (TYPE_TARGET_TYPE (type
),
2519 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2520 /* GDB allows dereferencing an int. */
2521 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2524 error (_("Attempt to take contents of a non-pointer value."));
2527 /* Allow * on an integer so we can cast it to whatever we want.
2528 This returns an int, which seems like the most C-like thing to
2529 do. "long long" variables are rare enough that
2530 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2531 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2532 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2533 (CORE_ADDR
) value_as_address (arg1
));
2534 return value_ind (arg1
);
2537 /* C++: check for and handle pointer to members. */
2539 op
= exp
->elts
[*pos
].opcode
;
2541 if (noside
== EVAL_SKIP
)
2543 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2548 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2555 if (noside
== EVAL_SKIP
)
2557 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2560 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2564 type
= exp
->elts
[pc
+ 1].type
;
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_CAST_TYPE
:
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 if (type
!= value_type (arg1
))
2579 arg1
= value_cast (type
, arg1
);
2582 case UNOP_DYNAMIC_CAST
:
2583 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2584 type
= value_type (arg1
);
2585 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2586 if (noside
== EVAL_SKIP
)
2588 return value_dynamic_cast (type
, arg1
);
2590 case UNOP_REINTERPRET_CAST
:
2591 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2592 type
= value_type (arg1
);
2593 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2594 if (noside
== EVAL_SKIP
)
2596 return value_reinterpret_cast (type
, arg1
);
2600 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2601 if (noside
== EVAL_SKIP
)
2603 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2604 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2606 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2607 value_as_address (arg1
));
2609 case UNOP_MEMVAL_TYPE
:
2610 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2611 type
= value_type (arg1
);
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 (type
, lval_memory
);
2618 return value_at_lazy (type
, value_as_address (arg1
));
2620 case UNOP_MEMVAL_TLS
:
2622 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2623 if (noside
== EVAL_SKIP
)
2625 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2626 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2631 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2632 value_as_address (arg1
));
2633 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2636 case UNOP_PREINCREMENT
:
2637 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2638 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2640 else if (unop_user_defined_p (op
, arg1
))
2642 return value_x_unop (arg1
, op
, noside
);
2646 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2647 arg2
= value_ptradd (arg1
, 1);
2650 struct value
*tmp
= arg1
;
2652 arg2
= value_one (value_type (arg1
));
2653 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2654 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2657 return value_assign (arg1
, arg2
);
2660 case UNOP_PREDECREMENT
:
2661 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2662 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2664 else if (unop_user_defined_p (op
, arg1
))
2666 return value_x_unop (arg1
, op
, noside
);
2670 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2671 arg2
= value_ptradd (arg1
, -1);
2674 struct value
*tmp
= arg1
;
2676 arg2
= value_one (value_type (arg1
));
2677 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2678 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2681 return value_assign (arg1
, arg2
);
2684 case UNOP_POSTINCREMENT
:
2685 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2686 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2688 else if (unop_user_defined_p (op
, arg1
))
2690 return value_x_unop (arg1
, op
, noside
);
2694 arg3
= value_non_lval (arg1
);
2696 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2697 arg2
= value_ptradd (arg1
, 1);
2700 struct value
*tmp
= arg1
;
2702 arg2
= value_one (value_type (arg1
));
2703 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2704 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2707 value_assign (arg1
, arg2
);
2711 case UNOP_POSTDECREMENT
:
2712 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2713 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2715 else if (unop_user_defined_p (op
, arg1
))
2717 return value_x_unop (arg1
, op
, noside
);
2721 arg3
= value_non_lval (arg1
);
2723 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2724 arg2
= value_ptradd (arg1
, -1);
2727 struct value
*tmp
= arg1
;
2729 arg2
= value_one (value_type (arg1
));
2730 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2731 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2734 value_assign (arg1
, arg2
);
2740 return value_of_this (exp
->language_defn
);
2743 /* The value is not supposed to be used. This is here to make it
2744 easier to accommodate expressions that contain types. */
2746 if (noside
== EVAL_SKIP
)
2748 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2750 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2752 /* If this is a typedef, then find its immediate target. We
2753 use check_typedef to resolve stubs, but we ignore its
2754 result because we do not want to dig past all
2756 check_typedef (type
);
2757 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2758 type
= TYPE_TARGET_TYPE (type
);
2759 return allocate_value (type
);
2762 error (_("Attempt to use a type name as an expression"));
2766 if (noside
== EVAL_SKIP
)
2768 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2771 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2773 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2774 struct value
*result
;
2776 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2777 EVAL_AVOID_SIDE_EFFECTS
);
2779 /* 'decltype' has special semantics for lvalues. */
2780 if (op
== OP_DECLTYPE
2781 && (sub_op
== BINOP_SUBSCRIPT
2782 || sub_op
== STRUCTOP_MEMBER
2783 || sub_op
== STRUCTOP_MPTR
2784 || sub_op
== UNOP_IND
2785 || sub_op
== STRUCTOP_STRUCT
2786 || sub_op
== STRUCTOP_PTR
2787 || sub_op
== OP_SCOPE
))
2789 struct type
*type
= value_type (result
);
2791 if (TYPE_CODE (check_typedef (type
)) != TYPE_CODE_REF
)
2793 type
= lookup_reference_type (type
);
2794 result
= allocate_value (type
);
2801 error (_("Attempt to use a type as an expression"));
2805 struct value
*result
;
2806 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2808 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2809 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2810 EVAL_AVOID_SIDE_EFFECTS
);
2812 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2814 if (noside
!= EVAL_NORMAL
)
2815 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2817 return cplus_typeid (result
);
2821 /* Removing this case and compiling with gcc -Wall reveals that
2822 a lot of cases are hitting this case. Some of these should
2823 probably be removed from expression.h; others are legitimate
2824 expressions which are (apparently) not fully implemented.
2826 If there are any cases landing here which mean a user error,
2827 then they should be separate cases, with more descriptive
2830 error (_("GDB does not (yet) know how to "
2831 "evaluate that kind of expression"));
2835 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2838 /* Evaluate a subexpression of EXP, at index *POS,
2839 and return the address of that subexpression.
2840 Advance *POS over the subexpression.
2841 If the subexpression isn't an lvalue, get an error.
2842 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2843 then only the type of the result need be correct. */
2845 static struct value
*
2846 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2856 op
= exp
->elts
[pc
].opcode
;
2862 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2864 /* We can't optimize out "&*" if there's a user-defined operator*. */
2865 if (unop_user_defined_p (op
, x
))
2867 x
= value_x_unop (x
, op
, noside
);
2868 goto default_case_after_eval
;
2871 return coerce_array (x
);
2875 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2876 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2878 case UNOP_MEMVAL_TYPE
:
2883 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2884 type
= value_type (x
);
2885 return value_cast (lookup_pointer_type (type
),
2886 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2890 var
= exp
->elts
[pc
+ 2].symbol
;
2892 /* C++: The "address" of a reference should yield the address
2893 * of the object pointed to. Let value_addr() deal with it. */
2894 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2898 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2901 lookup_pointer_type (SYMBOL_TYPE (var
));
2902 enum address_class sym_class
= SYMBOL_CLASS (var
);
2904 if (sym_class
== LOC_CONST
2905 || sym_class
== LOC_CONST_BYTES
2906 || sym_class
== LOC_REGISTER
)
2907 error (_("Attempt to take address of register or constant."));
2910 value_zero (type
, not_lval
);
2913 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2916 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2917 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2918 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2919 &exp
->elts
[pc
+ 3].string
,
2922 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2927 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2928 default_case_after_eval
:
2929 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2931 struct type
*type
= check_typedef (value_type (x
));
2933 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2934 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2936 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2937 return value_zero (lookup_pointer_type (value_type (x
)),
2940 error (_("Attempt to take address of "
2941 "value not located in memory."));
2943 return value_addr (x
);
2947 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2948 When used in contexts where arrays will be coerced anyway, this is
2949 equivalent to `evaluate_subexp' but much faster because it avoids
2950 actually fetching array contents (perhaps obsolete now that we have
2953 Note that we currently only do the coercion for C expressions, where
2954 arrays are zero based and the coercion is correct. For other languages,
2955 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2956 to decide if coercion is appropriate. */
2959 evaluate_subexp_with_coercion (struct expression
*exp
,
2960 int *pos
, enum noside noside
)
2969 op
= exp
->elts
[pc
].opcode
;
2974 var
= exp
->elts
[pc
+ 2].symbol
;
2975 type
= check_typedef (SYMBOL_TYPE (var
));
2976 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2977 && !TYPE_VECTOR (type
)
2978 && CAST_IS_CONVERSION (exp
->language_defn
))
2981 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2982 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2988 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2992 /* Evaluate a subexpression of EXP, at index *POS,
2993 and return a value for the size of that subexpression.
2994 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2995 we allow side-effects on the operand if its type is a variable
2998 static struct value
*
2999 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3002 /* FIXME: This should be size_t. */
3003 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3010 op
= exp
->elts
[pc
].opcode
;
3014 /* This case is handled specially
3015 so that we avoid creating a value for the result type.
3016 If the result type is very big, it's desirable not to
3017 create a value unnecessarily. */
3020 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3021 type
= check_typedef (value_type (val
));
3022 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3023 && TYPE_CODE (type
) != TYPE_CODE_REF
3024 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3025 error (_("Attempt to take contents of a non-pointer value."));
3026 type
= TYPE_TARGET_TYPE (type
);
3027 if (is_dynamic_type (type
))
3028 type
= value_type (value_ind (val
));
3029 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3033 type
= exp
->elts
[pc
+ 1].type
;
3036 case UNOP_MEMVAL_TYPE
:
3038 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3039 type
= value_type (val
);
3043 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3044 if (is_dynamic_type (type
))
3046 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3047 type
= value_type (val
);
3053 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3054 type of the subscript is a variable length array type. In this case we
3055 must re-evaluate the right hand side of the subcription to allow
3057 case BINOP_SUBSCRIPT
:
3058 if (noside
== EVAL_NORMAL
)
3060 int pc
= (*pos
) + 1;
3062 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3063 type
= check_typedef (value_type (val
));
3064 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3066 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3067 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3069 type
= TYPE_INDEX_TYPE (type
);
3070 /* Only re-evaluate the right hand side if the resulting type
3071 is a variable length type. */
3072 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3074 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3075 return value_from_longest
3076 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3085 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3086 type
= value_type (val
);
3090 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3091 "When applied to a reference or a reference type, the result is
3092 the size of the referenced type." */
3093 type
= check_typedef (type
);
3094 if (exp
->language_defn
->la_language
== language_cplus
3095 && TYPE_CODE (type
) == TYPE_CODE_REF
)
3096 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3097 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3100 /* Parse a type expression in the string [P..P+LENGTH). */
3103 parse_and_eval_type (char *p
, int length
)
3105 char *tmp
= (char *) alloca (length
+ 4);
3106 struct expression
*expr
;
3109 memcpy (tmp
+ 1, p
, length
);
3110 tmp
[length
+ 1] = ')';
3111 tmp
[length
+ 2] = '0';
3112 tmp
[length
+ 3] = '\0';
3113 expr
= parse_expression (tmp
);
3114 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3115 error (_("Internal error in eval_type."));
3116 return expr
->elts
[1].type
;
3120 calc_f77_array_dims (struct type
*array_type
)
3123 struct type
*tmp_type
;
3125 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3126 error (_("Can't get dimensions for a non-array type"));
3128 tmp_type
= array_type
;
3130 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3132 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)