1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2020 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"
42 #include "typeprint.h"
45 /* Prototypes for local functions. */
47 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *,
50 static struct value
*evaluate_subexp_for_address (struct expression
*,
53 static value
*evaluate_subexp_for_cast (expression
*exp
, int *pos
,
57 static struct value
*evaluate_struct_tuple (struct value
*,
58 struct expression
*, int *,
61 static LONGEST
init_array_element (struct value
*, struct value
*,
62 struct expression
*, int *, enum noside
,
66 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
67 int *pos
, enum noside noside
)
71 gdb::optional
<enable_thread_stack_temporaries
> stack_temporaries
;
72 if (*pos
== 0 && target_has_execution
73 && exp
->language_defn
->la_language
== language_cplus
74 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
75 stack_temporaries
.emplace (inferior_thread ());
77 retval
= (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
78 (expect_type
, exp
, pos
, noside
);
80 if (stack_temporaries
.has_value ()
81 && value_in_thread_stack_temporaries (retval
, inferior_thread ()))
82 retval
= value_non_lval (retval
);
87 /* Parse the string EXP as a C expression, evaluate it,
88 and return the result as a number. */
91 parse_and_eval_address (const char *exp
)
93 expression_up expr
= parse_expression (exp
);
95 return value_as_address (evaluate_expression (expr
.get ()));
98 /* Like parse_and_eval_address, but treats the value of the expression
99 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
101 parse_and_eval_long (const char *exp
)
103 expression_up expr
= parse_expression (exp
);
105 return value_as_long (evaluate_expression (expr
.get ()));
109 parse_and_eval (const char *exp
)
111 expression_up expr
= parse_expression (exp
);
113 return evaluate_expression (expr
.get ());
116 /* Parse up to a comma (or to a closeparen)
117 in the string EXPP as an expression, evaluate it, and return the value.
118 EXPP is advanced to point to the comma. */
121 parse_to_comma_and_eval (const char **expp
)
123 expression_up expr
= parse_exp_1 (expp
, 0, nullptr, 1);
125 return evaluate_expression (expr
.get ());
128 /* Evaluate an expression in internal prefix form
129 such as is constructed by parse.y.
131 See expression.h for info on the format of an expression. */
134 evaluate_expression (struct expression
*exp
)
138 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
141 /* Evaluate an expression, avoiding all memory references
142 and getting a value whose type alone is correct. */
145 evaluate_type (struct expression
*exp
)
149 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
152 /* Evaluate a subexpression, avoiding all memory references and
153 getting a value whose type alone is correct. */
156 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
158 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
161 /* Find the current value of a watchpoint on EXP. Return the value in
162 *VALP and *RESULTP and the chain of intermediate and final values
163 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
166 If PRESERVE_ERRORS is true, then exceptions are passed through.
167 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
168 occurs while evaluating the expression, *RESULTP will be set to
169 NULL. *RESULTP may be a lazy value, if the result could not be
170 read from memory. It is used to determine whether a value is
171 user-specified (we should watch the whole value) or intermediate
172 (we should watch only the bit used to locate the final value).
174 If the final value, or any intermediate value, could not be read
175 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
176 set to any referenced values. *VALP will never be a lazy value.
177 This is the value which we store in struct breakpoint.
179 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
180 released from the value chain. If VAL_CHAIN is NULL, all generated
181 values will be left on the value chain. */
184 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
185 struct value
**resultp
,
186 std::vector
<value_ref_ptr
> *val_chain
,
189 struct value
*mark
, *new_mark
, *result
;
197 /* Evaluate the expression. */
198 mark
= value_mark ();
203 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
205 catch (const gdb_exception
&ex
)
207 /* Ignore memory errors if we want watchpoints pointing at
208 inaccessible memory to still be created; otherwise, throw the
209 error to some higher catcher. */
213 if (!preserve_errors
)
222 new_mark
= value_mark ();
223 if (mark
== new_mark
)
228 /* Make sure it's not lazy, so that after the target stops again we
229 have a non-lazy previous value to compare with. */
232 if (!value_lazy (result
))
239 value_fetch_lazy (result
);
242 catch (const gdb_exception_error
&except
)
250 /* Return the chain of intermediate values. We use this to
251 decide which addresses to watch. */
252 *val_chain
= value_release_to_mark (mark
);
256 /* Extract a field operation from an expression. If the subexpression
257 of EXP starting at *SUBEXP is not a structure dereference
258 operation, return NULL. Otherwise, return the name of the
259 dereferenced field, and advance *SUBEXP to point to the
260 subexpression of the left-hand-side of the dereference. This is
261 used when completing field names. */
264 extract_field_op (struct expression
*exp
, int *subexp
)
269 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
270 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
272 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
273 result
= &exp
->elts
[*subexp
+ 2].string
;
274 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
278 /* This function evaluates brace-initializers (in C/C++) for
281 static struct value
*
282 evaluate_struct_tuple (struct value
*struct_val
,
283 struct expression
*exp
,
284 int *pos
, enum noside noside
, int nargs
)
286 struct type
*struct_type
= check_typedef (value_type (struct_val
));
287 struct type
*field_type
;
292 struct value
*val
= NULL
;
297 /* Skip static fields. */
298 while (fieldno
< struct_type
->num_fields ()
299 && field_is_static (&struct_type
->field (fieldno
)))
301 if (fieldno
>= struct_type
->num_fields ())
302 error (_("too many initializers"));
303 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
304 if (field_type
->code () == TYPE_CODE_UNION
305 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
306 error (_("don't know which variant you want to set"));
308 /* Here, struct_type is the type of the inner struct,
309 while substruct_type is the type of the inner struct.
310 These are the same for normal structures, but a variant struct
311 contains anonymous union fields that contain substruct fields.
312 The value fieldno is the index of the top-level (normal or
313 anonymous union) field in struct_field, while the value
314 subfieldno is the index of the actual real (named inner) field
315 in substruct_type. */
317 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
319 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
321 /* Now actually set the field in struct_val. */
323 /* Assign val to field fieldno. */
324 if (value_type (val
) != field_type
)
325 val
= value_cast (field_type
, val
);
327 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
328 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
329 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
331 modify_field (struct_type
, addr
,
332 value_as_long (val
), bitpos
% 8, bitsize
);
334 memcpy (addr
, value_contents (val
),
335 TYPE_LENGTH (value_type (val
)));
341 /* Recursive helper function for setting elements of array tuples.
342 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
343 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
344 Evaluates index expressions and sets the specified element(s) of
345 ARRAY to ELEMENT. Returns last index value. */
348 init_array_element (struct value
*array
, struct value
*element
,
349 struct expression
*exp
, int *pos
,
350 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
353 int element_size
= TYPE_LENGTH (value_type (element
));
355 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
358 init_array_element (array
, element
, exp
, pos
, noside
,
359 low_bound
, high_bound
);
360 return init_array_element (array
, element
,
361 exp
, pos
, noside
, low_bound
, high_bound
);
365 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
366 if (index
< low_bound
|| index
> high_bound
)
367 error (_("tuple index out of range"));
368 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
369 value_contents (element
), element_size
);
374 static struct value
*
375 value_f90_subarray (struct value
*array
,
376 struct expression
*exp
, int *pos
, enum noside noside
)
379 LONGEST low_bound
, high_bound
;
380 struct type
*range
= check_typedef (value_type (array
)->index_type ());
381 enum range_type range_type
382 = (enum range_type
) longest_to_int (exp
->elts
[pc
].longconst
);
386 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
387 low_bound
= TYPE_LOW_BOUND (range
);
389 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
391 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
392 high_bound
= TYPE_HIGH_BOUND (range
);
394 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
396 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
400 /* Promote value ARG1 as appropriate before performing a unary operation
402 If the result is not appropriate for any particular language then it
403 needs to patch this function. */
406 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
411 *arg1
= coerce_ref (*arg1
);
412 type1
= check_typedef (value_type (*arg1
));
414 if (is_integral_type (type1
))
416 switch (language
->la_language
)
419 /* Perform integral promotion for ANSI C/C++.
420 If not appropriate for any particular language
421 it needs to modify this function. */
423 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
425 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
426 *arg1
= value_cast (builtin_int
, *arg1
);
433 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
434 operation on those two operands.
435 If the result is not appropriate for any particular language then it
436 needs to patch this function. */
439 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
440 struct value
**arg1
, struct value
**arg2
)
442 struct type
*promoted_type
= NULL
;
446 *arg1
= coerce_ref (*arg1
);
447 *arg2
= coerce_ref (*arg2
);
449 type1
= check_typedef (value_type (*arg1
));
450 type2
= check_typedef (value_type (*arg2
));
452 if ((type1
->code () != TYPE_CODE_FLT
453 && type1
->code () != TYPE_CODE_DECFLOAT
454 && !is_integral_type (type1
))
455 || (type2
->code () != TYPE_CODE_FLT
456 && type2
->code () != TYPE_CODE_DECFLOAT
457 && !is_integral_type (type2
)))
460 if (type1
->code () == TYPE_CODE_DECFLOAT
461 || type2
->code () == TYPE_CODE_DECFLOAT
)
463 /* No promotion required. */
465 else if (type1
->code () == TYPE_CODE_FLT
466 || type2
->code () == TYPE_CODE_FLT
)
468 switch (language
->la_language
)
474 case language_opencl
:
475 /* No promotion required. */
479 /* For other languages the result type is unchanged from gdb
480 version 6.7 for backward compatibility.
481 If either arg was long double, make sure that value is also long
482 double. Otherwise use double. */
483 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
484 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
485 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
487 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
491 else if (type1
->code () == TYPE_CODE_BOOL
492 && type2
->code () == TYPE_CODE_BOOL
)
494 /* No promotion required. */
497 /* Integral operations here. */
498 /* FIXME: Also mixed integral/booleans, with result an integer. */
500 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
501 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
502 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
503 int is_unsigned1
= TYPE_UNSIGNED (type1
);
504 int is_unsigned2
= TYPE_UNSIGNED (type2
);
505 unsigned int result_len
;
506 int unsigned_operation
;
508 /* Determine type length and signedness after promotion for
510 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
513 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
515 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
518 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
521 if (promoted_len1
> promoted_len2
)
523 unsigned_operation
= is_unsigned1
;
524 result_len
= promoted_len1
;
526 else if (promoted_len2
> promoted_len1
)
528 unsigned_operation
= is_unsigned2
;
529 result_len
= promoted_len2
;
533 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
534 result_len
= promoted_len1
;
537 switch (language
->la_language
)
543 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
545 promoted_type
= (unsigned_operation
546 ? builtin
->builtin_unsigned_int
547 : builtin
->builtin_int
);
549 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
551 promoted_type
= (unsigned_operation
552 ? builtin
->builtin_unsigned_long
553 : builtin
->builtin_long
);
557 promoted_type
= (unsigned_operation
558 ? builtin
->builtin_unsigned_long_long
559 : builtin
->builtin_long_long
);
562 case language_opencl
:
563 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
568 ? lookup_unsigned_typename (language
, "int")
569 : lookup_signed_typename (language
, "int"));
571 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
576 ? lookup_unsigned_typename (language
, "long")
577 : lookup_signed_typename (language
,"long"));
581 /* For other languages the result type is unchanged from gdb
582 version 6.7 for backward compatibility.
583 If either arg was long long, make sure that value is also long
584 long. Otherwise use long. */
585 if (unsigned_operation
)
587 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
588 promoted_type
= builtin
->builtin_unsigned_long_long
;
590 promoted_type
= builtin
->builtin_unsigned_long
;
594 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
595 promoted_type
= builtin
->builtin_long_long
;
597 promoted_type
= builtin
->builtin_long
;
605 /* Promote both operands to common type. */
606 *arg1
= value_cast (promoted_type
, *arg1
);
607 *arg2
= value_cast (promoted_type
, *arg2
);
612 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
614 type
= check_typedef (type
);
615 if (TYPE_IS_REFERENCE (type
))
616 type
= TYPE_TARGET_TYPE (type
);
618 switch (type
->code ())
624 case TYPE_CODE_ARRAY
:
625 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
632 /* Represents a fake method with the given parameter types. This is
633 used by the parser to construct a temporary "expected" type for
634 method overload resolution. FLAGS is used as instance flags of the
635 new type, in order to be able to make the new type represent a
636 const/volatile overload. */
641 fake_method (type_instance_flags flags
,
642 int num_types
, struct type
**param_types
);
645 /* The constructed type. */
646 struct type
*type () { return &m_type
; }
649 struct type m_type
{};
650 main_type m_main_type
{};
653 fake_method::fake_method (type_instance_flags flags
,
654 int num_types
, struct type
**param_types
)
656 struct type
*type
= &m_type
;
658 TYPE_MAIN_TYPE (type
) = &m_main_type
;
659 TYPE_LENGTH (type
) = 1;
660 type
->set_code (TYPE_CODE_METHOD
);
661 TYPE_CHAIN (type
) = type
;
662 TYPE_INSTANCE_FLAGS (type
) = flags
;
665 if (param_types
[num_types
- 1] == NULL
)
668 TYPE_VARARGS (type
) = 1;
670 else if (check_typedef (param_types
[num_types
- 1])->code ()
674 /* Caller should have ensured this. */
675 gdb_assert (num_types
== 0);
676 TYPE_PROTOTYPED (type
) = 1;
680 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
681 neither an objfile nor a gdbarch. As a result we must manually
682 allocate memory for auxiliary fields, and free the memory ourselves
683 when we are done with it. */
684 type
->set_num_fields (num_types
);
686 ((struct field
*) xzalloc (sizeof (struct field
) * num_types
));
688 while (num_types
-- > 0)
689 type
->field (num_types
).set_type (param_types
[num_types
]);
692 fake_method::~fake_method ()
694 xfree (m_type
.fields ());
697 /* Helper for evaluating an OP_VAR_VALUE. */
700 evaluate_var_value (enum noside noside
, const block
*blk
, symbol
*var
)
702 /* JYG: We used to just return value_zero of the symbol type if
703 we're asked to avoid side effects. Otherwise we return
704 value_of_variable (...). However I'm not sure if
705 value_of_variable () has any side effect. We need a full value
706 object returned here for whatis_exp () to call evaluate_type ()
707 and then pass the full value to value_rtti_target_type () if we
708 are dealing with a pointer or reference to a base class and print
711 struct value
*ret
= NULL
;
715 ret
= value_of_variable (var
, blk
);
718 catch (const gdb_exception_error
&except
)
720 if (noside
!= EVAL_AVOID_SIDE_EFFECTS
)
723 ret
= value_zero (SYMBOL_TYPE (var
), not_lval
);
729 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
732 evaluate_var_msym_value (enum noside noside
,
733 struct objfile
*objfile
, minimal_symbol
*msymbol
)
736 type
*the_type
= find_minsym_type_and_address (msymbol
, objfile
, &address
);
738 if (noside
== EVAL_AVOID_SIDE_EFFECTS
&& !TYPE_GNU_IFUNC (the_type
))
739 return value_zero (the_type
, not_lval
);
741 return value_at_lazy (the_type
, address
);
744 /* Helper for returning a value when handling EVAL_SKIP. */
747 eval_skip_value (expression
*exp
)
749 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
752 /* Evaluate a function call. The function to be called is in
753 ARGVEC[0] and the arguments passed to the function are in
754 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
755 known. DEFAULT_RETURN_TYPE is used as the function's return type
756 if the return type is unknown. */
759 eval_call (expression
*exp
, enum noside noside
,
760 int nargs
, value
**argvec
,
761 const char *function_name
,
762 type
*default_return_type
)
764 if (argvec
[0] == NULL
)
765 error (_("Cannot evaluate function -- may be inlined"));
766 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
768 /* If the return type doesn't look like a function type,
769 call an error. This can happen if somebody tries to turn
770 a variable into a function call. */
772 type
*ftype
= value_type (argvec
[0]);
774 if (ftype
->code () == TYPE_CODE_INTERNAL_FUNCTION
)
776 /* We don't know anything about what the internal
777 function might return, but we have to return
779 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
782 else if (ftype
->code () == TYPE_CODE_XMETHOD
)
785 = result_type_of_xmethod (argvec
[0],
786 gdb::make_array_view (argvec
+ 1,
789 if (return_type
== NULL
)
790 error (_("Xmethod is missing return type."));
791 return value_zero (return_type
, not_lval
);
793 else if (ftype
->code () == TYPE_CODE_FUNC
794 || ftype
->code () == TYPE_CODE_METHOD
)
796 if (TYPE_GNU_IFUNC (ftype
))
798 CORE_ADDR address
= value_address (argvec
[0]);
799 type
*resolved_type
= find_gnu_ifunc_target_type (address
);
801 if (resolved_type
!= NULL
)
802 ftype
= resolved_type
;
805 type
*return_type
= TYPE_TARGET_TYPE (ftype
);
807 if (return_type
== NULL
)
808 return_type
= default_return_type
;
810 if (return_type
== NULL
)
811 error_call_unknown_return_type (function_name
);
813 return allocate_value (return_type
);
816 error (_("Expression of type other than "
817 "\"Function returning ...\" used as function"));
819 switch (value_type (argvec
[0])->code ())
821 case TYPE_CODE_INTERNAL_FUNCTION
:
822 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
823 argvec
[0], nargs
, argvec
+ 1);
824 case TYPE_CODE_XMETHOD
:
825 return call_xmethod (argvec
[0], gdb::make_array_view (argvec
+ 1, nargs
));
827 return call_function_by_hand (argvec
[0], default_return_type
,
828 gdb::make_array_view (argvec
+ 1, nargs
));
832 /* Helper for evaluating an OP_FUNCALL. */
835 evaluate_funcall (type
*expect_type
, expression
*exp
, int *pos
,
843 symbol
*function
= NULL
;
844 char *function_name
= NULL
;
845 const char *var_func_name
= NULL
;
850 exp_opcode op
= exp
->elts
[*pos
].opcode
;
851 int nargs
= longest_to_int (exp
->elts
[pc
].longconst
);
852 /* Allocate arg vector, including space for the function to be
853 called in argvec[0], a potential `this', and a terminating
855 value
**argvec
= (value
**) alloca (sizeof (value
*) * (nargs
+ 3));
856 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
858 /* First, evaluate the structure into arg2. */
861 if (op
== STRUCTOP_MEMBER
)
863 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
867 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
870 /* If the function is a virtual function, then the aggregate
871 value (providing the structure) plays its part by providing
872 the vtable. Otherwise, it is just along for the ride: call
873 the function directly. */
875 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
877 type
*a1_type
= check_typedef (value_type (arg1
));
878 if (noside
== EVAL_SKIP
)
879 tem
= 1; /* Set it to the right arg index so that all
880 arguments can also be skipped. */
881 else if (a1_type
->code () == TYPE_CODE_METHODPTR
)
883 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
884 arg1
= value_zero (TYPE_TARGET_TYPE (a1_type
), not_lval
);
886 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
888 /* Now, say which argument to start evaluating from. */
893 else if (a1_type
->code () == TYPE_CODE_MEMBERPTR
)
895 struct type
*type_ptr
896 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type
));
897 struct type
*target_type_ptr
898 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type
));
900 /* Now, convert these values to an address. */
901 arg2
= value_cast (type_ptr
, arg2
);
903 long mem_offset
= value_as_long (arg1
);
905 arg1
= value_from_pointer (target_type_ptr
,
906 value_as_long (arg2
) + mem_offset
);
907 arg1
= value_ind (arg1
);
911 error (_("Non-pointer-to-member value used in pointer-to-member "
914 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
916 /* Hair for method invocations. */
920 /* First, evaluate the structure into arg2. */
922 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
923 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
925 if (op
== STRUCTOP_STRUCT
)
927 /* If v is a variable in a register, and the user types
928 v.method (), this will produce an error, because v has no
931 A possible way around this would be to allocate a copy of
932 the variable on the stack, copy in the contents, call the
933 function, and copy out the contents. I.e. convert this
934 from call by reference to call by copy-return (or
935 whatever it's called). However, this does not work
936 because it is not the same: the method being called could
937 stash a copy of the address, and then future uses through
938 that address (after the method returns) would be expected
939 to use the variable itself, not some copy of it. */
940 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
944 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
946 /* Check to see if the operator '->' has been overloaded.
947 If the operator has been overloaded replace arg2 with the
948 value returned by the custom operator and continue
950 while (unop_user_defined_p (op
, arg2
))
952 struct value
*value
= NULL
;
955 value
= value_x_unop (arg2
, op
, noside
);
958 catch (const gdb_exception_error
&except
)
960 if (except
.error
== NOT_FOUND_ERROR
)
969 /* Now, say which argument to start evaluating from. */
972 else if (op
== OP_SCOPE
973 && overload_resolution
974 && (exp
->language_defn
->la_language
== language_cplus
))
976 /* Unpack it locally so we can properly handle overload
982 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
983 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
984 struct type
*type
= exp
->elts
[pc2
+ 1].type
;
985 name
= &exp
->elts
[pc2
+ 3].string
;
988 function_name
= NULL
;
989 if (type
->code () == TYPE_CODE_NAMESPACE
)
991 function
= cp_lookup_symbol_namespace (type
->name (),
993 get_selected_block (0),
995 if (function
== NULL
)
996 error (_("No symbol \"%s\" in namespace \"%s\"."),
997 name
, type
->name ());
1000 /* arg2 is left as NULL on purpose. */
1004 gdb_assert (type
->code () == TYPE_CODE_STRUCT
1005 || type
->code () == TYPE_CODE_UNION
);
1006 function_name
= name
;
1008 /* We need a properly typed value for method lookup. For
1009 static methods arg2 is otherwise unused. */
1010 arg2
= value_zero (type
, lval_memory
);
1015 else if (op
== OP_ADL_FUNC
)
1017 /* Save the function position and move pos so that the arguments
1018 can be evaluated. */
1024 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1025 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1029 /* Non-method function call. */
1033 /* If this is a C++ function wait until overload resolution. */
1034 if (op
== OP_VAR_VALUE
1035 && overload_resolution
1036 && (exp
->language_defn
->la_language
== language_cplus
))
1038 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1043 if (op
== OP_VAR_MSYM_VALUE
)
1045 minimal_symbol
*msym
= exp
->elts
[*pos
+ 2].msymbol
;
1046 var_func_name
= msym
->print_name ();
1048 else if (op
== OP_VAR_VALUE
)
1050 symbol
*sym
= exp
->elts
[*pos
+ 2].symbol
;
1051 var_func_name
= sym
->print_name ();
1054 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1055 type
*type
= value_type (argvec
[0]);
1056 if (type
&& type
->code () == TYPE_CODE_PTR
)
1057 type
= TYPE_TARGET_TYPE (type
);
1058 if (type
&& type
->code () == TYPE_CODE_FUNC
)
1060 for (; tem
<= nargs
&& tem
<= type
->num_fields (); tem
++)
1062 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1070 /* Evaluate arguments (if not already done, e.g., namespace::func()
1071 and overload-resolution is off). */
1072 for (; tem
<= nargs
; tem
++)
1074 /* Ensure that array expressions are coerced into pointer
1076 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1079 /* Signal end of arglist. */
1082 if (noside
== EVAL_SKIP
)
1083 return eval_skip_value (exp
);
1085 if (op
== OP_ADL_FUNC
)
1087 struct symbol
*symp
;
1090 int string_pc
= save_pos1
+ 3;
1092 /* Extract the function name. */
1093 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1094 func_name
= (char *) alloca (name_len
+ 1);
1095 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1097 find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1099 NON_METHOD
, /* not method */
1100 NULL
, NULL
, /* pass NULL symbol since
1101 symbol is unknown */
1102 NULL
, &symp
, NULL
, 0, noside
);
1104 /* Now fix the expression being evaluated. */
1105 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1106 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1109 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1110 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1112 int static_memfuncp
;
1115 /* Method invocation: stuff "this" as first parameter. If the
1116 method turns out to be static we undo this below. */
1121 /* Name of method from expression. */
1122 tstr
= &exp
->elts
[pc2
+ 2].string
;
1125 tstr
= function_name
;
1127 if (overload_resolution
&& (exp
->language_defn
->la_language
1130 /* Language is C++, do some overload resolution before
1132 struct value
*valp
= NULL
;
1134 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1136 METHOD
, /* method */
1137 &arg2
, /* the object */
1139 &static_memfuncp
, 0, noside
);
1141 if (op
== OP_SCOPE
&& !static_memfuncp
)
1143 /* For the time being, we don't handle this. */
1144 error (_("Call to overloaded function %s requires "
1148 argvec
[1] = arg2
; /* the ``this'' pointer */
1149 argvec
[0] = valp
; /* Use the method found after overload
1153 /* Non-C++ case -- or no overload resolution. */
1155 struct value
*temp
= arg2
;
1157 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1159 op
== STRUCTOP_STRUCT
1160 ? "structure" : "structure pointer");
1161 /* value_struct_elt updates temp with the correct value of
1162 the ``this'' pointer if necessary, so modify argvec[1] to
1163 reflect any ``this'' changes. */
1165 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1166 value_address (temp
)
1167 + value_embedded_offset (temp
));
1168 argvec
[1] = arg2
; /* the ``this'' pointer */
1171 /* Take out `this' if needed. */
1172 if (static_memfuncp
)
1174 argvec
[1] = argvec
[0];
1179 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1181 /* Pointer to member. argvec[1] is already set up. */
1184 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1186 /* Non-member function being called. */
1187 /* fn: This can only be done for C++ functions. A C-style
1188 function in a C++ program, for instance, does not have the
1189 fields that are expected here. */
1191 if (overload_resolution
&& (exp
->language_defn
->la_language
1194 /* Language is C++, do some overload resolution before
1196 struct symbol
*symp
;
1199 /* If a scope has been specified disable ADL. */
1203 if (op
== OP_VAR_VALUE
)
1204 function
= exp
->elts
[save_pos1
+2].symbol
;
1206 (void) find_overload_match (gdb::make_array_view (&argvec
[1], nargs
),
1207 NULL
, /* no need for name */
1208 NON_METHOD
, /* not method */
1209 NULL
, function
, /* the function */
1210 NULL
, &symp
, NULL
, no_adl
, noside
);
1212 if (op
== OP_VAR_VALUE
)
1214 /* Now fix the expression being evaluated. */
1215 exp
->elts
[save_pos1
+2].symbol
= symp
;
1216 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1220 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1224 /* Not C++, or no overload resolution allowed. */
1225 /* Nothing to be done; argvec already correctly set up. */
1230 /* It is probably a C-style function. */
1231 /* Nothing to be done; argvec already correctly set up. */
1234 return eval_call (exp
, noside
, nargs
, argvec
, var_func_name
, expect_type
);
1237 /* Helper for skipping all the arguments in an undetermined argument list.
1238 This function was designed for use in the OP_F77_UNDETERMINED_ARGLIST
1239 case of evaluate_subexp_standard as multiple, but not all, code paths
1240 require a generic skip. */
1243 skip_undetermined_arglist (int nargs
, struct expression
*exp
, int *pos
,
1246 for (int i
= 0; i
< nargs
; ++i
)
1247 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1250 /* Return true if type is integral or reference to integral */
1253 is_integral_or_integral_reference (struct type
*type
)
1255 if (is_integral_type (type
))
1258 type
= check_typedef (type
);
1259 return (type
!= nullptr
1260 && TYPE_IS_REFERENCE (type
)
1261 && is_integral_type (TYPE_TARGET_TYPE (type
)));
1265 evaluate_subexp_standard (struct type
*expect_type
,
1266 struct expression
*exp
, int *pos
,
1270 int tem
, tem2
, tem3
;
1272 struct value
*arg1
= NULL
;
1273 struct value
*arg2
= NULL
;
1277 struct value
**argvec
;
1281 struct type
**arg_types
;
1284 op
= exp
->elts
[pc
].opcode
;
1289 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1290 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
1291 if (noside
== EVAL_SKIP
)
1292 return eval_skip_value (exp
);
1293 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
1294 &exp
->elts
[pc
+ 3].string
,
1295 expect_type
, 0, noside
);
1297 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
1302 return value_from_longest (exp
->elts
[pc
+ 1].type
,
1303 exp
->elts
[pc
+ 2].longconst
);
1307 return value_from_contents (exp
->elts
[pc
+ 1].type
,
1308 exp
->elts
[pc
+ 2].floatconst
);
1314 symbol
*var
= exp
->elts
[pc
+ 2].symbol
;
1315 if (SYMBOL_TYPE (var
)->code () == TYPE_CODE_ERROR
)
1316 error_unknown_type (var
->print_name ());
1317 if (noside
!= EVAL_SKIP
)
1318 return evaluate_var_value (noside
, exp
->elts
[pc
+ 1].block
, var
);
1321 /* Return a dummy value of the correct type when skipping, so
1322 that parent functions know what is to be skipped. */
1323 return allocate_value (SYMBOL_TYPE (var
));
1327 case OP_VAR_MSYM_VALUE
:
1331 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
1332 value
*val
= evaluate_var_msym_value (noside
,
1333 exp
->elts
[pc
+ 1].objfile
,
1336 type
= value_type (val
);
1337 if (type
->code () == TYPE_CODE_ERROR
1338 && (noside
!= EVAL_AVOID_SIDE_EFFECTS
|| pc
!= 0))
1339 error_unknown_type (msymbol
->print_name ());
1343 case OP_VAR_ENTRY_VALUE
:
1345 if (noside
== EVAL_SKIP
)
1346 return eval_skip_value (exp
);
1349 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
1350 struct frame_info
*frame
;
1352 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1353 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
1355 if (SYMBOL_COMPUTED_OPS (sym
) == NULL
1356 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
1357 error (_("Symbol \"%s\" does not have any specific entry value"),
1358 sym
->print_name ());
1360 frame
= get_selected_frame (NULL
);
1361 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
1364 case OP_FUNC_STATIC_VAR
:
1365 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1366 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1367 if (noside
== EVAL_SKIP
)
1368 return eval_skip_value (exp
);
1371 value
*func
= evaluate_subexp_standard (NULL
, exp
, pos
, noside
);
1372 CORE_ADDR addr
= value_address (func
);
1374 const block
*blk
= block_for_pc (addr
);
1375 const char *var
= &exp
->elts
[pc
+ 2].string
;
1377 struct block_symbol sym
= lookup_symbol (var
, blk
, VAR_DOMAIN
, NULL
);
1379 if (sym
.symbol
== NULL
)
1380 error (_("No symbol \"%s\" in specified context."), var
);
1382 return evaluate_var_value (noside
, sym
.block
, sym
.symbol
);
1388 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
1392 const char *name
= &exp
->elts
[pc
+ 2].string
;
1396 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
1397 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
1398 name
, strlen (name
));
1400 error (_("Register $%s not available."), name
);
1402 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1403 a value with the appropriate register type. Unfortunately,
1404 we don't have easy access to the type of user registers.
1405 So for these registers, we fetch the register value regardless
1406 of the evaluation mode. */
1407 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1408 && regno
< gdbarch_num_cooked_regs (exp
->gdbarch
))
1409 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
1411 val
= value_of_register (regno
, get_selected_frame (NULL
));
1413 error (_("Value of register %s not available."), name
);
1419 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1420 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
1422 case OP_INTERNALVAR
:
1424 return value_of_internalvar (exp
->gdbarch
,
1425 exp
->elts
[pc
+ 1].internalvar
);
1428 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1429 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1430 if (noside
== EVAL_SKIP
)
1431 return eval_skip_value (exp
);
1432 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
1433 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
1435 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
1436 NSString constant. */
1437 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1438 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1439 if (noside
== EVAL_SKIP
)
1440 return eval_skip_value (exp
);
1441 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
1445 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1446 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
1447 nargs
= tem3
- tem2
+ 1;
1448 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
1450 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1451 && type
->code () == TYPE_CODE_STRUCT
)
1453 struct value
*rec
= allocate_value (expect_type
);
1455 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
1456 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
1459 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1460 && type
->code () == TYPE_CODE_ARRAY
)
1462 struct type
*range_type
= type
->index_type ();
1463 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
1464 struct value
*array
= allocate_value (expect_type
);
1465 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
1466 LONGEST low_bound
, high_bound
, index
;
1468 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
1471 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
1474 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
1475 for (tem
= nargs
; --nargs
>= 0;)
1477 struct value
*element
;
1480 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1481 if (value_type (element
) != element_type
)
1482 element
= value_cast (element_type
, element
);
1485 int continue_pc
= *pos
;
1488 index
= init_array_element (array
, element
, exp
, pos
, noside
,
1489 low_bound
, high_bound
);
1494 if (index
> high_bound
)
1495 /* To avoid memory corruption. */
1496 error (_("Too many array elements"));
1497 memcpy (value_contents_raw (array
)
1498 + (index
- low_bound
) * element_size
,
1499 value_contents (element
),
1507 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
1508 && type
->code () == TYPE_CODE_SET
)
1510 struct value
*set
= allocate_value (expect_type
);
1511 gdb_byte
*valaddr
= value_contents_raw (set
);
1512 struct type
*element_type
= type
->index_type ();
1513 struct type
*check_type
= element_type
;
1514 LONGEST low_bound
, high_bound
;
1516 /* Get targettype of elementtype. */
1517 while (check_type
->code () == TYPE_CODE_RANGE
1518 || check_type
->code () == TYPE_CODE_TYPEDEF
)
1519 check_type
= TYPE_TARGET_TYPE (check_type
);
1521 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
1522 error (_("(power)set type with unknown size"));
1523 memset (valaddr
, '\0', TYPE_LENGTH (type
));
1524 for (tem
= 0; tem
< nargs
; tem
++)
1526 LONGEST range_low
, range_high
;
1527 struct type
*range_low_type
, *range_high_type
;
1528 struct value
*elem_val
;
1530 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
1531 range_low_type
= range_high_type
= value_type (elem_val
);
1532 range_low
= range_high
= value_as_long (elem_val
);
1534 /* Check types of elements to avoid mixture of elements from
1535 different types. Also check if type of element is "compatible"
1536 with element type of powerset. */
1537 if (range_low_type
->code () == TYPE_CODE_RANGE
)
1538 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
1539 if (range_high_type
->code () == TYPE_CODE_RANGE
)
1540 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
1541 if ((range_low_type
->code () != range_high_type
->code ())
1542 || (range_low_type
->code () == TYPE_CODE_ENUM
1543 && (range_low_type
!= range_high_type
)))
1544 /* different element modes. */
1545 error (_("POWERSET tuple elements of different mode"));
1546 if ((check_type
->code () != range_low_type
->code ())
1547 || (check_type
->code () == TYPE_CODE_ENUM
1548 && range_low_type
!= check_type
))
1549 error (_("incompatible POWERSET tuple elements"));
1550 if (range_low
> range_high
)
1552 warning (_("empty POWERSET tuple range"));
1555 if (range_low
< low_bound
|| range_high
> high_bound
)
1556 error (_("POWERSET tuple element out of range"));
1557 range_low
-= low_bound
;
1558 range_high
-= low_bound
;
1559 for (; range_low
<= range_high
; range_low
++)
1561 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1563 if (gdbarch_byte_order (exp
->gdbarch
) == BFD_ENDIAN_BIG
)
1564 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1565 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1572 argvec
= XALLOCAVEC (struct value
*, nargs
);
1573 for (tem
= 0; tem
< nargs
; tem
++)
1575 /* Ensure that array expressions are coerced into pointer
1577 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1579 if (noside
== EVAL_SKIP
)
1580 return eval_skip_value (exp
);
1581 return value_array (tem2
, tem3
, argvec
);
1585 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1587 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1589 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1591 if (noside
== EVAL_SKIP
)
1592 return eval_skip_value (exp
);
1593 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1597 /* Skip third and second args to evaluate the first one. */
1598 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1599 if (value_logical_not (arg1
))
1601 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1602 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1606 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1607 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1611 case OP_OBJC_SELECTOR
:
1612 { /* Objective C @selector operator. */
1613 char *sel
= &exp
->elts
[pc
+ 2].string
;
1614 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1615 struct type
*selector_type
;
1617 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1618 if (noside
== EVAL_SKIP
)
1619 return eval_skip_value (exp
);
1622 sel
[len
] = 0; /* Make sure it's terminated. */
1624 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1625 return value_from_longest (selector_type
,
1626 lookup_child_selector (exp
->gdbarch
, sel
));
1629 case OP_OBJC_MSGCALL
:
1630 { /* Objective C message (method) call. */
1632 CORE_ADDR responds_selector
= 0;
1633 CORE_ADDR method_selector
= 0;
1635 CORE_ADDR selector
= 0;
1637 int struct_return
= 0;
1638 enum noside sub_no_side
= EVAL_NORMAL
;
1640 struct value
*msg_send
= NULL
;
1641 struct value
*msg_send_stret
= NULL
;
1642 int gnu_runtime
= 0;
1644 struct value
*target
= NULL
;
1645 struct value
*method
= NULL
;
1646 struct value
*called_method
= NULL
;
1648 struct type
*selector_type
= NULL
;
1649 struct type
*long_type
;
1651 struct value
*ret
= NULL
;
1654 selector
= exp
->elts
[pc
+ 1].longconst
;
1655 nargs
= exp
->elts
[pc
+ 2].longconst
;
1656 argvec
= XALLOCAVEC (struct value
*, nargs
+ 5);
1660 long_type
= builtin_type (exp
->gdbarch
)->builtin_long
;
1661 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1663 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1664 sub_no_side
= EVAL_NORMAL
;
1666 sub_no_side
= noside
;
1668 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
1670 if (value_as_long (target
) == 0)
1671 return value_from_longest (long_type
, 0);
1673 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym
)
1676 /* Find the method dispatch (Apple runtime) or method lookup
1677 (GNU runtime) function for Objective-C. These will be used
1678 to lookup the symbol information for the method. If we
1679 can't find any symbol information, then we'll use these to
1680 call the method, otherwise we can call the method
1681 directly. The msg_send_stret function is used in the special
1682 case of a method that returns a structure (Apple runtime
1686 type
= selector_type
;
1688 type
= lookup_function_type (type
);
1689 type
= lookup_pointer_type (type
);
1690 type
= lookup_function_type (type
);
1691 type
= lookup_pointer_type (type
);
1693 msg_send
= find_function_in_inferior ("objc_msg_lookup", NULL
);
1695 = find_function_in_inferior ("objc_msg_lookup", NULL
);
1697 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
1698 msg_send_stret
= value_from_pointer (type
,
1699 value_as_address (msg_send_stret
));
1703 msg_send
= find_function_in_inferior ("objc_msgSend", NULL
);
1704 /* Special dispatcher for methods returning structs. */
1706 = find_function_in_inferior ("objc_msgSend_stret", NULL
);
1709 /* Verify the target object responds to this method. The
1710 standard top-level 'Object' class uses a different name for
1711 the verification method than the non-standard, but more
1712 often used, 'NSObject' class. Make sure we check for both. */
1715 = lookup_child_selector (exp
->gdbarch
, "respondsToSelector:");
1716 if (responds_selector
== 0)
1718 = lookup_child_selector (exp
->gdbarch
, "respondsTo:");
1720 if (responds_selector
== 0)
1721 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1724 = lookup_child_selector (exp
->gdbarch
, "methodForSelector:");
1725 if (method_selector
== 0)
1727 = lookup_child_selector (exp
->gdbarch
, "methodFor:");
1729 if (method_selector
== 0)
1730 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1732 /* Call the verification method, to make sure that the target
1733 class implements the desired method. */
1735 argvec
[0] = msg_send
;
1737 argvec
[2] = value_from_longest (long_type
, responds_selector
);
1738 argvec
[3] = value_from_longest (long_type
, selector
);
1741 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1744 /* Function objc_msg_lookup returns a pointer. */
1746 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1748 if (value_as_long (ret
) == 0)
1749 error (_("Target does not respond to this message selector."));
1751 /* Call "methodForSelector:" method, to get the address of a
1752 function method that implements this selector for this
1753 class. If we can find a symbol at that address, then we
1754 know the return type, parameter types etc. (that's a good
1757 argvec
[0] = msg_send
;
1759 argvec
[2] = value_from_longest (long_type
, method_selector
);
1760 argvec
[3] = value_from_longest (long_type
, selector
);
1763 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1767 ret
= call_function_by_hand (argvec
[0], NULL
, {argvec
+ 1, 3});
1770 /* ret should now be the selector. */
1772 addr
= value_as_long (ret
);
1775 struct symbol
*sym
= NULL
;
1777 /* The address might point to a function descriptor;
1778 resolve it to the actual code address instead. */
1779 addr
= gdbarch_convert_from_func_ptr_addr (exp
->gdbarch
, addr
,
1780 current_top_target ());
1782 /* Is it a high_level symbol? */
1783 sym
= find_pc_function (addr
);
1785 method
= value_of_variable (sym
, 0);
1788 /* If we found a method with symbol information, check to see
1789 if it returns a struct. Otherwise assume it doesn't. */
1794 struct type
*val_type
;
1796 funaddr
= find_function_addr (method
, &val_type
);
1798 block_for_pc (funaddr
);
1800 val_type
= check_typedef (val_type
);
1802 if ((val_type
== NULL
)
1803 || (val_type
->code () == TYPE_CODE_ERROR
))
1805 if (expect_type
!= NULL
)
1806 val_type
= expect_type
;
1809 struct_return
= using_struct_return (exp
->gdbarch
, method
,
1812 else if (expect_type
!= NULL
)
1814 struct_return
= using_struct_return (exp
->gdbarch
, NULL
,
1815 check_typedef (expect_type
));
1818 /* Found a function symbol. Now we will substitute its
1819 value in place of the message dispatcher (obj_msgSend),
1820 so that we call the method directly instead of thru
1821 the dispatcher. The main reason for doing this is that
1822 we can now evaluate the return value and parameter values
1823 according to their known data types, in case we need to
1824 do things like promotion, dereferencing, special handling
1825 of structs and doubles, etc.
1827 We want to use the type signature of 'method', but still
1828 jump to objc_msgSend() or objc_msgSend_stret() to better
1829 mimic the behavior of the runtime. */
1833 if (value_type (method
)->code () != TYPE_CODE_FUNC
)
1834 error (_("method address has symbol information "
1835 "with non-function type; skipping"));
1837 /* Create a function pointer of the appropriate type, and
1838 replace its value with the value of msg_send or
1839 msg_send_stret. We must use a pointer here, as
1840 msg_send and msg_send_stret are of pointer type, and
1841 the representation may be different on systems that use
1842 function descriptors. */
1845 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1846 value_as_address (msg_send_stret
));
1849 = value_from_pointer (lookup_pointer_type (value_type (method
)),
1850 value_as_address (msg_send
));
1855 called_method
= msg_send_stret
;
1857 called_method
= msg_send
;
1860 if (noside
== EVAL_SKIP
)
1861 return eval_skip_value (exp
);
1863 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1865 /* If the return type doesn't look like a function type,
1866 call an error. This can happen if somebody tries to
1867 turn a variable into a function call. This is here
1868 because people often want to call, eg, strcmp, which
1869 gdb doesn't know is a function. If gdb isn't asked for
1870 it's opinion (ie. through "whatis"), it won't offer
1873 struct type
*callee_type
= value_type (called_method
);
1875 if (callee_type
&& callee_type
->code () == TYPE_CODE_PTR
)
1876 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1877 callee_type
= TYPE_TARGET_TYPE (callee_type
);
1881 if ((callee_type
->code () == TYPE_CODE_ERROR
) && expect_type
)
1882 return allocate_value (expect_type
);
1884 return allocate_value (callee_type
);
1887 error (_("Expression of type other than "
1888 "\"method returning ...\" used as a method"));
1891 /* Now depending on whether we found a symbol for the method,
1892 we will either call the runtime dispatcher or the method
1895 argvec
[0] = called_method
;
1897 argvec
[2] = value_from_longest (long_type
, selector
);
1898 /* User-supplied arguments. */
1899 for (tem
= 0; tem
< nargs
; tem
++)
1900 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1901 argvec
[tem
+ 3] = 0;
1903 auto call_args
= gdb::make_array_view (argvec
+ 1, nargs
+ 2);
1905 if (gnu_runtime
&& (method
!= NULL
))
1907 /* Function objc_msg_lookup returns a pointer. */
1908 deprecated_set_value_type (argvec
[0],
1909 lookup_pointer_type (lookup_function_type (value_type (argvec
[0]))));
1910 argvec
[0] = call_function_by_hand (argvec
[0], NULL
, call_args
);
1913 return call_function_by_hand (argvec
[0], NULL
, call_args
);
1918 return evaluate_funcall (expect_type
, exp
, pos
, noside
);
1920 case OP_F77_UNDETERMINED_ARGLIST
:
1922 /* Remember that in F77, functions, substring ops and
1923 array subscript operations cannot be disambiguated
1924 at parse time. We have made all array subscript operations,
1925 substring operations as well as function calls come here
1926 and we now have to discover what the heck this thing actually was.
1927 If it is a function, we process just as if we got an OP_FUNCALL. */
1929 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1932 /* First determine the type code we are dealing with. */
1933 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1934 type
= check_typedef (value_type (arg1
));
1935 code
= type
->code ();
1937 if (code
== TYPE_CODE_PTR
)
1939 /* Fortran always passes variable to subroutines as pointer.
1940 So we need to look into its target type to see if it is
1941 array, string or function. If it is, we need to switch
1942 to the target value the original one points to. */
1943 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1945 if (target_type
->code () == TYPE_CODE_ARRAY
1946 || target_type
->code () == TYPE_CODE_STRING
1947 || target_type
->code () == TYPE_CODE_FUNC
)
1949 arg1
= value_ind (arg1
);
1950 type
= check_typedef (value_type (arg1
));
1951 code
= type
->code ();
1957 case TYPE_CODE_ARRAY
:
1958 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1959 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1962 if (noside
== EVAL_SKIP
)
1964 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1965 /* Return the dummy value with the correct type. */
1968 goto multi_f77_subscript
;
1971 case TYPE_CODE_STRING
:
1972 if (exp
->elts
[*pos
].opcode
== OP_RANGE
)
1973 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1976 if (noside
== EVAL_SKIP
)
1978 skip_undetermined_arglist (nargs
, exp
, pos
, noside
);
1979 /* Return the dummy value with the correct type. */
1982 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1983 return value_subscript (arg1
, value_as_long (arg2
));
1987 case TYPE_CODE_FUNC
:
1988 case TYPE_CODE_INTERNAL_FUNCTION
:
1989 /* It's a function call. */
1990 /* Allocate arg vector, including space for the function to be
1991 called in argvec[0] and a terminating NULL. */
1992 argvec
= (struct value
**)
1993 alloca (sizeof (struct value
*) * (nargs
+ 2));
1996 for (; tem
<= nargs
; tem
++)
1998 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1999 /* Arguments in Fortran are passed by address. Coerce the
2000 arguments here rather than in value_arg_coerce as otherwise
2001 the call to malloc to place the non-lvalue parameters in
2002 target memory is hit by this Fortran specific logic. This
2003 results in malloc being called with a pointer to an integer
2004 followed by an attempt to malloc the arguments to malloc in
2005 target memory. Infinite recursion ensues. */
2006 if (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
)
2009 = TYPE_FIELD_ARTIFICIAL (value_type (arg1
), tem
- 1);
2010 argvec
[tem
] = fortran_argument_convert (argvec
[tem
],
2014 argvec
[tem
] = 0; /* signal end of arglist */
2015 if (noside
== EVAL_SKIP
)
2016 return eval_skip_value (exp
);
2017 return eval_call (exp
, noside
, nargs
, argvec
, NULL
, expect_type
);
2020 error (_("Cannot perform substring on this type"));
2024 /* We have a complex number, There should be 2 floating
2025 point numbers that compose it. */
2027 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2028 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2030 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
2032 case STRUCTOP_STRUCT
:
2033 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2034 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2035 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2036 if (noside
== EVAL_SKIP
)
2037 return eval_skip_value (exp
);
2038 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2040 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2041 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2045 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2046 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
2047 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2048 if (noside
== EVAL_SKIP
)
2049 return eval_skip_value (exp
);
2051 /* Check to see if operator '->' has been overloaded. If so replace
2052 arg1 with the value returned by evaluating operator->(). */
2053 while (unop_user_defined_p (op
, arg1
))
2055 struct value
*value
= NULL
;
2058 value
= value_x_unop (arg1
, op
, noside
);
2061 catch (const gdb_exception_error
&except
)
2063 if (except
.error
== NOT_FOUND_ERROR
)
2072 /* JYG: if print object is on we need to replace the base type
2073 with rtti type in order to continue on with successful
2074 lookup of member / method only available in the rtti type. */
2076 struct type
*arg_type
= value_type (arg1
);
2077 struct type
*real_type
;
2078 int full
, using_enc
;
2080 struct value_print_options opts
;
2082 get_user_print_options (&opts
);
2083 if (opts
.objectprint
&& TYPE_TARGET_TYPE (arg_type
)
2084 && (TYPE_TARGET_TYPE (arg_type
)->code () == TYPE_CODE_STRUCT
))
2086 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
2089 arg1
= value_cast (real_type
, arg1
);
2093 arg3
= value_struct_elt (&arg1
, NULL
, &exp
->elts
[pc
+ 2].string
,
2094 NULL
, "structure pointer");
2095 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2096 arg3
= value_zero (value_type (arg3
), VALUE_LVAL (arg3
));
2099 case STRUCTOP_MEMBER
:
2101 if (op
== STRUCTOP_MEMBER
)
2102 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
2104 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2106 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2108 if (noside
== EVAL_SKIP
)
2109 return eval_skip_value (exp
);
2111 type
= check_typedef (value_type (arg2
));
2112 switch (type
->code ())
2114 case TYPE_CODE_METHODPTR
:
2115 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2116 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
2119 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
2120 gdb_assert (value_type (arg2
)->code () == TYPE_CODE_PTR
);
2121 return value_ind (arg2
);
2124 case TYPE_CODE_MEMBERPTR
:
2125 /* Now, convert these values to an address. */
2126 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type
)),
2129 mem_offset
= value_as_long (arg2
);
2131 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2132 value_as_long (arg1
) + mem_offset
);
2133 return value_ind (arg3
);
2136 error (_("non-pointer-to-member value used "
2137 "in pointer-to-member construct"));
2142 type_instance_flags flags
2143 = (type_instance_flag_value
) longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2144 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2145 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
2146 for (ix
= 0; ix
< nargs
; ++ix
)
2147 arg_types
[ix
] = exp
->elts
[pc
+ 2 + ix
+ 1].type
;
2149 fake_method
fake_expect_type (flags
, nargs
, arg_types
);
2150 *(pos
) += 4 + nargs
;
2151 return evaluate_subexp_standard (fake_expect_type
.type (), exp
, pos
,
2156 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2157 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2158 if (noside
== EVAL_SKIP
)
2159 return eval_skip_value (exp
);
2160 if (binop_user_defined_p (op
, arg1
, arg2
))
2161 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2163 return value_concat (arg1
, arg2
);
2166 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2167 /* Special-case assignments where the left-hand-side is a
2168 convenience variable -- in these, don't bother setting an
2169 expected type. This avoids a weird case where re-assigning a
2170 string or array to an internal variable could error with "Too
2171 many array elements". */
2172 arg2
= evaluate_subexp (VALUE_LVAL (arg1
) == lval_internalvar
2173 ? NULL_TYPE
: value_type (arg1
),
2176 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2178 if (binop_user_defined_p (op
, arg1
, arg2
))
2179 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2181 return value_assign (arg1
, arg2
);
2183 case BINOP_ASSIGN_MODIFY
:
2185 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2186 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2187 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2189 op
= exp
->elts
[pc
+ 1].opcode
;
2190 if (binop_user_defined_p (op
, arg1
, arg2
))
2191 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2192 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2194 && is_integral_type (value_type (arg2
)))
2195 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2196 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2198 && is_integral_type (value_type (arg2
)))
2199 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2202 struct value
*tmp
= arg1
;
2204 /* For shift and integer exponentiation operations,
2205 only promote the first argument. */
2206 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2207 && is_integral_type (value_type (arg2
)))
2208 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2210 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2212 arg2
= value_binop (tmp
, arg2
, op
);
2214 return value_assign (arg1
, arg2
);
2217 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2218 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2219 if (noside
== EVAL_SKIP
)
2220 return eval_skip_value (exp
);
2221 if (binop_user_defined_p (op
, arg1
, arg2
))
2222 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2223 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2224 && is_integral_or_integral_reference (value_type (arg2
)))
2225 return value_ptradd (arg1
, value_as_long (arg2
));
2226 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2227 && is_integral_or_integral_reference (value_type (arg1
)))
2228 return value_ptradd (arg2
, value_as_long (arg1
));
2231 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2232 return value_binop (arg1
, arg2
, BINOP_ADD
);
2236 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2237 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2238 if (noside
== EVAL_SKIP
)
2239 return eval_skip_value (exp
);
2240 if (binop_user_defined_p (op
, arg1
, arg2
))
2241 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2242 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2243 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2245 /* FIXME -- should be ptrdiff_t */
2246 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2247 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
2249 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2250 && is_integral_or_integral_reference (value_type (arg2
)))
2251 return value_ptradd (arg1
, - value_as_long (arg2
));
2254 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2255 return value_binop (arg1
, arg2
, BINOP_SUB
);
2266 case BINOP_BITWISE_AND
:
2267 case BINOP_BITWISE_IOR
:
2268 case BINOP_BITWISE_XOR
:
2269 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2270 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2271 if (noside
== EVAL_SKIP
)
2272 return eval_skip_value (exp
);
2273 if (binop_user_defined_p (op
, arg1
, arg2
))
2274 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2277 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2278 fudge arg2 to avoid division-by-zero, the caller is
2279 (theoretically) only looking for the type of the result. */
2280 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2281 /* ??? Do we really want to test for BINOP_MOD here?
2282 The implementation of value_binop gives it a well-defined
2285 || op
== BINOP_INTDIV
2288 && value_logical_not (arg2
))
2290 struct value
*v_one
, *retval
;
2292 v_one
= value_one (value_type (arg2
));
2293 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2294 retval
= value_binop (arg1
, v_one
, op
);
2299 /* For shift and integer exponentiation operations,
2300 only promote the first argument. */
2301 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2302 && is_integral_type (value_type (arg2
)))
2303 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2305 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2307 return value_binop (arg1
, arg2
, op
);
2311 case BINOP_SUBSCRIPT
:
2312 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2313 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2314 if (noside
== EVAL_SKIP
)
2315 return eval_skip_value (exp
);
2316 if (binop_user_defined_p (op
, arg1
, arg2
))
2317 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2320 /* If the user attempts to subscript something that is not an
2321 array or pointer type (like a plain int variable for example),
2322 then report this as an error. */
2324 arg1
= coerce_ref (arg1
);
2325 type
= check_typedef (value_type (arg1
));
2326 if (type
->code () != TYPE_CODE_ARRAY
2327 && type
->code () != TYPE_CODE_PTR
)
2330 error (_("cannot subscript something of type `%s'"),
2333 error (_("cannot subscript requested type"));
2336 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2337 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2339 return value_subscript (arg1
, value_as_long (arg2
));
2341 case MULTI_SUBSCRIPT
:
2343 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2344 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2347 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2348 /* FIXME: EVAL_SKIP handling may not be correct. */
2349 if (noside
== EVAL_SKIP
)
2353 return eval_skip_value (exp
);
2355 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2356 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2358 /* If the user attempts to subscript something that has no target
2359 type (like a plain int variable for example), then report this
2362 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2365 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2371 error (_("cannot subscript something of type `%s'"),
2372 value_type (arg1
)->name ());
2376 if (binop_user_defined_p (op
, arg1
, arg2
))
2378 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2382 arg1
= coerce_ref (arg1
);
2383 type
= check_typedef (value_type (arg1
));
2385 switch (type
->code ())
2388 case TYPE_CODE_ARRAY
:
2389 case TYPE_CODE_STRING
:
2390 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2395 error (_("cannot subscript something of type `%s'"),
2398 error (_("cannot subscript requested type"));
2404 multi_f77_subscript
:
2406 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2407 int ndimensions
= 1, i
;
2408 struct value
*array
= arg1
;
2410 if (nargs
> MAX_FORTRAN_DIMS
)
2411 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2413 ndimensions
= calc_f77_array_dims (type
);
2415 if (nargs
!= ndimensions
)
2416 error (_("Wrong number of subscripts"));
2418 gdb_assert (nargs
> 0);
2420 /* Now that we know we have a legal array subscript expression
2421 let us actually find out where this element exists in the array. */
2423 /* Take array indices left to right. */
2424 for (i
= 0; i
< nargs
; i
++)
2426 /* Evaluate each subscript; it must be a legal integer in F77. */
2427 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2429 /* Fill in the subscript array. */
2431 subscript_array
[i
] = value_as_long (arg2
);
2434 /* Internal type of array is arranged right to left. */
2435 for (i
= nargs
; i
> 0; i
--)
2437 struct type
*array_type
= check_typedef (value_type (array
));
2438 LONGEST index
= subscript_array
[i
- 1];
2440 array
= value_subscripted_rvalue (array
, index
,
2441 f77_get_lowerbound (array_type
));
2447 case BINOP_LOGICAL_AND
:
2448 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2449 if (noside
== EVAL_SKIP
)
2451 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2452 return eval_skip_value (exp
);
2456 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2459 if (binop_user_defined_p (op
, arg1
, arg2
))
2461 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2462 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2466 tem
= value_logical_not (arg1
);
2467 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2468 (tem
? EVAL_SKIP
: noside
));
2469 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2470 return value_from_longest (type
,
2471 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2474 case BINOP_LOGICAL_OR
:
2475 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2476 if (noside
== EVAL_SKIP
)
2478 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2479 return eval_skip_value (exp
);
2483 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2486 if (binop_user_defined_p (op
, arg1
, arg2
))
2488 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2489 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2493 tem
= value_logical_not (arg1
);
2494 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2495 (!tem
? EVAL_SKIP
: noside
));
2496 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2497 return value_from_longest (type
,
2498 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2502 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2503 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2504 if (noside
== EVAL_SKIP
)
2505 return eval_skip_value (exp
);
2506 if (binop_user_defined_p (op
, arg1
, arg2
))
2508 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2512 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2513 tem
= value_equal (arg1
, arg2
);
2514 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2515 return value_from_longest (type
, (LONGEST
) tem
);
2518 case BINOP_NOTEQUAL
:
2519 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2520 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2521 if (noside
== EVAL_SKIP
)
2522 return eval_skip_value (exp
);
2523 if (binop_user_defined_p (op
, arg1
, arg2
))
2525 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2529 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2530 tem
= value_equal (arg1
, arg2
);
2531 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2532 return value_from_longest (type
, (LONGEST
) ! tem
);
2536 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2537 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2538 if (noside
== EVAL_SKIP
)
2539 return eval_skip_value (exp
);
2540 if (binop_user_defined_p (op
, arg1
, arg2
))
2542 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2546 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2547 tem
= value_less (arg1
, arg2
);
2548 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2549 return value_from_longest (type
, (LONGEST
) tem
);
2553 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2554 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2555 if (noside
== EVAL_SKIP
)
2556 return eval_skip_value (exp
);
2557 if (binop_user_defined_p (op
, arg1
, arg2
))
2559 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2563 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2564 tem
= value_less (arg2
, arg1
);
2565 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2566 return value_from_longest (type
, (LONGEST
) tem
);
2570 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2571 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2572 if (noside
== EVAL_SKIP
)
2573 return eval_skip_value (exp
);
2574 if (binop_user_defined_p (op
, arg1
, arg2
))
2576 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2580 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2581 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2582 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2583 return value_from_longest (type
, (LONGEST
) tem
);
2587 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2588 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2589 if (noside
== EVAL_SKIP
)
2590 return eval_skip_value (exp
);
2591 if (binop_user_defined_p (op
, arg1
, arg2
))
2593 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2597 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2598 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2599 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2600 return value_from_longest (type
, (LONGEST
) tem
);
2604 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2605 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2606 if (noside
== EVAL_SKIP
)
2607 return eval_skip_value (exp
);
2608 type
= check_typedef (value_type (arg2
));
2609 if (type
->code () != TYPE_CODE_INT
2610 && type
->code () != TYPE_CODE_ENUM
)
2611 error (_("Non-integral right operand for \"@\" operator."));
2612 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2614 return allocate_repeat_value (value_type (arg1
),
2615 longest_to_int (value_as_long (arg2
)));
2618 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2621 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2622 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2625 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2626 if (noside
== EVAL_SKIP
)
2627 return eval_skip_value (exp
);
2628 if (unop_user_defined_p (op
, arg1
))
2629 return value_x_unop (arg1
, op
, noside
);
2632 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2633 return value_pos (arg1
);
2637 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2638 if (noside
== EVAL_SKIP
)
2639 return eval_skip_value (exp
);
2640 if (unop_user_defined_p (op
, arg1
))
2641 return value_x_unop (arg1
, op
, noside
);
2644 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2645 return value_neg (arg1
);
2648 case UNOP_COMPLEMENT
:
2649 /* C++: check for and handle destructor names. */
2651 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2652 if (noside
== EVAL_SKIP
)
2653 return eval_skip_value (exp
);
2654 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2655 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2658 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2659 return value_complement (arg1
);
2662 case UNOP_LOGICAL_NOT
:
2663 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2664 if (noside
== EVAL_SKIP
)
2665 return eval_skip_value (exp
);
2666 if (unop_user_defined_p (op
, arg1
))
2667 return value_x_unop (arg1
, op
, noside
);
2670 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2671 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2675 if (expect_type
&& expect_type
->code () == TYPE_CODE_PTR
)
2676 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2677 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2678 type
= check_typedef (value_type (arg1
));
2679 if (type
->code () == TYPE_CODE_METHODPTR
2680 || type
->code () == TYPE_CODE_MEMBERPTR
)
2681 error (_("Attempt to dereference pointer "
2682 "to member without an object"));
2683 if (noside
== EVAL_SKIP
)
2684 return eval_skip_value (exp
);
2685 if (unop_user_defined_p (op
, arg1
))
2686 return value_x_unop (arg1
, op
, noside
);
2687 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2689 type
= check_typedef (value_type (arg1
));
2690 if (type
->code () == TYPE_CODE_PTR
2691 || TYPE_IS_REFERENCE (type
)
2692 /* In C you can dereference an array to get the 1st elt. */
2693 || type
->code () == TYPE_CODE_ARRAY
2695 return value_zero (TYPE_TARGET_TYPE (type
),
2697 else if (type
->code () == TYPE_CODE_INT
)
2698 /* GDB allows dereferencing an int. */
2699 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2702 error (_("Attempt to take contents of a non-pointer value."));
2705 /* Allow * on an integer so we can cast it to whatever we want.
2706 This returns an int, which seems like the most C-like thing to
2707 do. "long long" variables are rare enough that
2708 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2709 if (type
->code () == TYPE_CODE_INT
)
2710 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2711 (CORE_ADDR
) value_as_address (arg1
));
2712 return value_ind (arg1
);
2715 /* C++: check for and handle pointer to members. */
2717 if (noside
== EVAL_SKIP
)
2719 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2720 return eval_skip_value (exp
);
2724 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2731 if (noside
== EVAL_SKIP
)
2733 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2734 return eval_skip_value (exp
);
2736 return evaluate_subexp_for_sizeof (exp
, pos
, noside
);
2740 type
= value_type (evaluate_subexp (NULL_TYPE
, exp
, pos
,
2741 EVAL_AVOID_SIDE_EFFECTS
));
2742 /* FIXME: This should be size_t. */
2743 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
2744 ULONGEST align
= type_align (type
);
2746 error (_("could not determine alignment of type"));
2747 return value_from_longest (size_type
, align
);
2752 type
= exp
->elts
[pc
+ 1].type
;
2753 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2755 case UNOP_CAST_TYPE
:
2756 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2757 type
= value_type (arg1
);
2758 return evaluate_subexp_for_cast (exp
, pos
, noside
, type
);
2760 case UNOP_DYNAMIC_CAST
:
2761 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2762 type
= value_type (arg1
);
2763 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2764 if (noside
== EVAL_SKIP
)
2765 return eval_skip_value (exp
);
2766 return value_dynamic_cast (type
, arg1
);
2768 case UNOP_REINTERPRET_CAST
:
2769 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2770 type
= value_type (arg1
);
2771 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2772 if (noside
== EVAL_SKIP
)
2773 return eval_skip_value (exp
);
2774 return value_reinterpret_cast (type
, arg1
);
2778 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2779 if (noside
== EVAL_SKIP
)
2780 return eval_skip_value (exp
);
2781 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2782 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2784 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2785 value_as_address (arg1
));
2787 case UNOP_MEMVAL_TYPE
:
2788 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2789 type
= value_type (arg1
);
2790 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2791 if (noside
== EVAL_SKIP
)
2792 return eval_skip_value (exp
);
2793 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2794 return value_zero (type
, lval_memory
);
2796 return value_at_lazy (type
, value_as_address (arg1
));
2798 case UNOP_PREINCREMENT
:
2799 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2800 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2802 else if (unop_user_defined_p (op
, arg1
))
2804 return value_x_unop (arg1
, op
, noside
);
2808 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2809 arg2
= value_ptradd (arg1
, 1);
2812 struct value
*tmp
= arg1
;
2814 arg2
= value_one (value_type (arg1
));
2815 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2816 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2819 return value_assign (arg1
, arg2
);
2822 case UNOP_PREDECREMENT
:
2823 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2824 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2826 else if (unop_user_defined_p (op
, arg1
))
2828 return value_x_unop (arg1
, op
, noside
);
2832 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2833 arg2
= value_ptradd (arg1
, -1);
2836 struct value
*tmp
= arg1
;
2838 arg2
= value_one (value_type (arg1
));
2839 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2840 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2843 return value_assign (arg1
, arg2
);
2846 case UNOP_POSTINCREMENT
:
2847 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2848 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2850 else if (unop_user_defined_p (op
, arg1
))
2852 return value_x_unop (arg1
, op
, noside
);
2856 arg3
= value_non_lval (arg1
);
2858 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2859 arg2
= value_ptradd (arg1
, 1);
2862 struct value
*tmp
= arg1
;
2864 arg2
= value_one (value_type (arg1
));
2865 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2866 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2869 value_assign (arg1
, arg2
);
2873 case UNOP_POSTDECREMENT
:
2874 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2875 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2877 else if (unop_user_defined_p (op
, arg1
))
2879 return value_x_unop (arg1
, op
, noside
);
2883 arg3
= value_non_lval (arg1
);
2885 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2886 arg2
= value_ptradd (arg1
, -1);
2889 struct value
*tmp
= arg1
;
2891 arg2
= value_one (value_type (arg1
));
2892 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2893 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2896 value_assign (arg1
, arg2
);
2902 return value_of_this (exp
->language_defn
);
2905 /* The value is not supposed to be used. This is here to make it
2906 easier to accommodate expressions that contain types. */
2908 if (noside
== EVAL_SKIP
)
2909 return eval_skip_value (exp
);
2910 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2911 return allocate_value (exp
->elts
[pc
+ 1].type
);
2913 error (_("Attempt to use a type name as an expression"));
2917 if (noside
== EVAL_SKIP
)
2919 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2920 return eval_skip_value (exp
);
2922 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2924 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2925 struct value
*result
;
2927 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2928 EVAL_AVOID_SIDE_EFFECTS
);
2930 /* 'decltype' has special semantics for lvalues. */
2931 if (op
== OP_DECLTYPE
2932 && (sub_op
== BINOP_SUBSCRIPT
2933 || sub_op
== STRUCTOP_MEMBER
2934 || sub_op
== STRUCTOP_MPTR
2935 || sub_op
== UNOP_IND
2936 || sub_op
== STRUCTOP_STRUCT
2937 || sub_op
== STRUCTOP_PTR
2938 || sub_op
== OP_SCOPE
))
2940 type
= value_type (result
);
2942 if (!TYPE_IS_REFERENCE (type
))
2944 type
= lookup_lvalue_reference_type (type
);
2945 result
= allocate_value (type
);
2952 error (_("Attempt to use a type as an expression"));
2956 struct value
*result
;
2957 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2959 if (sub_op
== OP_TYPE
|| sub_op
== OP_DECLTYPE
|| sub_op
== OP_TYPEOF
)
2960 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2961 EVAL_AVOID_SIDE_EFFECTS
);
2963 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2965 if (noside
!= EVAL_NORMAL
)
2966 return allocate_value (cplus_typeid_type (exp
->gdbarch
));
2968 return cplus_typeid (result
);
2972 /* Removing this case and compiling with gcc -Wall reveals that
2973 a lot of cases are hitting this case. Some of these should
2974 probably be removed from expression.h; others are legitimate
2975 expressions which are (apparently) not fully implemented.
2977 If there are any cases landing here which mean a user error,
2978 then they should be separate cases, with more descriptive
2981 error (_("GDB does not (yet) know how to "
2982 "evaluate that kind of expression"));
2985 gdb_assert_not_reached ("missed return?");
2988 /* Evaluate a subexpression of EXP, at index *POS,
2989 and return the address of that subexpression.
2990 Advance *POS over the subexpression.
2991 If the subexpression isn't an lvalue, get an error.
2992 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2993 then only the type of the result need be correct. */
2995 static struct value
*
2996 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
3006 op
= exp
->elts
[pc
].opcode
;
3012 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3014 /* We can't optimize out "&*" if there's a user-defined operator*. */
3015 if (unop_user_defined_p (op
, x
))
3017 x
= value_x_unop (x
, op
, noside
);
3018 goto default_case_after_eval
;
3021 return coerce_array (x
);
3025 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
3026 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
3028 case UNOP_MEMVAL_TYPE
:
3033 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3034 type
= value_type (x
);
3035 return value_cast (lookup_pointer_type (type
),
3036 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
3040 var
= exp
->elts
[pc
+ 2].symbol
;
3042 /* C++: The "address" of a reference should yield the address
3043 * of the object pointed to. Let value_addr() deal with it. */
3044 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var
)))
3048 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3051 lookup_pointer_type (SYMBOL_TYPE (var
));
3052 enum address_class sym_class
= SYMBOL_CLASS (var
);
3054 if (sym_class
== LOC_CONST
3055 || sym_class
== LOC_CONST_BYTES
3056 || sym_class
== LOC_REGISTER
)
3057 error (_("Attempt to take address of register or constant."));
3060 value_zero (type
, not_lval
);
3063 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3065 case OP_VAR_MSYM_VALUE
:
3069 value
*val
= evaluate_var_msym_value (noside
,
3070 exp
->elts
[pc
+ 1].objfile
,
3071 exp
->elts
[pc
+ 2].msymbol
);
3072 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3074 struct type
*type
= lookup_pointer_type (value_type (val
));
3075 return value_zero (type
, not_lval
);
3078 return value_addr (val
);
3082 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
3083 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
3084 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
3085 &exp
->elts
[pc
+ 3].string
,
3088 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
3093 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3094 default_case_after_eval
:
3095 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3097 struct type
*type
= check_typedef (value_type (x
));
3099 if (TYPE_IS_REFERENCE (type
))
3100 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3102 else if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
3103 return value_zero (lookup_pointer_type (value_type (x
)),
3106 error (_("Attempt to take address of "
3107 "value not located in memory."));
3109 return value_addr (x
);
3113 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3114 When used in contexts where arrays will be coerced anyway, this is
3115 equivalent to `evaluate_subexp' but much faster because it avoids
3116 actually fetching array contents (perhaps obsolete now that we have
3119 Note that we currently only do the coercion for C expressions, where
3120 arrays are zero based and the coercion is correct. For other languages,
3121 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3122 to decide if coercion is appropriate. */
3125 evaluate_subexp_with_coercion (struct expression
*exp
,
3126 int *pos
, enum noside noside
)
3135 op
= exp
->elts
[pc
].opcode
;
3140 var
= exp
->elts
[pc
+ 2].symbol
;
3141 type
= check_typedef (SYMBOL_TYPE (var
));
3142 if (type
->code () == TYPE_CODE_ARRAY
3143 && !TYPE_VECTOR (type
)
3144 && CAST_IS_CONVERSION (exp
->language_defn
))
3147 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
3148 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
3154 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
3158 /* Evaluate a subexpression of EXP, at index *POS,
3159 and return a value for the size of that subexpression.
3160 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3161 we allow side-effects on the operand if its type is a variable
3164 static struct value
*
3165 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
,
3168 /* FIXME: This should be size_t. */
3169 struct type
*size_type
= builtin_type (exp
->gdbarch
)->builtin_int
;
3176 op
= exp
->elts
[pc
].opcode
;
3180 /* This case is handled specially
3181 so that we avoid creating a value for the result type.
3182 If the result type is very big, it's desirable not to
3183 create a value unnecessarily. */
3186 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3187 type
= check_typedef (value_type (val
));
3188 if (type
->code () != TYPE_CODE_PTR
3189 && !TYPE_IS_REFERENCE (type
)
3190 && type
->code () != TYPE_CODE_ARRAY
)
3191 error (_("Attempt to take contents of a non-pointer value."));
3192 type
= TYPE_TARGET_TYPE (type
);
3193 if (is_dynamic_type (type
))
3194 type
= value_type (value_ind (val
));
3195 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3199 type
= exp
->elts
[pc
+ 1].type
;
3202 case UNOP_MEMVAL_TYPE
:
3204 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3205 type
= value_type (val
);
3209 type
= SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
);
3210 if (is_dynamic_type (type
))
3212 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3213 type
= value_type (val
);
3214 if (type
->code () == TYPE_CODE_ARRAY
3215 && is_dynamic_type (type
->index_type ())
3216 && TYPE_HIGH_BOUND_UNDEFINED (type
->index_type ()))
3217 return allocate_optimized_out_value (size_type
);
3223 case OP_VAR_MSYM_VALUE
:
3227 minimal_symbol
*msymbol
= exp
->elts
[pc
+ 2].msymbol
;
3228 value
*mval
= evaluate_var_msym_value (noside
,
3229 exp
->elts
[pc
+ 1].objfile
,
3232 type
= value_type (mval
);
3233 if (type
->code () == TYPE_CODE_ERROR
)
3234 error_unknown_type (msymbol
->print_name ());
3236 return value_from_longest (size_type
, TYPE_LENGTH (type
));
3240 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3241 type of the subscript is a variable length array type. In this case we
3242 must re-evaluate the right hand side of the subscription to allow
3244 case BINOP_SUBSCRIPT
:
3245 if (noside
== EVAL_NORMAL
)
3247 int npc
= (*pos
) + 1;
3249 val
= evaluate_subexp (NULL_TYPE
, exp
, &npc
, EVAL_AVOID_SIDE_EFFECTS
);
3250 type
= check_typedef (value_type (val
));
3251 if (type
->code () == TYPE_CODE_ARRAY
)
3253 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3254 if (type
->code () == TYPE_CODE_ARRAY
)
3256 type
= type
->index_type ();
3257 /* Only re-evaluate the right hand side if the resulting type
3258 is a variable length type. */
3259 if (TYPE_RANGE_DATA (type
)->flag_bound_evaluated
)
3261 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_NORMAL
);
3262 return value_from_longest
3263 (size_type
, (LONGEST
) TYPE_LENGTH (value_type (val
)));
3272 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3273 type
= value_type (val
);
3277 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3278 "When applied to a reference or a reference type, the result is
3279 the size of the referenced type." */
3280 type
= check_typedef (type
);
3281 if (exp
->language_defn
->la_language
== language_cplus
3282 && (TYPE_IS_REFERENCE (type
)))
3283 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3284 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3287 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3288 for that subexpression cast to TO_TYPE. Advance *POS over the
3292 evaluate_subexp_for_cast (expression
*exp
, int *pos
,
3294 struct type
*to_type
)
3298 /* Don't let symbols be evaluated with evaluate_subexp because that
3299 throws an "unknown type" error for no-debug data symbols.
3300 Instead, we want the cast to reinterpret the symbol. */
3301 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
3302 || exp
->elts
[pc
].opcode
== OP_VAR_VALUE
)
3307 if (exp
->elts
[pc
].opcode
== OP_VAR_MSYM_VALUE
)
3309 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
3310 return value_zero (to_type
, not_lval
);
3312 val
= evaluate_var_msym_value (noside
,
3313 exp
->elts
[pc
+ 1].objfile
,
3314 exp
->elts
[pc
+ 2].msymbol
);
3317 val
= evaluate_var_value (noside
,
3318 exp
->elts
[pc
+ 1].block
,
3319 exp
->elts
[pc
+ 2].symbol
);
3321 if (noside
== EVAL_SKIP
)
3322 return eval_skip_value (exp
);
3324 val
= value_cast (to_type
, val
);
3326 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3327 if (VALUE_LVAL (val
) == lval_memory
)
3329 if (value_lazy (val
))
3330 value_fetch_lazy (val
);
3331 VALUE_LVAL (val
) = not_lval
;
3336 value
*val
= evaluate_subexp (to_type
, exp
, pos
, noside
);
3337 if (noside
== EVAL_SKIP
)
3338 return eval_skip_value (exp
);
3339 return value_cast (to_type
, val
);
3342 /* Parse a type expression in the string [P..P+LENGTH). */
3345 parse_and_eval_type (char *p
, int length
)
3347 char *tmp
= (char *) alloca (length
+ 4);
3350 memcpy (tmp
+ 1, p
, length
);
3351 tmp
[length
+ 1] = ')';
3352 tmp
[length
+ 2] = '0';
3353 tmp
[length
+ 3] = '\0';
3354 expression_up expr
= parse_expression (tmp
);
3355 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3356 error (_("Internal error in eval_type."));
3357 return expr
->elts
[1].type
;
3361 calc_f77_array_dims (struct type
*array_type
)
3364 struct type
*tmp_type
;
3366 if ((array_type
->code () != TYPE_CODE_ARRAY
))
3367 error (_("Can't get dimensions for a non-array type"));
3369 tmp_type
= array_type
;
3371 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3373 if (tmp_type
->code () == TYPE_CODE_ARRAY
)