1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdbthread.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
29 #include "f-lang.h" /* For array bound stuff. */
32 #include "objc-lang.h"
34 #include "parser-defs.h"
35 #include "cp-support.h"
38 #include "user-regs.h"
40 #include "gdb_obstack.h"
44 /* This is defined in valops.c */
45 extern int overload_resolution
;
47 /* Prototypes for local functions. */
49 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
52 static struct value
*evaluate_subexp_for_address (struct expression
*,
55 static struct value
*evaluate_struct_tuple (struct value
*,
56 struct expression
*, int *,
59 static LONGEST
init_array_element (struct value
*, struct value
*,
60 struct expression
*, int *, enum noside
,
64 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
65 int *pos
, enum noside noside
)
67 struct cleanup
*cleanups
;
69 int cleanup_temps
= 0;
71 if (*pos
== 0 && target_has_execution
72 && exp
->language_defn
->la_language
== language_cplus
73 && !thread_stack_temporaries_enabled_p (inferior_ptid
))
75 cleanups
= enable_thread_stack_temporaries (inferior_ptid
);
79 retval
= (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
80 (expect_type
, exp
, pos
, noside
);
84 if (value_in_thread_stack_temporaries (retval
, inferior_ptid
))
85 retval
= value_non_lval (retval
);
86 do_cleanups (cleanups
);
92 /* Parse the string EXP as a C expression, evaluate it,
93 and return the result as a number. */
96 parse_and_eval_address (const char *exp
)
98 struct expression
*expr
= parse_expression (exp
);
100 struct cleanup
*old_chain
=
101 make_cleanup (free_current_contents
, &expr
);
103 addr
= value_as_address (evaluate_expression (expr
));
104 do_cleanups (old_chain
);
108 /* Like parse_and_eval_address, but treats the value of the expression
109 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
111 parse_and_eval_long (const char *exp
)
113 struct expression
*expr
= parse_expression (exp
);
115 struct cleanup
*old_chain
=
116 make_cleanup (free_current_contents
, &expr
);
118 retval
= value_as_long (evaluate_expression (expr
));
119 do_cleanups (old_chain
);
124 parse_and_eval (const char *exp
)
126 struct expression
*expr
= parse_expression (exp
);
128 struct cleanup
*old_chain
=
129 make_cleanup (free_current_contents
, &expr
);
131 val
= evaluate_expression (expr
);
132 do_cleanups (old_chain
);
136 /* Parse up to a comma (or to a closeparen)
137 in the string EXPP as an expression, evaluate it, and return the value.
138 EXPP is advanced to point to the comma. */
141 parse_to_comma_and_eval (const char **expp
)
143 struct expression
*expr
= parse_exp_1 (expp
, 0, (struct block
*) 0, 1);
145 struct cleanup
*old_chain
=
146 make_cleanup (free_current_contents
, &expr
);
148 val
= evaluate_expression (expr
);
149 do_cleanups (old_chain
);
153 /* Evaluate an expression in internal prefix form
154 such as is constructed by parse.y.
156 See expression.h for info on the format of an expression. */
159 evaluate_expression (struct expression
*exp
)
163 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
166 /* Evaluate an expression, avoiding all memory references
167 and getting a value whose type alone is correct. */
170 evaluate_type (struct expression
*exp
)
174 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
177 /* Evaluate a subexpression, avoiding all memory references and
178 getting a value whose type alone is correct. */
181 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
183 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
186 /* Find the current value of a watchpoint on EXP. Return the value in
187 *VALP and *RESULTP and the chain of intermediate and final values
188 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
191 If PRESERVE_ERRORS is true, then exceptions are passed through.
192 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
193 occurs while evaluating the expression, *RESULTP will be set to
194 NULL. *RESULTP may be a lazy value, if the result could not be
195 read from memory. It is used to determine whether a value is
196 user-specified (we should watch the whole value) or intermediate
197 (we should watch only the bit used to locate the final value).
199 If the final value, or any intermediate value, could not be read
200 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
201 set to any referenced values. *VALP will never be a lazy value.
202 This is the value which we store in struct breakpoint.
204 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
205 value chain. The caller must free the values individually. If
206 VAL_CHAIN is NULL, all generated values will be left on the value
210 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
211 struct value
**resultp
, struct value
**val_chain
,
214 struct value
*mark
, *new_mark
, *result
;
215 volatile struct gdb_exception ex
;
223 /* Evaluate the expression. */
224 mark
= value_mark ();
227 TRY_CATCH (ex
, RETURN_MASK_ALL
)
229 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
233 /* Ignore memory errors if we want watchpoints pointing at
234 inaccessible memory to still be created; otherwise, throw the
235 error to some higher catcher. */
239 if (!preserve_errors
)
242 throw_exception (ex
);
247 new_mark
= value_mark ();
248 if (mark
== new_mark
)
253 /* Make sure it's not lazy, so that after the target stops again we
254 have a non-lazy previous value to compare with. */
257 if (!value_lazy (result
))
261 volatile struct gdb_exception except
;
263 TRY_CATCH (except
, RETURN_MASK_ERROR
)
265 value_fetch_lazy (result
);
273 /* Return the chain of intermediate values. We use this to
274 decide which addresses to watch. */
275 *val_chain
= new_mark
;
276 value_release_to_mark (mark
);
280 /* Extract a field operation from an expression. If the subexpression
281 of EXP starting at *SUBEXP is not a structure dereference
282 operation, return NULL. Otherwise, return the name of the
283 dereferenced field, and advance *SUBEXP to point to the
284 subexpression of the left-hand-side of the dereference. This is
285 used when completing field names. */
288 extract_field_op (struct expression
*exp
, int *subexp
)
293 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
294 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
296 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
297 result
= &exp
->elts
[*subexp
+ 2].string
;
298 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
302 /* This function evaluates brace-initializers (in C/C++) for
305 static struct value
*
306 evaluate_struct_tuple (struct value
*struct_val
,
307 struct expression
*exp
,
308 int *pos
, enum noside noside
, int nargs
)
310 struct type
*struct_type
= check_typedef (value_type (struct_val
));
311 struct type
*field_type
;
316 struct value
*val
= NULL
;
321 /* Skip static fields. */
322 while (fieldno
< TYPE_NFIELDS (struct_type
)
323 && field_is_static (&TYPE_FIELD (struct_type
,
326 if (fieldno
>= TYPE_NFIELDS (struct_type
))
327 error (_("too many initializers"));
328 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
329 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
330 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
331 error (_("don't know which variant you want to set"));
333 /* Here, struct_type is the type of the inner struct,
334 while substruct_type is the type of the inner struct.
335 These are the same for normal structures, but a variant struct
336 contains anonymous union fields that contain substruct fields.
337 The value fieldno is the index of the top-level (normal or
338 anonymous union) field in struct_field, while the value
339 subfieldno is the index of the actual real (named inner) field
340 in substruct_type. */
342 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
344 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
346 /* Now actually set the field in struct_val. */
348 /* Assign val to field fieldno. */
349 if (value_type (val
) != field_type
)
350 val
= value_cast (field_type
, val
);
352 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
353 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
354 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
356 modify_field (struct_type
, addr
,
357 value_as_long (val
), bitpos
% 8, bitsize
);
359 memcpy (addr
, value_contents (val
),
360 TYPE_LENGTH (value_type (val
)));
366 /* Recursive helper function for setting elements of array tuples.
367 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
368 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
369 Evaluates index expresions and sets the specified element(s) of
370 ARRAY to ELEMENT. Returns last index value. */
373 init_array_element (struct value
*array
, struct value
*element
,
374 struct expression
*exp
, int *pos
,
375 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
378 int element_size
= TYPE_LENGTH (value_type (element
));
380 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
383 init_array_element (array
, element
, exp
, pos
, noside
,
384 low_bound
, high_bound
);
385 return init_array_element (array
, element
,
386 exp
, pos
, noside
, low_bound
, high_bound
);
390 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
391 if (index
< low_bound
|| index
> high_bound
)
392 error (_("tuple index out of range"));
393 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
394 value_contents (element
), element_size
);
399 static struct value
*
400 value_f90_subarray (struct value
*array
,
401 struct expression
*exp
, int *pos
, enum noside noside
)
404 LONGEST low_bound
, high_bound
;
405 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
406 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
410 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
411 low_bound
= TYPE_LOW_BOUND (range
);
413 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
415 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
416 high_bound
= TYPE_HIGH_BOUND (range
);
418 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
420 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
424 /* Promote value ARG1 as appropriate before performing a unary operation
426 If the result is not appropriate for any particular language then it
427 needs to patch this function. */
430 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
435 *arg1
= coerce_ref (*arg1
);
436 type1
= check_typedef (value_type (*arg1
));
438 if (is_integral_type (type1
))
440 switch (language
->la_language
)
443 /* Perform integral promotion for ANSI C/C++.
444 If not appropropriate for any particular language
445 it needs to modify this function. */
447 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
449 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
450 *arg1
= value_cast (builtin_int
, *arg1
);
457 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
458 operation on those two operands.
459 If the result is not appropriate for any particular language then it
460 needs to patch this function. */
463 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
464 struct value
**arg1
, struct value
**arg2
)
466 struct type
*promoted_type
= NULL
;
470 *arg1
= coerce_ref (*arg1
);
471 *arg2
= coerce_ref (*arg2
);
473 type1
= check_typedef (value_type (*arg1
));
474 type2
= check_typedef (value_type (*arg2
));
476 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
477 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
478 && !is_integral_type (type1
))
479 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
480 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
481 && !is_integral_type (type2
)))
484 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
485 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
487 /* No promotion required. */
489 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
490 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
492 switch (language
->la_language
)
498 case language_opencl
:
499 /* No promotion required. */
503 /* For other languages the result type is unchanged from gdb
504 version 6.7 for backward compatibility.
505 If either arg was long double, make sure that value is also long
506 double. Otherwise use double. */
507 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
508 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
509 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
511 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
515 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
516 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
518 /* No promotion required. */
521 /* Integral operations here. */
522 /* FIXME: Also mixed integral/booleans, with result an integer. */
524 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
525 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
526 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
527 int is_unsigned1
= TYPE_UNSIGNED (type1
);
528 int is_unsigned2
= TYPE_UNSIGNED (type2
);
529 unsigned int result_len
;
530 int unsigned_operation
;
532 /* Determine type length and signedness after promotion for
534 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
537 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
539 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
542 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
545 if (promoted_len1
> promoted_len2
)
547 unsigned_operation
= is_unsigned1
;
548 result_len
= promoted_len1
;
550 else if (promoted_len2
> promoted_len1
)
552 unsigned_operation
= is_unsigned2
;
553 result_len
= promoted_len2
;
557 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
558 result_len
= promoted_len1
;
561 switch (language
->la_language
)
567 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
569 promoted_type
= (unsigned_operation
570 ? builtin
->builtin_unsigned_int
571 : builtin
->builtin_int
);
573 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
575 promoted_type
= (unsigned_operation
576 ? builtin
->builtin_unsigned_long
577 : builtin
->builtin_long
);
581 promoted_type
= (unsigned_operation
582 ? builtin
->builtin_unsigned_long_long
583 : builtin
->builtin_long_long
);
586 case language_opencl
:
587 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
588 (language
, gdbarch
, "int")))
592 ? lookup_unsigned_typename (language
, gdbarch
, "int")
593 : lookup_signed_typename (language
, gdbarch
, "int"));
595 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
596 (language
, gdbarch
, "long")))
600 ? lookup_unsigned_typename (language
, gdbarch
, "long")
601 : lookup_signed_typename (language
, gdbarch
,"long"));
605 /* For other languages the result type is unchanged from gdb
606 version 6.7 for backward compatibility.
607 If either arg was long long, make sure that value is also long
608 long. Otherwise use long. */
609 if (unsigned_operation
)
611 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
612 promoted_type
= builtin
->builtin_unsigned_long_long
;
614 promoted_type
= builtin
->builtin_unsigned_long
;
618 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
619 promoted_type
= builtin
->builtin_long_long
;
621 promoted_type
= builtin
->builtin_long
;
629 /* Promote both operands to common type. */
630 *arg1
= value_cast (promoted_type
, *arg1
);
631 *arg2
= value_cast (promoted_type
, *arg2
);
636 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
638 type
= check_typedef (type
);
639 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
640 type
= TYPE_TARGET_TYPE (type
);
642 switch (TYPE_CODE (type
))
648 case TYPE_CODE_ARRAY
:
649 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
656 /* Constructs a fake method with the given parameter types.
657 This function is used by the parser to construct an "expected"
658 type for method overload resolution. */
661 make_params (int num_types
, struct type
**param_types
)
663 struct type
*type
= XCNEW (struct type
);
664 TYPE_MAIN_TYPE (type
) = XCNEW (struct main_type
);
665 TYPE_LENGTH (type
) = 1;
666 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
667 TYPE_VPTR_FIELDNO (type
) = -1;
668 TYPE_CHAIN (type
) = type
;
671 if (param_types
[num_types
- 1] == NULL
)
674 TYPE_VARARGS (type
) = 1;
676 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
680 /* Caller should have ensured this. */
681 gdb_assert (num_types
== 0);
682 TYPE_PROTOTYPED (type
) = 1;
686 TYPE_NFIELDS (type
) = num_types
;
687 TYPE_FIELDS (type
) = (struct field
*)
688 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
690 while (num_types
-- > 0)
691 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
697 evaluate_subexp_standard (struct type
*expect_type
,
698 struct expression
*exp
, int *pos
,
703 int pc
, pc2
= 0, oldpos
;
704 struct value
*arg1
= NULL
;
705 struct value
*arg2
= NULL
;
709 struct value
**argvec
;
713 struct type
**arg_types
;
715 struct symbol
*function
= NULL
;
716 char *function_name
= NULL
;
719 op
= exp
->elts
[pc
].opcode
;
724 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
725 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
726 if (noside
== EVAL_SKIP
)
728 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
729 &exp
->elts
[pc
+ 3].string
,
730 expect_type
, 0, noside
);
732 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
737 return value_from_longest (exp
->elts
[pc
+ 1].type
,
738 exp
->elts
[pc
+ 2].longconst
);
742 return value_from_double (exp
->elts
[pc
+ 1].type
,
743 exp
->elts
[pc
+ 2].doubleconst
);
747 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
748 exp
->elts
[pc
+ 2].decfloatconst
);
753 if (noside
== EVAL_SKIP
)
756 /* JYG: We used to just return value_zero of the symbol type
757 if we're asked to avoid side effects. Otherwise we return
758 value_of_variable (...). However I'm not sure if
759 value_of_variable () has any side effect.
760 We need a full value object returned here for whatis_exp ()
761 to call evaluate_type () and then pass the full value to
762 value_rtti_target_type () if we are dealing with a pointer
763 or reference to a base class and print object is on. */
766 volatile struct gdb_exception except
;
767 struct value
*ret
= NULL
;
769 TRY_CATCH (except
, RETURN_MASK_ERROR
)
771 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
772 exp
->elts
[pc
+ 1].block
);
775 if (except
.reason
< 0)
777 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
778 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
781 throw_exception (except
);
787 case OP_VAR_ENTRY_VALUE
:
789 if (noside
== EVAL_SKIP
)
793 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
794 struct frame_info
*frame
;
796 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
797 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
799 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
800 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
801 error (_("Symbol \"%s\" does not have any specific entry value"),
802 SYMBOL_PRINT_NAME (sym
));
804 frame
= get_selected_frame (NULL
);
805 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
811 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
815 const char *name
= &exp
->elts
[pc
+ 2].string
;
819 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
820 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
821 name
, strlen (name
));
823 error (_("Register $%s not available."), name
);
825 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
826 a value with the appropriate register type. Unfortunately,
827 we don't have easy access to the type of user registers.
828 So for these registers, we fetch the register value regardless
829 of the evaluation mode. */
830 if (noside
== EVAL_AVOID_SIDE_EFFECTS
831 && regno
< gdbarch_num_regs (exp
->gdbarch
)
832 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
833 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
835 val
= value_of_register (regno
, get_selected_frame (NULL
));
837 error (_("Value of register %s not available."), name
);
843 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
844 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
848 return value_of_internalvar (exp
->gdbarch
,
849 exp
->elts
[pc
+ 1].internalvar
);
852 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
853 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
854 if (noside
== EVAL_SKIP
)
856 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
857 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
859 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
860 NSString constant. */
861 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
862 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
863 if (noside
== EVAL_SKIP
)
867 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
871 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
872 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
873 nargs
= tem3
- tem2
+ 1;
874 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
876 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
877 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
879 struct value
*rec
= allocate_value (expect_type
);
881 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
882 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
885 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
886 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
888 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
889 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
890 struct value
*array
= allocate_value (expect_type
);
891 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
892 LONGEST low_bound
, high_bound
, index
;
894 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
897 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
900 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
901 for (tem
= nargs
; --nargs
>= 0;)
903 struct value
*element
;
906 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
907 if (value_type (element
) != element_type
)
908 element
= value_cast (element_type
, element
);
911 int continue_pc
= *pos
;
914 index
= init_array_element (array
, element
, exp
, pos
, noside
,
915 low_bound
, high_bound
);
920 if (index
> high_bound
)
921 /* To avoid memory corruption. */
922 error (_("Too many array elements"));
923 memcpy (value_contents_raw (array
)
924 + (index
- low_bound
) * element_size
,
925 value_contents (element
),
933 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
934 && TYPE_CODE (type
) == TYPE_CODE_SET
)
936 struct value
*set
= allocate_value (expect_type
);
937 gdb_byte
*valaddr
= value_contents_raw (set
);
938 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
939 struct type
*check_type
= element_type
;
940 LONGEST low_bound
, high_bound
;
942 /* Get targettype of elementtype. */
943 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
944 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
945 check_type
= TYPE_TARGET_TYPE (check_type
);
947 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
948 error (_("(power)set type with unknown size"));
949 memset (valaddr
, '\0', TYPE_LENGTH (type
));
950 for (tem
= 0; tem
< nargs
; tem
++)
952 LONGEST range_low
, range_high
;
953 struct type
*range_low_type
, *range_high_type
;
954 struct value
*elem_val
;
956 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
957 range_low_type
= range_high_type
= value_type (elem_val
);
958 range_low
= range_high
= value_as_long (elem_val
);
960 /* Check types of elements to avoid mixture of elements from
961 different types. Also check if type of element is "compatible"
962 with element type of powerset. */
963 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
964 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
965 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
966 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
967 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
968 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
969 && (range_low_type
!= range_high_type
)))
970 /* different element modes. */
971 error (_("POWERSET tuple elements of different mode"));
972 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
973 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
974 && range_low_type
!= check_type
))
975 error (_("incompatible POWERSET tuple elements"));
976 if (range_low
> range_high
)
978 warning (_("empty POWERSET tuple range"));
981 if (range_low
< low_bound
|| range_high
> high_bound
)
982 error (_("POWERSET tuple element out of range"));
983 range_low
-= low_bound
;
984 range_high
-= low_bound
;
985 for (; range_low
<= range_high
; range_low
++)
987 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
989 if (gdbarch_bits_big_endian (exp
->gdbarch
))
990 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
991 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
998 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
999 for (tem
= 0; tem
< nargs
; tem
++)
1001 /* Ensure that array expressions are coerced into pointer
1003 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1005 if (noside
== EVAL_SKIP
)
1007 return value_array (tem2
, tem3
, argvec
);
1011 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1013 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1015 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1017 if (noside
== EVAL_SKIP
)
1019 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1023 /* Skip third and second args to evaluate the first one. */
1024 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1025 if (value_logical_not (arg1
))
1027 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1028 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1032 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1033 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1037 case OP_OBJC_SELECTOR
:
1038 { /* Objective C @selector operator. */
1039 char *sel
= &exp
->elts
[pc
+ 2].string
;
1040 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1041 struct type
*selector_type
;
1043 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1044 if (noside
== EVAL_SKIP
)
1048 sel
[len
] = 0; /* Make sure it's terminated. */
1050 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1051 return value_from_longest (selector_type
,
1052 lookup_child_selector (exp
->gdbarch
, sel
));
1055 case OP_OBJC_MSGCALL
:
1056 { /* Objective C message (method) call. */
1058 CORE_ADDR responds_selector
= 0;
1059 CORE_ADDR method_selector
= 0;
1061 CORE_ADDR selector
= 0;
1063 int struct_return
= 0;
1064 int sub_no_side
= 0;
1066 struct value
*msg_send
= NULL
;
1067 struct value
*msg_send_stret
= NULL
;
1068 int gnu_runtime
= 0;
1070 struct value
*target
= NULL
;
1071 struct value
*method
= NULL
;
1072 struct value
*called_method
= NULL
;
1074 struct type
*selector_type
= NULL
;
1075 struct type
*long_type
;
1077 struct value
*ret
= NULL
;
1080 selector
= exp
->elts
[pc
+ 1].longconst
;
1081 nargs
= exp
->elts
[pc
+ 2].longconst
;
1082 argvec
= (struct value
**) alloca (sizeof (struct value
*)
1087 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1088 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1090 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1091 sub_no_side
= EVAL_NORMAL
;
1093 sub_no_side
= noside
;
1095 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1097 if (value_as_long (target
) == 0)
1098 return value_from_longest (long_type
, 0);
1100 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1103 /* Find the method dispatch (Apple runtime) or method lookup
1104 (GNU runtime) function for Objective-C. These will be used
1105 to lookup the symbol information for the method. If we
1106 can't find any symbol information, then we'll use these to
1107 call the method, otherwise we can call the method
1108 directly. The msg_send_stret function is used in the special
1109 case of a method that returns a structure (Apple runtime
1113 struct type
*type
= selector_type
;
1115 type
= lookup_function_type (type
);
1116 type
= lookup_pointer_type (type
);
1117 type
= lookup_function_type (type
);
1118 type
= lookup_pointer_type (type
);
1120 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1122 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1124 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1125 msg_send_stret
= value_from_pointer (type
,
1126 value_as_address (msg_send_stret
));
1130 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1131 /* Special dispatcher for methods returning structs. */
1133 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1136 /* Verify the target object responds to this method. The
1137 standard top-level 'Object' class uses a different name for
1138 the verification method than the non-standard, but more
1139 often used, 'NSObject' class. Make sure we check for both. */
1142 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1143 if (responds_selector
== 0)
1145 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1147 if (responds_selector
== 0)
1148 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1151 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1152 if (method_selector
== 0)
1154 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1156 if (method_selector
== 0)
1157 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1159 /* Call the verification method, to make sure that the target
1160 class implements the desired method. */
1162 argvec
[0] = msg_send
;
1164 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1165 argvec
[3] = value_from_longest (long_type
, selector
);
1168 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1171 /* Function objc_msg_lookup returns a pointer. */
1173 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1175 if (value_as_long (ret
) == 0)
1176 error (_("Target does not respond to this message selector."));
1178 /* Call "methodForSelector:" method, to get the address of a
1179 function method that implements this selector for this
1180 class. If we can find a symbol at that address, then we
1181 know the return type, parameter types etc. (that's a good
1184 argvec
[0] = msg_send
;
1186 argvec
[2] = value_from_longest (long_type
, method_selector
);
1187 argvec
[3] = value_from_longest (long_type
, selector
);
1190 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1194 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
1197 /* ret should now be the selector. */
1199 addr
= value_as_long (ret
);
1202 struct symbol
*sym
= NULL
;
1204 /* The address might point to a function descriptor;
1205 resolve it to the actual code address instead. */
1206 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1209 /* Is it a high_level symbol? */
1210 sym
= find_pc_function (addr
);
1212 method
= value_of_variable (sym
, 0);
1215 /* If we found a method with symbol information, check to see
1216 if it returns a struct. Otherwise assume it doesn't. */
1221 struct type
*val_type
;
1223 funaddr
= find_function_addr (method
, &val_type
);
1225 block_for_pc (funaddr
);
1227 CHECK_TYPEDEF (val_type
);
1229 if ((val_type
== NULL
)
1230 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1232 if (expect_type
!= NULL
)
1233 val_type
= expect_type
;
1236 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1239 else if (expect_type
!= NULL
)
1241 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1242 check_typedef (expect_type
));
1245 /* Found a function symbol. Now we will substitute its
1246 value in place of the message dispatcher (obj_msgSend),
1247 so that we call the method directly instead of thru
1248 the dispatcher. The main reason for doing this is that
1249 we can now evaluate the return value and parameter values
1250 according to their known data types, in case we need to
1251 do things like promotion, dereferencing, special handling
1252 of structs and doubles, etc.
1254 We want to use the type signature of 'method', but still
1255 jump to objc_msgSend() or objc_msgSend_stret() to better
1256 mimic the behavior of the runtime. */
1260 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1261 error (_("method address has symbol information "
1262 "with non-function type; skipping"));
1264 /* Create a function pointer of the appropriate type, and
1265 replace its value with the value of msg_send or
1266 msg_send_stret. We must use a pointer here, as
1267 msg_send and msg_send_stret are of pointer type, and
1268 the representation may be different on systems that use
1269 function descriptors. */
1272 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1273 value_as_address (msg_send_stret
));
1276 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1277 value_as_address (msg_send
));
1282 called_method
= msg_send_stret
;
1284 called_method
= msg_send
;
1287 if (noside
== EVAL_SKIP
)
1290 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1292 /* If the return type doesn't look like a function type,
1293 call an error. This can happen if somebody tries to
1294 turn a variable into a function call. This is here
1295 because people often want to call, eg, strcmp, which
1296 gdb doesn't know is a function. If gdb isn't asked for
1297 it's opinion (ie. through "whatis"), it won't offer
1300 struct type
*type
= value_type (called_method
);
1302 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1303 type
= TYPE_TARGET_TYPE (type
);
1304 type
= TYPE_TARGET_TYPE (type
);
1308 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1309 return allocate_value (expect_type
);
1311 return allocate_value (type
);
1314 error (_("Expression of type other than "
1315 "\"method returning ...\" used as a method"));
1318 /* Now depending on whether we found a symbol for the method,
1319 we will either call the runtime dispatcher or the method
1322 argvec
[0] = called_method
;
1324 argvec
[2] = value_from_longest (long_type
, selector
);
1325 /* User-supplied arguments. */
1326 for (tem
= 0; tem
< nargs
; tem
++)
1327 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1328 argvec
[tem
+ 3] = 0;
1330 if (gnu_runtime
&& (method
!= NULL
))
1332 /* Function objc_msg_lookup returns a pointer. */
1333 deprecated_set_value_type (argvec
[0],
1334 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1336 = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1339 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1346 op
= exp
->elts
[*pos
].opcode
;
1347 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1348 /* Allocate arg vector, including space for the function to be
1349 called in argvec[0], a potential `this', and a terminating NULL. */
1350 argvec
= (struct value
**)
1351 alloca (sizeof (struct value
*) * (nargs
+ 3));
1352 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1354 /* First, evaluate the structure into arg2. */
1357 if (op
== STRUCTOP_MEMBER
)
1359 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1363 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1366 /* If the function is a virtual function, then the
1367 aggregate value (providing the structure) plays
1368 its part by providing the vtable. Otherwise,
1369 it is just along for the ride: call the function
1372 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1374 type
= check_typedef (value_type (arg1
));
1375 if (noside
== EVAL_SKIP
)
1376 tem
= 1; /* Set it to the right arg index so that all arguments
1377 can also be skipped. */
1378 else if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
)
1380 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1381 arg1
= value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1383 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1385 /* Now, say which argument to start evaluating from. */
1390 else if (TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1392 struct type
*type_ptr
1393 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type
));
1394 struct type
*target_type_ptr
1395 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1397 /* Now, convert these values to an address. */
1398 arg2
= value_cast (type_ptr
, arg2
);
1400 mem_offset
= value_as_long (arg1
);
1402 arg1
= value_from_pointer (target_type_ptr
,
1403 value_as_long (arg2
) + mem_offset
);
1404 arg1
= value_ind (arg1
);
1408 error (_("Non-pointer-to-member value used in pointer-to-member "
1411 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1413 /* Hair for method invocations. */
1417 /* First, evaluate the structure into arg2. */
1419 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1420 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1422 if (op
== STRUCTOP_STRUCT
)
1424 /* If v is a variable in a register, and the user types
1425 v.method (), this will produce an error, because v has
1428 A possible way around this would be to allocate a
1429 copy of the variable on the stack, copy in the
1430 contents, call the function, and copy out the
1431 contents. I.e. convert this from call by reference
1432 to call by copy-return (or whatever it's called).
1433 However, this does not work because it is not the
1434 same: the method being called could stash a copy of
1435 the address, and then future uses through that address
1436 (after the method returns) would be expected to
1437 use the variable itself, not some copy of it. */
1438 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1442 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1444 /* Check to see if the operator '->' has been
1445 overloaded. If the operator has been overloaded
1446 replace arg2 with the value returned by the custom
1447 operator and continue evaluation. */
1448 while (unop_user_defined_p (op
, arg2
))
1450 volatile struct gdb_exception except
;
1451 struct value
*value
= NULL
;
1452 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1454 value
= value_x_unop (arg2
, op
, noside
);
1457 if (except
.reason
< 0)
1459 if (except
.error
== NOT_FOUND_ERROR
)
1462 throw_exception (except
);
1467 /* Now, say which argument to start evaluating from. */
1470 else if (op
== OP_SCOPE
1471 && overload_resolution
1472 && (exp
->language_defn
->la_language
== language_cplus
))
1474 /* Unpack it locally so we can properly handle overload
1480 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1481 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1482 type
= exp
->elts
[pc2
+ 1].type
;
1483 name
= &exp
->elts
[pc2
+ 3].string
;
1486 function_name
= NULL
;
1487 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1489 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1491 get_selected_block (0),
1493 if (function
== NULL
)
1494 error (_("No symbol \"%s\" in namespace \"%s\"."),
1495 name
, TYPE_TAG_NAME (type
));
1498 /* arg2 is left as NULL on purpose. */
1502 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1503 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1504 function_name
= name
;
1506 /* We need a properly typed value for method lookup. For
1507 static methods arg2 is otherwise unused. */
1508 arg2
= value_zero (type
, lval_memory
);
1513 else if (op
== OP_ADL_FUNC
)
1515 /* Save the function position and move pos so that the arguments
1516 can be evaluated. */
1522 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1523 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1527 /* Non-method function call. */
1531 /* If this is a C++ function wait until overload resolution. */
1532 if (op
== OP_VAR_VALUE
1533 && overload_resolution
1534 && (exp
->language_defn
->la_language
== language_cplus
))
1536 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1541 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1542 type
= value_type (argvec
[0]);
1543 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1544 type
= TYPE_TARGET_TYPE (type
);
1545 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1547 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1549 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1557 /* Evaluate arguments (if not already done, e.g., namespace::func()
1558 and overload-resolution is off). */
1559 for (; tem
<= nargs
; tem
++)
1561 /* Ensure that array expressions are coerced into pointer
1563 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1566 /* Signal end of arglist. */
1569 if (noside
== EVAL_SKIP
)
1572 if (op
== OP_ADL_FUNC
)
1574 struct symbol
*symp
;
1577 int string_pc
= save_pos1
+ 3;
1579 /* Extract the function name. */
1580 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1581 func_name
= (char *) alloca (name_len
+ 1);
1582 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1584 find_overload_match (&argvec
[1], nargs
, func_name
,
1585 NON_METHOD
, /* not method */
1586 NULL
, NULL
, /* pass NULL symbol since
1587 symbol is unknown */
1588 NULL
, &symp
, NULL
, 0, noside
);
1590 /* Now fix the expression being evaluated. */
1591 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1592 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1595 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1596 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1598 int static_memfuncp
;
1601 /* Method invocation: stuff "this" as first parameter.
1602 If the method turns out to be static we undo this below. */
1607 /* Name of method from expression. */
1608 tstr
= &exp
->elts
[pc2
+ 2].string
;
1611 tstr
= function_name
;
1613 if (overload_resolution
&& (exp
->language_defn
->la_language
1616 /* Language is C++, do some overload resolution before
1618 struct value
*valp
= NULL
;
1620 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1621 METHOD
, /* method */
1622 &arg2
, /* the object */
1624 &static_memfuncp
, 0, noside
);
1626 if (op
== OP_SCOPE
&& !static_memfuncp
)
1628 /* For the time being, we don't handle this. */
1629 error (_("Call to overloaded function %s requires "
1633 argvec
[1] = arg2
; /* the ``this'' pointer */
1634 argvec
[0] = valp
; /* Use the method found after overload
1638 /* Non-C++ case -- or no overload resolution. */
1640 struct value
*temp
= arg2
;
1642 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1644 op
== STRUCTOP_STRUCT
1645 ? "structure" : "structure pointer");
1646 /* value_struct_elt updates temp with the correct value
1647 of the ``this'' pointer if necessary, so modify argvec[1] to
1648 reflect any ``this'' changes. */
1650 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1651 value_address (temp
)
1652 + value_embedded_offset (temp
));
1653 argvec
[1] = arg2
; /* the ``this'' pointer */
1656 /* Take out `this' if needed. */
1657 if (static_memfuncp
)
1659 argvec
[1] = argvec
[0];
1664 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1666 /* Pointer to member. argvec[1] is already set up. */
1669 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1671 /* Non-member function being called. */
1672 /* fn: This can only be done for C++ functions. A C-style function
1673 in a C++ program, for instance, does not have the fields that
1674 are expected here. */
1676 if (overload_resolution
&& (exp
->language_defn
->la_language
1679 /* Language is C++, do some overload resolution before
1681 struct symbol
*symp
;
1684 /* If a scope has been specified disable ADL. */
1688 if (op
== OP_VAR_VALUE
)
1689 function
= exp
->elts
[save_pos1
+2].symbol
;
1691 (void) find_overload_match (&argvec
[1], nargs
,
1692 NULL
, /* no need for name */
1693 NON_METHOD
, /* not method */
1694 NULL
, function
, /* the function */
1695 NULL
, &symp
, NULL
, no_adl
, noside
);
1697 if (op
== OP_VAR_VALUE
)
1699 /* Now fix the expression being evaluated. */
1700 exp
->elts
[save_pos1
+2].symbol
= symp
;
1701 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1705 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1709 /* Not C++, or no overload resolution allowed. */
1710 /* Nothing to be done; argvec already correctly set up. */
1715 /* It is probably a C-style function. */
1716 /* Nothing to be done; argvec already correctly set up. */
1721 if (argvec
[0] == NULL
)
1722 error (_("Cannot evaluate function -- may be inlined"));
1723 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1725 /* If the return type doesn't look like a function type, call an
1726 error. This can happen if somebody tries to turn a variable into
1727 a function call. This is here because people often want to
1728 call, eg, strcmp, which gdb doesn't know is a function. If
1729 gdb isn't asked for it's opinion (ie. through "whatis"),
1730 it won't offer it. */
1732 struct type
*ftype
= value_type (argvec
[0]);
1734 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1736 /* We don't know anything about what the internal
1737 function might return, but we have to return
1739 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1742 else if (TYPE_GNU_IFUNC (ftype
))
1743 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1744 else if (TYPE_TARGET_TYPE (ftype
))
1745 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1747 error (_("Expression of type other than "
1748 "\"Function returning ...\" used as function"));
1750 switch (TYPE_CODE (value_type (argvec
[0])))
1752 case TYPE_CODE_INTERNAL_FUNCTION
:
1753 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1754 argvec
[0], nargs
, argvec
+ 1);
1755 case TYPE_CODE_XMETHOD
:
1756 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
1758 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1760 /* pai: FIXME save value from call_function_by_hand, then adjust
1761 pc by adjust_fn_pc if +ve. */
1763 case OP_F77_UNDETERMINED_ARGLIST
:
1765 /* Remember that in F77, functions, substring ops and
1766 array subscript operations cannot be disambiguated
1767 at parse time. We have made all array subscript operations,
1768 substring operations as well as function calls come here
1769 and we now have to discover what the heck this thing actually was.
1770 If it is a function, we process just as if we got an OP_FUNCALL. */
1772 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1775 /* First determine the type code we are dealing with. */
1776 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1777 type
= check_typedef (value_type (arg1
));
1778 code
= TYPE_CODE (type
);
1780 if (code
== TYPE_CODE_PTR
)
1782 /* Fortran always passes variable to subroutines as pointer.
1783 So we need to look into its target type to see if it is
1784 array, string or function. If it is, we need to switch
1785 to the target value the original one points to. */
1786 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1788 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1789 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1790 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1792 arg1
= value_ind (arg1
);
1793 type
= check_typedef (value_type (arg1
));
1794 code
= TYPE_CODE (type
);
1800 case TYPE_CODE_ARRAY
:
1801 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1802 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1804 goto multi_f77_subscript
;
1806 case TYPE_CODE_STRING
:
1807 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1808 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1811 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1812 return value_subscript (arg1
, value_as_long (arg2
));
1816 case TYPE_CODE_FUNC
:
1817 /* It's a function call. */
1818 /* Allocate arg vector, including space for the function to be
1819 called in argvec[0] and a terminating NULL. */
1820 argvec
= (struct value
**)
1821 alloca (sizeof (struct value
*) * (nargs
+ 2));
1824 for (; tem
<= nargs
; tem
++)
1825 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1826 argvec
[tem
] = 0; /* signal end of arglist */
1827 if (noside
== EVAL_SKIP
)
1832 error (_("Cannot perform substring on this type"));
1836 /* We have a complex number, There should be 2 floating
1837 point numbers that compose it. */
1839 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1840 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1842 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1844 case STRUCTOP_STRUCT
:
1845 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1846 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1847 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1848 if (noside
== EVAL_SKIP
)
1850 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1852 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1853 arg3
= value_zero (value_type (arg3
), not_lval
);
1857 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1858 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1859 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1860 if (noside
== EVAL_SKIP
)
1863 /* Check to see if operator '->' has been overloaded. If so replace
1864 arg1 with the value returned by evaluating operator->(). */
1865 while (unop_user_defined_p (op
, arg1
))
1867 volatile struct gdb_exception except
;
1868 struct value
*value
= NULL
;
1869 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1871 value
= value_x_unop (arg1
, op
, noside
);
1874 if (except
.reason
< 0)
1876 if (except
.error
== NOT_FOUND_ERROR
)
1879 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
, top
, using_enc
;
1891 struct value_print_options opts
;
1893 get_user_print_options (&opts
);
1894 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1895 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
1897 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1900 arg1
= value_cast (real_type
, arg1
);
1904 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1905 NULL
, "structure pointer");
1906 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1907 arg3
= value_zero (value_type (arg3
), not_lval
);
1910 case STRUCTOP_MEMBER
:
1912 if (op
== STRUCTOP_MEMBER
)
1913 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1915 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1917 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1919 if (noside
== EVAL_SKIP
)
1922 type
= check_typedef (value_type (arg2
));
1923 switch (TYPE_CODE (type
))
1925 case TYPE_CODE_METHODPTR
:
1926 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1927 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1930 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1931 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1932 return value_ind (arg2
);
1935 case TYPE_CODE_MEMBERPTR
:
1936 /* Now, convert these values to an address. */
1937 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1940 mem_offset
= value_as_long (arg2
);
1942 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1943 value_as_long (arg1
) + mem_offset
);
1944 return value_ind (arg3
);
1947 error (_("non-pointer-to-member value used "
1948 "in pointer-to-member construct"));
1952 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1953 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1954 for (ix
= 0; ix
< nargs
; ++ix
)
1955 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1957 expect_type
= make_params (nargs
, arg_types
);
1958 *(pos
) += 3 + nargs
;
1959 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1960 xfree (TYPE_FIELDS (expect_type
));
1961 xfree (TYPE_MAIN_TYPE (expect_type
));
1962 xfree (expect_type
);
1966 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1967 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1968 if (noside
== EVAL_SKIP
)
1970 if (binop_user_defined_p (op
, arg1
, arg2
))
1971 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1973 return value_concat (arg1
, arg2
);
1976 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1977 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1979 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1981 if (binop_user_defined_p (op
, arg1
, arg2
))
1982 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1984 return value_assign (arg1
, arg2
);
1986 case BINOP_ASSIGN_MODIFY
:
1988 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1989 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1990 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1992 op
= exp
->elts
[pc
+ 1].opcode
;
1993 if (binop_user_defined_p (op
, arg1
, arg2
))
1994 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1995 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
1997 && is_integral_type (value_type (arg2
)))
1998 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
1999 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2001 && is_integral_type (value_type (arg2
)))
2002 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2005 struct value
*tmp
= arg1
;
2007 /* For shift and integer exponentiation operations,
2008 only promote the first argument. */
2009 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2010 && is_integral_type (value_type (arg2
)))
2011 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2013 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2015 arg2
= value_binop (tmp
, arg2
, op
);
2017 return value_assign (arg1
, arg2
);
2020 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2021 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2022 if (noside
== EVAL_SKIP
)
2024 if (binop_user_defined_p (op
, arg1
, arg2
))
2025 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2026 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2027 && is_integral_type (value_type (arg2
)))
2028 return value_ptradd (arg1
, value_as_long (arg2
));
2029 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2030 && is_integral_type (value_type (arg1
)))
2031 return value_ptradd (arg2
, value_as_long (arg1
));
2034 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2035 return value_binop (arg1
, arg2
, BINOP_ADD
);
2039 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2040 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2041 if (noside
== EVAL_SKIP
)
2043 if (binop_user_defined_p (op
, arg1
, arg2
))
2044 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2045 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2046 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2048 /* FIXME -- should be ptrdiff_t */
2049 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2050 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2052 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2053 && is_integral_type (value_type (arg2
)))
2054 return value_ptradd (arg1
, - value_as_long (arg2
));
2057 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2058 return value_binop (arg1
, arg2
, BINOP_SUB
);
2069 case BINOP_BITWISE_AND
:
2070 case BINOP_BITWISE_IOR
:
2071 case BINOP_BITWISE_XOR
:
2072 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2073 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2074 if (noside
== EVAL_SKIP
)
2076 if (binop_user_defined_p (op
, arg1
, arg2
))
2077 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2080 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2081 fudge arg2 to avoid division-by-zero, the caller is
2082 (theoretically) only looking for the type of the result. */
2083 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2084 /* ??? Do we really want to test for BINOP_MOD here?
2085 The implementation of value_binop gives it a well-defined
2088 || op
== BINOP_INTDIV
2091 && value_logical_not (arg2
))
2093 struct value
*v_one
, *retval
;
2095 v_one
= value_one (value_type (arg2
));
2096 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2097 retval
= value_binop (arg1
, v_one
, op
);
2102 /* For shift and integer exponentiation operations,
2103 only promote the first argument. */
2104 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2105 && is_integral_type (value_type (arg2
)))
2106 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2108 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2110 return value_binop (arg1
, arg2
, op
);
2114 case BINOP_SUBSCRIPT
:
2115 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2116 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2117 if (noside
== EVAL_SKIP
)
2119 if (binop_user_defined_p (op
, arg1
, arg2
))
2120 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2123 /* If the user attempts to subscript something that is not an
2124 array or pointer type (like a plain int variable for example),
2125 then report this as an error. */
2127 arg1
= coerce_ref (arg1
);
2128 type
= check_typedef (value_type (arg1
));
2129 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2130 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2132 if (TYPE_NAME (type
))
2133 error (_("cannot subscript something of type `%s'"),
2136 error (_("cannot subscript requested type"));
2139 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2140 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2142 return value_subscript (arg1
, value_as_long (arg2
));
2144 case MULTI_SUBSCRIPT
:
2146 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2147 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2150 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2151 /* FIXME: EVAL_SKIP handling may not be correct. */
2152 if (noside
== EVAL_SKIP
)
2163 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2164 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2166 /* If the user attempts to subscript something that has no target
2167 type (like a plain int variable for example), then report this
2170 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2173 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2179 error (_("cannot subscript something of type `%s'"),
2180 TYPE_NAME (value_type (arg1
)));
2184 if (binop_user_defined_p (op
, arg1
, arg2
))
2186 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2190 arg1
= coerce_ref (arg1
);
2191 type
= check_typedef (value_type (arg1
));
2193 switch (TYPE_CODE (type
))
2196 case TYPE_CODE_ARRAY
:
2197 case TYPE_CODE_STRING
:
2198 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2202 if (TYPE_NAME (type
))
2203 error (_("cannot subscript something of type `%s'"),
2206 error (_("cannot subscript requested type"));
2212 multi_f77_subscript
:
2214 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2215 int ndimensions
= 1, i
;
2216 struct value
*array
= arg1
;
2218 if (nargs
> MAX_FORTRAN_DIMS
)
2219 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2221 ndimensions
= calc_f77_array_dims (type
);
2223 if (nargs
!= ndimensions
)
2224 error (_("Wrong number of subscripts"));
2226 gdb_assert (nargs
> 0);
2228 /* Now that we know we have a legal array subscript expression
2229 let us actually find out where this element exists in the array. */
2231 /* Take array indices left to right. */
2232 for (i
= 0; i
< nargs
; i
++)
2234 /* Evaluate each subscript; it must be a legal integer in F77. */
2235 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2237 /* Fill in the subscript array. */
2239 subscript_array
[i
] = value_as_long (arg2
);
2242 /* Internal type of array is arranged right to left. */
2243 for (i
= nargs
; i
> 0; i
--)
2245 struct type
*array_type
= check_typedef (value_type (array
));
2246 LONGEST index
= subscript_array
[i
- 1];
2248 array
= value_subscripted_rvalue (array
, index
,
2249 f77_get_lowerbound (array_type
));
2255 case BINOP_LOGICAL_AND
:
2256 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2257 if (noside
== EVAL_SKIP
)
2259 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2264 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2267 if (binop_user_defined_p (op
, arg1
, arg2
))
2269 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2270 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2274 tem
= value_logical_not (arg1
);
2275 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2276 (tem
? EVAL_SKIP
: noside
));
2277 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2278 return value_from_longest (type
,
2279 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2282 case BINOP_LOGICAL_OR
:
2283 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2284 if (noside
== EVAL_SKIP
)
2286 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2291 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2294 if (binop_user_defined_p (op
, arg1
, arg2
))
2296 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2297 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2301 tem
= value_logical_not (arg1
);
2302 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2303 (!tem
? EVAL_SKIP
: noside
));
2304 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2305 return value_from_longest (type
,
2306 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
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
);
2326 case BINOP_NOTEQUAL
:
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_equal (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 (arg1
, arg2
);
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
);
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 (arg2
, arg1
) || 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 (value_type (arg1
), exp
, pos
, noside
);
2397 if (noside
== EVAL_SKIP
)
2399 if (binop_user_defined_p (op
, arg1
, arg2
))
2401 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2405 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2406 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2407 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2408 return value_from_longest (type
, (LONGEST
) tem
);
2412 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2413 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2414 if (noside
== EVAL_SKIP
)
2416 type
= check_typedef (value_type (arg2
));
2417 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2418 error (_("Non-integral right operand for \"@\" operator."));
2419 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2421 return allocate_repeat_value (value_type (arg1
),
2422 longest_to_int (value_as_long (arg2
)));
2425 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2428 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2429 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2432 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2433 if (noside
== EVAL_SKIP
)
2435 if (unop_user_defined_p (op
, arg1
))
2436 return value_x_unop (arg1
, op
, noside
);
2439 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2440 return value_pos (arg1
);
2444 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2445 if (noside
== EVAL_SKIP
)
2447 if (unop_user_defined_p (op
, arg1
))
2448 return value_x_unop (arg1
, op
, noside
);
2451 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2452 return value_neg (arg1
);
2455 case UNOP_COMPLEMENT
:
2456 /* C++: check for and handle destructor names. */
2457 op
= exp
->elts
[*pos
].opcode
;
2459 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2460 if (noside
== EVAL_SKIP
)
2462 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2463 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2466 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2467 return value_complement (arg1
);
2470 case UNOP_LOGICAL_NOT
:
2471 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2472 if (noside
== EVAL_SKIP
)
2474 if (unop_user_defined_p (op
, arg1
))
2475 return value_x_unop (arg1
, op
, noside
);
2478 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2479 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2483 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2484 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2485 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2486 type
= check_typedef (value_type (arg1
));
2487 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2488 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2489 error (_("Attempt to dereference pointer "
2490 "to member without an object"));
2491 if (noside
== EVAL_SKIP
)
2493 if (unop_user_defined_p (op
, arg1
))
2494 return value_x_unop (arg1
, op
, noside
);
2495 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2497 type
= check_typedef (value_type (arg1
));
2498 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2499 || TYPE_CODE (type
) == TYPE_CODE_REF
2500 /* In C you can dereference an array to get the 1st elt. */
2501 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2503 return value_zero (TYPE_TARGET_TYPE (type
),
2505 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2506 /* GDB allows dereferencing an int. */
2507 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2510 error (_("Attempt to take contents of a non-pointer value."));
2513 /* Allow * on an integer so we can cast it to whatever we want.
2514 This returns an int, which seems like the most C-like thing to
2515 do. "long long" variables are rare enough that
2516 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2517 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2518 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2519 (CORE_ADDR
) value_as_address (arg1
));
2520 return value_ind (arg1
);
2523 /* C++: check for and handle pointer to members. */
2525 op
= exp
->elts
[*pos
].opcode
;
2527 if (noside
== EVAL_SKIP
)
2529 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2534 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2541 if (noside
== EVAL_SKIP
)
2543 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2546 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2550 type
= exp
->elts
[pc
+ 1].type
;
2551 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2552 if (noside
== EVAL_SKIP
)
2554 if (type
!= value_type (arg1
))
2555 arg1
= value_cast (type
, arg1
);
2558 case UNOP_CAST_TYPE
:
2559 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2560 type
= value_type (arg1
);
2561 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2562 if (noside
== EVAL_SKIP
)
2564 if (type
!= value_type (arg1
))
2565 arg1
= value_cast (type
, arg1
);
2568 case UNOP_DYNAMIC_CAST
:
2569 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2570 type
= value_type (arg1
);
2571 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2572 if (noside
== EVAL_SKIP
)
2574 return value_dynamic_cast (type
, arg1
);
2576 case UNOP_REINTERPRET_CAST
:
2577 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2578 type
= value_type (arg1
);
2579 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2580 if (noside
== EVAL_SKIP
)
2582 return value_reinterpret_cast (type
, arg1
);
2586 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2587 if (noside
== EVAL_SKIP
)
2589 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2590 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2592 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2593 value_as_address (arg1
));
2595 case UNOP_MEMVAL_TYPE
:
2596 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2597 type
= value_type (arg1
);
2598 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2599 if (noside
== EVAL_SKIP
)
2601 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2602 return value_zero (type
, lval_memory
);
2604 return value_at_lazy (type
, value_as_address (arg1
));
2606 case UNOP_MEMVAL_TLS
:
2608 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2609 if (noside
== EVAL_SKIP
)
2611 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2612 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2617 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2618 value_as_address (arg1
));
2619 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2622 case UNOP_PREINCREMENT
:
2623 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2624 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2626 else if (unop_user_defined_p (op
, arg1
))
2628 return value_x_unop (arg1
, op
, noside
);
2632 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2633 arg2
= value_ptradd (arg1
, 1);
2636 struct value
*tmp
= arg1
;
2638 arg2
= value_one (value_type (arg1
));
2639 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2640 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2643 return value_assign (arg1
, arg2
);
2646 case UNOP_PREDECREMENT
:
2647 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2648 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2650 else if (unop_user_defined_p (op
, arg1
))
2652 return value_x_unop (arg1
, op
, noside
);
2656 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2657 arg2
= value_ptradd (arg1
, -1);
2660 struct value
*tmp
= arg1
;
2662 arg2
= value_one (value_type (arg1
));
2663 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2664 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2667 return value_assign (arg1
, arg2
);
2670 case UNOP_POSTINCREMENT
:
2671 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2672 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2674 else if (unop_user_defined_p (op
, arg1
))
2676 return value_x_unop (arg1
, op
, noside
);
2680 arg3
= value_non_lval (arg1
);
2682 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2683 arg2
= value_ptradd (arg1
, 1);
2686 struct value
*tmp
= arg1
;
2688 arg2
= value_one (value_type (arg1
));
2689 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2690 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2693 value_assign (arg1
, arg2
);
2697 case UNOP_POSTDECREMENT
:
2698 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2699 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2701 else if (unop_user_defined_p (op
, arg1
))
2703 return value_x_unop (arg1
, op
, noside
);
2707 arg3
= value_non_lval (arg1
);
2709 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2710 arg2
= value_ptradd (arg1
, -1);
2713 struct value
*tmp
= arg1
;
2715 arg2
= value_one (value_type (arg1
));
2716 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2717 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2720 value_assign (arg1
, arg2
);
2726 return value_of_this (exp
->language_defn
);
2729 /* The value is not supposed to be used. This is here to make it
2730 easier to accommodate expressions that contain types. */
2732 if (noside
== EVAL_SKIP
)
2734 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2736 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2738 /* If this is a typedef, then find its immediate target. We
2739 use check_typedef to resolve stubs, but we ignore its
2740 result because we do not want to dig past all
2742 check_typedef (type
);
2743 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2744 type
= TYPE_TARGET_TYPE (type
);
2745 return allocate_value (type
);
2748 error (_("Attempt to use a type name as an expression"));
2752 if (noside
== EVAL_SKIP
)
2754 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2757 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2759 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2760 struct value
*result
;
2762 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2763 EVAL_AVOID_SIDE_EFFECTS
);
2765 /* 'decltype' has special semantics for lvalues. */
2766 if (op
== OP_DECLTYPE
2767 && (sub_op
== BINOP_SUBSCRIPT
2768 || sub_op
== STRUCTOP_MEMBER
2769 || sub_op
== STRUCTOP_MPTR
2770 || sub_op
== UNOP_IND
2771 || sub_op
== STRUCTOP_STRUCT
2772 || sub_op
== STRUCTOP_PTR
2773 || sub_op
== OP_SCOPE
))
2775 struct type
*type
= value_type (result
);
2777 if (TYPE_CODE (check_typedef (type
)) != TYPE_CODE_REF
)
2779 type
= lookup_reference_type (type
);
2780 result
= allocate_value (type
);
2787 error (_("Attempt to use a type as an expression"));
2791 struct value
*result
;
2792 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2794 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2795 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2796 EVAL_AVOID_SIDE_EFFECTS
);
2798 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2800 if (noside
!= EVAL_NORMAL
)
2801 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2803 return cplus_typeid (result
);
2807 /* Removing this case and compiling with gcc -Wall reveals that
2808 a lot of cases are hitting this case. Some of these should
2809 probably be removed from expression.h; others are legitimate
2810 expressions which are (apparently) not fully implemented.
2812 If there are any cases landing here which mean a user error,
2813 then they should be separate cases, with more descriptive
2816 error (_("GDB does not (yet) know how to "
2817 "evaluate that kind of expression"));
2821 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2824 /* Evaluate a subexpression of EXP, at index *POS,
2825 and return the address of that subexpression.
2826 Advance *POS over the subexpression.
2827 If the subexpression isn't an lvalue, get an error.
2828 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2829 then only the type of the result need be correct. */
2831 static struct value
*
2832 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2842 op
= exp
->elts
[pc
].opcode
;
2848 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2850 /* We can't optimize out "&*" if there's a user-defined operator*. */
2851 if (unop_user_defined_p (op
, x
))
2853 x
= value_x_unop (x
, op
, noside
);
2854 goto default_case_after_eval
;
2857 return coerce_array (x
);
2861 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2862 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2864 case UNOP_MEMVAL_TYPE
:
2869 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2870 type
= value_type (x
);
2871 return value_cast (lookup_pointer_type (type
),
2872 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2876 var
= exp
->elts
[pc
+ 2].symbol
;
2878 /* C++: The "address" of a reference should yield the address
2879 * of the object pointed to. Let value_addr() deal with it. */
2880 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2884 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2887 lookup_pointer_type (SYMBOL_TYPE (var
));
2888 enum address_class sym_class
= SYMBOL_CLASS (var
);
2890 if (sym_class
== LOC_CONST
2891 || sym_class
== LOC_CONST_BYTES
2892 || sym_class
== LOC_REGISTER
)
2893 error (_("Attempt to take address of register or constant."));
2896 value_zero (type
, not_lval
);
2899 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2902 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2903 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2904 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2905 &exp
->elts
[pc
+ 3].string
,
2908 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2913 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2914 default_case_after_eval
:
2915 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2917 struct type
*type
= check_typedef (value_type (x
));
2919 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2920 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2922 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2923 return value_zero (lookup_pointer_type (value_type (x
)),
2926 error (_("Attempt to take address of "
2927 "value not located in memory."));
2929 return value_addr (x
);
2933 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2934 When used in contexts where arrays will be coerced anyway, this is
2935 equivalent to `evaluate_subexp' but much faster because it avoids
2936 actually fetching array contents (perhaps obsolete now that we have
2939 Note that we currently only do the coercion for C expressions, where
2940 arrays are zero based and the coercion is correct. For other languages,
2941 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2942 to decide if coercion is appropriate. */
2945 evaluate_subexp_with_coercion (struct expression
*exp
,
2946 int *pos
, enum noside noside
)
2955 op
= exp
->elts
[pc
].opcode
;
2960 var
= exp
->elts
[pc
+ 2].symbol
;
2961 type
= check_typedef (SYMBOL_TYPE (var
));
2962 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2963 && !TYPE_VECTOR (type
)
2964 && CAST_IS_CONVERSION (exp
->language_defn
))
2967 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2968 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2974 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2978 /* Evaluate a subexpression of EXP, at index *POS,
2979 and return a value for the size of that subexpression.
2980 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2981 we allow side-effects on the operand if its type is a variable
2984 static struct value
*
2985 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
2988 /* FIXME: This should be size_t. */
2989 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2996 op
= exp
->elts
[pc
].opcode
;
3000 /* This case is handled specially
3001 so that we avoid creating a value for the result type.
3002 If the result type is very big, it's desirable not to
3003 create a value unnecessarily. */
3006 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3007 type
= check_typedef (value_type (val
));
3008 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3009 && TYPE_CODE (type
) != TYPE_CODE_REF
3010 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3011 error (_("Attempt to take contents of a non-pointer value."));
3012 type
= TYPE_TARGET_TYPE (type
);
3013 if (is_dynamic_type (type
))
3014 type
= value_type (value_ind (val
));
3015 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3019 type
= exp
->elts
[pc
+ 1].type
;
3022 case UNOP_MEMVAL_TYPE
:
3024 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3025 type
= value_type (val
);
3029 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3030 if (is_dynamic_type (type
))
3032 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3033 type
= value_type (val
);
3039 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3040 type of the subscript is a variable length array type. In this case we
3041 must re-evaluate the right hand side of the subcription to allow
3043 case BINOP_SUBSCRIPT
:
3044 if (noside
== EVAL_NORMAL
)
3046 int pc
= (*pos
) + 1;
3048 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3049 type
= check_typedef (value_type (val
));
3050 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3052 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3053 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3055 type
= TYPE_INDEX_TYPE (type
);
3056 /* Only re-evaluate the right hand side if the resulting type
3057 is a variable length type. */
3058 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3060 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3061 return value_from_longest
3062 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3071 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3072 type
= value_type (val
);
3076 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3077 "When applied to a reference or a reference type, the result is
3078 the size of the referenced type." */
3079 CHECK_TYPEDEF (type
);
3080 if (exp
->language_defn
->la_language
== language_cplus
3081 && TYPE_CODE (type
) == TYPE_CODE_REF
)
3082 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3083 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3086 /* Parse a type expression in the string [P..P+LENGTH). */
3089 parse_and_eval_type (char *p
, int length
)
3091 char *tmp
= (char *) alloca (length
+ 4);
3092 struct expression
*expr
;
3095 memcpy (tmp
+ 1, p
, length
);
3096 tmp
[length
+ 1] = ')';
3097 tmp
[length
+ 2] = '0';
3098 tmp
[length
+ 3] = '\0';
3099 expr
= parse_expression (tmp
);
3100 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3101 error (_("Internal error in eval_type."));
3102 return expr
->elts
[1].type
;
3106 calc_f77_array_dims (struct type
*array_type
)
3109 struct type
*tmp_type
;
3111 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3112 error (_("Can't get dimensions for a non-array type"));
3114 tmp_type
= array_type
;
3116 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3118 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)