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
];
679 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
682 evaluate_var_msym_value (enum noside noside
,
683 struct objfile
*objfile
, minimal_symbol
*msymbol
)
685 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
687 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, NULL
);
688 return value_zero (the_type
, not_lval
);
693 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
694 return value_at_lazy (the_type
, address
);
699 evaluate_subexp_standard (struct type
*expect_type
,
700 struct expression
*exp
, int *pos
,
705 int pc
, pc2
= 0, oldpos
;
706 struct value
*arg1
= NULL
;
707 struct value
*arg2
= NULL
;
711 struct value
**argvec
;
715 struct type
**arg_types
;
717 struct symbol
*function
= NULL
;
718 char *function_name
= NULL
;
721 op
= exp
->elts
[pc
].opcode
;
726 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
727 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
728 if (noside
== EVAL_SKIP
)
730 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
731 &exp
->elts
[pc
+ 3].string
,
732 expect_type
, 0, noside
);
734 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
739 return value_from_longest (exp
->elts
[pc
+ 1].type
,
740 exp
->elts
[pc
+ 2].longconst
);
744 return value_from_double (exp
->elts
[pc
+ 1].type
,
745 exp
->elts
[pc
+ 2].doubleconst
);
749 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
750 exp
->elts
[pc
+ 2].decfloatconst
);
755 if (noside
== EVAL_SKIP
)
758 /* JYG: We used to just return value_zero of the symbol type
759 if we're asked to avoid side effects. Otherwise we return
760 value_of_variable (...). However I'm not sure if
761 value_of_variable () has any side effect.
762 We need a full value object returned here for whatis_exp ()
763 to call evaluate_type () and then pass the full value to
764 value_rtti_target_type () if we are dealing with a pointer
765 or reference to a base class and print object is on. */
768 struct value
*ret
= NULL
;
772 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
773 exp
->elts
[pc
+ 1].block
);
776 CATCH (except
, RETURN_MASK_ERROR
)
778 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
779 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
782 throw_exception (except
);
788 case OP_VAR_MSYM_VALUE
:
790 return evaluate_var_msym_value (noside
,
791 exp
->elts
[pc
+ 1].objfile
,
792 exp
->elts
[pc
+ 2].msymbol
);
794 case OP_VAR_ENTRY_VALUE
:
796 if (noside
== EVAL_SKIP
)
800 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
801 struct frame_info
*frame
;
803 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
804 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
806 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
807 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
808 error (_("Symbol \"%s\" does not have any specific entry value"),
809 SYMBOL_PRINT_NAME (sym
));
811 frame
= get_selected_frame (NULL
);
812 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
818 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
822 const char *name
= &exp
->elts
[pc
+ 2].string
;
826 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
827 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
828 name
, strlen (name
));
830 error (_("Register $%s not available."), name
);
832 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
833 a value with the appropriate register type. Unfortunately,
834 we don't have easy access to the type of user registers.
835 So for these registers, we fetch the register value regardless
836 of the evaluation mode. */
837 if (noside
== EVAL_AVOID_SIDE_EFFECTS
838 && regno
< gdbarch_num_regs (exp
->gdbarch
)
839 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
840 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
842 val
= value_of_register (regno
, get_selected_frame (NULL
));
844 error (_("Value of register %s not available."), name
);
850 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
851 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
855 return value_of_internalvar (exp
->gdbarch
,
856 exp
->elts
[pc
+ 1].internalvar
);
859 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
860 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
861 if (noside
== EVAL_SKIP
)
863 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
864 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
866 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
867 NSString constant. */
868 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
869 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
870 if (noside
== EVAL_SKIP
)
874 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
878 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
879 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
880 nargs
= tem3
- tem2
+ 1;
881 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
883 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
884 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
886 struct value
*rec
= allocate_value (expect_type
);
888 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
889 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
892 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
893 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
895 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
896 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
897 struct value
*array
= allocate_value (expect_type
);
898 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
899 LONGEST low_bound
, high_bound
, index
;
901 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
904 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
907 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
908 for (tem
= nargs
; --nargs
>= 0;)
910 struct value
*element
;
913 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
914 if (value_type (element
) != element_type
)
915 element
= value_cast (element_type
, element
);
918 int continue_pc
= *pos
;
921 index
= init_array_element (array
, element
, exp
, pos
, noside
,
922 low_bound
, high_bound
);
927 if (index
> high_bound
)
928 /* To avoid memory corruption. */
929 error (_("Too many array elements"));
930 memcpy (value_contents_raw (array
)
931 + (index
- low_bound
) * element_size
,
932 value_contents (element
),
940 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
941 && TYPE_CODE (type
) == TYPE_CODE_SET
)
943 struct value
*set
= allocate_value (expect_type
);
944 gdb_byte
*valaddr
= value_contents_raw (set
);
945 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
946 struct type
*check_type
= element_type
;
947 LONGEST low_bound
, high_bound
;
949 /* Get targettype of elementtype. */
950 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
951 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
952 check_type
= TYPE_TARGET_TYPE (check_type
);
954 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
955 error (_("(power)set type with unknown size"));
956 memset (valaddr
, '\0', TYPE_LENGTH (type
));
957 for (tem
= 0; tem
< nargs
; tem
++)
959 LONGEST range_low
, range_high
;
960 struct type
*range_low_type
, *range_high_type
;
961 struct value
*elem_val
;
963 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
964 range_low_type
= range_high_type
= value_type (elem_val
);
965 range_low
= range_high
= value_as_long (elem_val
);
967 /* Check types of elements to avoid mixture of elements from
968 different types. Also check if type of element is "compatible"
969 with element type of powerset. */
970 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
971 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
972 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
973 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
974 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
975 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
976 && (range_low_type
!= range_high_type
)))
977 /* different element modes. */
978 error (_("POWERSET tuple elements of different mode"));
979 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
980 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
981 && range_low_type
!= check_type
))
982 error (_("incompatible POWERSET tuple elements"));
983 if (range_low
> range_high
)
985 warning (_("empty POWERSET tuple range"));
988 if (range_low
< low_bound
|| range_high
> high_bound
)
989 error (_("POWERSET tuple element out of range"));
990 range_low
-= low_bound
;
991 range_high
-= low_bound
;
992 for (; range_low
<= range_high
; range_low
++)
994 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
996 if (gdbarch_bits_big_endian (exp
->gdbarch
))
997 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
998 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1005 argvec
= XALLOCAVEC (struct value
*, nargs
);
1006 for (tem
= 0; tem
< nargs
; tem
++)
1008 /* Ensure that array expressions are coerced into pointer
1010 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1012 if (noside
== EVAL_SKIP
)
1014 return value_array (tem2
, tem3
, argvec
);
1018 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1020 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1022 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1024 if (noside
== EVAL_SKIP
)
1026 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1030 /* Skip third and second args to evaluate the first one. */
1031 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1032 if (value_logical_not (arg1
))
1034 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1035 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1039 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1040 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1044 case OP_OBJC_SELECTOR
:
1045 { /* Objective C @selector operator. */
1046 char *sel
= &exp
->elts
[pc
+ 2].string
;
1047 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1048 struct type
*selector_type
;
1050 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1051 if (noside
== EVAL_SKIP
)
1055 sel
[len
] = 0; /* Make sure it's terminated. */
1057 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1058 return value_from_longest (selector_type
,
1059 lookup_child_selector (exp
->gdbarch
, sel
));
1062 case OP_OBJC_MSGCALL
:
1063 { /* Objective C message (method) call. */
1065 CORE_ADDR responds_selector
= 0;
1066 CORE_ADDR method_selector
= 0;
1068 CORE_ADDR selector
= 0;
1070 int struct_return
= 0;
1071 enum noside sub_no_side
= EVAL_NORMAL
;
1073 struct value
*msg_send
= NULL
;
1074 struct value
*msg_send_stret
= NULL
;
1075 int gnu_runtime
= 0;
1077 struct value
*target
= NULL
;
1078 struct value
*method
= NULL
;
1079 struct value
*called_method
= NULL
;
1081 struct type
*selector_type
= NULL
;
1082 struct type
*long_type
;
1084 struct value
*ret
= NULL
;
1087 selector
= exp
->elts
[pc
+ 1].longconst
;
1088 nargs
= exp
->elts
[pc
+ 2].longconst
;
1089 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1093 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1094 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1096 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1097 sub_no_side
= EVAL_NORMAL
;
1099 sub_no_side
= noside
;
1101 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1103 if (value_as_long (target
) == 0)
1104 return value_from_longest (long_type
, 0);
1106 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1109 /* Find the method dispatch (Apple runtime) or method lookup
1110 (GNU runtime) function for Objective-C. These will be used
1111 to lookup the symbol information for the method. If we
1112 can't find any symbol information, then we'll use these to
1113 call the method, otherwise we can call the method
1114 directly. The msg_send_stret function is used in the special
1115 case of a method that returns a structure (Apple runtime
1119 struct type
*type
= selector_type
;
1121 type
= lookup_function_type (type
);
1122 type
= lookup_pointer_type (type
);
1123 type
= lookup_function_type (type
);
1124 type
= lookup_pointer_type (type
);
1126 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1128 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1130 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1131 msg_send_stret
= value_from_pointer (type
,
1132 value_as_address (msg_send_stret
));
1136 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1137 /* Special dispatcher for methods returning structs. */
1139 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1142 /* Verify the target object responds to this method. The
1143 standard top-level 'Object' class uses a different name for
1144 the verification method than the non-standard, but more
1145 often used, 'NSObject' class. Make sure we check for both. */
1148 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1149 if (responds_selector
== 0)
1151 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1153 if (responds_selector
== 0)
1154 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1157 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1158 if (method_selector
== 0)
1160 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1162 if (method_selector
== 0)
1163 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1165 /* Call the verification method, to make sure that the target
1166 class implements the desired method. */
1168 argvec
[0] = msg_send
;
1170 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1171 argvec
[3] = value_from_longest (long_type
, selector
);
1174 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1177 /* Function objc_msg_lookup returns a pointer. */
1179 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1181 if (value_as_long (ret
) == 0)
1182 error (_("Target does not respond to this message selector."));
1184 /* Call "methodForSelector:" method, to get the address of a
1185 function method that implements this selector for this
1186 class. If we can find a symbol at that address, then we
1187 know the return type, parameter types etc. (that's a good
1190 argvec
[0] = msg_send
;
1192 argvec
[2] = value_from_longest (long_type
, method_selector
);
1193 argvec
[3] = value_from_longest (long_type
, selector
);
1196 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1200 ret
= call_function_by_hand (argvec
[0], NULL
, 3, argvec
+ 1);
1203 /* ret should now be the selector. */
1205 addr
= value_as_long (ret
);
1208 struct symbol
*sym
= NULL
;
1210 /* The address might point to a function descriptor;
1211 resolve it to the actual code address instead. */
1212 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1215 /* Is it a high_level symbol? */
1216 sym
= find_pc_function (addr
);
1218 method
= value_of_variable (sym
, 0);
1221 /* If we found a method with symbol information, check to see
1222 if it returns a struct. Otherwise assume it doesn't. */
1227 struct type
*val_type
;
1229 funaddr
= find_function_addr (method
, &val_type
);
1231 block_for_pc (funaddr
);
1233 val_type
= check_typedef (val_type
);
1235 if ((val_type
== NULL
)
1236 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
1238 if (expect_type
!= NULL
)
1239 val_type
= expect_type
;
1242 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1245 else if (expect_type
!= NULL
)
1247 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1248 check_typedef (expect_type
));
1251 /* Found a function symbol. Now we will substitute its
1252 value in place of the message dispatcher (obj_msgSend),
1253 so that we call the method directly instead of thru
1254 the dispatcher. The main reason for doing this is that
1255 we can now evaluate the return value and parameter values
1256 according to their known data types, in case we need to
1257 do things like promotion, dereferencing, special handling
1258 of structs and doubles, etc.
1260 We want to use the type signature of 'method', but still
1261 jump to objc_msgSend() or objc_msgSend_stret() to better
1262 mimic the behavior of the runtime. */
1266 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
1267 error (_("method address has symbol information "
1268 "with non-function type; skipping"));
1270 /* Create a function pointer of the appropriate type, and
1271 replace its value with the value of msg_send or
1272 msg_send_stret. We must use a pointer here, as
1273 msg_send and msg_send_stret are of pointer type, and
1274 the representation may be different on systems that use
1275 function descriptors. */
1278 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1279 value_as_address (msg_send_stret
));
1282 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1283 value_as_address (msg_send
));
1288 called_method
= msg_send_stret
;
1290 called_method
= msg_send
;
1293 if (noside
== EVAL_SKIP
)
1296 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1298 /* If the return type doesn't look like a function type,
1299 call an error. This can happen if somebody tries to
1300 turn a variable into a function call. This is here
1301 because people often want to call, eg, strcmp, which
1302 gdb doesn't know is a function. If gdb isn't asked for
1303 it's opinion (ie. through "whatis"), it won't offer
1306 struct type
*type
= value_type (called_method
);
1308 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1309 type
= TYPE_TARGET_TYPE (type
);
1310 type
= TYPE_TARGET_TYPE (type
);
1314 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1315 return allocate_value (expect_type
);
1317 return allocate_value (type
);
1320 error (_("Expression of type other than "
1321 "\"method returning ...\" used as a method"));
1324 /* Now depending on whether we found a symbol for the method,
1325 we will either call the runtime dispatcher or the method
1328 argvec
[0] = called_method
;
1330 argvec
[2] = value_from_longest (long_type
, selector
);
1331 /* User-supplied arguments. */
1332 for (tem
= 0; tem
< nargs
; tem
++)
1333 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1334 argvec
[tem
+ 3] = 0;
1336 if (gnu_runtime
&& (method
!= NULL
))
1338 /* Function objc_msg_lookup returns a pointer. */
1339 deprecated_set_value_type (argvec
[0],
1340 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1342 = call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1345 ret
= call_function_by_hand (argvec
[0], NULL
, nargs
+ 2, argvec
+ 1);
1352 op
= exp
->elts
[*pos
].opcode
;
1353 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1354 /* Allocate arg vector, including space for the function to be
1355 called in argvec[0], a potential `this', and a terminating NULL. */
1356 argvec
= (struct value
**)
1357 alloca (sizeof (struct value
*) * (nargs
+ 3));
1358 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1360 /* First, evaluate the structure into arg2. */
1363 if (op
== STRUCTOP_MEMBER
)
1365 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1369 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1372 /* If the function is a virtual function, then the
1373 aggregate value (providing the structure) plays
1374 its part by providing the vtable. Otherwise,
1375 it is just along for the ride: call the function
1378 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1380 type
= check_typedef (value_type (arg1
));
1381 if (noside
== EVAL_SKIP
)
1382 tem
= 1; /* Set it to the right arg index so that all arguments
1383 can also be skipped. */
1384 else if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
)
1386 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1387 arg1
= value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1389 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1391 /* Now, say which argument to start evaluating from. */
1396 else if (TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1398 struct type
*type_ptr
1399 = lookup_pointer_type (TYPE_SELF_TYPE (type
));
1400 struct type
*target_type_ptr
1401 = lookup_pointer_type (TYPE_TARGET_TYPE (type
));
1403 /* Now, convert these values to an address. */
1404 arg2
= value_cast (type_ptr
, arg2
);
1406 mem_offset
= value_as_long (arg1
);
1408 arg1
= value_from_pointer (target_type_ptr
,
1409 value_as_long (arg2
) + mem_offset
);
1410 arg1
= value_ind (arg1
);
1414 error (_("Non-pointer-to-member value used in pointer-to-member "
1417 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1419 /* Hair for method invocations. */
1423 /* First, evaluate the structure into arg2. */
1425 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1426 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1428 if (op
== STRUCTOP_STRUCT
)
1430 /* If v is a variable in a register, and the user types
1431 v.method (), this will produce an error, because v has
1434 A possible way around this would be to allocate a
1435 copy of the variable on the stack, copy in the
1436 contents, call the function, and copy out the
1437 contents. I.e. convert this from call by reference
1438 to call by copy-return (or whatever it's called).
1439 However, this does not work because it is not the
1440 same: the method being called could stash a copy of
1441 the address, and then future uses through that address
1442 (after the method returns) would be expected to
1443 use the variable itself, not some copy of it. */
1444 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1448 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1450 /* Check to see if the operator '->' has been
1451 overloaded. If the operator has been overloaded
1452 replace arg2 with the value returned by the custom
1453 operator and continue evaluation. */
1454 while (unop_user_defined_p (op
, arg2
))
1456 struct value
*value
= NULL
;
1459 value
= value_x_unop (arg2
, op
, noside
);
1462 CATCH (except
, RETURN_MASK_ERROR
)
1464 if (except
.error
== NOT_FOUND_ERROR
)
1467 throw_exception (except
);
1474 /* Now, say which argument to start evaluating from. */
1477 else if (op
== OP_SCOPE
1478 && overload_resolution
1479 && (exp
->language_defn
->la_language
== language_cplus
))
1481 /* Unpack it locally so we can properly handle overload
1487 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1488 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1489 type
= exp
->elts
[pc2
+ 1].type
;
1490 name
= &exp
->elts
[pc2
+ 3].string
;
1493 function_name
= NULL
;
1494 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1496 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1498 get_selected_block (0),
1500 if (function
== NULL
)
1501 error (_("No symbol \"%s\" in namespace \"%s\"."),
1502 name
, TYPE_TAG_NAME (type
));
1505 /* arg2 is left as NULL on purpose. */
1509 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1510 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1511 function_name
= name
;
1513 /* We need a properly typed value for method lookup. For
1514 static methods arg2 is otherwise unused. */
1515 arg2
= value_zero (type
, lval_memory
);
1520 else if (op
== OP_ADL_FUNC
)
1522 /* Save the function position and move pos so that the arguments
1523 can be evaluated. */
1529 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1530 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1534 /* Non-method function call. */
1538 /* If this is a C++ function wait until overload resolution. */
1539 if (op
== OP_VAR_VALUE
1540 && overload_resolution
1541 && (exp
->language_defn
->la_language
== language_cplus
))
1543 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1548 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1549 type
= value_type (argvec
[0]);
1550 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1551 type
= TYPE_TARGET_TYPE (type
);
1552 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1554 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1556 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1564 /* Evaluate arguments (if not already done, e.g., namespace::func()
1565 and overload-resolution is off). */
1566 for (; tem
<= nargs
; tem
++)
1568 /* Ensure that array expressions are coerced into pointer
1570 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1573 /* Signal end of arglist. */
1576 if (noside
== EVAL_SKIP
)
1579 if (op
== OP_ADL_FUNC
)
1581 struct symbol
*symp
;
1584 int string_pc
= save_pos1
+ 3;
1586 /* Extract the function name. */
1587 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1588 func_name
= (char *) alloca (name_len
+ 1);
1589 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1591 find_overload_match (&argvec
[1], nargs
, func_name
,
1592 NON_METHOD
, /* not method */
1593 NULL
, NULL
, /* pass NULL symbol since
1594 symbol is unknown */
1595 NULL
, &symp
, NULL
, 0, noside
);
1597 /* Now fix the expression being evaluated. */
1598 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1599 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1602 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1603 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1605 int static_memfuncp
;
1608 /* Method invocation: stuff "this" as first parameter.
1609 If the method turns out to be static we undo this below. */
1614 /* Name of method from expression. */
1615 tstr
= &exp
->elts
[pc2
+ 2].string
;
1618 tstr
= function_name
;
1620 if (overload_resolution
&& (exp
->language_defn
->la_language
1623 /* Language is C++, do some overload resolution before
1625 struct value
*valp
= NULL
;
1627 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1628 METHOD
, /* method */
1629 &arg2
, /* the object */
1631 &static_memfuncp
, 0, noside
);
1633 if (op
== OP_SCOPE
&& !static_memfuncp
)
1635 /* For the time being, we don't handle this. */
1636 error (_("Call to overloaded function %s requires "
1640 argvec
[1] = arg2
; /* the ``this'' pointer */
1641 argvec
[0] = valp
; /* Use the method found after overload
1645 /* Non-C++ case -- or no overload resolution. */
1647 struct value
*temp
= arg2
;
1649 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1651 op
== STRUCTOP_STRUCT
1652 ? "structure" : "structure pointer");
1653 /* value_struct_elt updates temp with the correct value
1654 of the ``this'' pointer if necessary, so modify argvec[1] to
1655 reflect any ``this'' changes. */
1657 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1658 value_address (temp
)
1659 + value_embedded_offset (temp
));
1660 argvec
[1] = arg2
; /* the ``this'' pointer */
1663 /* Take out `this' if needed. */
1664 if (static_memfuncp
)
1666 argvec
[1] = argvec
[0];
1671 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1673 /* Pointer to member. argvec[1] is already set up. */
1676 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1678 /* Non-member function being called. */
1679 /* fn: This can only be done for C++ functions. A C-style function
1680 in a C++ program, for instance, does not have the fields that
1681 are expected here. */
1683 if (overload_resolution
&& (exp
->language_defn
->la_language
1686 /* Language is C++, do some overload resolution before
1688 struct symbol
*symp
;
1691 /* If a scope has been specified disable ADL. */
1695 if (op
== OP_VAR_VALUE
)
1696 function
= exp
->elts
[save_pos1
+2].symbol
;
1698 (void) find_overload_match (&argvec
[1], nargs
,
1699 NULL
, /* no need for name */
1700 NON_METHOD
, /* not method */
1701 NULL
, function
, /* the function */
1702 NULL
, &symp
, NULL
, no_adl
, noside
);
1704 if (op
== OP_VAR_VALUE
)
1706 /* Now fix the expression being evaluated. */
1707 exp
->elts
[save_pos1
+2].symbol
= symp
;
1708 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1712 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1716 /* Not C++, or no overload resolution allowed. */
1717 /* Nothing to be done; argvec already correctly set up. */
1722 /* It is probably a C-style function. */
1723 /* Nothing to be done; argvec already correctly set up. */
1728 if (argvec
[0] == NULL
)
1729 error (_("Cannot evaluate function -- may be inlined"));
1730 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1732 /* If the return type doesn't look like a function type,
1733 call an error. This can happen if somebody tries to turn
1734 a variable into a function call. */
1736 struct type
*ftype
= value_type (argvec
[0]);
1738 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1740 /* We don't know anything about what the internal
1741 function might return, but we have to return
1743 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1746 else if (TYPE_CODE (ftype
) == TYPE_CODE_XMETHOD
)
1748 struct type
*return_type
1749 = result_type_of_xmethod (argvec
[0], nargs
, argvec
+ 1);
1751 if (return_type
== NULL
)
1752 error (_("Xmethod is missing return type."));
1753 return value_zero (return_type
, not_lval
);
1755 else if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
1756 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
1758 struct type
*return_type
= TYPE_TARGET_TYPE (ftype
);
1760 if (return_type
== NULL
)
1761 return_type
= expect_type
;
1763 if (return_type
== NULL
)
1764 error_call_unknown_return_type (NULL
);
1766 return allocate_value (return_type
);
1769 error (_("Expression of type other than "
1770 "\"Function returning ...\" used as function"));
1772 switch (TYPE_CODE (value_type (argvec
[0])))
1774 case TYPE_CODE_INTERNAL_FUNCTION
:
1775 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1776 argvec
[0], nargs
, argvec
+ 1);
1777 case TYPE_CODE_XMETHOD
:
1778 return call_xmethod (argvec
[0], nargs
, argvec
+ 1);
1780 return call_function_by_hand (argvec
[0],
1781 expect_type
, nargs
, argvec
+ 1);
1783 /* pai: FIXME save value from call_function_by_hand, then adjust
1784 pc by adjust_fn_pc if +ve. */
1786 case OP_F77_UNDETERMINED_ARGLIST
:
1788 /* Remember that in F77, functions, substring ops and
1789 array subscript operations cannot be disambiguated
1790 at parse time. We have made all array subscript operations,
1791 substring operations as well as function calls come here
1792 and we now have to discover what the heck this thing actually was.
1793 If it is a function, we process just as if we got an OP_FUNCALL. */
1795 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1798 /* First determine the type code we are dealing with. */
1799 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1800 type
= check_typedef (value_type (arg1
));
1801 code
= TYPE_CODE (type
);
1803 if (code
== TYPE_CODE_PTR
)
1805 /* Fortran always passes variable to subroutines as pointer.
1806 So we need to look into its target type to see if it is
1807 array, string or function. If it is, we need to switch
1808 to the target value the original one points to. */
1809 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1811 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1812 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1813 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1815 arg1
= value_ind (arg1
);
1816 type
= check_typedef (value_type (arg1
));
1817 code
= TYPE_CODE (type
);
1823 case TYPE_CODE_ARRAY
:
1824 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1825 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1827 goto multi_f77_subscript
;
1829 case TYPE_CODE_STRING
:
1830 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1831 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1834 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1835 return value_subscript (arg1
, value_as_long (arg2
));
1839 case TYPE_CODE_FUNC
:
1840 /* It's a function call. */
1841 /* Allocate arg vector, including space for the function to be
1842 called in argvec[0] and a terminating NULL. */
1843 argvec
= (struct value
**)
1844 alloca (sizeof (struct value
*) * (nargs
+ 2));
1847 for (; tem
<= nargs
; tem
++)
1848 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1849 argvec
[tem
] = 0; /* signal end of arglist */
1850 if (noside
== EVAL_SKIP
)
1855 error (_("Cannot perform substring on this type"));
1859 /* We have a complex number, There should be 2 floating
1860 point numbers that compose it. */
1862 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1863 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1865 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1867 case STRUCTOP_STRUCT
:
1868 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1869 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1870 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1871 if (noside
== EVAL_SKIP
)
1873 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1875 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1876 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1880 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1881 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1882 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1883 if (noside
== EVAL_SKIP
)
1886 /* Check to see if operator '->' has been overloaded. If so replace
1887 arg1 with the value returned by evaluating operator->(). */
1888 while (unop_user_defined_p (op
, arg1
))
1890 struct value
*value
= NULL
;
1893 value
= value_x_unop (arg1
, op
, noside
);
1896 CATCH (except
, RETURN_MASK_ERROR
)
1898 if (except
.error
== NOT_FOUND_ERROR
)
1901 throw_exception (except
);
1908 /* JYG: if print object is on we need to replace the base type
1909 with rtti type in order to continue on with successful
1910 lookup of member / method only available in the rtti type. */
1912 struct type
*type
= value_type (arg1
);
1913 struct type
*real_type
;
1914 int full
, using_enc
;
1916 struct value_print_options opts
;
1918 get_user_print_options (&opts
);
1919 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1920 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_STRUCT
))
1922 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1925 arg1
= value_cast (real_type
, arg1
);
1929 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
1930 NULL
, "structure pointer");
1931 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1932 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
1935 case STRUCTOP_MEMBER
:
1937 if (op
== STRUCTOP_MEMBER
)
1938 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1940 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1942 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1944 if (noside
== EVAL_SKIP
)
1947 type
= check_typedef (value_type (arg2
));
1948 switch (TYPE_CODE (type
))
1950 case TYPE_CODE_METHODPTR
:
1951 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1952 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1955 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1956 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1957 return value_ind (arg2
);
1960 case TYPE_CODE_MEMBERPTR
:
1961 /* Now, convert these values to an address. */
1962 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
1965 mem_offset
= value_as_long (arg2
);
1967 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1968 value_as_long (arg1
) + mem_offset
);
1969 return value_ind (arg3
);
1972 error (_("non-pointer-to-member value used "
1973 "in pointer-to-member construct"));
1977 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1978 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1979 for (ix
= 0; ix
< nargs
; ++ix
)
1980 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1982 expect_type
= make_params (nargs
, arg_types
);
1983 *(pos
) += 3 + nargs
;
1984 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1985 xfree (TYPE_FIELDS (expect_type
));
1986 xfree (TYPE_MAIN_TYPE (expect_type
));
1987 xfree (expect_type
);
1991 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1992 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1993 if (noside
== EVAL_SKIP
)
1995 if (binop_user_defined_p (op
, arg1
, arg2
))
1996 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1998 return value_concat (arg1
, arg2
);
2001 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2002 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2004 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2006 if (binop_user_defined_p (op
, arg1
, arg2
))
2007 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2009 return value_assign (arg1
, arg2
);
2011 case BINOP_ASSIGN_MODIFY
:
2013 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2014 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2015 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2017 op
= exp
->elts
[pc
+ 1].opcode
;
2018 if (binop_user_defined_p (op
, arg1
, arg2
))
2019 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2020 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2022 && is_integral_type (value_type (arg2
)))
2023 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2024 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2026 && is_integral_type (value_type (arg2
)))
2027 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2030 struct value
*tmp
= arg1
;
2032 /* For shift and integer exponentiation operations,
2033 only promote the first argument. */
2034 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2035 && is_integral_type (value_type (arg2
)))
2036 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2038 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2040 arg2
= value_binop (tmp
, arg2
, op
);
2042 return value_assign (arg1
, arg2
);
2045 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2046 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2047 if (noside
== EVAL_SKIP
)
2049 if (binop_user_defined_p (op
, arg1
, arg2
))
2050 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2051 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2052 && is_integral_type (value_type (arg2
)))
2053 return value_ptradd (arg1
, value_as_long (arg2
));
2054 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2055 && is_integral_type (value_type (arg1
)))
2056 return value_ptradd (arg2
, value_as_long (arg1
));
2059 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2060 return value_binop (arg1
, arg2
, BINOP_ADD
);
2064 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2065 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2066 if (noside
== EVAL_SKIP
)
2068 if (binop_user_defined_p (op
, arg1
, arg2
))
2069 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2070 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2071 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2073 /* FIXME -- should be ptrdiff_t */
2074 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2075 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2077 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2078 && is_integral_type (value_type (arg2
)))
2079 return value_ptradd (arg1
, - value_as_long (arg2
));
2082 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2083 return value_binop (arg1
, arg2
, BINOP_SUB
);
2094 case BINOP_BITWISE_AND
:
2095 case BINOP_BITWISE_IOR
:
2096 case BINOP_BITWISE_XOR
:
2097 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2098 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2099 if (noside
== EVAL_SKIP
)
2101 if (binop_user_defined_p (op
, arg1
, arg2
))
2102 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2105 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2106 fudge arg2 to avoid division-by-zero, the caller is
2107 (theoretically) only looking for the type of the result. */
2108 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2109 /* ??? Do we really want to test for BINOP_MOD here?
2110 The implementation of value_binop gives it a well-defined
2113 || op
== BINOP_INTDIV
2116 && value_logical_not (arg2
))
2118 struct value
*v_one
, *retval
;
2120 v_one
= value_one (value_type (arg2
));
2121 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2122 retval
= value_binop (arg1
, v_one
, op
);
2127 /* For shift and integer exponentiation operations,
2128 only promote the first argument. */
2129 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2130 && is_integral_type (value_type (arg2
)))
2131 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2133 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2135 return value_binop (arg1
, arg2
, op
);
2139 case BINOP_SUBSCRIPT
:
2140 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2141 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2142 if (noside
== EVAL_SKIP
)
2144 if (binop_user_defined_p (op
, arg1
, arg2
))
2145 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2148 /* If the user attempts to subscript something that is not an
2149 array or pointer type (like a plain int variable for example),
2150 then report this as an error. */
2152 arg1
= coerce_ref (arg1
);
2153 type
= check_typedef (value_type (arg1
));
2154 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2155 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2157 if (TYPE_NAME (type
))
2158 error (_("cannot subscript something of type `%s'"),
2161 error (_("cannot subscript requested type"));
2164 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2165 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2167 return value_subscript (arg1
, value_as_long (arg2
));
2169 case MULTI_SUBSCRIPT
:
2171 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2172 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2175 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2176 /* FIXME: EVAL_SKIP handling may not be correct. */
2177 if (noside
== EVAL_SKIP
)
2188 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2189 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2191 /* If the user attempts to subscript something that has no target
2192 type (like a plain int variable for example), then report this
2195 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2198 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2204 error (_("cannot subscript something of type `%s'"),
2205 TYPE_NAME (value_type (arg1
)));
2209 if (binop_user_defined_p (op
, arg1
, arg2
))
2211 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2215 arg1
= coerce_ref (arg1
);
2216 type
= check_typedef (value_type (arg1
));
2218 switch (TYPE_CODE (type
))
2221 case TYPE_CODE_ARRAY
:
2222 case TYPE_CODE_STRING
:
2223 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2227 if (TYPE_NAME (type
))
2228 error (_("cannot subscript something of type `%s'"),
2231 error (_("cannot subscript requested type"));
2237 multi_f77_subscript
:
2239 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2240 int ndimensions
= 1, i
;
2241 struct value
*array
= arg1
;
2243 if (nargs
> MAX_FORTRAN_DIMS
)
2244 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2246 ndimensions
= calc_f77_array_dims (type
);
2248 if (nargs
!= ndimensions
)
2249 error (_("Wrong number of subscripts"));
2251 gdb_assert (nargs
> 0);
2253 /* Now that we know we have a legal array subscript expression
2254 let us actually find out where this element exists in the array. */
2256 /* Take array indices left to right. */
2257 for (i
= 0; i
< nargs
; i
++)
2259 /* Evaluate each subscript; it must be a legal integer in F77. */
2260 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2262 /* Fill in the subscript array. */
2264 subscript_array
[i
] = value_as_long (arg2
);
2267 /* Internal type of array is arranged right to left. */
2268 for (i
= nargs
; i
> 0; i
--)
2270 struct type
*array_type
= check_typedef (value_type (array
));
2271 LONGEST index
= subscript_array
[i
- 1];
2273 array
= value_subscripted_rvalue (array
, index
,
2274 f77_get_lowerbound (array_type
));
2280 case BINOP_LOGICAL_AND
:
2281 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2282 if (noside
== EVAL_SKIP
)
2284 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2289 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2292 if (binop_user_defined_p (op
, arg1
, arg2
))
2294 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2295 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2299 tem
= value_logical_not (arg1
);
2300 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2301 (tem
? EVAL_SKIP
: noside
));
2302 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2303 return value_from_longest (type
,
2304 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2307 case BINOP_LOGICAL_OR
:
2308 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2309 if (noside
== EVAL_SKIP
)
2311 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2316 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2319 if (binop_user_defined_p (op
, arg1
, arg2
))
2321 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2322 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2326 tem
= value_logical_not (arg1
);
2327 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2328 (!tem
? EVAL_SKIP
: noside
));
2329 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2330 return value_from_longest (type
,
2331 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2335 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2336 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2337 if (noside
== EVAL_SKIP
)
2339 if (binop_user_defined_p (op
, arg1
, arg2
))
2341 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2345 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2346 tem
= value_equal (arg1
, arg2
);
2347 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2348 return value_from_longest (type
, (LONGEST
) tem
);
2351 case BINOP_NOTEQUAL
:
2352 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2353 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2354 if (noside
== EVAL_SKIP
)
2356 if (binop_user_defined_p (op
, arg1
, arg2
))
2358 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2362 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2363 tem
= value_equal (arg1
, arg2
);
2364 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2365 return value_from_longest (type
, (LONGEST
) ! tem
);
2369 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2370 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2371 if (noside
== EVAL_SKIP
)
2373 if (binop_user_defined_p (op
, arg1
, arg2
))
2375 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2379 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2380 tem
= value_less (arg1
, arg2
);
2381 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2382 return value_from_longest (type
, (LONGEST
) tem
);
2386 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2387 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2388 if (noside
== EVAL_SKIP
)
2390 if (binop_user_defined_p (op
, arg1
, arg2
))
2392 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2396 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2397 tem
= value_less (arg2
, arg1
);
2398 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2399 return value_from_longest (type
, (LONGEST
) tem
);
2403 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2404 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2405 if (noside
== EVAL_SKIP
)
2407 if (binop_user_defined_p (op
, arg1
, arg2
))
2409 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2413 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2414 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2415 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2416 return value_from_longest (type
, (LONGEST
) tem
);
2420 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2421 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2422 if (noside
== EVAL_SKIP
)
2424 if (binop_user_defined_p (op
, arg1
, arg2
))
2426 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2430 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2431 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2432 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2433 return value_from_longest (type
, (LONGEST
) tem
);
2437 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2438 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2439 if (noside
== EVAL_SKIP
)
2441 type
= check_typedef (value_type (arg2
));
2442 if (TYPE_CODE (type
) != TYPE_CODE_INT
2443 && TYPE_CODE (type
) != TYPE_CODE_ENUM
)
2444 error (_("Non-integral right operand for \"@\" operator."));
2445 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2447 return allocate_repeat_value (value_type (arg1
),
2448 longest_to_int (value_as_long (arg2
)));
2451 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2454 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2455 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2458 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2459 if (noside
== EVAL_SKIP
)
2461 if (unop_user_defined_p (op
, arg1
))
2462 return value_x_unop (arg1
, op
, noside
);
2465 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2466 return value_pos (arg1
);
2470 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2471 if (noside
== EVAL_SKIP
)
2473 if (unop_user_defined_p (op
, arg1
))
2474 return value_x_unop (arg1
, op
, noside
);
2477 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2478 return value_neg (arg1
);
2481 case UNOP_COMPLEMENT
:
2482 /* C++: check for and handle destructor names. */
2483 op
= exp
->elts
[*pos
].opcode
;
2485 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2486 if (noside
== EVAL_SKIP
)
2488 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2489 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2492 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2493 return value_complement (arg1
);
2496 case UNOP_LOGICAL_NOT
:
2497 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2498 if (noside
== EVAL_SKIP
)
2500 if (unop_user_defined_p (op
, arg1
))
2501 return value_x_unop (arg1
, op
, noside
);
2504 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2505 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2509 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2510 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2511 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2512 type
= check_typedef (value_type (arg1
));
2513 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2514 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2515 error (_("Attempt to dereference pointer "
2516 "to member without an object"));
2517 if (noside
== EVAL_SKIP
)
2519 if (unop_user_defined_p (op
, arg1
))
2520 return value_x_unop (arg1
, op
, noside
);
2521 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2523 type
= check_typedef (value_type (arg1
));
2524 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2525 || TYPE_IS_REFERENCE (type
)
2526 /* In C you can dereference an array to get the 1st elt. */
2527 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2529 return value_zero (TYPE_TARGET_TYPE (type
),
2531 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2532 /* GDB allows dereferencing an int. */
2533 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2536 error (_("Attempt to take contents of a non-pointer value."));
2539 /* Allow * on an integer so we can cast it to whatever we want.
2540 This returns an int, which seems like the most C-like thing to
2541 do. "long long" variables are rare enough that
2542 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2543 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2544 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2545 (CORE_ADDR
) value_as_address (arg1
));
2546 return value_ind (arg1
);
2549 /* C++: check for and handle pointer to members. */
2551 op
= exp
->elts
[*pos
].opcode
;
2553 if (noside
== EVAL_SKIP
)
2555 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2560 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2567 if (noside
== EVAL_SKIP
)
2569 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2572 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2576 type
= exp
->elts
[pc
+ 1].type
;
2577 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2578 if (noside
== EVAL_SKIP
)
2580 if (type
!= value_type (arg1
))
2581 arg1
= value_cast (type
, arg1
);
2584 case UNOP_CAST_TYPE
:
2585 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2586 type
= value_type (arg1
);
2587 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2588 if (noside
== EVAL_SKIP
)
2590 if (type
!= value_type (arg1
))
2591 arg1
= value_cast (type
, arg1
);
2594 case UNOP_DYNAMIC_CAST
:
2595 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2596 type
= value_type (arg1
);
2597 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2598 if (noside
== EVAL_SKIP
)
2600 return value_dynamic_cast (type
, arg1
);
2602 case UNOP_REINTERPRET_CAST
:
2603 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2604 type
= value_type (arg1
);
2605 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2606 if (noside
== EVAL_SKIP
)
2608 return value_reinterpret_cast (type
, arg1
);
2612 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2613 if (noside
== EVAL_SKIP
)
2615 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2616 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2618 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2619 value_as_address (arg1
));
2621 case UNOP_MEMVAL_TYPE
:
2622 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2623 type
= value_type (arg1
);
2624 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2625 if (noside
== EVAL_SKIP
)
2627 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2628 return value_zero (type
, lval_memory
);
2630 return value_at_lazy (type
, value_as_address (arg1
));
2632 case UNOP_MEMVAL_TLS
:
2634 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2635 if (noside
== EVAL_SKIP
)
2637 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2638 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2643 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2644 value_as_address (arg1
));
2645 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2648 case UNOP_PREINCREMENT
:
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_ADD
);
2669 return value_assign (arg1
, arg2
);
2672 case UNOP_PREDECREMENT
:
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 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_SUB
);
2693 return value_assign (arg1
, arg2
);
2696 case UNOP_POSTINCREMENT
:
2697 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2698 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2700 else if (unop_user_defined_p (op
, arg1
))
2702 return value_x_unop (arg1
, op
, noside
);
2706 arg3
= value_non_lval (arg1
);
2708 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2709 arg2
= value_ptradd (arg1
, 1);
2712 struct value
*tmp
= arg1
;
2714 arg2
= value_one (value_type (arg1
));
2715 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2716 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2719 value_assign (arg1
, arg2
);
2723 case UNOP_POSTDECREMENT
:
2724 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2725 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2727 else if (unop_user_defined_p (op
, arg1
))
2729 return value_x_unop (arg1
, op
, noside
);
2733 arg3
= value_non_lval (arg1
);
2735 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2736 arg2
= value_ptradd (arg1
, -1);
2739 struct value
*tmp
= arg1
;
2741 arg2
= value_one (value_type (arg1
));
2742 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2743 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2746 value_assign (arg1
, arg2
);
2752 return value_of_this (exp
->language_defn
);
2755 /* The value is not supposed to be used. This is here to make it
2756 easier to accommodate expressions that contain types. */
2758 if (noside
== EVAL_SKIP
)
2760 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2761 return allocate_value (exp
->elts
[pc
+ 1].type
);
2763 error (_("Attempt to use a type name as an expression"));
2767 if (noside
== EVAL_SKIP
)
2769 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2772 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2774 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2775 struct value
*result
;
2777 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2778 EVAL_AVOID_SIDE_EFFECTS
);
2780 /* 'decltype' has special semantics for lvalues. */
2781 if (op
== OP_DECLTYPE
2782 && (sub_op
== BINOP_SUBSCRIPT
2783 || sub_op
== STRUCTOP_MEMBER
2784 || sub_op
== STRUCTOP_MPTR
2785 || sub_op
== UNOP_IND
2786 || sub_op
== STRUCTOP_STRUCT
2787 || sub_op
== STRUCTOP_PTR
2788 || sub_op
== OP_SCOPE
))
2790 struct type
*type
= value_type (result
);
2792 if (!TYPE_IS_REFERENCE (type
))
2794 type
= lookup_lvalue_reference_type (type
);
2795 result
= allocate_value (type
);
2802 error (_("Attempt to use a type as an expression"));
2806 struct value
*result
;
2807 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2809 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2810 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2811 EVAL_AVOID_SIDE_EFFECTS
);
2813 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2815 if (noside
!= EVAL_NORMAL
)
2816 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2818 return cplus_typeid (result
);
2822 /* Removing this case and compiling with gcc -Wall reveals that
2823 a lot of cases are hitting this case. Some of these should
2824 probably be removed from expression.h; others are legitimate
2825 expressions which are (apparently) not fully implemented.
2827 If there are any cases landing here which mean a user error,
2828 then they should be separate cases, with more descriptive
2831 error (_("GDB does not (yet) know how to "
2832 "evaluate that kind of expression"));
2836 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2839 /* Evaluate a subexpression of EXP, at index *POS,
2840 and return the address of that subexpression.
2841 Advance *POS over the subexpression.
2842 If the subexpression isn't an lvalue, get an error.
2843 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2844 then only the type of the result need be correct. */
2846 static struct value
*
2847 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2857 op
= exp
->elts
[pc
].opcode
;
2863 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2865 /* We can't optimize out "&*" if there's a user-defined operator*. */
2866 if (unop_user_defined_p (op
, x
))
2868 x
= value_x_unop (x
, op
, noside
);
2869 goto default_case_after_eval
;
2872 return coerce_array (x
);
2876 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2877 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2879 case UNOP_MEMVAL_TYPE
:
2884 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2885 type
= value_type (x
);
2886 return value_cast (lookup_pointer_type (type
),
2887 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2891 var
= exp
->elts
[pc
+ 2].symbol
;
2893 /* C++: The "address" of a reference should yield the address
2894 * of the object pointed to. Let value_addr() deal with it. */
2895 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
2899 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2902 lookup_pointer_type (SYMBOL_TYPE (var
));
2903 enum address_class sym_class
= SYMBOL_CLASS (var
);
2905 if (sym_class
== LOC_CONST
2906 || sym_class
== LOC_CONST_BYTES
2907 || sym_class
== LOC_REGISTER
)
2908 error (_("Attempt to take address of register or constant."));
2911 value_zero (type
, not_lval
);
2914 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2917 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2918 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2919 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2920 &exp
->elts
[pc
+ 3].string
,
2923 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2928 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2929 default_case_after_eval
:
2930 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2932 struct type
*type
= check_typedef (value_type (x
));
2934 if (TYPE_IS_REFERENCE (type
))
2935 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2937 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2938 return value_zero (lookup_pointer_type (value_type (x
)),
2941 error (_("Attempt to take address of "
2942 "value not located in memory."));
2944 return value_addr (x
);
2948 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2949 When used in contexts where arrays will be coerced anyway, this is
2950 equivalent to `evaluate_subexp' but much faster because it avoids
2951 actually fetching array contents (perhaps obsolete now that we have
2954 Note that we currently only do the coercion for C expressions, where
2955 arrays are zero based and the coercion is correct. For other languages,
2956 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2957 to decide if coercion is appropriate. */
2960 evaluate_subexp_with_coercion (struct expression
*exp
,
2961 int *pos
, enum noside noside
)
2970 op
= exp
->elts
[pc
].opcode
;
2975 var
= exp
->elts
[pc
+ 2].symbol
;
2976 type
= check_typedef (SYMBOL_TYPE (var
));
2977 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2978 && !TYPE_VECTOR (type
)
2979 && CAST_IS_CONVERSION (exp
->language_defn
))
2982 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2983 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2989 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2993 /* Evaluate a subexpression of EXP, at index *POS,
2994 and return a value for the size of that subexpression.
2995 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2996 we allow side-effects on the operand if its type is a variable
2999 static struct value
*
3000 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3003 /* FIXME: This should be size_t. */
3004 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3011 op
= exp
->elts
[pc
].opcode
;
3015 /* This case is handled specially
3016 so that we avoid creating a value for the result type.
3017 If the result type is very big, it's desirable not to
3018 create a value unnecessarily. */
3021 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3022 type
= check_typedef (value_type (val
));
3023 if (TYPE_CODE (type
) != TYPE_CODE_PTR
3024 && !TYPE_IS_REFERENCE (type
)
3025 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
3026 error (_("Attempt to take contents of a non-pointer value."));
3027 type
= TYPE_TARGET_TYPE (type
);
3028 if (is_dynamic_type (type
))
3029 type
= value_type (value_ind (val
));
3030 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3034 type
= exp
->elts
[pc
+ 1].type
;
3037 case UNOP_MEMVAL_TYPE
:
3039 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3040 type
= value_type (val
);
3044 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3045 if (is_dynamic_type (type
))
3047 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3048 type
= value_type (val
);
3054 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3055 type of the subscript is a variable length array type. In this case we
3056 must re-evaluate the right hand side of the subcription to allow
3058 case BINOP_SUBSCRIPT
:
3059 if (noside
== EVAL_NORMAL
)
3061 int pc
= (*pos
) + 1;
3063 val
= evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
3064 type
= check_typedef (value_type (val
));
3065 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3067 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3068 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
3070 type
= TYPE_INDEX_TYPE (type
);
3071 /* Only re-evaluate the right hand side if the resulting type
3072 is a variable length type. */
3073 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3075 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3076 return value_from_longest
3077 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3086 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3087 type
= value_type (val
);
3091 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3092 "When applied to a reference or a reference type, the result is
3093 the size of the referenced type." */
3094 type
= check_typedef (type
);
3095 if (exp
->language_defn
->la_language
== language_cplus
3096 && (TYPE_IS_REFERENCE (type
)))
3097 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3098 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3101 /* Parse a type expression in the string [P..P+LENGTH). */
3104 parse_and_eval_type (char *p
, int length
)
3106 char *tmp
= (char *) alloca (length
+ 4);
3109 memcpy (tmp
+ 1, p
, length
);
3110 tmp
[length
+ 1] = ')';
3111 tmp
[length
+ 2] = '0';
3112 tmp
[length
+ 3] = '\0';
3113 expression_up expr
= parse_expression (tmp
);
3114 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3115 error (_("Internal error in eval_type."));
3116 return expr
->elts
[1].type
;
3120 calc_f77_array_dims (struct type
*array_type
)
3123 struct type
*tmp_type
;
3125 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3126 error (_("Can't get dimensions for a non-array type"));
3128 tmp_type
= array_type
;
3130 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3132 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)