1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "expression.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
29 #include "f-lang.h" /* For array bound stuff. */
32 #include "objc-lang.h"
34 #include "parser-defs.h"
35 #include "cp-support.h"
37 #include "exceptions.h"
39 #include "user-regs.h"
41 #include "gdb_obstack.h"
44 #include "gdb_assert.h"
48 /* This is defined in valops.c */
49 extern int overload_resolution
;
51 /* Prototypes for local functions. */
53 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
56 static struct value
*evaluate_subexp_for_address (struct expression
*,
59 static struct value
*evaluate_struct_tuple (struct value
*,
60 struct expression
*, int *,
63 static LONGEST
init_array_element (struct value
*, struct value
*,
64 struct expression
*, int *, enum noside
,
68 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
69 int *pos
, enum noside noside
)
71 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
72 (expect_type
, exp
, pos
, noside
);
75 /* Parse the string EXP as a C expression, evaluate it,
76 and return the result as a number. */
79 parse_and_eval_address (const char *exp
)
81 struct expression
*expr
= parse_expression (exp
);
83 struct cleanup
*old_chain
=
84 make_cleanup (free_current_contents
, &expr
);
86 addr
= value_as_address (evaluate_expression (expr
));
87 do_cleanups (old_chain
);
91 /* Like parse_and_eval_address, but treats the value of the expression
92 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
94 parse_and_eval_long (const char *exp
)
96 struct expression
*expr
= parse_expression (exp
);
98 struct cleanup
*old_chain
=
99 make_cleanup (free_current_contents
, &expr
);
101 retval
= value_as_long (evaluate_expression (expr
));
102 do_cleanups (old_chain
);
107 parse_and_eval (const char *exp
)
109 struct expression
*expr
= parse_expression (exp
);
111 struct cleanup
*old_chain
=
112 make_cleanup (free_current_contents
, &expr
);
114 val
= evaluate_expression (expr
);
115 do_cleanups (old_chain
);
119 /* Parse up to a comma (or to a closeparen)
120 in the string EXPP as an expression, evaluate it, and return the value.
121 EXPP is advanced to point to the comma. */
124 parse_to_comma_and_eval (const char **expp
)
126 struct expression
*expr
= parse_exp_1 (expp
, 0, (struct block
*) 0, 1);
128 struct cleanup
*old_chain
=
129 make_cleanup (free_current_contents
, &expr
);
131 val
= evaluate_expression (expr
);
132 do_cleanups (old_chain
);
136 /* Evaluate an expression in internal prefix form
137 such as is constructed by parse.y.
139 See expression.h for info on the format of an expression. */
142 evaluate_expression (struct expression
*exp
)
146 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
149 /* Evaluate an expression, avoiding all memory references
150 and getting a value whose type alone is correct. */
153 evaluate_type (struct expression
*exp
)
157 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
160 /* Evaluate a subexpression, avoiding all memory references and
161 getting a value whose type alone is correct. */
164 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
166 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
169 /* Find the current value of a watchpoint on EXP. Return the value in
170 *VALP and *RESULTP and the chain of intermediate and final values
171 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
174 If PRESERVE_ERRORS is true, then exceptions are passed through.
175 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
176 occurs while evaluating the expression, *RESULTP will be set to
177 NULL. *RESULTP may be a lazy value, if the result could not be
178 read from memory. It is used to determine whether a value is
179 user-specified (we should watch the whole value) or intermediate
180 (we should watch only the bit used to locate the final value).
182 If the final value, or any intermediate value, could not be read
183 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
184 set to any referenced values. *VALP will never be a lazy value.
185 This is the value which we store in struct breakpoint.
187 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
188 value chain. The caller must free the values individually. If
189 VAL_CHAIN is NULL, all generated values will be left on the value
193 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
194 struct value
**resultp
, struct value
**val_chain
,
197 struct value
*mark
, *new_mark
, *result
;
198 volatile struct gdb_exception ex
;
206 /* Evaluate the expression. */
207 mark
= value_mark ();
210 TRY_CATCH (ex
, RETURN_MASK_ALL
)
212 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
216 /* Ignore memory errors if we want watchpoints pointing at
217 inaccessible memory to still be created; otherwise, throw the
218 error to some higher catcher. */
222 if (!preserve_errors
)
225 throw_exception (ex
);
230 new_mark
= value_mark ();
231 if (mark
== new_mark
)
236 /* Make sure it's not lazy, so that after the target stops again we
237 have a non-lazy previous value to compare with. */
240 if (!value_lazy (result
))
244 volatile struct gdb_exception except
;
246 TRY_CATCH (except
, RETURN_MASK_ERROR
)
248 value_fetch_lazy (result
);
256 /* Return the chain of intermediate values. We use this to
257 decide which addresses to watch. */
258 *val_chain
= new_mark
;
259 value_release_to_mark (mark
);
263 /* Extract a field operation from an expression. If the subexpression
264 of EXP starting at *SUBEXP is not a structure dereference
265 operation, return NULL. Otherwise, return the name of the
266 dereferenced field, and advance *SUBEXP to point to the
267 subexpression of the left-hand-side of the dereference. This is
268 used when completing field names. */
271 extract_field_op (struct expression
*exp
, int *subexp
)
276 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
277 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
279 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
280 result
= &exp
->elts
[*subexp
+ 2].string
;
281 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
285 /* This function evaluates brace-initializers (in C/C++) for
288 static struct value
*
289 evaluate_struct_tuple (struct value
*struct_val
,
290 struct expression
*exp
,
291 int *pos
, enum noside noside
, int nargs
)
293 struct type
*struct_type
= check_typedef (value_type (struct_val
));
294 struct type
*field_type
;
299 struct value
*val
= NULL
;
304 /* Skip static fields. */
305 while (fieldno
< TYPE_NFIELDS (struct_type
)
306 && field_is_static (&TYPE_FIELD (struct_type
,
309 if (fieldno
>= TYPE_NFIELDS (struct_type
))
310 error (_("too many initializers"));
311 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
312 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
313 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
314 error (_("don't know which variant you want to set"));
316 /* Here, struct_type is the type of the inner struct,
317 while substruct_type is the type of the inner struct.
318 These are the same for normal structures, but a variant struct
319 contains anonymous union fields that contain substruct fields.
320 The value fieldno is the index of the top-level (normal or
321 anonymous union) field in struct_field, while the value
322 subfieldno is the index of the actual real (named inner) field
323 in substruct_type. */
325 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
327 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
329 /* Now actually set the field in struct_val. */
331 /* Assign val to field fieldno. */
332 if (value_type (val
) != field_type
)
333 val
= value_cast (field_type
, val
);
335 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
336 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
337 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
339 modify_field (struct_type
, addr
,
340 value_as_long (val
), bitpos
% 8, bitsize
);
342 memcpy (addr
, value_contents (val
),
343 TYPE_LENGTH (value_type (val
)));
349 /* Recursive helper function for setting elements of array tuples for
350 (the deleted) Chill. The target is ARRAY (which has bounds
351 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
352 and NOSIDE are as usual. Evaluates index expresions and sets the
353 specified element(s) of ARRAY to ELEMENT. Returns last index
357 init_array_element (struct value
*array
, struct value
*element
,
358 struct expression
*exp
, int *pos
,
359 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
362 int element_size
= TYPE_LENGTH (value_type (element
));
364 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
367 init_array_element (array
, element
, exp
, pos
, noside
,
368 low_bound
, high_bound
);
369 return init_array_element (array
, element
,
370 exp
, pos
, noside
, low_bound
, high_bound
);
374 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
375 if (index
< low_bound
|| index
> high_bound
)
376 error (_("tuple index out of range"));
377 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
378 value_contents (element
), element_size
);
383 static struct value
*
384 value_f90_subarray (struct value
*array
,
385 struct expression
*exp
, int *pos
, enum noside noside
)
388 LONGEST low_bound
, high_bound
;
389 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
390 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
394 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
395 low_bound
= TYPE_LOW_BOUND (range
);
397 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
399 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
400 high_bound
= TYPE_HIGH_BOUND (range
);
402 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
404 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
408 /* Promote value ARG1 as appropriate before performing a unary operation
410 If the result is not appropriate for any particular language then it
411 needs to patch this function. */
414 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
419 *arg1
= coerce_ref (*arg1
);
420 type1
= check_typedef (value_type (*arg1
));
422 if (is_integral_type (type1
))
424 switch (language
->la_language
)
427 /* Perform integral promotion for ANSI C/C++.
428 If not appropropriate for any particular language
429 it needs to modify this function. */
431 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
433 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
434 *arg1
= value_cast (builtin_int
, *arg1
);
441 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
442 operation on those two operands.
443 If the result is not appropriate for any particular language then it
444 needs to patch this function. */
447 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
448 struct value
**arg1
, struct value
**arg2
)
450 struct type
*promoted_type
= NULL
;
454 *arg1
= coerce_ref (*arg1
);
455 *arg2
= coerce_ref (*arg2
);
457 type1
= check_typedef (value_type (*arg1
));
458 type2
= check_typedef (value_type (*arg2
));
460 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
461 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
462 && !is_integral_type (type1
))
463 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
464 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
465 && !is_integral_type (type2
)))
468 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
469 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
471 /* No promotion required. */
473 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
474 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
476 switch (language
->la_language
)
482 case language_opencl
:
483 /* No promotion required. */
487 /* For other languages the result type is unchanged from gdb
488 version 6.7 for backward compatibility.
489 If either arg was long double, make sure that value is also long
490 double. Otherwise use double. */
491 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
492 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
493 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
495 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
499 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
500 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
502 /* No promotion required. */
505 /* Integral operations here. */
506 /* FIXME: Also mixed integral/booleans, with result an integer. */
508 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
509 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
510 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
511 int is_unsigned1
= TYPE_UNSIGNED (type1
);
512 int is_unsigned2
= TYPE_UNSIGNED (type2
);
513 unsigned int result_len
;
514 int unsigned_operation
;
516 /* Determine type length and signedness after promotion for
518 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
521 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
523 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
526 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
529 if (promoted_len1
> promoted_len2
)
531 unsigned_operation
= is_unsigned1
;
532 result_len
= promoted_len1
;
534 else if (promoted_len2
> promoted_len1
)
536 unsigned_operation
= is_unsigned2
;
537 result_len
= promoted_len2
;
541 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
542 result_len
= promoted_len1
;
545 switch (language
->la_language
)
551 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
553 promoted_type
= (unsigned_operation
554 ? builtin
->builtin_unsigned_int
555 : builtin
->builtin_int
);
557 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
559 promoted_type
= (unsigned_operation
560 ? builtin
->builtin_unsigned_long
561 : builtin
->builtin_long
);
565 promoted_type
= (unsigned_operation
566 ? builtin
->builtin_unsigned_long_long
567 : builtin
->builtin_long_long
);
570 case language_opencl
:
571 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
572 (language
, gdbarch
, "int")))
576 ? lookup_unsigned_typename (language
, gdbarch
, "int")
577 : lookup_signed_typename (language
, gdbarch
, "int"));
579 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
580 (language
, gdbarch
, "long")))
584 ? lookup_unsigned_typename (language
, gdbarch
, "long")
585 : lookup_signed_typename (language
, gdbarch
,"long"));
589 /* For other languages the result type is unchanged from gdb
590 version 6.7 for backward compatibility.
591 If either arg was long long, make sure that value is also long
592 long. Otherwise use long. */
593 if (unsigned_operation
)
595 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
596 promoted_type
= builtin
->builtin_unsigned_long_long
;
598 promoted_type
= builtin
->builtin_unsigned_long
;
602 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
603 promoted_type
= builtin
->builtin_long_long
;
605 promoted_type
= builtin
->builtin_long
;
613 /* Promote both operands to common type. */
614 *arg1
= value_cast (promoted_type
, *arg1
);
615 *arg2
= value_cast (promoted_type
, *arg2
);
620 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
622 type
= check_typedef (type
);
623 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
624 type
= TYPE_TARGET_TYPE (type
);
626 switch (TYPE_CODE (type
))
632 case TYPE_CODE_ARRAY
:
633 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
640 /* Constructs a fake method with the given parameter types.
641 This function is used by the parser to construct an "expected"
642 type for method overload resolution. */
645 make_params (int num_types
, struct type
**param_types
)
647 struct type
*type
= XCNEW (struct type
);
648 TYPE_MAIN_TYPE (type
) = XCNEW (struct main_type
);
649 TYPE_LENGTH (type
) = 1;
650 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
651 TYPE_VPTR_FIELDNO (type
) = -1;
652 TYPE_CHAIN (type
) = type
;
655 if (param_types
[num_types
- 1] == NULL
)
658 TYPE_VARARGS (type
) = 1;
660 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
664 /* Caller should have ensured this. */
665 gdb_assert (num_types
== 0);
666 TYPE_PROTOTYPED (type
) = 1;
670 TYPE_NFIELDS (type
) = num_types
;
671 TYPE_FIELDS (type
) = (struct field
*)
672 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
674 while (num_types
-- > 0)
675 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
681 evaluate_subexp_standard (struct type
*expect_type
,
682 struct expression
*exp
, int *pos
,
687 int pc
, pc2
= 0, oldpos
;
688 struct value
*arg1
= NULL
;
689 struct value
*arg2
= NULL
;
693 struct value
**argvec
;
697 struct type
**arg_types
;
699 struct symbol
*function
= NULL
;
700 char *function_name
= NULL
;
703 op
= exp
->elts
[pc
].opcode
;
708 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
709 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
710 if (noside
== EVAL_SKIP
)
712 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
713 &exp
->elts
[pc
+ 3].string
,
714 expect_type
, 0, noside
);
716 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
721 return value_from_longest (exp
->elts
[pc
+ 1].type
,
722 exp
->elts
[pc
+ 2].longconst
);
726 return value_from_double (exp
->elts
[pc
+ 1].type
,
727 exp
->elts
[pc
+ 2].doubleconst
);
731 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
732 exp
->elts
[pc
+ 2].decfloatconst
);
737 if (noside
== EVAL_SKIP
)
740 /* JYG: We used to just return value_zero of the symbol type
741 if we're asked to avoid side effects. Otherwise we return
742 value_of_variable (...). However I'm not sure if
743 value_of_variable () has any side effect.
744 We need a full value object returned here for whatis_exp ()
745 to call evaluate_type () and then pass the full value to
746 value_rtti_target_type () if we are dealing with a pointer
747 or reference to a base class and print object is on. */
750 volatile struct gdb_exception except
;
751 struct value
*ret
= NULL
;
753 TRY_CATCH (except
, RETURN_MASK_ERROR
)
755 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
756 exp
->elts
[pc
+ 1].block
);
759 if (except
.reason
< 0)
761 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
762 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
765 throw_exception (except
);
771 case OP_VAR_ENTRY_VALUE
:
773 if (noside
== EVAL_SKIP
)
777 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
778 struct frame_info
*frame
;
780 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
781 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
783 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
784 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
785 error (_("Symbol \"%s\" does not have any specific entry value"),
786 SYMBOL_PRINT_NAME (sym
));
788 frame
= get_selected_frame (NULL
);
789 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
795 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
799 const char *name
= &exp
->elts
[pc
+ 2].string
;
803 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
804 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
805 name
, strlen (name
));
807 error (_("Register $%s not available."), name
);
809 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
810 a value with the appropriate register type. Unfortunately,
811 we don't have easy access to the type of user registers.
812 So for these registers, we fetch the register value regardless
813 of the evaluation mode. */
814 if (noside
== EVAL_AVOID_SIDE_EFFECTS
815 && regno
< gdbarch_num_regs (exp
->gdbarch
)
816 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
817 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
819 val
= value_of_register (regno
, get_selected_frame (NULL
));
821 error (_("Value of register %s not available."), name
);
827 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
828 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
832 return value_of_internalvar (exp
->gdbarch
,
833 exp
->elts
[pc
+ 1].internalvar
);
836 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
837 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
838 if (noside
== EVAL_SKIP
)
840 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
841 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
843 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
844 NSString constant. */
845 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
846 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
847 if (noside
== EVAL_SKIP
)
851 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
855 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
856 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
857 nargs
= tem3
- tem2
+ 1;
858 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
860 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
861 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
863 struct value
*rec
= allocate_value (expect_type
);
865 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
866 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
869 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
870 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
872 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
873 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
874 struct value
*array
= allocate_value (expect_type
);
875 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
876 LONGEST low_bound
, high_bound
, index
;
878 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
881 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
884 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
885 for (tem
= nargs
; --nargs
>= 0;)
887 struct value
*element
;
890 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
891 if (value_type (element
) != element_type
)
892 element
= value_cast (element_type
, element
);
895 int continue_pc
= *pos
;
898 index
= init_array_element (array
, element
, exp
, pos
, noside
,
899 low_bound
, high_bound
);
904 if (index
> high_bound
)
905 /* To avoid memory corruption. */
906 error (_("Too many array elements"));
907 memcpy (value_contents_raw (array
)
908 + (index
- low_bound
) * element_size
,
909 value_contents (element
),
917 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
918 && TYPE_CODE (type
) == TYPE_CODE_SET
)
920 struct value
*set
= allocate_value (expect_type
);
921 gdb_byte
*valaddr
= value_contents_raw (set
);
922 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
923 struct type
*check_type
= element_type
;
924 LONGEST low_bound
, high_bound
;
926 /* Get targettype of elementtype. */
927 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
928 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
929 check_type
= TYPE_TARGET_TYPE (check_type
);
931 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
932 error (_("(power)set type with unknown size"));
933 memset (valaddr
, '\0', TYPE_LENGTH (type
));
934 for (tem
= 0; tem
< nargs
; tem
++)
936 LONGEST range_low
, range_high
;
937 struct type
*range_low_type
, *range_high_type
;
938 struct value
*elem_val
;
940 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
941 range_low_type
= range_high_type
= value_type (elem_val
);
942 range_low
= range_high
= value_as_long (elem_val
);
944 /* Check types of elements to avoid mixture of elements from
945 different types. Also check if type of element is "compatible"
946 with element type of powerset. */
947 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
948 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
949 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
950 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
951 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
952 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
953 && (range_low_type
!= range_high_type
)))
954 /* different element modes. */
955 error (_("POWERSET tuple elements of different mode"));
956 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
957 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
958 && range_low_type
!= check_type
))
959 error (_("incompatible POWERSET tuple elements"));
960 if (range_low
> range_high
)
962 warning (_("empty POWERSET tuple range"));
965 if (range_low
< low_bound
|| range_high
> high_bound
)
966 error (_("POWERSET tuple element out of range"));
967 range_low
-= low_bound
;
968 range_high
-= low_bound
;
969 for (; range_low
<= range_high
; range_low
++)
971 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
973 if (gdbarch_bits_big_endian (exp
->gdbarch
))
974 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
975 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
982 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
983 for (tem
= 0; tem
< nargs
; tem
++)
985 /* Ensure that array expressions are coerced into pointer
987 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
989 if (noside
== EVAL_SKIP
)
991 return value_array (tem2
, tem3
, argvec
);
995 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
997 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
999 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1001 if (noside
== EVAL_SKIP
)
1003 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1007 /* Skip third and second args to evaluate the first one. */
1008 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1009 if (value_logical_not (arg1
))
1011 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1012 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1016 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1017 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1021 case OP_OBJC_SELECTOR
:
1022 { /* Objective C @selector operator. */
1023 char *sel
= &exp
->elts
[pc
+ 2].string
;
1024 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1025 struct type
*selector_type
;
1027 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1028 if (noside
== EVAL_SKIP
)
1032 sel
[len
] = 0; /* Make sure it's terminated. */
1034 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1035 return value_from_longest (selector_type
,
1036 lookup_child_selector (exp
->gdbarch
, sel
));
1039 case OP_OBJC_MSGCALL
:
1040 { /* Objective C message (method) call. */
1042 CORE_ADDR responds_selector
= 0;
1043 CORE_ADDR method_selector
= 0;
1045 CORE_ADDR selector
= 0;
1047 int struct_return
= 0;
1048 int sub_no_side
= 0;
1050 struct value
*msg_send
= NULL
;
1051 struct value
*msg_send_stret
= NULL
;
1052 int gnu_runtime
= 0;
1054 struct value
*target
= NULL
;
1055 struct value
*method
= NULL
;
1056 struct value
*called_method
= NULL
;
1058 struct type
*selector_type
= NULL
;
1059 struct type
*long_type
;
1061 struct value
*ret
= NULL
;
1064 selector
= exp
->elts
[pc
+ 1].longconst
;
1065 nargs
= exp
->elts
[pc
+ 2].longconst
;
1066 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1071 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1072 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1074 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1075 sub_no_side
= EVAL_NORMAL
;
1077 sub_no_side
= noside
;
1079 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1081 if (value_as_long (target
) == 0)
1082 return value_from_longest (long_type
, 0);
1084 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1087 /* Find the method dispatch (Apple runtime) or method lookup
1088 (GNU runtime) function for Objective-C. These will be used
1089 to lookup the symbol information for the method. If we
1090 can't find any symbol information, then we'll use these to
1091 call the method, otherwise we can call the method
1092 directly. The msg_send_stret function is used in the special
1093 case of a method that returns a structure (Apple runtime
1097 struct type
*type
= selector_type
;
1099 type
= lookup_function_type (type
);
1100 type
= lookup_pointer_type (type
);
1101 type
= lookup_function_type (type
);
1102 type
= lookup_pointer_type (type
);
1104 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1106 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1108 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1109 msg_send_stret
= value_from_pointer (type
,
1110 value_as_address (msg_send_stret
));
1114 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1115 /* Special dispatcher for methods returning structs. */
1117 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1120 /* Verify the target object responds to this method. The
1121 standard top-level 'Object' class uses a different name for
1122 the verification method than the non-standard, but more
1123 often used, 'NSObject' class. Make sure we check for both. */
1126 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1127 if (responds_selector
== 0)
1129 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1131 if (responds_selector
== 0)
1132 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1135 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1136 if (method_selector
== 0)
1138 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1140 if (method_selector
== 0)
1141 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1143 /* Call the verification method, to make sure that the target
1144 class implements the desired method. */
1146 argvec
[0] = msg_send
;
1148 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1149 argvec
[3] = value_from_longest (long_type
, selector
);
1152 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1155 /* Function objc_msg_lookup returns a pointer. */
1157 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1159 if (value_as_long (ret
) == 0)
1160 error (_("Target does not respond to this message selector."));
1162 /* Call "methodForSelector:" method, to get the address of a
1163 function method that implements this selector for this
1164 class. If we can find a symbol at that address, then we
1165 know the return type, parameter types etc. (that's a good
1168 argvec
[0] = msg_send
;
1170 argvec
[2] = value_from_longest (long_type
, method_selector
);
1171 argvec
[3] = value_from_longest (long_type
, selector
);
1174 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1178 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1181 /* ret should now be the selector. */
1183 addr
= value_as_long (ret
);
1186 struct symbol
*sym
= NULL
;
1188 /* The address might point to a function descriptor;
1189 resolve it to the actual code address instead. */
1190 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1193 /* Is it a high_level symbol? */
1194 sym
= find_pc_function (addr
);
1196 method
= value_of_variable (sym
, 0);
1199 /* If we found a method with symbol information, check to see
1200 if it returns a struct. Otherwise assume it doesn't. */
1205 struct type
*val_type
;
1207 funaddr
= find_function_addr (method
, &val_type
);
1209 block_for_pc (funaddr
);
1211 CHECK_TYPEDEF (val_type
);
1213 if ((val_type
== NULL
)
1214 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1216 if (expect_type
!= NULL
)
1217 val_type
= expect_type
;
1220 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1223 else if (expect_type
!= NULL
)
1225 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1226 check_typedef (expect_type
));
1229 /* Found a function symbol. Now we will substitute its
1230 value in place of the message dispatcher (obj_msgSend),
1231 so that we call the method directly instead of thru
1232 the dispatcher. The main reason for doing this is that
1233 we can now evaluate the return value and parameter values
1234 according to their known data types, in case we need to
1235 do things like promotion, dereferencing, special handling
1236 of structs and doubles, etc.
1238 We want to use the type signature of 'method', but still
1239 jump to objc_msgSend() or objc_msgSend_stret() to better
1240 mimic the behavior of the runtime. */
1244 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1245 error (_("method address has symbol information "
1246 "with non-function type; skipping"));
1248 /* Create a function pointer of the appropriate type, and
1249 replace its value with the value of msg_send or
1250 msg_send_stret. We must use a pointer here, as
1251 msg_send and msg_send_stret are of pointer type, and
1252 the representation may be different on systems that use
1253 function descriptors. */
1256 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1257 value_as_address (msg_send_stret
));
1260 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1261 value_as_address (msg_send
));
1266 called_method
= msg_send_stret
;
1268 called_method
= msg_send
;
1271 if (noside
== EVAL_SKIP
)
1274 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1276 /* If the return type doesn't look like a function type,
1277 call an error. This can happen if somebody tries to
1278 turn a variable into a function call. This is here
1279 because people often want to call, eg, strcmp, which
1280 gdb doesn't know is a function. If gdb isn't asked for
1281 it's opinion (ie. through "whatis"), it won't offer
1284 struct type
*type
= value_type (called_method
);
1286 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1287 type
= TYPE_TARGET_TYPE (type
);
1288 type
= TYPE_TARGET_TYPE (type
);
1292 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1293 return allocate_value (expect_type
);
1295 return allocate_value (type
);
1298 error (_("Expression of type other than "
1299 "\"method returning ...\" used as a method"));
1302 /* Now depending on whether we found a symbol for the method,
1303 we will either call the runtime dispatcher or the method
1306 argvec
[0] = called_method
;
1308 argvec
[2] = value_from_longest (long_type
, selector
);
1309 /* User-supplied arguments. */
1310 for (tem
= 0; tem
< nargs
; tem
++)
1311 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1312 argvec
[tem
+ 3] = 0;
1314 if (gnu_runtime
&& (method
!= NULL
))
1316 /* Function objc_msg_lookup returns a pointer. */
1317 deprecated_set_value_type (argvec
[0],
1318 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1320 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1323 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1330 op
= exp
->elts
[*pos
].opcode
;
1331 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1332 /* Allocate arg vector, including space for the function to be
1333 called in argvec[0], a potential `this', and a terminating NULL. */
1334 argvec
= (struct value
**)
1335 alloca (sizeof (struct value
*) * (nargs
+ 3));
1336 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1338 /* First, evaluate the structure into arg2. */
1341 if (noside
== EVAL_SKIP
)
1344 if (op
== STRUCTOP_MEMBER
)
1346 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1350 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1353 /* If the function is a virtual function, then the
1354 aggregate value (providing the structure) plays
1355 its part by providing the vtable. Otherwise,
1356 it is just along for the ride: call the function
1359 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1361 type
= check_typedef (value_type (arg1
));
1362 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
)
1364 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1365 arg1
= value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1367 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1369 /* Now, say which argument to start evaluating from. */
1374 else if (TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1376 struct type
*type_ptr
1377 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type
));
1378 struct type
*target_type_ptr
1379 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1381 /* Now, convert these values to an address. */
1382 arg2
= value_cast (type_ptr
, arg2
);
1384 mem_offset
= value_as_long (arg1
);
1386 arg1
= value_from_pointer (target_type_ptr
,
1387 value_as_long (arg2
) + mem_offset
);
1388 arg1
= value_ind (arg1
);
1392 error (_("Non-pointer-to-member value used in pointer-to-member "
1395 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1397 /* Hair for method invocations. */
1401 /* First, evaluate the structure into arg2. */
1403 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1404 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1405 if (noside
== EVAL_SKIP
)
1408 if (op
== STRUCTOP_STRUCT
)
1410 /* If v is a variable in a register, and the user types
1411 v.method (), this will produce an error, because v has
1414 A possible way around this would be to allocate a
1415 copy of the variable on the stack, copy in the
1416 contents, call the function, and copy out the
1417 contents. I.e. convert this from call by reference
1418 to call by copy-return (or whatever it's called).
1419 However, this does not work because it is not the
1420 same: the method being called could stash a copy of
1421 the address, and then future uses through that address
1422 (after the method returns) would be expected to
1423 use the variable itself, not some copy of it. */
1424 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1428 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1430 /* Check to see if the operator '->' has been
1431 overloaded. If the operator has been overloaded
1432 replace arg2 with the value returned by the custom
1433 operator and continue evaluation. */
1434 while (unop_user_defined_p (op
, arg2
))
1436 volatile struct gdb_exception except
;
1437 struct value
*value
= NULL
;
1438 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1440 value
= value_x_unop (arg2
, op
, noside
);
1443 if (except
.reason
< 0)
1445 if (except
.error
== NOT_FOUND_ERROR
)
1448 throw_exception (except
);
1453 /* Now, say which argument to start evaluating from. */
1456 else if (op
== OP_SCOPE
1457 && overload_resolution
1458 && (exp
->language_defn
->la_language
== language_cplus
))
1460 /* Unpack it locally so we can properly handle overload
1466 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1467 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1468 type
= exp
->elts
[pc2
+ 1].type
;
1469 name
= &exp
->elts
[pc2
+ 3].string
;
1472 function_name
= NULL
;
1473 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1475 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1477 get_selected_block (0),
1479 if (function
== NULL
)
1480 error (_("No symbol \"%s\" in namespace \"%s\"."),
1481 name
, TYPE_TAG_NAME (type
));
1484 /* arg2 is left as NULL on purpose. */
1488 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1489 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1490 function_name
= name
;
1492 /* We need a properly typed value for method lookup. For
1493 static methods arg2 is otherwise unused. */
1494 arg2
= value_zero (type
, lval_memory
);
1499 else if (op
== OP_ADL_FUNC
)
1501 /* Save the function position and move pos so that the arguments
1502 can be evaluated. */
1508 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1509 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1513 /* Non-method function call. */
1517 /* If this is a C++ function wait until overload resolution. */
1518 if (op
== OP_VAR_VALUE
1519 && overload_resolution
1520 && (exp
->language_defn
->la_language
== language_cplus
))
1522 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1527 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1528 type
= value_type (argvec
[0]);
1529 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1530 type
= TYPE_TARGET_TYPE (type
);
1531 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1533 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1535 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1543 /* Evaluate arguments (if not already done, e.g., namespace::func()
1544 and overload-resolution is off). */
1545 for (; tem
<= nargs
; tem
++)
1547 /* Ensure that array expressions are coerced into pointer
1549 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1552 /* Signal end of arglist. */
1555 if (op
== OP_ADL_FUNC
)
1557 struct symbol
*symp
;
1560 int string_pc
= save_pos1
+ 3;
1562 /* Extract the function name. */
1563 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1564 func_name
= (char *) alloca (name_len
+ 1);
1565 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1567 find_overload_match (&argvec
[1], nargs
, func_name
,
1568 NON_METHOD
, /* not method */
1569 NULL
, NULL
, /* pass NULL symbol since
1570 symbol is unknown */
1571 NULL
, &symp
, NULL
, 0);
1573 /* Now fix the expression being evaluated. */
1574 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1575 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1578 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1579 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1581 int static_memfuncp
;
1584 /* Method invocation: stuff "this" as first parameter.
1585 If the method turns out to be static we undo this below. */
1590 /* Name of method from expression. */
1591 tstr
= &exp
->elts
[pc2
+ 2].string
;
1594 tstr
= function_name
;
1596 if (overload_resolution
&& (exp
->language_defn
->la_language
1599 /* Language is C++, do some overload resolution before
1601 struct value
*valp
= NULL
;
1603 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1604 METHOD
, /* method */
1605 &arg2
, /* the object */
1607 &static_memfuncp
, 0);
1609 if (op
== OP_SCOPE
&& !static_memfuncp
)
1611 /* For the time being, we don't handle this. */
1612 error (_("Call to overloaded function %s requires "
1616 argvec
[1] = arg2
; /* the ``this'' pointer */
1617 argvec
[0] = valp
; /* Use the method found after overload
1621 /* Non-C++ case -- or no overload resolution. */
1623 struct value
*temp
= arg2
;
1625 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1627 op
== STRUCTOP_STRUCT
1628 ? "structure" : "structure pointer");
1629 /* value_struct_elt updates temp with the correct value
1630 of the ``this'' pointer if necessary, so modify argvec[1] to
1631 reflect any ``this'' changes. */
1633 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1634 value_address (temp
)
1635 + value_embedded_offset (temp
));
1636 argvec
[1] = arg2
; /* the ``this'' pointer */
1639 /* Take out `this' if needed. */
1640 if (static_memfuncp
)
1642 argvec
[1] = argvec
[0];
1647 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1649 /* Pointer to member. argvec[1] is already set up. */
1652 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1654 /* Non-member function being called. */
1655 /* fn: This can only be done for C++ functions. A C-style function
1656 in a C++ program, for instance, does not have the fields that
1657 are expected here. */
1659 if (overload_resolution
&& (exp
->language_defn
->la_language
1662 /* Language is C++, do some overload resolution before
1664 struct symbol
*symp
;
1667 /* If a scope has been specified disable ADL. */
1671 if (op
== OP_VAR_VALUE
)
1672 function
= exp
->elts
[save_pos1
+2].symbol
;
1674 (void) find_overload_match (&argvec
[1], nargs
,
1675 NULL
, /* no need for name */
1676 NON_METHOD
, /* not method */
1677 NULL
, function
, /* the function */
1678 NULL
, &symp
, NULL
, no_adl
);
1680 if (op
== OP_VAR_VALUE
)
1682 /* Now fix the expression being evaluated. */
1683 exp
->elts
[save_pos1
+2].symbol
= symp
;
1684 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1688 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1692 /* Not C++, or no overload resolution allowed. */
1693 /* Nothing to be done; argvec already correctly set up. */
1698 /* It is probably a C-style function. */
1699 /* Nothing to be done; argvec already correctly set up. */
1704 if (noside
== EVAL_SKIP
)
1706 if (argvec
[0] == NULL
)
1707 error (_("Cannot evaluate function -- may be inlined"));
1708 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1710 /* If the return type doesn't look like a function type, call an
1711 error. This can happen if somebody tries to turn a variable into
1712 a function call. This is here because people often want to
1713 call, eg, strcmp, which gdb doesn't know is a function. If
1714 gdb isn't asked for it's opinion (ie. through "whatis"),
1715 it won't offer it. */
1717 struct type
*ftype
= value_type (argvec
[0]);
1719 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1721 /* We don't know anything about what the internal
1722 function might return, but we have to return
1724 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1727 else if (TYPE_GNU_IFUNC (ftype
))
1728 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1729 else if (TYPE_TARGET_TYPE (ftype
))
1730 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1732 error (_("Expression of type other than "
1733 "\"Function returning ...\" used as function"));
1735 switch (TYPE_CODE (value_type (argvec
[0])))
1737 case TYPE_CODE_INTERNAL_FUNCTION
:
1738 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1739 argvec
[0], nargs
, argvec
+ 1);
1740 case TYPE_CODE_XMETHOD
:
1741 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
1743 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1745 /* pai: FIXME save value from call_function_by_hand, then adjust
1746 pc by adjust_fn_pc if +ve. */
1748 case OP_F77_UNDETERMINED_ARGLIST
:
1750 /* Remember that in F77, functions, substring ops and
1751 array subscript operations cannot be disambiguated
1752 at parse time. We have made all array subscript operations,
1753 substring operations as well as function calls come here
1754 and we now have to discover what the heck this thing actually was.
1755 If it is a function, we process just as if we got an OP_FUNCALL. */
1757 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1760 /* First determine the type code we are dealing with. */
1761 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1762 type
= check_typedef (value_type (arg1
));
1763 code
= TYPE_CODE (type
);
1765 if (code
== TYPE_CODE_PTR
)
1767 /* Fortran always passes variable to subroutines as pointer.
1768 So we need to look into its target type to see if it is
1769 array, string or function. If it is, we need to switch
1770 to the target value the original one points to. */
1771 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1773 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1774 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1775 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1777 arg1
= value_ind (arg1
);
1778 type
= check_typedef (value_type (arg1
));
1779 code
= TYPE_CODE (type
);
1785 case TYPE_CODE_ARRAY
:
1786 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1787 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1789 goto multi_f77_subscript
;
1791 case TYPE_CODE_STRING
:
1792 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1793 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1796 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1797 return value_subscript (arg1
, value_as_long (arg2
));
1801 case TYPE_CODE_FUNC
:
1802 /* It's a function call. */
1803 /* Allocate arg vector, including space for the function to be
1804 called in argvec[0] and a terminating NULL. */
1805 argvec
= (struct value
**)
1806 alloca (sizeof (struct value
*) * (nargs
+ 2));
1809 for (; tem
<= nargs
; tem
++)
1810 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1811 argvec
[tem
] = 0; /* signal end of arglist */
1815 error (_("Cannot perform substring on this type"));
1819 /* We have a complex number, There should be 2 floating
1820 point numbers that compose it. */
1822 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1823 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1825 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1827 case STRUCTOP_STRUCT
:
1828 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1829 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1830 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1831 if (noside
== EVAL_SKIP
)
1833 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1835 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1836 arg3
= value_zero (value_type (arg3
), not_lval
);
1840 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1841 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1842 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1843 if (noside
== EVAL_SKIP
)
1846 /* Check to see if operator '->' has been overloaded. If so replace
1847 arg1 with the value returned by evaluating operator->(). */
1848 while (unop_user_defined_p (op
, arg1
))
1850 volatile struct gdb_exception except
;
1851 struct value
*value
= NULL
;
1852 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1854 value
= value_x_unop (arg1
, op
, noside
);
1857 if (except
.reason
< 0)
1859 if (except
.error
== NOT_FOUND_ERROR
)
1862 throw_exception (except
);
1867 /* JYG: if print object is on we need to replace the base type
1868 with rtti type in order to continue on with successful
1869 lookup of member / method only available in the rtti type. */
1871 struct type
*type
= value_type (arg1
);
1872 struct type
*real_type
;
1873 int full
, top
, using_enc
;
1874 struct value_print_options opts
;
1876 get_user_print_options (&opts
);
1877 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1878 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1880 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1883 arg1
= value_cast (real_type
, arg1
);
1887 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1888 NULL
, "structure pointer");
1889 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1890 arg3
= value_zero (value_type (arg3
), not_lval
);
1893 case STRUCTOP_MEMBER
:
1895 if (op
== STRUCTOP_MEMBER
)
1896 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1898 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1900 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1902 if (noside
== EVAL_SKIP
)
1905 type
= check_typedef (value_type (arg2
));
1906 switch (TYPE_CODE (type
))
1908 case TYPE_CODE_METHODPTR
:
1909 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1910 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1913 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1914 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1915 return value_ind (arg2
);
1918 case TYPE_CODE_MEMBERPTR
:
1919 /* Now, convert these values to an address. */
1920 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1923 mem_offset
= value_as_long (arg2
);
1925 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1926 value_as_long (arg1
) + mem_offset
);
1927 return value_ind (arg3
);
1930 error (_("non-pointer-to-member value used "
1931 "in pointer-to-member construct"));
1935 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1936 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1937 for (ix
= 0; ix
< nargs
; ++ix
)
1938 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1940 expect_type
= make_params (nargs
, arg_types
);
1941 *(pos
) += 3 + nargs
;
1942 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1943 xfree (TYPE_FIELDS (expect_type
));
1944 xfree (TYPE_MAIN_TYPE (expect_type
));
1945 xfree (expect_type
);
1949 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1950 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1951 if (noside
== EVAL_SKIP
)
1953 if (binop_user_defined_p (op
, arg1
, arg2
))
1954 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1956 return value_concat (arg1
, arg2
);
1959 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1960 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1962 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1964 if (binop_user_defined_p (op
, arg1
, arg2
))
1965 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1967 return value_assign (arg1
, arg2
);
1969 case BINOP_ASSIGN_MODIFY
:
1971 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1972 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1973 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1975 op
= exp
->elts
[pc
+ 1].opcode
;
1976 if (binop_user_defined_p (op
, arg1
, arg2
))
1977 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1978 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
1980 && is_integral_type (value_type (arg2
)))
1981 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
1982 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
1984 && is_integral_type (value_type (arg2
)))
1985 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
1988 struct value
*tmp
= arg1
;
1990 /* For shift and integer exponentiation operations,
1991 only promote the first argument. */
1992 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
1993 && is_integral_type (value_type (arg2
)))
1994 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
1996 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
1998 arg2
= value_binop (tmp
, arg2
, op
);
2000 return value_assign (arg1
, arg2
);
2003 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2004 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2005 if (noside
== EVAL_SKIP
)
2007 if (binop_user_defined_p (op
, arg1
, arg2
))
2008 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2009 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2010 && is_integral_type (value_type (arg2
)))
2011 return value_ptradd (arg1
, value_as_long (arg2
));
2012 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2013 && is_integral_type (value_type (arg1
)))
2014 return value_ptradd (arg2
, value_as_long (arg1
));
2017 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2018 return value_binop (arg1
, arg2
, BINOP_ADD
);
2022 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2023 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2024 if (noside
== EVAL_SKIP
)
2026 if (binop_user_defined_p (op
, arg1
, arg2
))
2027 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2028 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2029 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2031 /* FIXME -- should be ptrdiff_t */
2032 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2033 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2035 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2036 && is_integral_type (value_type (arg2
)))
2037 return value_ptradd (arg1
, - value_as_long (arg2
));
2040 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2041 return value_binop (arg1
, arg2
, BINOP_SUB
);
2052 case BINOP_BITWISE_AND
:
2053 case BINOP_BITWISE_IOR
:
2054 case BINOP_BITWISE_XOR
:
2055 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2056 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2057 if (noside
== EVAL_SKIP
)
2059 if (binop_user_defined_p (op
, arg1
, arg2
))
2060 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2063 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2064 fudge arg2 to avoid division-by-zero, the caller is
2065 (theoretically) only looking for the type of the result. */
2066 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2067 /* ??? Do we really want to test for BINOP_MOD here?
2068 The implementation of value_binop gives it a well-defined
2071 || op
== BINOP_INTDIV
2074 && value_logical_not (arg2
))
2076 struct value
*v_one
, *retval
;
2078 v_one
= value_one (value_type (arg2
));
2079 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2080 retval
= value_binop (arg1
, v_one
, op
);
2085 /* For shift and integer exponentiation operations,
2086 only promote the first argument. */
2087 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2088 && is_integral_type (value_type (arg2
)))
2089 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2091 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2093 return value_binop (arg1
, arg2
, op
);
2097 case BINOP_SUBSCRIPT
:
2098 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2099 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2100 if (noside
== EVAL_SKIP
)
2102 if (binop_user_defined_p (op
, arg1
, arg2
))
2103 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2106 /* If the user attempts to subscript something that is not an
2107 array or pointer type (like a plain int variable for example),
2108 then report this as an error. */
2110 arg1
= coerce_ref (arg1
);
2111 type
= check_typedef (value_type (arg1
));
2112 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2113 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2115 if (TYPE_NAME (type
))
2116 error (_("cannot subscript something of type `%s'"),
2119 error (_("cannot subscript requested type"));
2122 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2123 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2125 return value_subscript (arg1
, value_as_long (arg2
));
2127 case MULTI_SUBSCRIPT
:
2129 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2130 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2133 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2134 /* FIXME: EVAL_SKIP handling may not be correct. */
2135 if (noside
== EVAL_SKIP
)
2146 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2147 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2149 /* If the user attempts to subscript something that has no target
2150 type (like a plain int variable for example), then report this
2153 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2156 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2162 error (_("cannot subscript something of type `%s'"),
2163 TYPE_NAME (value_type (arg1
)));
2167 if (binop_user_defined_p (op
, arg1
, arg2
))
2169 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2173 arg1
= coerce_ref (arg1
);
2174 type
= check_typedef (value_type (arg1
));
2176 switch (TYPE_CODE (type
))
2179 case TYPE_CODE_ARRAY
:
2180 case TYPE_CODE_STRING
:
2181 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2185 if (TYPE_NAME (type
))
2186 error (_("cannot subscript something of type `%s'"),
2189 error (_("cannot subscript requested type"));
2195 multi_f77_subscript
:
2197 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2198 int ndimensions
= 1, i
;
2199 struct value
*array
= arg1
;
2201 if (nargs
> MAX_FORTRAN_DIMS
)
2202 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2204 ndimensions
= calc_f77_array_dims (type
);
2206 if (nargs
!= ndimensions
)
2207 error (_("Wrong number of subscripts"));
2209 gdb_assert (nargs
> 0);
2211 /* Now that we know we have a legal array subscript expression
2212 let us actually find out where this element exists in the array. */
2214 /* Take array indices left to right. */
2215 for (i
= 0; i
< nargs
; i
++)
2217 /* Evaluate each subscript; it must be a legal integer in F77. */
2218 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2220 /* Fill in the subscript array. */
2222 subscript_array
[i
] = value_as_long (arg2
);
2225 /* Internal type of array is arranged right to left. */
2226 for (i
= nargs
; i
> 0; i
--)
2228 struct type
*array_type
= check_typedef (value_type (array
));
2229 LONGEST index
= subscript_array
[i
- 1];
2231 array
= value_subscripted_rvalue (array
, index
,
2232 f77_get_lowerbound (array_type
));
2238 case BINOP_LOGICAL_AND
:
2239 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2240 if (noside
== EVAL_SKIP
)
2242 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2247 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2250 if (binop_user_defined_p (op
, arg1
, arg2
))
2252 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2253 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2257 tem
= value_logical_not (arg1
);
2258 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2259 (tem
? EVAL_SKIP
: noside
));
2260 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2261 return value_from_longest (type
,
2262 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2265 case BINOP_LOGICAL_OR
:
2266 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2267 if (noside
== EVAL_SKIP
)
2269 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2274 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2277 if (binop_user_defined_p (op
, arg1
, arg2
))
2279 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2280 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2284 tem
= value_logical_not (arg1
);
2285 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2286 (!tem
? EVAL_SKIP
: noside
));
2287 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2288 return value_from_longest (type
,
2289 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2293 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2294 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2295 if (noside
== EVAL_SKIP
)
2297 if (binop_user_defined_p (op
, arg1
, arg2
))
2299 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2303 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2304 tem
= value_equal (arg1
, arg2
);
2305 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2306 return value_from_longest (type
, (LONGEST
) tem
);
2309 case BINOP_NOTEQUAL
:
2310 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2311 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2312 if (noside
== EVAL_SKIP
)
2314 if (binop_user_defined_p (op
, arg1
, arg2
))
2316 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2320 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2321 tem
= value_equal (arg1
, arg2
);
2322 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2323 return value_from_longest (type
, (LONGEST
) ! tem
);
2327 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2328 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2329 if (noside
== EVAL_SKIP
)
2331 if (binop_user_defined_p (op
, arg1
, arg2
))
2333 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2337 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2338 tem
= value_less (arg1
, arg2
);
2339 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2340 return value_from_longest (type
, (LONGEST
) tem
);
2344 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2345 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2346 if (noside
== EVAL_SKIP
)
2348 if (binop_user_defined_p (op
, arg1
, arg2
))
2350 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2354 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2355 tem
= value_less (arg2
, arg1
);
2356 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2357 return value_from_longest (type
, (LONGEST
) tem
);
2361 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2362 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2363 if (noside
== EVAL_SKIP
)
2365 if (binop_user_defined_p (op
, arg1
, arg2
))
2367 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2371 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2372 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2373 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2374 return value_from_longest (type
, (LONGEST
) tem
);
2378 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2379 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2380 if (noside
== EVAL_SKIP
)
2382 if (binop_user_defined_p (op
, arg1
, arg2
))
2384 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2388 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2389 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2390 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2391 return value_from_longest (type
, (LONGEST
) tem
);
2395 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2396 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2397 if (noside
== EVAL_SKIP
)
2399 type
= check_typedef (value_type (arg2
));
2400 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2401 error (_("Non-integral right operand for \"@\" operator."));
2402 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2404 return allocate_repeat_value (value_type (arg1
),
2405 longest_to_int (value_as_long (arg2
)));
2408 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2411 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2412 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2415 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2416 if (noside
== EVAL_SKIP
)
2418 if (unop_user_defined_p (op
, arg1
))
2419 return value_x_unop (arg1
, op
, noside
);
2422 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2423 return value_pos (arg1
);
2427 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2428 if (noside
== EVAL_SKIP
)
2430 if (unop_user_defined_p (op
, arg1
))
2431 return value_x_unop (arg1
, op
, noside
);
2434 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2435 return value_neg (arg1
);
2438 case UNOP_COMPLEMENT
:
2439 /* C++: check for and handle destructor names. */
2440 op
= exp
->elts
[*pos
].opcode
;
2442 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2443 if (noside
== EVAL_SKIP
)
2445 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2446 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2449 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2450 return value_complement (arg1
);
2453 case UNOP_LOGICAL_NOT
:
2454 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2455 if (noside
== EVAL_SKIP
)
2457 if (unop_user_defined_p (op
, arg1
))
2458 return value_x_unop (arg1
, op
, noside
);
2461 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2462 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2466 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2467 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2468 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2469 type
= check_typedef (value_type (arg1
));
2470 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2471 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2472 error (_("Attempt to dereference pointer "
2473 "to member without an object"));
2474 if (noside
== EVAL_SKIP
)
2476 if (unop_user_defined_p (op
, arg1
))
2477 return value_x_unop (arg1
, op
, noside
);
2478 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2480 type
= check_typedef (value_type (arg1
));
2481 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2482 || TYPE_CODE (type
) == TYPE_CODE_REF
2483 /* In C you can dereference an array to get the 1st elt. */
2484 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2486 return value_zero (TYPE_TARGET_TYPE (type
),
2488 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2489 /* GDB allows dereferencing an int. */
2490 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2493 error (_("Attempt to take contents of a non-pointer value."));
2496 /* Allow * on an integer so we can cast it to whatever we want.
2497 This returns an int, which seems like the most C-like thing to
2498 do. "long long" variables are rare enough that
2499 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2500 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2501 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2502 (CORE_ADDR
) value_as_address (arg1
));
2503 return value_ind (arg1
);
2506 /* C++: check for and handle pointer to members. */
2508 op
= exp
->elts
[*pos
].opcode
;
2510 if (noside
== EVAL_SKIP
)
2512 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2517 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2524 if (noside
== EVAL_SKIP
)
2526 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2529 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2533 type
= exp
->elts
[pc
+ 1].type
;
2534 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2535 if (noside
== EVAL_SKIP
)
2537 if (type
!= value_type (arg1
))
2538 arg1
= value_cast (type
, arg1
);
2541 case UNOP_CAST_TYPE
:
2542 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2543 type
= value_type (arg1
);
2544 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2545 if (noside
== EVAL_SKIP
)
2547 if (type
!= value_type (arg1
))
2548 arg1
= value_cast (type
, arg1
);
2551 case UNOP_DYNAMIC_CAST
:
2552 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2553 type
= value_type (arg1
);
2554 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2555 if (noside
== EVAL_SKIP
)
2557 return value_dynamic_cast (type
, arg1
);
2559 case UNOP_REINTERPRET_CAST
:
2560 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2561 type
= value_type (arg1
);
2562 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2563 if (noside
== EVAL_SKIP
)
2565 return value_reinterpret_cast (type
, arg1
);
2569 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2570 if (noside
== EVAL_SKIP
)
2572 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2573 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2575 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2576 value_as_address (arg1
));
2578 case UNOP_MEMVAL_TYPE
:
2579 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2580 type
= value_type (arg1
);
2581 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2582 if (noside
== EVAL_SKIP
)
2584 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2585 return value_zero (type
, lval_memory
);
2587 return value_at_lazy (type
, value_as_address (arg1
));
2589 case UNOP_MEMVAL_TLS
:
2591 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2592 if (noside
== EVAL_SKIP
)
2594 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2595 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2600 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2601 value_as_address (arg1
));
2602 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2605 case UNOP_PREINCREMENT
:
2606 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2607 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2609 else if (unop_user_defined_p (op
, arg1
))
2611 return value_x_unop (arg1
, op
, noside
);
2615 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2616 arg2
= value_ptradd (arg1
, 1);
2619 struct value
*tmp
= arg1
;
2621 arg2
= value_one (value_type (arg1
));
2622 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2623 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2626 return value_assign (arg1
, arg2
);
2629 case UNOP_PREDECREMENT
:
2630 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2631 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2633 else if (unop_user_defined_p (op
, arg1
))
2635 return value_x_unop (arg1
, op
, noside
);
2639 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2640 arg2
= value_ptradd (arg1
, -1);
2643 struct value
*tmp
= arg1
;
2645 arg2
= value_one (value_type (arg1
));
2646 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2647 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2650 return value_assign (arg1
, arg2
);
2653 case UNOP_POSTINCREMENT
:
2654 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2655 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2657 else if (unop_user_defined_p (op
, arg1
))
2659 return value_x_unop (arg1
, op
, noside
);
2663 arg3
= value_non_lval (arg1
);
2665 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2666 arg2
= value_ptradd (arg1
, 1);
2669 struct value
*tmp
= arg1
;
2671 arg2
= value_one (value_type (arg1
));
2672 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2673 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2676 value_assign (arg1
, arg2
);
2680 case UNOP_POSTDECREMENT
:
2681 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2682 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2684 else if (unop_user_defined_p (op
, arg1
))
2686 return value_x_unop (arg1
, op
, noside
);
2690 arg3
= value_non_lval (arg1
);
2692 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2693 arg2
= value_ptradd (arg1
, -1);
2696 struct value
*tmp
= arg1
;
2698 arg2
= value_one (value_type (arg1
));
2699 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2700 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2703 value_assign (arg1
, arg2
);
2709 return value_of_this (exp
->language_defn
);
2712 /* The value is not supposed to be used. This is here to make it
2713 easier to accommodate expressions that contain types. */
2715 if (noside
== EVAL_SKIP
)
2717 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2719 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2721 /* If this is a typedef, then find its immediate target. We
2722 use check_typedef to resolve stubs, but we ignore its
2723 result because we do not want to dig past all
2725 check_typedef (type
);
2726 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2727 type
= TYPE_TARGET_TYPE (type
);
2728 return allocate_value (type
);
2731 error (_("Attempt to use a type name as an expression"));
2735 if (noside
== EVAL_SKIP
)
2737 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2740 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2742 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2743 struct value
*result
;
2745 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2746 EVAL_AVOID_SIDE_EFFECTS
);
2748 /* 'decltype' has special semantics for lvalues. */
2749 if (op
== OP_DECLTYPE
2750 && (sub_op
== BINOP_SUBSCRIPT
2751 || sub_op
== STRUCTOP_MEMBER
2752 || sub_op
== STRUCTOP_MPTR
2753 || sub_op
== UNOP_IND
2754 || sub_op
== STRUCTOP_STRUCT
2755 || sub_op
== STRUCTOP_PTR
2756 || sub_op
== OP_SCOPE
))
2758 struct type
*type
= value_type (result
);
2760 if (TYPE_CODE (check_typedef (type
)) != TYPE_CODE_REF
)
2762 type
= lookup_reference_type (type
);
2763 result
= allocate_value (type
);
2770 error (_("Attempt to use a type as an expression"));
2774 struct value
*result
;
2775 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2777 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2778 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2779 EVAL_AVOID_SIDE_EFFECTS
);
2781 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2783 if (noside
!= EVAL_NORMAL
)
2784 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2786 return cplus_typeid (result
);
2790 /* Removing this case and compiling with gcc -Wall reveals that
2791 a lot of cases are hitting this case. Some of these should
2792 probably be removed from expression.h; others are legitimate
2793 expressions which are (apparently) not fully implemented.
2795 If there are any cases landing here which mean a user error,
2796 then they should be separate cases, with more descriptive
2799 error (_("GDB does not (yet) know how to "
2800 "evaluate that kind of expression"));
2804 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2807 /* Evaluate a subexpression of EXP, at index *POS,
2808 and return the address of that subexpression.
2809 Advance *POS over the subexpression.
2810 If the subexpression isn't an lvalue, get an error.
2811 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2812 then only the type of the result need be correct. */
2814 static struct value
*
2815 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2825 op
= exp
->elts
[pc
].opcode
;
2831 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2833 /* We can't optimize out "&*" if there's a user-defined operator*. */
2834 if (unop_user_defined_p (op
, x
))
2836 x
= value_x_unop (x
, op
, noside
);
2837 goto default_case_after_eval
;
2840 return coerce_array (x
);
2844 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2845 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2847 case UNOP_MEMVAL_TYPE
:
2852 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2853 type
= value_type (x
);
2854 return value_cast (lookup_pointer_type (type
),
2855 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2859 var
= exp
->elts
[pc
+ 2].symbol
;
2861 /* C++: The "address" of a reference should yield the address
2862 * of the object pointed to. Let value_addr() deal with it. */
2863 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2867 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2870 lookup_pointer_type (SYMBOL_TYPE (var
));
2871 enum address_class sym_class
= SYMBOL_CLASS (var
);
2873 if (sym_class
== LOC_CONST
2874 || sym_class
== LOC_CONST_BYTES
2875 || sym_class
== LOC_REGISTER
)
2876 error (_("Attempt to take address of register or constant."));
2879 value_zero (type
, not_lval
);
2882 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2885 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2886 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2887 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2888 &exp
->elts
[pc
+ 3].string
,
2891 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2896 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2897 default_case_after_eval
:
2898 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2900 struct type
*type
= check_typedef (value_type (x
));
2902 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2903 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2905 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2906 return value_zero (lookup_pointer_type (value_type (x
)),
2909 error (_("Attempt to take address of "
2910 "value not located in memory."));
2912 return value_addr (x
);
2916 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2917 When used in contexts where arrays will be coerced anyway, this is
2918 equivalent to `evaluate_subexp' but much faster because it avoids
2919 actually fetching array contents (perhaps obsolete now that we have
2922 Note that we currently only do the coercion for C expressions, where
2923 arrays are zero based and the coercion is correct. For other languages,
2924 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2925 to decide if coercion is appropriate. */
2928 evaluate_subexp_with_coercion (struct expression
*exp
,
2929 int *pos
, enum noside noside
)
2938 op
= exp
->elts
[pc
].opcode
;
2943 var
= exp
->elts
[pc
+ 2].symbol
;
2944 type
= check_typedef (SYMBOL_TYPE (var
));
2945 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2946 && !TYPE_VECTOR (type
)
2947 && CAST_IS_CONVERSION (exp
->language_defn
))
2950 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2951 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2957 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2961 /* Evaluate a subexpression of EXP, at index *POS,
2962 and return a value for the size of that subexpression.
2963 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2964 we allow side-effects on the operand if its type is a variable
2967 static struct value
*
2968 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2971 /* FIXME: This should be size_t. */
2972 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2979 op
= exp
->elts
[pc
].opcode
;
2983 /* This case is handled specially
2984 so that we avoid creating a value for the result type.
2985 If the result type is very big, it's desirable not to
2986 create a value unnecessarily. */
2989 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2990 type
= check_typedef (value_type (val
));
2991 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2992 && TYPE_CODE (type
) != TYPE_CODE_REF
2993 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2994 error (_("Attempt to take contents of a non-pointer value."));
2995 type
= TYPE_TARGET_TYPE (type
);
2996 if (is_dynamic_type (type
))
2997 type
= value_type (value_ind (val
));
2998 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3002 type
= exp
->elts
[pc
+ 1].type
;
3005 case UNOP_MEMVAL_TYPE
:
3007 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3008 type
= value_type (val
);
3012 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3013 if (is_dynamic_type (type
))
3015 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3016 type
= value_type (val
);
3022 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3023 type of the subscript is a variable length array type. In this case we
3024 must re-evaluate the right hand side of the subcription to allow
3026 case BINOP_SUBSCRIPT
:
3027 if (noside
== EVAL_NORMAL
)
3029 int pc
= (*pos
) + 1;
3031 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3032 type
= check_typedef (value_type (val
));
3033 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3035 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3036 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3038 type
= TYPE_INDEX_TYPE (type
);
3039 /* Only re-evaluate the right hand side if the resulting type
3040 is a variable length type. */
3041 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3043 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3044 return value_from_longest
3045 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3054 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3055 type
= value_type (val
);
3059 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3060 "When applied to a reference or a reference type, the result is
3061 the size of the referenced type." */
3062 CHECK_TYPEDEF (type
);
3063 if (exp
->language_defn
->la_language
== language_cplus
3064 && TYPE_CODE (type
) == TYPE_CODE_REF
)
3065 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3066 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3069 /* Parse a type expression in the string [P..P+LENGTH). */
3072 parse_and_eval_type (char *p
, int length
)
3074 char *tmp
= (char *) alloca (length
+ 4);
3075 struct expression
*expr
;
3078 memcpy (tmp
+ 1, p
, length
);
3079 tmp
[length
+ 1] = ')';
3080 tmp
[length
+ 2] = '0';
3081 tmp
[length
+ 3] = '\0';
3082 expr
= parse_expression (tmp
);
3083 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3084 error (_("Internal error in eval_type."));
3085 return expr
->elts
[1].type
;
3089 calc_f77_array_dims (struct type
*array_type
)
3092 struct type
*tmp_type
;
3094 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3095 error (_("Can't get dimensions for a non-array type"));
3097 tmp_type
= array_type
;
3099 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3101 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)