1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2017 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 expression_up expr
= parse_expression (exp
);
100 return value_as_address (evaluate_expression (expr
.get ()));
103 /* Like parse_and_eval_address, but treats the value of the expression
104 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
106 parse_and_eval_long (const char *exp
)
108 expression_up expr
= parse_expression (exp
);
110 return value_as_long (evaluate_expression (expr
.get ()));
114 parse_and_eval (const char *exp
)
116 expression_up expr
= parse_expression (exp
);
118 return evaluate_expression (expr
.get ());
121 /* Parse up to a comma (or to a closeparen)
122 in the string EXPP as an expression, evaluate it, and return the value.
123 EXPP is advanced to point to the comma. */
126 parse_to_comma_and_eval (const char **expp
)
128 expression_up expr
= parse_exp_1 (expp
, 0, (struct block
*) 0, 1);
130 return evaluate_expression (expr
.get ());
133 /* Evaluate an expression in internal prefix form
134 such as is constructed by parse.y.
136 See expression.h for info on the format of an expression. */
139 evaluate_expression (struct expression
*exp
)
143 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
146 /* Evaluate an expression, avoiding all memory references
147 and getting a value whose type alone is correct. */
150 evaluate_type (struct expression
*exp
)
154 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
157 /* Evaluate a subexpression, avoiding all memory references and
158 getting a value whose type alone is correct. */
161 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
163 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
166 /* Find the current value of a watchpoint on EXP. Return the value in
167 *VALP and *RESULTP and the chain of intermediate and final values
168 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
171 If PRESERVE_ERRORS is true, then exceptions are passed through.
172 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
173 occurs while evaluating the expression, *RESULTP will be set to
174 NULL. *RESULTP may be a lazy value, if the result could not be
175 read from memory. It is used to determine whether a value is
176 user-specified (we should watch the whole value) or intermediate
177 (we should watch only the bit used to locate the final value).
179 If the final value, or any intermediate value, could not be read
180 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
181 set to any referenced values. *VALP will never be a lazy value.
182 This is the value which we store in struct breakpoint.
184 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
185 value chain. The caller must free the values individually. If
186 VAL_CHAIN is NULL, all generated values will be left on the value
190 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
191 struct value
**resultp
, struct value
**val_chain
,
194 struct value
*mark
, *new_mark
, *result
;
202 /* Evaluate the expression. */
203 mark
= value_mark ();
208 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
210 CATCH (ex
, RETURN_MASK_ALL
)
212 /* Ignore memory errors if we want watchpoints pointing at
213 inaccessible memory to still be created; otherwise, throw the
214 error to some higher catcher. */
218 if (!preserve_errors
)
221 throw_exception (ex
);
227 new_mark
= value_mark ();
228 if (mark
== new_mark
)
233 /* Make sure it's not lazy, so that after the target stops again we
234 have a non-lazy previous value to compare with. */
237 if (!value_lazy (result
))
244 value_fetch_lazy (result
);
247 CATCH (except
, RETURN_MASK_ERROR
)
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.
350 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
351 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
352 Evaluates index expresions and sets the specified element(s) of
353 ARRAY to ELEMENT. Returns last index value. */
356 init_array_element (struct value
*array
, struct value
*element
,
357 struct expression
*exp
, int *pos
,
358 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
361 int element_size
= TYPE_LENGTH (value_type (element
));
363 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
366 init_array_element (array
, element
, exp
, pos
, noside
,
367 low_bound
, high_bound
);
368 return init_array_element (array
, element
,
369 exp
, pos
, noside
, low_bound
, high_bound
);
373 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
374 if (index
< low_bound
|| index
> high_bound
)
375 error (_("tuple index out of range"));
376 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
377 value_contents (element
), element_size
);
382 static struct value
*
383 value_f90_subarray (struct value
*array
,
384 struct expression
*exp
, int *pos
, enum noside noside
)
387 LONGEST low_bound
, high_bound
;
388 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
389 enum range_type range_type
390 = (enum 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_IS_REFERENCE (type
))
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_CHAIN (type
) = type
;
654 if (param_types
[num_types
- 1] == NULL
)
657 TYPE_VARARGS (type
) = 1;
659 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
663 /* Caller should have ensured this. */
664 gdb_assert (num_types
== 0);
665 TYPE_PROTOTYPED (type
) = 1;
669 TYPE_NFIELDS (type
) = num_types
;
670 TYPE_FIELDS (type
) = (struct field
*)
671 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
673 while (num_types
-- > 0)
674 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
680 evaluate_subexp_standard (struct type
*expect_type
,
681 struct expression
*exp
, int *pos
,
686 int pc
, pc2
= 0, oldpos
;
687 struct value
*arg1
= NULL
;
688 struct value
*arg2
= NULL
;
692 struct value
**argvec
;
696 struct type
**arg_types
;
698 struct symbol
*function
= NULL
;
699 char *function_name
= NULL
;
702 op
= exp
->elts
[pc
].opcode
;
707 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
708 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
709 if (noside
== EVAL_SKIP
)
711 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
712 &exp
->elts
[pc
+ 3].string
,
713 expect_type
, 0, noside
);
715 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
720 return value_from_longest (exp
->elts
[pc
+ 1].type
,
721 exp
->elts
[pc
+ 2].longconst
);
725 return value_from_double (exp
->elts
[pc
+ 1].type
,
726 exp
->elts
[pc
+ 2].doubleconst
);
730 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
731 exp
->elts
[pc
+ 2].decfloatconst
);
736 if (noside
== EVAL_SKIP
)
739 /* JYG: We used to just return value_zero of the symbol type
740 if we're asked to avoid side effects. Otherwise we return
741 value_of_variable (...). However I'm not sure if
742 value_of_variable () has any side effect.
743 We need a full value object returned here for whatis_exp ()
744 to call evaluate_type () and then pass the full value to
745 value_rtti_target_type () if we are dealing with a pointer
746 or reference to a base class and print object is on. */
749 struct value
*ret
= NULL
;
753 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
754 exp
->elts
[pc
+ 1].block
);
757 CATCH (except
, RETURN_MASK_ERROR
)
759 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
760 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
763 throw_exception (except
);
770 case OP_VAR_ENTRY_VALUE
:
772 if (noside
== EVAL_SKIP
)
776 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
777 struct frame_info
*frame
;
779 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
780 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
782 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
783 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
784 error (_("Symbol \"%s\" does not have any specific entry value"),
785 SYMBOL_PRINT_NAME (sym
));
787 frame
= get_selected_frame (NULL
);
788 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
794 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
798 const char *name
= &exp
->elts
[pc
+ 2].string
;
802 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
803 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
804 name
, strlen (name
));
806 error (_("Register $%s not available."), name
);
808 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
809 a value with the appropriate register type. Unfortunately,
810 we don't have easy access to the type of user registers.
811 So for these registers, we fetch the register value regardless
812 of the evaluation mode. */
813 if (noside
== EVAL_AVOID_SIDE_EFFECTS
814 && regno
< gdbarch_num_regs (exp
->gdbarch
)
815 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
816 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
818 val
= value_of_register (regno
, get_selected_frame (NULL
));
820 error (_("Value of register %s not available."), name
);
826 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
827 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
831 return value_of_internalvar (exp
->gdbarch
,
832 exp
->elts
[pc
+ 1].internalvar
);
835 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
836 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
837 if (noside
== EVAL_SKIP
)
839 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
840 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
842 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
843 NSString constant. */
844 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
845 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
846 if (noside
== EVAL_SKIP
)
850 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
854 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
855 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
856 nargs
= tem3
- tem2
+ 1;
857 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
859 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
860 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
862 struct value
*rec
= allocate_value (expect_type
);
864 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
865 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
868 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
869 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
871 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
872 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
873 struct value
*array
= allocate_value (expect_type
);
874 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
875 LONGEST low_bound
, high_bound
, index
;
877 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
880 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
883 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
884 for (tem
= nargs
; --nargs
>= 0;)
886 struct value
*element
;
889 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
890 if (value_type (element
) != element_type
)
891 element
= value_cast (element_type
, element
);
894 int continue_pc
= *pos
;
897 index
= init_array_element (array
, element
, exp
, pos
, noside
,
898 low_bound
, high_bound
);
903 if (index
> high_bound
)
904 /* To avoid memory corruption. */
905 error (_("Too many array elements"));
906 memcpy (value_contents_raw (array
)
907 + (index
- low_bound
) * element_size
,
908 value_contents (element
),
916 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
917 && TYPE_CODE (type
) == TYPE_CODE_SET
)
919 struct value
*set
= allocate_value (expect_type
);
920 gdb_byte
*valaddr
= value_contents_raw (set
);
921 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
922 struct type
*check_type
= element_type
;
923 LONGEST low_bound
, high_bound
;
925 /* Get targettype of elementtype. */
926 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
927 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
928 check_type
= TYPE_TARGET_TYPE (check_type
);
930 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
931 error (_("(power)set type with unknown size"));
932 memset (valaddr
, '\0', TYPE_LENGTH (type
));
933 for (tem
= 0; tem
< nargs
; tem
++)
935 LONGEST range_low
, range_high
;
936 struct type
*range_low_type
, *range_high_type
;
937 struct value
*elem_val
;
939 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
940 range_low_type
= range_high_type
= value_type (elem_val
);
941 range_low
= range_high
= value_as_long (elem_val
);
943 /* Check types of elements to avoid mixture of elements from
944 different types. Also check if type of element is "compatible"
945 with element type of powerset. */
946 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
947 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
948 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
949 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
950 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
951 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
952 && (range_low_type
!= range_high_type
)))
953 /* different element modes. */
954 error (_("POWERSET tuple elements of different mode"));
955 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
956 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
957 && range_low_type
!= check_type
))
958 error (_("incompatible POWERSET tuple elements"));
959 if (range_low
> range_high
)
961 warning (_("empty POWERSET tuple range"));
964 if (range_low
< low_bound
|| range_high
> high_bound
)
965 error (_("POWERSET tuple element out of range"));
966 range_low
-= low_bound
;
967 range_high
-= low_bound
;
968 for (; range_low
<= range_high
; range_low
++)
970 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
972 if (gdbarch_bits_big_endian (exp
->gdbarch
))
973 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
974 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
981 argvec
= XALLOCAVEC (struct value
*, nargs
);
982 for (tem
= 0; tem
< nargs
; tem
++)
984 /* Ensure that array expressions are coerced into pointer
986 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
988 if (noside
== EVAL_SKIP
)
990 return value_array (tem2
, tem3
, argvec
);
994 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
996 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
998 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1000 if (noside
== EVAL_SKIP
)
1002 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1006 /* Skip third and second args to evaluate the first one. */
1007 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1008 if (value_logical_not (arg1
))
1010 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1011 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1015 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1016 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1020 case OP_OBJC_SELECTOR
:
1021 { /* Objective C @selector operator. */
1022 char *sel
= &exp
->elts
[pc
+ 2].string
;
1023 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1024 struct type
*selector_type
;
1026 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1027 if (noside
== EVAL_SKIP
)
1031 sel
[len
] = 0; /* Make sure it's terminated. */
1033 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1034 return value_from_longest (selector_type
,
1035 lookup_child_selector (exp
->gdbarch
, sel
));
1038 case OP_OBJC_MSGCALL
:
1039 { /* Objective C message (method) call. */
1041 CORE_ADDR responds_selector
= 0;
1042 CORE_ADDR method_selector
= 0;
1044 CORE_ADDR selector
= 0;
1046 int struct_return
= 0;
1047 enum noside sub_no_side
= EVAL_NORMAL
;
1049 struct value
*msg_send
= NULL
;
1050 struct value
*msg_send_stret
= NULL
;
1051 int gnu_runtime
= 0;
1053 struct value
*target
= NULL
;
1054 struct value
*method
= NULL
;
1055 struct value
*called_method
= NULL
;
1057 struct type
*selector_type
= NULL
;
1058 struct type
*long_type
;
1060 struct value
*ret
= NULL
;
1063 selector
= exp
->elts
[pc
+ 1].longconst
;
1064 nargs
= exp
->elts
[pc
+ 2].longconst
;
1065 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1069 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1070 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1072 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1073 sub_no_side
= EVAL_NORMAL
;
1075 sub_no_side
= noside
;
1077 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1079 if (value_as_long (target
) == 0)
1080 return value_from_longest (long_type
, 0);
1082 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1085 /* Find the method dispatch (Apple runtime) or method lookup
1086 (GNU runtime) function for Objective-C. These will be used
1087 to lookup the symbol information for the method. If we
1088 can't find any symbol information, then we'll use these to
1089 call the method, otherwise we can call the method
1090 directly. The msg_send_stret function is used in the special
1091 case of a method that returns a structure (Apple runtime
1095 struct type
*type
= selector_type
;
1097 type
= lookup_function_type (type
);
1098 type
= lookup_pointer_type (type
);
1099 type
= lookup_function_type (type
);
1100 type
= lookup_pointer_type (type
);
1102 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1104 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1106 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1107 msg_send_stret
= value_from_pointer (type
,
1108 value_as_address (msg_send_stret
));
1112 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1113 /* Special dispatcher for methods returning structs. */
1115 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1118 /* Verify the target object responds to this method. The
1119 standard top-level 'Object' class uses a different name for
1120 the verification method than the non-standard, but more
1121 often used, 'NSObject' class. Make sure we check for both. */
1124 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1125 if (responds_selector
== 0)
1127 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1129 if (responds_selector
== 0)
1130 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1133 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1134 if (method_selector
== 0)
1136 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1138 if (method_selector
== 0)
1139 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1141 /* Call the verification method, to make sure that the target
1142 class implements the desired method. */
1144 argvec
[0] = msg_send
;
1146 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1147 argvec
[3] = value_from_longest (long_type
, selector
);
1150 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1153 /* Function objc_msg_lookup returns a pointer. */
1155 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1157 if (value_as_long (ret
) == 0)
1158 error (_("Target does not respond to this message selector."));
1160 /* Call "methodForSelector:" method, to get the address of a
1161 function method that implements this selector for this
1162 class. If we can find a symbol at that address, then we
1163 know the return type, parameter types etc. (that's a good
1166 argvec
[0] = msg_send
;
1168 argvec
[2] = value_from_longest (long_type
, method_selector
);
1169 argvec
[3] = value_from_longest (long_type
, selector
);
1172 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1176 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1179 /* ret should now be the selector. */
1181 addr
= value_as_long (ret
);
1184 struct symbol
*sym
= NULL
;
1186 /* The address might point to a function descriptor;
1187 resolve it to the actual code address instead. */
1188 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1191 /* Is it a high_level symbol? */
1192 sym
= find_pc_function (addr
);
1194 method
= value_of_variable (sym
, 0);
1197 /* If we found a method with symbol information, check to see
1198 if it returns a struct. Otherwise assume it doesn't. */
1203 struct type
*val_type
;
1205 funaddr
= find_function_addr (method
, &val_type
);
1207 block_for_pc (funaddr
);
1209 val_type
= check_typedef (val_type
);
1211 if ((val_type
== NULL
)
1212 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1214 if (expect_type
!= NULL
)
1215 val_type
= expect_type
;
1218 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1221 else if (expect_type
!= NULL
)
1223 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1224 check_typedef (expect_type
));
1227 /* Found a function symbol. Now we will substitute its
1228 value in place of the message dispatcher (obj_msgSend),
1229 so that we call the method directly instead of thru
1230 the dispatcher. The main reason for doing this is that
1231 we can now evaluate the return value and parameter values
1232 according to their known data types, in case we need to
1233 do things like promotion, dereferencing, special handling
1234 of structs and doubles, etc.
1236 We want to use the type signature of 'method', but still
1237 jump to objc_msgSend() or objc_msgSend_stret() to better
1238 mimic the behavior of the runtime. */
1242 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1243 error (_("method address has symbol information "
1244 "with non-function type; skipping"));
1246 /* Create a function pointer of the appropriate type, and
1247 replace its value with the value of msg_send or
1248 msg_send_stret. We must use a pointer here, as
1249 msg_send and msg_send_stret are of pointer type, and
1250 the representation may be different on systems that use
1251 function descriptors. */
1254 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1255 value_as_address (msg_send_stret
));
1258 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1259 value_as_address (msg_send
));
1264 called_method
= msg_send_stret
;
1266 called_method
= msg_send
;
1269 if (noside
== EVAL_SKIP
)
1272 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1274 /* If the return type doesn't look like a function type,
1275 call an error. This can happen if somebody tries to
1276 turn a variable into a function call. This is here
1277 because people often want to call, eg, strcmp, which
1278 gdb doesn't know is a function. If gdb isn't asked for
1279 it's opinion (ie. through "whatis"), it won't offer
1282 struct type
*type
= value_type (called_method
);
1284 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1285 type
= TYPE_TARGET_TYPE (type
);
1286 type
= TYPE_TARGET_TYPE (type
);
1290 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1291 return allocate_value (expect_type
);
1293 return allocate_value (type
);
1296 error (_("Expression of type other than "
1297 "\"method returning ...\" used as a method"));
1300 /* Now depending on whether we found a symbol for the method,
1301 we will either call the runtime dispatcher or the method
1304 argvec
[0] = called_method
;
1306 argvec
[2] = value_from_longest (long_type
, selector
);
1307 /* User-supplied arguments. */
1308 for (tem
= 0; tem
< nargs
; tem
++)
1309 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1310 argvec
[tem
+ 3] = 0;
1312 if (gnu_runtime
&& (method
!= NULL
))
1314 /* Function objc_msg_lookup returns a pointer. */
1315 deprecated_set_value_type (argvec
[0],
1316 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1318 = call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1321 ret
= call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1328 op
= exp
->elts
[*pos
].opcode
;
1329 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1330 /* Allocate arg vector, including space for the function to be
1331 called in argvec[0], a potential `this', and a terminating NULL. */
1332 argvec
= (struct value
**)
1333 alloca (sizeof (struct value
*) * (nargs
+ 3));
1334 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1336 /* First, evaluate the structure into arg2. */
1339 if (op
== STRUCTOP_MEMBER
)
1341 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1345 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1348 /* If the function is a virtual function, then the
1349 aggregate value (providing the structure) plays
1350 its part by providing the vtable. Otherwise,
1351 it is just along for the ride: call the function
1354 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1356 type
= check_typedef (value_type (arg1
));
1357 if (noside
== EVAL_SKIP
)
1358 tem
= 1; /* Set it to the right arg index so that all arguments
1359 can also be skipped. */
1360 else if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
)
1362 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1363 arg1
= value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1365 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1367 /* Now, say which argument to start evaluating from. */
1372 else if (TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1374 struct type
*type_ptr
1375 = lookup_pointer_type (TYPE_SELF_TYPE (type
));
1376 struct type
*target_type_ptr
1377 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1379 /* Now, convert these values to an address. */
1380 arg2
= value_cast (type_ptr
, arg2
);
1382 mem_offset
= value_as_long (arg1
);
1384 arg1
= value_from_pointer (target_type_ptr
,
1385 value_as_long (arg2
) + mem_offset
);
1386 arg1
= value_ind (arg1
);
1390 error (_("Non-pointer-to-member value used in pointer-to-member "
1393 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1395 /* Hair for method invocations. */
1399 /* First, evaluate the structure into arg2. */
1401 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1402 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1404 if (op
== STRUCTOP_STRUCT
)
1406 /* If v is a variable in a register, and the user types
1407 v.method (), this will produce an error, because v has
1410 A possible way around this would be to allocate a
1411 copy of the variable on the stack, copy in the
1412 contents, call the function, and copy out the
1413 contents. I.e. convert this from call by reference
1414 to call by copy-return (or whatever it's called).
1415 However, this does not work because it is not the
1416 same: the method being called could stash a copy of
1417 the address, and then future uses through that address
1418 (after the method returns) would be expected to
1419 use the variable itself, not some copy of it. */
1420 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1424 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1426 /* Check to see if the operator '->' has been
1427 overloaded. If the operator has been overloaded
1428 replace arg2 with the value returned by the custom
1429 operator and continue evaluation. */
1430 while (unop_user_defined_p (op
, arg2
))
1432 struct value
*value
= NULL
;
1435 value
= value_x_unop (arg2
, op
, noside
);
1438 CATCH (except
, RETURN_MASK_ERROR
)
1440 if (except
.error
== NOT_FOUND_ERROR
)
1443 throw_exception (except
);
1450 /* Now, say which argument to start evaluating from. */
1453 else if (op
== OP_SCOPE
1454 && overload_resolution
1455 && (exp
->language_defn
->la_language
== language_cplus
))
1457 /* Unpack it locally so we can properly handle overload
1463 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1464 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1465 type
= exp
->elts
[pc2
+ 1].type
;
1466 name
= &exp
->elts
[pc2
+ 3].string
;
1469 function_name
= NULL
;
1470 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1472 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1474 get_selected_block (0),
1476 if (function
== NULL
)
1477 error (_("No symbol \"%s\" in namespace \"%s\"."),
1478 name
, TYPE_TAG_NAME (type
));
1481 /* arg2 is left as NULL on purpose. */
1485 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1486 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1487 function_name
= name
;
1489 /* We need a properly typed value for method lookup. For
1490 static methods arg2 is otherwise unused. */
1491 arg2
= value_zero (type
, lval_memory
);
1496 else if (op
== OP_ADL_FUNC
)
1498 /* Save the function position and move pos so that the arguments
1499 can be evaluated. */
1505 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1506 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1510 /* Non-method function call. */
1514 /* If this is a C++ function wait until overload resolution. */
1515 if (op
== OP_VAR_VALUE
1516 && overload_resolution
1517 && (exp
->language_defn
->la_language
== language_cplus
))
1519 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1524 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1525 type
= value_type (argvec
[0]);
1526 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1527 type
= TYPE_TARGET_TYPE (type
);
1528 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1530 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1532 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1540 /* Evaluate arguments (if not already done, e.g., namespace::func()
1541 and overload-resolution is off). */
1542 for (; tem
<= nargs
; tem
++)
1544 /* Ensure that array expressions are coerced into pointer
1546 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1549 /* Signal end of arglist. */
1552 if (noside
== EVAL_SKIP
)
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, noside
);
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, noside
);
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
, noside
);
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 (argvec
[0] == NULL
)
1705 error (_("Cannot evaluate function -- may be inlined"));
1706 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1708 /* If the return type doesn't look like a function type,
1709 call an error. This can happen if somebody tries to turn
1710 a variable into a function call. */
1712 struct type
*ftype
= value_type (argvec
[0]);
1714 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1716 /* We don't know anything about what the internal
1717 function might return, but we have to return
1719 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1722 else if (TYPE_CODE (ftype
) == TYPE_CODE_XMETHOD
)
1724 struct type
*return_type
1725 = result_type_of_xmethod (argvec
[0], nargs
, argvec
+ 1);
1727 if (return_type
== NULL
)
1728 error (_("Xmethod is missing return type."));
1729 return value_zero (return_type
, not_lval
);
1731 else if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
1732 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
1734 struct type
*return_type
= TYPE_TARGET_TYPE (ftype
);
1736 if (return_type
== NULL
)
1737 return_type
= expect_type
;
1739 if (return_type
== NULL
)
1740 error_call_unknown_return_type (NULL
);
1742 return allocate_value (return_type
);
1745 error (_("Expression of type other than "
1746 "\"Function returning ...\" used as function"));
1748 switch (TYPE_CODE (value_type (argvec
[0])))
1750 case TYPE_CODE_INTERNAL_FUNCTION
:
1751 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1752 argvec
[0], nargs
, argvec
+ 1);
1753 case TYPE_CODE_XMETHOD
:
1754 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
1756 return call_function_by_hand (argvec
[0],
1757 expect_type
, nargs
, argvec
+ 1);
1759 /* pai: FIXME save value from call_function_by_hand, then adjust
1760 pc by adjust_fn_pc if +ve. */
1762 case OP_F77_UNDETERMINED_ARGLIST
:
1764 /* Remember that in F77, functions, substring ops and
1765 array subscript operations cannot be disambiguated
1766 at parse time. We have made all array subscript operations,
1767 substring operations as well as function calls come here
1768 and we now have to discover what the heck this thing actually was.
1769 If it is a function, we process just as if we got an OP_FUNCALL. */
1771 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1774 /* First determine the type code we are dealing with. */
1775 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1776 type
= check_typedef (value_type (arg1
));
1777 code
= TYPE_CODE (type
);
1779 if (code
== TYPE_CODE_PTR
)
1781 /* Fortran always passes variable to subroutines as pointer.
1782 So we need to look into its target type to see if it is
1783 array, string or function. If it is, we need to switch
1784 to the target value the original one points to. */
1785 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1787 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1788 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1789 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1791 arg1
= value_ind (arg1
);
1792 type
= check_typedef (value_type (arg1
));
1793 code
= TYPE_CODE (type
);
1799 case TYPE_CODE_ARRAY
:
1800 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1801 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1803 goto multi_f77_subscript
;
1805 case TYPE_CODE_STRING
:
1806 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1807 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1810 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1811 return value_subscript (arg1
, value_as_long (arg2
));
1815 case TYPE_CODE_FUNC
:
1816 /* It's a function call. */
1817 /* Allocate arg vector, including space for the function to be
1818 called in argvec[0] and a terminating NULL. */
1819 argvec
= (struct value
**)
1820 alloca (sizeof (struct value
*) * (nargs
+ 2));
1823 for (; tem
<= nargs
; tem
++)
1824 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1825 argvec
[tem
] = 0; /* signal end of arglist */
1826 if (noside
== EVAL_SKIP
)
1831 error (_("Cannot perform substring on this type"));
1835 /* We have a complex number, There should be 2 floating
1836 point numbers that compose it. */
1838 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1839 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1841 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1843 case STRUCTOP_STRUCT
:
1844 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1845 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1846 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1847 if (noside
== EVAL_SKIP
)
1849 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1851 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1852 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1856 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1857 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1858 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1859 if (noside
== EVAL_SKIP
)
1862 /* Check to see if operator '->' has been overloaded. If so replace
1863 arg1 with the value returned by evaluating operator->(). */
1864 while (unop_user_defined_p (op
, arg1
))
1866 struct value
*value
= NULL
;
1869 value
= value_x_unop (arg1
, op
, noside
);
1872 CATCH (except
, RETURN_MASK_ERROR
)
1874 if (except
.error
== NOT_FOUND_ERROR
)
1877 throw_exception (except
);
1884 /* JYG: if print object is on we need to replace the base type
1885 with rtti type in order to continue on with successful
1886 lookup of member / method only available in the rtti type. */
1888 struct type
*type
= value_type (arg1
);
1889 struct type
*real_type
;
1890 int full
, using_enc
;
1892 struct value_print_options opts
;
1894 get_user_print_options (&opts
);
1895 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1896 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
1898 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1901 arg1
= value_cast (real_type
, arg1
);
1905 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1906 NULL
, "structure pointer");
1907 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1908 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1911 case STRUCTOP_MEMBER
:
1913 if (op
== STRUCTOP_MEMBER
)
1914 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1916 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1918 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1920 if (noside
== EVAL_SKIP
)
1923 type
= check_typedef (value_type (arg2
));
1924 switch (TYPE_CODE (type
))
1926 case TYPE_CODE_METHODPTR
:
1927 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1928 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1931 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1932 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1933 return value_ind (arg2
);
1936 case TYPE_CODE_MEMBERPTR
:
1937 /* Now, convert these values to an address. */
1938 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1941 mem_offset
= value_as_long (arg2
);
1943 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1944 value_as_long (arg1
) + mem_offset
);
1945 return value_ind (arg3
);
1948 error (_("non-pointer-to-member value used "
1949 "in pointer-to-member construct"));
1953 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1954 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1955 for (ix
= 0; ix
< nargs
; ++ix
)
1956 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1958 expect_type
= make_params (nargs
, arg_types
);
1959 *(pos
) += 3 + nargs
;
1960 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1961 xfree (TYPE_FIELDS (expect_type
));
1962 xfree (TYPE_MAIN_TYPE (expect_type
));
1963 xfree (expect_type
);
1967 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1968 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1969 if (noside
== EVAL_SKIP
)
1971 if (binop_user_defined_p (op
, arg1
, arg2
))
1972 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1974 return value_concat (arg1
, arg2
);
1977 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1978 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1980 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1982 if (binop_user_defined_p (op
, arg1
, arg2
))
1983 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1985 return value_assign (arg1
, arg2
);
1987 case BINOP_ASSIGN_MODIFY
:
1989 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1990 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1991 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1993 op
= exp
->elts
[pc
+ 1].opcode
;
1994 if (binop_user_defined_p (op
, arg1
, arg2
))
1995 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1996 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
1998 && is_integral_type (value_type (arg2
)))
1999 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2000 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2002 && is_integral_type (value_type (arg2
)))
2003 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2006 struct value
*tmp
= arg1
;
2008 /* For shift and integer exponentiation operations,
2009 only promote the first argument. */
2010 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2011 && is_integral_type (value_type (arg2
)))
2012 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2014 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2016 arg2
= value_binop (tmp
, arg2
, op
);
2018 return value_assign (arg1
, arg2
);
2021 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2022 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2023 if (noside
== EVAL_SKIP
)
2025 if (binop_user_defined_p (op
, arg1
, arg2
))
2026 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2027 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2028 && is_integral_type (value_type (arg2
)))
2029 return value_ptradd (arg1
, value_as_long (arg2
));
2030 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2031 && is_integral_type (value_type (arg1
)))
2032 return value_ptradd (arg2
, value_as_long (arg1
));
2035 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2036 return value_binop (arg1
, arg2
, BINOP_ADD
);
2040 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2041 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2042 if (noside
== EVAL_SKIP
)
2044 if (binop_user_defined_p (op
, arg1
, arg2
))
2045 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2046 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2047 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2049 /* FIXME -- should be ptrdiff_t */
2050 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2051 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2053 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2054 && is_integral_type (value_type (arg2
)))
2055 return value_ptradd (arg1
, - value_as_long (arg2
));
2058 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2059 return value_binop (arg1
, arg2
, BINOP_SUB
);
2070 case BINOP_BITWISE_AND
:
2071 case BINOP_BITWISE_IOR
:
2072 case BINOP_BITWISE_XOR
:
2073 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2074 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2075 if (noside
== EVAL_SKIP
)
2077 if (binop_user_defined_p (op
, arg1
, arg2
))
2078 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2081 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2082 fudge arg2 to avoid division-by-zero, the caller is
2083 (theoretically) only looking for the type of the result. */
2084 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2085 /* ??? Do we really want to test for BINOP_MOD here?
2086 The implementation of value_binop gives it a well-defined
2089 || op
== BINOP_INTDIV
2092 && value_logical_not (arg2
))
2094 struct value
*v_one
, *retval
;
2096 v_one
= value_one (value_type (arg2
));
2097 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2098 retval
= value_binop (arg1
, v_one
, op
);
2103 /* For shift and integer exponentiation operations,
2104 only promote the first argument. */
2105 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2106 && is_integral_type (value_type (arg2
)))
2107 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2109 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2111 return value_binop (arg1
, arg2
, op
);
2115 case BINOP_SUBSCRIPT
:
2116 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2117 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2118 if (noside
== EVAL_SKIP
)
2120 if (binop_user_defined_p (op
, arg1
, arg2
))
2121 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2124 /* If the user attempts to subscript something that is not an
2125 array or pointer type (like a plain int variable for example),
2126 then report this as an error. */
2128 arg1
= coerce_ref (arg1
);
2129 type
= check_typedef (value_type (arg1
));
2130 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2131 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2133 if (TYPE_NAME (type
))
2134 error (_("cannot subscript something of type `%s'"),
2137 error (_("cannot subscript requested type"));
2140 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2141 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2143 return value_subscript (arg1
, value_as_long (arg2
));
2145 case MULTI_SUBSCRIPT
:
2147 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2148 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2151 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2152 /* FIXME: EVAL_SKIP handling may not be correct. */
2153 if (noside
== EVAL_SKIP
)
2164 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2165 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2167 /* If the user attempts to subscript something that has no target
2168 type (like a plain int variable for example), then report this
2171 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2174 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2180 error (_("cannot subscript something of type `%s'"),
2181 TYPE_NAME (value_type (arg1
)));
2185 if (binop_user_defined_p (op
, arg1
, arg2
))
2187 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2191 arg1
= coerce_ref (arg1
);
2192 type
= check_typedef (value_type (arg1
));
2194 switch (TYPE_CODE (type
))
2197 case TYPE_CODE_ARRAY
:
2198 case TYPE_CODE_STRING
:
2199 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2203 if (TYPE_NAME (type
))
2204 error (_("cannot subscript something of type `%s'"),
2207 error (_("cannot subscript requested type"));
2213 multi_f77_subscript
:
2215 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2216 int ndimensions
= 1, i
;
2217 struct value
*array
= arg1
;
2219 if (nargs
> MAX_FORTRAN_DIMS
)
2220 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2222 ndimensions
= calc_f77_array_dims (type
);
2224 if (nargs
!= ndimensions
)
2225 error (_("Wrong number of subscripts"));
2227 gdb_assert (nargs
> 0);
2229 /* Now that we know we have a legal array subscript expression
2230 let us actually find out where this element exists in the array. */
2232 /* Take array indices left to right. */
2233 for (i
= 0; i
< nargs
; i
++)
2235 /* Evaluate each subscript; it must be a legal integer in F77. */
2236 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2238 /* Fill in the subscript array. */
2240 subscript_array
[i
] = value_as_long (arg2
);
2243 /* Internal type of array is arranged right to left. */
2244 for (i
= nargs
; i
> 0; i
--)
2246 struct type
*array_type
= check_typedef (value_type (array
));
2247 LONGEST index
= subscript_array
[i
- 1];
2249 array
= value_subscripted_rvalue (array
, index
,
2250 f77_get_lowerbound (array_type
));
2256 case BINOP_LOGICAL_AND
:
2257 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2258 if (noside
== EVAL_SKIP
)
2260 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2265 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2268 if (binop_user_defined_p (op
, arg1
, arg2
))
2270 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2271 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2275 tem
= value_logical_not (arg1
);
2276 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2277 (tem
? EVAL_SKIP
: noside
));
2278 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2279 return value_from_longest (type
,
2280 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2283 case BINOP_LOGICAL_OR
:
2284 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2285 if (noside
== EVAL_SKIP
)
2287 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2292 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2295 if (binop_user_defined_p (op
, arg1
, arg2
))
2297 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2298 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2302 tem
= value_logical_not (arg1
);
2303 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2304 (!tem
? EVAL_SKIP
: noside
));
2305 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2306 return value_from_longest (type
,
2307 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2311 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2312 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2313 if (noside
== EVAL_SKIP
)
2315 if (binop_user_defined_p (op
, arg1
, arg2
))
2317 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2321 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2322 tem
= value_equal (arg1
, arg2
);
2323 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2324 return value_from_longest (type
, (LONGEST
) tem
);
2327 case BINOP_NOTEQUAL
:
2328 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2329 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2330 if (noside
== EVAL_SKIP
)
2332 if (binop_user_defined_p (op
, arg1
, arg2
))
2334 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2338 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2339 tem
= value_equal (arg1
, arg2
);
2340 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2341 return value_from_longest (type
, (LONGEST
) ! tem
);
2345 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2346 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2347 if (noside
== EVAL_SKIP
)
2349 if (binop_user_defined_p (op
, arg1
, arg2
))
2351 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2355 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2356 tem
= value_less (arg1
, arg2
);
2357 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2358 return value_from_longest (type
, (LONGEST
) tem
);
2362 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2363 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2364 if (noside
== EVAL_SKIP
)
2366 if (binop_user_defined_p (op
, arg1
, arg2
))
2368 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2372 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2373 tem
= value_less (arg2
, arg1
);
2374 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2375 return value_from_longest (type
, (LONGEST
) tem
);
2379 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2380 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2381 if (noside
== EVAL_SKIP
)
2383 if (binop_user_defined_p (op
, arg1
, arg2
))
2385 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2389 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2390 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2391 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2392 return value_from_longest (type
, (LONGEST
) tem
);
2396 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2397 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2398 if (noside
== EVAL_SKIP
)
2400 if (binop_user_defined_p (op
, arg1
, arg2
))
2402 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2406 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2407 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2408 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2409 return value_from_longest (type
, (LONGEST
) tem
);
2413 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2414 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2415 if (noside
== EVAL_SKIP
)
2417 type
= check_typedef (value_type (arg2
));
2418 if (TYPE_CODE (type
) != TYPE_CODE_INT
2419 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
2420 error (_("Non-integral right operand for \"@\" operator."));
2421 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2423 return allocate_repeat_value (value_type (arg1
),
2424 longest_to_int (value_as_long (arg2
)));
2427 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2430 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2431 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2434 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2435 if (noside
== EVAL_SKIP
)
2437 if (unop_user_defined_p (op
, arg1
))
2438 return value_x_unop (arg1
, op
, noside
);
2441 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2442 return value_pos (arg1
);
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_neg (arg1
);
2457 case UNOP_COMPLEMENT
:
2458 /* C++: check for and handle destructor names. */
2459 op
= exp
->elts
[*pos
].opcode
;
2461 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2462 if (noside
== EVAL_SKIP
)
2464 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2465 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2468 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2469 return value_complement (arg1
);
2472 case UNOP_LOGICAL_NOT
:
2473 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2474 if (noside
== EVAL_SKIP
)
2476 if (unop_user_defined_p (op
, arg1
))
2477 return value_x_unop (arg1
, op
, noside
);
2480 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2481 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2485 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2486 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2487 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2488 type
= check_typedef (value_type (arg1
));
2489 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2490 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2491 error (_("Attempt to dereference pointer "
2492 "to member without an object"));
2493 if (noside
== EVAL_SKIP
)
2495 if (unop_user_defined_p (op
, arg1
))
2496 return value_x_unop (arg1
, op
, noside
);
2497 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2499 type
= check_typedef (value_type (arg1
));
2500 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2501 || TYPE_IS_REFERENCE (type
)
2502 /* In C you can dereference an array to get the 1st elt. */
2503 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2505 return value_zero (TYPE_TARGET_TYPE (type
),
2507 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2508 /* GDB allows dereferencing an int. */
2509 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2512 error (_("Attempt to take contents of a non-pointer value."));
2515 /* Allow * on an integer so we can cast it to whatever we want.
2516 This returns an int, which seems like the most C-like thing to
2517 do. "long long" variables are rare enough that
2518 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2519 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2520 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2521 (CORE_ADDR
) value_as_address (arg1
));
2522 return value_ind (arg1
);
2525 /* C++: check for and handle pointer to members. */
2527 op
= exp
->elts
[*pos
].opcode
;
2529 if (noside
== EVAL_SKIP
)
2531 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2536 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2543 if (noside
== EVAL_SKIP
)
2545 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2548 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2552 type
= exp
->elts
[pc
+ 1].type
;
2553 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2554 if (noside
== EVAL_SKIP
)
2556 if (type
!= value_type (arg1
))
2557 arg1
= value_cast (type
, arg1
);
2560 case UNOP_CAST_TYPE
:
2561 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2562 type
= value_type (arg1
);
2563 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2564 if (noside
== EVAL_SKIP
)
2566 if (type
!= value_type (arg1
))
2567 arg1
= value_cast (type
, arg1
);
2570 case UNOP_DYNAMIC_CAST
:
2571 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2572 type
= value_type (arg1
);
2573 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2574 if (noside
== EVAL_SKIP
)
2576 return value_dynamic_cast (type
, arg1
);
2578 case UNOP_REINTERPRET_CAST
:
2579 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2580 type
= value_type (arg1
);
2581 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2582 if (noside
== EVAL_SKIP
)
2584 return value_reinterpret_cast (type
, arg1
);
2588 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2589 if (noside
== EVAL_SKIP
)
2591 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2592 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2594 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2595 value_as_address (arg1
));
2597 case UNOP_MEMVAL_TYPE
:
2598 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2599 type
= value_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 (type
, lval_memory
);
2606 return value_at_lazy (type
, value_as_address (arg1
));
2608 case UNOP_MEMVAL_TLS
:
2610 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2611 if (noside
== EVAL_SKIP
)
2613 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2614 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2619 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2620 value_as_address (arg1
));
2621 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2624 case UNOP_PREINCREMENT
:
2625 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2626 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2628 else if (unop_user_defined_p (op
, arg1
))
2630 return value_x_unop (arg1
, op
, noside
);
2634 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2635 arg2
= value_ptradd (arg1
, 1);
2638 struct value
*tmp
= arg1
;
2640 arg2
= value_one (value_type (arg1
));
2641 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2642 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2645 return value_assign (arg1
, arg2
);
2648 case UNOP_PREDECREMENT
:
2649 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2650 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2652 else if (unop_user_defined_p (op
, arg1
))
2654 return value_x_unop (arg1
, op
, noside
);
2658 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2659 arg2
= value_ptradd (arg1
, -1);
2662 struct value
*tmp
= arg1
;
2664 arg2
= value_one (value_type (arg1
));
2665 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2666 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2669 return value_assign (arg1
, arg2
);
2672 case UNOP_POSTINCREMENT
:
2673 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2674 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2676 else if (unop_user_defined_p (op
, arg1
))
2678 return value_x_unop (arg1
, op
, noside
);
2682 arg3
= value_non_lval (arg1
);
2684 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2685 arg2
= value_ptradd (arg1
, 1);
2688 struct value
*tmp
= arg1
;
2690 arg2
= value_one (value_type (arg1
));
2691 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2692 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2695 value_assign (arg1
, arg2
);
2699 case UNOP_POSTDECREMENT
:
2700 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2701 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2703 else if (unop_user_defined_p (op
, arg1
))
2705 return value_x_unop (arg1
, op
, noside
);
2709 arg3
= value_non_lval (arg1
);
2711 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2712 arg2
= value_ptradd (arg1
, -1);
2715 struct value
*tmp
= arg1
;
2717 arg2
= value_one (value_type (arg1
));
2718 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2719 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2722 value_assign (arg1
, arg2
);
2728 return value_of_this (exp
->language_defn
);
2731 /* The value is not supposed to be used. This is here to make it
2732 easier to accommodate expressions that contain types. */
2734 if (noside
== EVAL_SKIP
)
2736 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2737 return allocate_value (exp
->elts
[pc
+ 1].type
);
2739 error (_("Attempt to use a type name as an expression"));
2743 if (noside
== EVAL_SKIP
)
2745 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2748 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2750 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2751 struct value
*result
;
2753 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2754 EVAL_AVOID_SIDE_EFFECTS
);
2756 /* 'decltype' has special semantics for lvalues. */
2757 if (op
== OP_DECLTYPE
2758 && (sub_op
== BINOP_SUBSCRIPT
2759 || sub_op
== STRUCTOP_MEMBER
2760 || sub_op
== STRUCTOP_MPTR
2761 || sub_op
== UNOP_IND
2762 || sub_op
== STRUCTOP_STRUCT
2763 || sub_op
== STRUCTOP_PTR
2764 || sub_op
== OP_SCOPE
))
2766 struct type
*type
= value_type (result
);
2768 if (!TYPE_IS_REFERENCE (type
))
2770 type
= lookup_lvalue_reference_type (type
);
2771 result
= allocate_value (type
);
2778 error (_("Attempt to use a type as an expression"));
2782 struct value
*result
;
2783 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2785 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2786 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2787 EVAL_AVOID_SIDE_EFFECTS
);
2789 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2791 if (noside
!= EVAL_NORMAL
)
2792 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2794 return cplus_typeid (result
);
2798 /* Removing this case and compiling with gcc -Wall reveals that
2799 a lot of cases are hitting this case. Some of these should
2800 probably be removed from expression.h; others are legitimate
2801 expressions which are (apparently) not fully implemented.
2803 If there are any cases landing here which mean a user error,
2804 then they should be separate cases, with more descriptive
2807 error (_("GDB does not (yet) know how to "
2808 "evaluate that kind of expression"));
2812 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2815 /* Evaluate a subexpression of EXP, at index *POS,
2816 and return the address of that subexpression.
2817 Advance *POS over the subexpression.
2818 If the subexpression isn't an lvalue, get an error.
2819 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2820 then only the type of the result need be correct. */
2822 static struct value
*
2823 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2833 op
= exp
->elts
[pc
].opcode
;
2839 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2841 /* We can't optimize out "&*" if there's a user-defined operator*. */
2842 if (unop_user_defined_p (op
, x
))
2844 x
= value_x_unop (x
, op
, noside
);
2845 goto default_case_after_eval
;
2848 return coerce_array (x
);
2852 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2853 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2855 case UNOP_MEMVAL_TYPE
:
2860 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2861 type
= value_type (x
);
2862 return value_cast (lookup_pointer_type (type
),
2863 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2867 var
= exp
->elts
[pc
+ 2].symbol
;
2869 /* C++: The "address" of a reference should yield the address
2870 * of the object pointed to. Let value_addr() deal with it. */
2871 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2875 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2878 lookup_pointer_type (SYMBOL_TYPE (var
));
2879 enum address_class sym_class
= SYMBOL_CLASS (var
);
2881 if (sym_class
== LOC_CONST
2882 || sym_class
== LOC_CONST_BYTES
2883 || sym_class
== LOC_REGISTER
)
2884 error (_("Attempt to take address of register or constant."));
2887 value_zero (type
, not_lval
);
2890 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2893 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2894 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2895 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2896 &exp
->elts
[pc
+ 3].string
,
2899 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2904 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2905 default_case_after_eval
:
2906 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2908 struct type
*type
= check_typedef (value_type (x
));
2910 if (TYPE_IS_REFERENCE (type
))
2911 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2913 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2914 return value_zero (lookup_pointer_type (value_type (x
)),
2917 error (_("Attempt to take address of "
2918 "value not located in memory."));
2920 return value_addr (x
);
2924 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2925 When used in contexts where arrays will be coerced anyway, this is
2926 equivalent to `evaluate_subexp' but much faster because it avoids
2927 actually fetching array contents (perhaps obsolete now that we have
2930 Note that we currently only do the coercion for C expressions, where
2931 arrays are zero based and the coercion is correct. For other languages,
2932 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2933 to decide if coercion is appropriate. */
2936 evaluate_subexp_with_coercion (struct expression
*exp
,
2937 int *pos
, enum noside noside
)
2946 op
= exp
->elts
[pc
].opcode
;
2951 var
= exp
->elts
[pc
+ 2].symbol
;
2952 type
= check_typedef (SYMBOL_TYPE (var
));
2953 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2954 && !TYPE_VECTOR (type
)
2955 && CAST_IS_CONVERSION (exp
->language_defn
))
2958 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2959 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2965 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2969 /* Evaluate a subexpression of EXP, at index *POS,
2970 and return a value for the size of that subexpression.
2971 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2972 we allow side-effects on the operand if its type is a variable
2975 static struct value
*
2976 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2979 /* FIXME: This should be size_t. */
2980 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2987 op
= exp
->elts
[pc
].opcode
;
2991 /* This case is handled specially
2992 so that we avoid creating a value for the result type.
2993 If the result type is very big, it's desirable not to
2994 create a value unnecessarily. */
2997 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2998 type
= check_typedef (value_type (val
));
2999 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3000 && !TYPE_IS_REFERENCE (type
)
3001 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3002 error (_("Attempt to take contents of a non-pointer value."));
3003 type
= TYPE_TARGET_TYPE (type
);
3004 if (is_dynamic_type (type
))
3005 type
= value_type (value_ind (val
));
3006 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3010 type
= exp
->elts
[pc
+ 1].type
;
3013 case UNOP_MEMVAL_TYPE
:
3015 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3016 type
= value_type (val
);
3020 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3021 if (is_dynamic_type (type
))
3023 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3024 type
= value_type (val
);
3030 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3031 type of the subscript is a variable length array type. In this case we
3032 must re-evaluate the right hand side of the subcription to allow
3034 case BINOP_SUBSCRIPT
:
3035 if (noside
== EVAL_NORMAL
)
3037 int pc
= (*pos
) + 1;
3039 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3040 type
= check_typedef (value_type (val
));
3041 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3043 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3044 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3046 type
= TYPE_INDEX_TYPE (type
);
3047 /* Only re-evaluate the right hand side if the resulting type
3048 is a variable length type. */
3049 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3051 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3052 return value_from_longest
3053 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3062 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3063 type
= value_type (val
);
3067 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3068 "When applied to a reference or a reference type, the result is
3069 the size of the referenced type." */
3070 type
= check_typedef (type
);
3071 if (exp
->language_defn
->la_language
== language_cplus
3072 && (TYPE_IS_REFERENCE (type
)))
3073 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3074 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3077 /* Parse a type expression in the string [P..P+LENGTH). */
3080 parse_and_eval_type (char *p
, int length
)
3082 char *tmp
= (char *) alloca (length
+ 4);
3085 memcpy (tmp
+ 1, p
, length
);
3086 tmp
[length
+ 1] = ')';
3087 tmp
[length
+ 2] = '0';
3088 tmp
[length
+ 3] = '\0';
3089 expression_up expr
= parse_expression (tmp
);
3090 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3091 error (_("Internal error in eval_type."));
3092 return expr
->elts
[1].type
;
3096 calc_f77_array_dims (struct type
*array_type
)
3099 struct type
*tmp_type
;
3101 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3102 error (_("Can't get dimensions for a non-array type"));
3104 tmp_type
= array_type
;
3106 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3108 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)