1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2019 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 /* This is defined in valops.c */
46 extern int overload_resolution;
48 /* Prototypes for local functions. */
50 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *,
53 static struct value *evaluate_subexp_for_address (struct expression *,
56 static value *evaluate_subexp_for_cast (expression *exp, int *pos,
60 static struct value *evaluate_struct_tuple (struct value *,
61 struct expression *, int *,
64 static LONGEST init_array_element (struct value *, struct value *,
65 struct expression *, int *, enum noside,
69 evaluate_subexp (struct type *expect_type, struct expression *exp,
70 int *pos, enum noside noside)
74 gdb::optional<enable_thread_stack_temporaries> stack_temporaries;
75 if (*pos == 0 && target_has_execution
76 && exp->language_defn->la_language == language_cplus
77 && !thread_stack_temporaries_enabled_p (inferior_thread ()))
78 stack_temporaries.emplace (inferior_thread ());
80 retval = (*exp->language_defn->la_exp_desc->evaluate_exp)
81 (expect_type, exp, pos, noside);
83 if (stack_temporaries.has_value ()
84 && value_in_thread_stack_temporaries (retval, inferior_thread ()))
85 retval = value_non_lval (retval);
90 /* Parse the string EXP as a C expression, evaluate it,
91 and return the result as a number. */
94 parse_and_eval_address (const char *exp)
96 expression_up expr = parse_expression (exp);
98 return value_as_address (evaluate_expression (expr.get ()));
101 /* Like parse_and_eval_address, but treats the value of the expression
102 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
104 parse_and_eval_long (const char *exp)
106 expression_up expr = parse_expression (exp);
108 return value_as_long (evaluate_expression (expr.get ()));
112 parse_and_eval (const char *exp)
114 expression_up expr = parse_expression (exp);
116 return evaluate_expression (expr.get ());
119 /* Parse up to a comma (or to a closeparen)
120 in the string EXPP as an expression, evaluate it, and return the value.
121 EXPP is advanced to point to the comma. */
124 parse_to_comma_and_eval (const char **expp)
126 expression_up expr = parse_exp_1 (expp, 0, nullptr, 1);
128 return evaluate_expression (expr.get ());
131 /* Evaluate an expression in internal prefix form
132 such as is constructed by parse.y.
134 See expression.h for info on the format of an expression. */
137 evaluate_expression (struct expression *exp)
141 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
144 /* Evaluate an expression, avoiding all memory references
145 and getting a value whose type alone is correct. */
148 evaluate_type (struct expression *exp)
152 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
155 /* Evaluate a subexpression, avoiding all memory references and
156 getting a value whose type alone is correct. */
159 evaluate_subexpression_type (struct expression *exp, int subexp)
161 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
164 /* Find the current value of a watchpoint on EXP. Return the value in
165 *VALP and *RESULTP and the chain of intermediate and final values
166 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
169 If PRESERVE_ERRORS is true, then exceptions are passed through.
170 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
171 occurs while evaluating the expression, *RESULTP will be set to
172 NULL. *RESULTP may be a lazy value, if the result could not be
173 read from memory. It is used to determine whether a value is
174 user-specified (we should watch the whole value) or intermediate
175 (we should watch only the bit used to locate the final value).
177 If the final value, or any intermediate value, could not be read
178 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
179 set to any referenced values. *VALP will never be a lazy value.
180 This is the value which we store in struct breakpoint.
182 If VAL_CHAIN is non-NULL, the values put into *VAL_CHAIN will be
183 released from the value chain. If VAL_CHAIN is NULL, all generated
184 values will be left on the value chain. */
187 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
188 struct value **resultp,
189 std::vector<value_ref_ptr> *val_chain,
192 struct value *mark, *new_mark, *result;
200 /* Evaluate the expression. */
201 mark = value_mark ();
206 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
208 CATCH (ex, RETURN_MASK_ALL)
210 /* Ignore memory errors if we want watchpoints pointing at
211 inaccessible memory to still be created; otherwise, throw the
212 error to some higher catcher. */
216 if (!preserve_errors)
220 throw_exception (ex);
226 new_mark = value_mark ();
227 if (mark == new_mark)
232 /* Make sure it's not lazy, so that after the target stops again we
233 have a non-lazy previous value to compare with. */
236 if (!value_lazy (result))
243 value_fetch_lazy (result);
246 CATCH (except, RETURN_MASK_ERROR)
255 /* Return the chain of intermediate values. We use this to
256 decide which addresses to watch. */
257 *val_chain = value_release_to_mark (mark);
261 /* Extract a field operation from an expression. If the subexpression
262 of EXP starting at *SUBEXP is not a structure dereference
263 operation, return NULL. Otherwise, return the name of the
264 dereferenced field, and advance *SUBEXP to point to the
265 subexpression of the left-hand-side of the dereference. This is
266 used when completing field names. */
269 extract_field_op (struct expression *exp, int *subexp)
274 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
275 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
277 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
278 result = &exp->elts[*subexp + 2].string;
279 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
283 /* This function evaluates brace-initializers (in C/C++) for
286 static struct value *
287 evaluate_struct_tuple (struct value *struct_val,
288 struct expression *exp,
289 int *pos, enum noside noside, int nargs)
291 struct type *struct_type = check_typedef (value_type (struct_val));
292 struct type *field_type;
297 struct value *val = NULL;
302 /* Skip static fields. */
303 while (fieldno < TYPE_NFIELDS (struct_type)
304 && field_is_static (&TYPE_FIELD (struct_type,
307 if (fieldno >= TYPE_NFIELDS (struct_type))
308 error (_("too many initializers"));
309 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
310 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
311 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
312 error (_("don't know which variant you want to set"));
314 /* Here, struct_type is the type of the inner struct,
315 while substruct_type is the type of the inner struct.
316 These are the same for normal structures, but a variant struct
317 contains anonymous union fields that contain substruct fields.
318 The value fieldno is the index of the top-level (normal or
319 anonymous union) field in struct_field, while the value
320 subfieldno is the index of the actual real (named inner) field
321 in substruct_type. */
323 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
325 val = evaluate_subexp (field_type, exp, pos, noside);
327 /* Now actually set the field in struct_val. */
329 /* Assign val to field fieldno. */
330 if (value_type (val) != field_type)
331 val = value_cast (field_type, val);
333 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
334 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
335 addr = value_contents_writeable (struct_val) + bitpos / 8;
337 modify_field (struct_type, addr,
338 value_as_long (val), bitpos % 8, bitsize);
340 memcpy (addr, value_contents (val),
341 TYPE_LENGTH (value_type (val)));
347 /* Recursive helper function for setting elements of array tuples.
348 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
349 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
350 Evaluates index expresions and sets the specified element(s) of
351 ARRAY to ELEMENT. Returns last index value. */
354 init_array_element (struct value *array, struct value *element,
355 struct expression *exp, int *pos,
356 enum noside noside, LONGEST low_bound, LONGEST high_bound)
359 int element_size = TYPE_LENGTH (value_type (element));
361 if (exp->elts[*pos].opcode == BINOP_COMMA)
364 init_array_element (array, element, exp, pos, noside,
365 low_bound, high_bound);
366 return init_array_element (array, element,
367 exp, pos, noside, low_bound, high_bound);
371 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
372 if (index < low_bound || index > high_bound)
373 error (_("tuple index out of range"));
374 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
375 value_contents (element), element_size);
380 static struct value *
381 value_f90_subarray (struct value *array,
382 struct expression *exp, int *pos, enum noside noside)
385 LONGEST low_bound, high_bound;
386 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
387 enum range_type range_type
388 = (enum range_type) longest_to_int (exp->elts[pc].longconst);
392 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
393 low_bound = TYPE_LOW_BOUND (range);
395 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
397 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
398 high_bound = TYPE_HIGH_BOUND (range);
400 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
402 return value_slice (array, low_bound, high_bound - low_bound + 1);
406 /* Promote value ARG1 as appropriate before performing a unary operation
408 If the result is not appropriate for any particular language then it
409 needs to patch this function. */
412 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
417 *arg1 = coerce_ref (*arg1);
418 type1 = check_typedef (value_type (*arg1));
420 if (is_integral_type (type1))
422 switch (language->la_language)
425 /* Perform integral promotion for ANSI C/C++.
426 If not appropropriate for any particular language
427 it needs to modify this function. */
429 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
431 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
432 *arg1 = value_cast (builtin_int, *arg1);
439 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
440 operation on those two operands.
441 If the result is not appropriate for any particular language then it
442 needs to patch this function. */
445 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
446 struct value **arg1, struct value **arg2)
448 struct type *promoted_type = NULL;
452 *arg1 = coerce_ref (*arg1);
453 *arg2 = coerce_ref (*arg2);
455 type1 = check_typedef (value_type (*arg1));
456 type2 = check_typedef (value_type (*arg2));
458 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
459 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
460 && !is_integral_type (type1))
461 || (TYPE_CODE (type2) != TYPE_CODE_FLT
462 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
463 && !is_integral_type (type2)))
466 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
467 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
469 /* No promotion required. */
471 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
472 || TYPE_CODE (type2) == TYPE_CODE_FLT)
474 switch (language->la_language)
480 case language_opencl:
481 /* No promotion required. */
485 /* For other languages the result type is unchanged from gdb
486 version 6.7 for backward compatibility.
487 If either arg was long double, make sure that value is also long
488 double. Otherwise use double. */
489 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
490 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
491 promoted_type = builtin_type (gdbarch)->builtin_long_double;
493 promoted_type = builtin_type (gdbarch)->builtin_double;
497 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
498 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
500 /* No promotion required. */
503 /* Integral operations here. */
504 /* FIXME: Also mixed integral/booleans, with result an integer. */
506 const struct builtin_type *builtin = builtin_type (gdbarch);
507 unsigned int promoted_len1 = TYPE_LENGTH (type1);
508 unsigned int promoted_len2 = TYPE_LENGTH (type2);
509 int is_unsigned1 = TYPE_UNSIGNED (type1);
510 int is_unsigned2 = TYPE_UNSIGNED (type2);
511 unsigned int result_len;
512 int unsigned_operation;
514 /* Determine type length and signedness after promotion for
516 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
519 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
521 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
524 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
527 if (promoted_len1 > promoted_len2)
529 unsigned_operation = is_unsigned1;
530 result_len = promoted_len1;
532 else if (promoted_len2 > promoted_len1)
534 unsigned_operation = is_unsigned2;
535 result_len = promoted_len2;
539 unsigned_operation = is_unsigned1 || is_unsigned2;
540 result_len = promoted_len1;
543 switch (language->la_language)
549 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
551 promoted_type = (unsigned_operation
552 ? builtin->builtin_unsigned_int
553 : builtin->builtin_int);
555 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
557 promoted_type = (unsigned_operation
558 ? builtin->builtin_unsigned_long
559 : builtin->builtin_long);
563 promoted_type = (unsigned_operation
564 ? builtin->builtin_unsigned_long_long
565 : builtin->builtin_long_long);
568 case language_opencl:
569 if (result_len <= TYPE_LENGTH (lookup_signed_typename
570 (language, gdbarch, "int")))
574 ? lookup_unsigned_typename (language, gdbarch, "int")
575 : lookup_signed_typename (language, gdbarch, "int"));
577 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
578 (language, gdbarch, "long")))
582 ? lookup_unsigned_typename (language, gdbarch, "long")
583 : lookup_signed_typename (language, gdbarch,"long"));
587 /* For other languages the result type is unchanged from gdb
588 version 6.7 for backward compatibility.
589 If either arg was long long, make sure that value is also long
590 long. Otherwise use long. */
591 if (unsigned_operation)
593 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
594 promoted_type = builtin->builtin_unsigned_long_long;
596 promoted_type = builtin->builtin_unsigned_long;
600 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
601 promoted_type = builtin->builtin_long_long;
603 promoted_type = builtin->builtin_long;
611 /* Promote both operands to common type. */
612 *arg1 = value_cast (promoted_type, *arg1);
613 *arg2 = value_cast (promoted_type, *arg2);
618 ptrmath_type_p (const struct language_defn *lang, struct type *type)
620 type = check_typedef (type);
621 if (TYPE_IS_REFERENCE (type))
622 type = TYPE_TARGET_TYPE (type);
624 switch (TYPE_CODE (type))
630 case TYPE_CODE_ARRAY:
631 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
638 /* Represents a fake method with the given parameter types. This is
639 used by the parser to construct a temporary "expected" type for
640 method overload resolution. FLAGS is used as instance flags of the
641 new type, in order to be able to make the new type represent a
642 const/volatile overload. */
647 fake_method (type_instance_flags flags,
648 int num_types, struct type **param_types);
651 /* The constructed type. */
652 struct type *type () { return &m_type; }
655 struct type m_type {};
656 main_type m_main_type {};
659 fake_method::fake_method (type_instance_flags flags,
660 int num_types, struct type **param_types)
662 struct type *type = &m_type;
664 TYPE_MAIN_TYPE (type) = &m_main_type;
665 TYPE_LENGTH (type) = 1;
666 TYPE_CODE (type) = TYPE_CODE_METHOD;
667 TYPE_CHAIN (type) = type;
668 TYPE_INSTANCE_FLAGS (type) = flags;
671 if (param_types[num_types - 1] == NULL)
674 TYPE_VARARGS (type) = 1;
676 else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
680 /* Caller should have ensured this. */
681 gdb_assert (num_types == 0);
682 TYPE_PROTOTYPED (type) = 1;
686 /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
687 neither an objfile nor a gdbarch. As a result we must manually
688 allocate memory for auxiliary fields, and free the memory ourselves
689 when we are done with it. */
690 TYPE_NFIELDS (type) = num_types;
691 TYPE_FIELDS (type) = (struct field *)
692 xzalloc (sizeof (struct field) * num_types);
694 while (num_types-- > 0)
695 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
698 fake_method::~fake_method ()
700 xfree (TYPE_FIELDS (&m_type));
703 /* Helper for evaluating an OP_VAR_VALUE. */
706 evaluate_var_value (enum noside noside, const block *blk, symbol *var)
708 /* JYG: We used to just return value_zero of the symbol type if
709 we're asked to avoid side effects. Otherwise we return
710 value_of_variable (...). However I'm not sure if
711 value_of_variable () has any side effect. We need a full value
712 object returned here for whatis_exp () to call evaluate_type ()
713 and then pass the full value to value_rtti_target_type () if we
714 are dealing with a pointer or reference to a base class and print
717 struct value *ret = NULL;
721 ret = value_of_variable (var, blk);
724 CATCH (except, RETURN_MASK_ERROR)
726 if (noside != EVAL_AVOID_SIDE_EFFECTS)
727 throw_exception (except);
729 ret = value_zero (SYMBOL_TYPE (var), not_lval);
736 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
739 evaluate_var_msym_value (enum noside noside,
740 struct objfile *objfile, minimal_symbol *msymbol)
743 type *the_type = find_minsym_type_and_address (msymbol, objfile, &address);
745 if (noside == EVAL_AVOID_SIDE_EFFECTS && !TYPE_GNU_IFUNC (the_type))
746 return value_zero (the_type, not_lval);
748 return value_at_lazy (the_type, address);
751 /* Helper for returning a value when handling EVAL_SKIP. */
754 eval_skip_value (expression *exp)
756 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
759 /* Evaluate a function call. The function to be called is in
760 ARGVEC[0] and the arguments passed to the function are in
761 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
762 known. DEFAULT_RETURN_TYPE is used as the function's return type
763 if the return type is unknown. */
766 eval_call (expression *exp, enum noside noside,
767 int nargs, value **argvec,
768 const char *function_name,
769 type *default_return_type)
771 if (argvec[0] == NULL)
772 error (_("Cannot evaluate function -- may be inlined"));
773 if (noside == EVAL_AVOID_SIDE_EFFECTS)
775 /* If the return type doesn't look like a function type,
776 call an error. This can happen if somebody tries to turn
777 a variable into a function call. */
779 type *ftype = value_type (argvec[0]);
781 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
783 /* We don't know anything about what the internal
784 function might return, but we have to return
786 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
789 else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
792 = result_type_of_xmethod (argvec[0],
793 gdb::make_array_view (argvec + 1,
796 if (return_type == NULL)
797 error (_("Xmethod is missing return type."));
798 return value_zero (return_type, not_lval);
800 else if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
801 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
803 if (TYPE_GNU_IFUNC (ftype))
805 CORE_ADDR address = value_address (argvec[0]);
806 type *resolved_type = find_gnu_ifunc_target_type (address);
808 if (resolved_type != NULL)
809 ftype = resolved_type;
812 type *return_type = TYPE_TARGET_TYPE (ftype);
814 if (return_type == NULL)
815 return_type = default_return_type;
817 if (return_type == NULL)
818 error_call_unknown_return_type (function_name);
820 return allocate_value (return_type);
823 error (_("Expression of type other than "
824 "\"Function returning ...\" used as function"));
826 switch (TYPE_CODE (value_type (argvec[0])))
828 case TYPE_CODE_INTERNAL_FUNCTION:
829 return call_internal_function (exp->gdbarch, exp->language_defn,
830 argvec[0], nargs, argvec + 1);
831 case TYPE_CODE_XMETHOD:
832 return call_xmethod (argvec[0], gdb::make_array_view (argvec + 1, nargs));
834 return call_function_by_hand (argvec[0], default_return_type,
835 gdb::make_array_view (argvec + 1, nargs));
839 /* Helper for evaluating an OP_FUNCALL. */
842 evaluate_funcall (type *expect_type, expression *exp, int *pos,
850 symbol *function = NULL;
851 char *function_name = NULL;
852 const char *var_func_name = NULL;
857 exp_opcode op = exp->elts[*pos].opcode;
858 int nargs = longest_to_int (exp->elts[pc].longconst);
859 /* Allocate arg vector, including space for the function to be
860 called in argvec[0], a potential `this', and a terminating
862 value **argvec = (value **) alloca (sizeof (value *) * (nargs + 3));
863 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
865 /* First, evaluate the structure into arg2. */
868 if (op == STRUCTOP_MEMBER)
870 arg2 = evaluate_subexp_for_address (exp, pos, noside);
874 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
877 /* If the function is a virtual function, then the aggregate
878 value (providing the structure) plays its part by providing
879 the vtable. Otherwise, it is just along for the ride: call
880 the function directly. */
882 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
884 type *a1_type = check_typedef (value_type (arg1));
885 if (noside == EVAL_SKIP)
886 tem = 1; /* Set it to the right arg index so that all
887 arguments can also be skipped. */
888 else if (TYPE_CODE (a1_type) == TYPE_CODE_METHODPTR)
890 if (noside == EVAL_AVOID_SIDE_EFFECTS)
891 arg1 = value_zero (TYPE_TARGET_TYPE (a1_type), not_lval);
893 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
895 /* Now, say which argument to start evaluating from. */
900 else if (TYPE_CODE (a1_type) == TYPE_CODE_MEMBERPTR)
902 struct type *type_ptr
903 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type));
904 struct type *target_type_ptr
905 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type));
907 /* Now, convert these values to an address. */
908 arg2 = value_cast (type_ptr, arg2);
910 long mem_offset = value_as_long (arg1);
912 arg1 = value_from_pointer (target_type_ptr,
913 value_as_long (arg2) + mem_offset);
914 arg1 = value_ind (arg1);
918 error (_("Non-pointer-to-member value used in pointer-to-member "
921 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
923 /* Hair for method invocations. */
927 /* First, evaluate the structure into arg2. */
929 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
930 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
932 if (op == STRUCTOP_STRUCT)
934 /* If v is a variable in a register, and the user types
935 v.method (), this will produce an error, because v has no
938 A possible way around this would be to allocate a copy of
939 the variable on the stack, copy in the contents, call the
940 function, and copy out the contents. I.e. convert this
941 from call by reference to call by copy-return (or
942 whatever it's called). However, this does not work
943 because it is not the same: the method being called could
944 stash a copy of the address, and then future uses through
945 that address (after the method returns) would be expected
946 to use the variable itself, not some copy of it. */
947 arg2 = evaluate_subexp_for_address (exp, pos, noside);
951 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
953 /* Check to see if the operator '->' has been overloaded.
954 If the operator has been overloaded replace arg2 with the
955 value returned by the custom operator and continue
957 while (unop_user_defined_p (op, arg2))
959 struct value *value = NULL;
962 value = value_x_unop (arg2, op, noside);
965 CATCH (except, RETURN_MASK_ERROR)
967 if (except.error == NOT_FOUND_ERROR)
970 throw_exception (except);
977 /* Now, say which argument to start evaluating from. */
980 else if (op == OP_SCOPE
981 && overload_resolution
982 && (exp->language_defn->la_language == language_cplus))
984 /* Unpack it locally so we can properly handle overload
990 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
991 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
992 struct type *type = exp->elts[pc2 + 1].type;
993 name = &exp->elts[pc2 + 3].string;
996 function_name = NULL;
997 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
999 function = cp_lookup_symbol_namespace (TYPE_NAME (type),
1001 get_selected_block (0),
1003 if (function == NULL)
1004 error (_("No symbol \"%s\" in namespace \"%s\"."),
1005 name, TYPE_NAME (type));
1008 /* arg2 is left as NULL on purpose. */
1012 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1013 || TYPE_CODE (type) == TYPE_CODE_UNION);
1014 function_name = name;
1016 /* We need a properly typed value for method lookup. For
1017 static methods arg2 is otherwise unused. */
1018 arg2 = value_zero (type, lval_memory);
1023 else if (op == OP_ADL_FUNC)
1025 /* Save the function position and move pos so that the arguments
1026 can be evaluated. */
1032 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1033 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1037 /* Non-method function call. */
1041 /* If this is a C++ function wait until overload resolution. */
1042 if (op == OP_VAR_VALUE
1043 && overload_resolution
1044 && (exp->language_defn->la_language == language_cplus))
1046 (*pos) += 4; /* Skip the evaluation of the symbol. */
1051 if (op == OP_VAR_MSYM_VALUE)
1053 minimal_symbol *msym = exp->elts[*pos + 2].msymbol;
1054 var_func_name = MSYMBOL_PRINT_NAME (msym);
1056 else if (op == OP_VAR_VALUE)
1058 symbol *sym = exp->elts[*pos + 2].symbol;
1059 var_func_name = SYMBOL_PRINT_NAME (sym);
1062 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1063 type *type = value_type (argvec[0]);
1064 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1065 type = TYPE_TARGET_TYPE (type);
1066 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1068 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1070 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1078 /* Evaluate arguments (if not already done, e.g., namespace::func()
1079 and overload-resolution is off). */
1080 for (; tem <= nargs; tem++)
1082 /* Ensure that array expressions are coerced into pointer
1084 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1087 /* Signal end of arglist. */
1090 if (noside == EVAL_SKIP)
1091 return eval_skip_value (exp);
1093 if (op == OP_ADL_FUNC)
1095 struct symbol *symp;
1098 int string_pc = save_pos1 + 3;
1100 /* Extract the function name. */
1101 name_len = longest_to_int (exp->elts[string_pc].longconst);
1102 func_name = (char *) alloca (name_len + 1);
1103 strcpy (func_name, &exp->elts[string_pc + 1].string);
1105 find_overload_match (gdb::make_array_view (&argvec[1], nargs),
1107 NON_METHOD, /* not method */
1108 NULL, NULL, /* pass NULL symbol since
1109 symbol is unknown */
1110 NULL, &symp, NULL, 0, noside);
1112 /* Now fix the expression being evaluated. */
1113 exp->elts[save_pos1 + 2].symbol = symp;
1114 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1117 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1118 || (op == OP_SCOPE && function_name != NULL))
1120 int static_memfuncp;
1123 /* Method invocation: stuff "this" as first parameter. If the
1124 method turns out to be static we undo this below. */
1129 /* Name of method from expression. */
1130 tstr = &exp->elts[pc2 + 2].string;
1133 tstr = function_name;
1135 if (overload_resolution && (exp->language_defn->la_language
1138 /* Language is C++, do some overload resolution before
1140 struct value *valp = NULL;
1142 (void) find_overload_match (gdb::make_array_view (&argvec[1], nargs),
1144 METHOD, /* method */
1145 &arg2, /* the object */
1147 &static_memfuncp, 0, noside);
1149 if (op == OP_SCOPE && !static_memfuncp)
1151 /* For the time being, we don't handle this. */
1152 error (_("Call to overloaded function %s requires "
1156 argvec[1] = arg2; /* the ``this'' pointer */
1157 argvec[0] = valp; /* Use the method found after overload
1161 /* Non-C++ case -- or no overload resolution. */
1163 struct value *temp = arg2;
1165 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1167 op == STRUCTOP_STRUCT
1168 ? "structure" : "structure pointer");
1169 /* value_struct_elt updates temp with the correct value of
1170 the ``this'' pointer if necessary, so modify argvec[1] to
1171 reflect any ``this'' changes. */
1173 = value_from_longest (lookup_pointer_type(value_type (temp)),
1174 value_address (temp)
1175 + value_embedded_offset (temp));
1176 argvec[1] = arg2; /* the ``this'' pointer */
1179 /* Take out `this' if needed. */
1180 if (static_memfuncp)
1182 argvec[1] = argvec[0];
1187 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1189 /* Pointer to member. argvec[1] is already set up. */
1192 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1194 /* Non-member function being called. */
1195 /* fn: This can only be done for C++ functions. A C-style
1196 function in a C++ program, for instance, does not have the
1197 fields that are expected here. */
1199 if (overload_resolution && (exp->language_defn->la_language
1202 /* Language is C++, do some overload resolution before
1204 struct symbol *symp;
1207 /* If a scope has been specified disable ADL. */
1211 if (op == OP_VAR_VALUE)
1212 function = exp->elts[save_pos1+2].symbol;
1214 (void) find_overload_match (gdb::make_array_view (&argvec[1], nargs),
1215 NULL, /* no need for name */
1216 NON_METHOD, /* not method */
1217 NULL, function, /* the function */
1218 NULL, &symp, NULL, no_adl, noside);
1220 if (op == OP_VAR_VALUE)
1222 /* Now fix the expression being evaluated. */
1223 exp->elts[save_pos1+2].symbol = symp;
1224 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1228 argvec[0] = value_of_variable (symp, get_selected_block (0));
1232 /* Not C++, or no overload resolution allowed. */
1233 /* Nothing to be done; argvec already correctly set up. */
1238 /* It is probably a C-style function. */
1239 /* Nothing to be done; argvec already correctly set up. */
1242 return eval_call (exp, noside, nargs, argvec, var_func_name, expect_type);
1245 /* Helper for skipping all the arguments in an undetermined argument list.
1246 This function was designed for use in the OP_F77_UNDETERMINED_ARGLIST
1247 case of evaluate_subexp_standard as multiple, but not all, code paths
1248 require a generic skip. */
1251 skip_undetermined_arglist (int nargs, struct expression *exp, int *pos,
1254 for (int i = 0; i < nargs; ++i)
1255 evaluate_subexp (NULL_TYPE, exp, pos, noside);
1259 evaluate_subexp_standard (struct type *expect_type,
1260 struct expression *exp, int *pos,
1264 int tem, tem2, tem3;
1266 struct value *arg1 = NULL;
1267 struct value *arg2 = NULL;
1271 struct value **argvec;
1275 struct type **arg_types;
1278 op = exp->elts[pc].opcode;
1283 tem = longest_to_int (exp->elts[pc + 2].longconst);
1284 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
1285 if (noside == EVAL_SKIP)
1286 return eval_skip_value (exp);
1287 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
1288 &exp->elts[pc + 3].string,
1289 expect_type, 0, noside);
1291 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
1296 return value_from_longest (exp->elts[pc + 1].type,
1297 exp->elts[pc + 2].longconst);
1301 return value_from_contents (exp->elts[pc + 1].type,
1302 exp->elts[pc + 2].floatconst);
1308 symbol *var = exp->elts[pc + 2].symbol;
1309 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR)
1310 error_unknown_type (SYMBOL_PRINT_NAME (var));
1311 if (noside != EVAL_SKIP)
1312 return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
1315 /* Return a dummy value of the correct type when skipping, so
1316 that parent functions know what is to be skipped. */
1317 return allocate_value (SYMBOL_TYPE (var));
1321 case OP_VAR_MSYM_VALUE:
1325 minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
1326 value *val = evaluate_var_msym_value (noside,
1327 exp->elts[pc + 1].objfile,
1330 type = value_type (val);
1331 if (TYPE_CODE (type) == TYPE_CODE_ERROR
1332 && (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0))
1333 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
1337 case OP_VAR_ENTRY_VALUE:
1339 if (noside == EVAL_SKIP)
1340 return eval_skip_value (exp);
1343 struct symbol *sym = exp->elts[pc + 1].symbol;
1344 struct frame_info *frame;
1346 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1347 return value_zero (SYMBOL_TYPE (sym), not_lval);
1349 if (SYMBOL_COMPUTED_OPS (sym) == NULL
1350 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
1351 error (_("Symbol \"%s\" does not have any specific entry value"),
1352 SYMBOL_PRINT_NAME (sym));
1354 frame = get_selected_frame (NULL);
1355 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
1358 case OP_FUNC_STATIC_VAR:
1359 tem = longest_to_int (exp->elts[pc + 1].longconst);
1360 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1361 if (noside == EVAL_SKIP)
1362 return eval_skip_value (exp);
1365 value *func = evaluate_subexp_standard (NULL, exp, pos, noside);
1366 CORE_ADDR addr = value_address (func);
1368 const block *blk = block_for_pc (addr);
1369 const char *var = &exp->elts[pc + 2].string;
1371 struct block_symbol sym = lookup_symbol (var, blk, VAR_DOMAIN, NULL);
1373 if (sym.symbol == NULL)
1374 error (_("No symbol \"%s\" in specified context."), var);
1376 return evaluate_var_value (noside, sym.block, sym.symbol);
1382 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
1386 const char *name = &exp->elts[pc + 2].string;
1390 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
1391 regno = user_reg_map_name_to_regnum (exp->gdbarch,
1392 name, strlen (name));
1394 error (_("Register $%s not available."), name);
1396 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1397 a value with the appropriate register type. Unfortunately,
1398 we don't have easy access to the type of user registers.
1399 So for these registers, we fetch the register value regardless
1400 of the evaluation mode. */
1401 if (noside == EVAL_AVOID_SIDE_EFFECTS
1402 && regno < gdbarch_num_cooked_regs (exp->gdbarch))
1403 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
1405 val = value_of_register (regno, get_selected_frame (NULL));
1407 error (_("Value of register %s not available."), name);
1413 type = language_bool_type (exp->language_defn, exp->gdbarch);
1414 return value_from_longest (type, exp->elts[pc + 1].longconst);
1416 case OP_INTERNALVAR:
1418 return value_of_internalvar (exp->gdbarch,
1419 exp->elts[pc + 1].internalvar);
1422 tem = longest_to_int (exp->elts[pc + 1].longconst);
1423 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1424 if (noside == EVAL_SKIP)
1425 return eval_skip_value (exp);
1426 type = language_string_char_type (exp->language_defn, exp->gdbarch);
1427 return value_string (&exp->elts[pc + 2].string, tem, type);
1429 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
1430 NSString constant. */
1431 tem = longest_to_int (exp->elts[pc + 1].longconst);
1432 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1433 if (noside == EVAL_SKIP)
1434 return eval_skip_value (exp);
1435 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
1439 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
1440 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
1441 nargs = tem3 - tem2 + 1;
1442 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
1444 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1445 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
1447 struct value *rec = allocate_value (expect_type);
1449 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
1450 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
1453 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1454 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
1456 struct type *range_type = TYPE_INDEX_TYPE (type);
1457 struct type *element_type = TYPE_TARGET_TYPE (type);
1458 struct value *array = allocate_value (expect_type);
1459 int element_size = TYPE_LENGTH (check_typedef (element_type));
1460 LONGEST low_bound, high_bound, index;
1462 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
1465 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
1468 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
1469 for (tem = nargs; --nargs >= 0;)
1471 struct value *element;
1474 element = evaluate_subexp (element_type, exp, pos, noside);
1475 if (value_type (element) != element_type)
1476 element = value_cast (element_type, element);
1479 int continue_pc = *pos;
1482 index = init_array_element (array, element, exp, pos, noside,
1483 low_bound, high_bound);
1488 if (index > high_bound)
1489 /* To avoid memory corruption. */
1490 error (_("Too many array elements"));
1491 memcpy (value_contents_raw (array)
1492 + (index - low_bound) * element_size,
1493 value_contents (element),
1501 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1502 && TYPE_CODE (type) == TYPE_CODE_SET)
1504 struct value *set = allocate_value (expect_type);
1505 gdb_byte *valaddr = value_contents_raw (set);
1506 struct type *element_type = TYPE_INDEX_TYPE (type);
1507 struct type *check_type = element_type;
1508 LONGEST low_bound, high_bound;
1510 /* Get targettype of elementtype. */
1511 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
1512 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
1513 check_type = TYPE_TARGET_TYPE (check_type);
1515 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
1516 error (_("(power)set type with unknown size"));
1517 memset (valaddr, '\0', TYPE_LENGTH (type));
1518 for (tem = 0; tem < nargs; tem++)
1520 LONGEST range_low, range_high;
1521 struct type *range_low_type, *range_high_type;
1522 struct value *elem_val;
1524 elem_val = evaluate_subexp (element_type, exp, pos, noside);
1525 range_low_type = range_high_type = value_type (elem_val);
1526 range_low = range_high = value_as_long (elem_val);
1528 /* Check types of elements to avoid mixture of elements from
1529 different types. Also check if type of element is "compatible"
1530 with element type of powerset. */
1531 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
1532 range_low_type = TYPE_TARGET_TYPE (range_low_type);
1533 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
1534 range_high_type = TYPE_TARGET_TYPE (range_high_type);
1535 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
1536 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
1537 && (range_low_type != range_high_type)))
1538 /* different element modes. */
1539 error (_("POWERSET tuple elements of different mode"));
1540 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
1541 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
1542 && range_low_type != check_type))
1543 error (_("incompatible POWERSET tuple elements"));
1544 if (range_low > range_high)
1546 warning (_("empty POWERSET tuple range"));
1549 if (range_low < low_bound || range_high > high_bound)
1550 error (_("POWERSET tuple element out of range"));
1551 range_low -= low_bound;
1552 range_high -= low_bound;
1553 for (; range_low <= range_high; range_low++)
1555 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
1557 if (gdbarch_bits_big_endian (exp->gdbarch))
1558 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
1559 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1566 argvec = XALLOCAVEC (struct value *, nargs);
1567 for (tem = 0; tem < nargs; tem++)
1569 /* Ensure that array expressions are coerced into pointer
1571 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1573 if (noside == EVAL_SKIP)
1574 return eval_skip_value (exp);
1575 return value_array (tem2, tem3, argvec);
1579 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1581 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1583 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1585 if (noside == EVAL_SKIP)
1586 return eval_skip_value (exp);
1587 return value_slice (array, lowbound, upper - lowbound + 1);
1591 /* Skip third and second args to evaluate the first one. */
1592 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1593 if (value_logical_not (arg1))
1595 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1596 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1600 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1601 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1605 case OP_OBJC_SELECTOR:
1606 { /* Objective C @selector operator. */
1607 char *sel = &exp->elts[pc + 2].string;
1608 int len = longest_to_int (exp->elts[pc + 1].longconst);
1609 struct type *selector_type;
1611 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1612 if (noside == EVAL_SKIP)
1613 return eval_skip_value (exp);
1616 sel[len] = 0; /* Make sure it's terminated. */
1618 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1619 return value_from_longest (selector_type,
1620 lookup_child_selector (exp->gdbarch, sel));
1623 case OP_OBJC_MSGCALL:
1624 { /* Objective C message (method) call. */
1626 CORE_ADDR responds_selector = 0;
1627 CORE_ADDR method_selector = 0;
1629 CORE_ADDR selector = 0;
1631 int struct_return = 0;
1632 enum noside sub_no_side = EVAL_NORMAL;
1634 struct value *msg_send = NULL;
1635 struct value *msg_send_stret = NULL;
1636 int gnu_runtime = 0;
1638 struct value *target = NULL;
1639 struct value *method = NULL;
1640 struct value *called_method = NULL;
1642 struct type *selector_type = NULL;
1643 struct type *long_type;
1645 struct value *ret = NULL;
1648 selector = exp->elts[pc + 1].longconst;
1649 nargs = exp->elts[pc + 2].longconst;
1650 argvec = XALLOCAVEC (struct value *, nargs + 5);
1654 long_type = builtin_type (exp->gdbarch)->builtin_long;
1655 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1657 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1658 sub_no_side = EVAL_NORMAL;
1660 sub_no_side = noside;
1662 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1664 if (value_as_long (target) == 0)
1665 return value_from_longest (long_type, 0);
1667 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
1670 /* Find the method dispatch (Apple runtime) or method lookup
1671 (GNU runtime) function for Objective-C. These will be used
1672 to lookup the symbol information for the method. If we
1673 can't find any symbol information, then we'll use these to
1674 call the method, otherwise we can call the method
1675 directly. The msg_send_stret function is used in the special
1676 case of a method that returns a structure (Apple runtime
1680 type = selector_type;
1682 type = lookup_function_type (type);
1683 type = lookup_pointer_type (type);
1684 type = lookup_function_type (type);
1685 type = lookup_pointer_type (type);
1687 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1689 = find_function_in_inferior ("objc_msg_lookup", NULL);
1691 msg_send = value_from_pointer (type, value_as_address (msg_send));
1692 msg_send_stret = value_from_pointer (type,
1693 value_as_address (msg_send_stret));
1697 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1698 /* Special dispatcher for methods returning structs. */
1700 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1703 /* Verify the target object responds to this method. The
1704 standard top-level 'Object' class uses a different name for
1705 the verification method than the non-standard, but more
1706 often used, 'NSObject' class. Make sure we check for both. */
1709 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1710 if (responds_selector == 0)
1712 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1714 if (responds_selector == 0)
1715 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1718 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1719 if (method_selector == 0)
1721 = lookup_child_selector (exp->gdbarch, "methodFor:");
1723 if (method_selector == 0)
1724 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1726 /* Call the verification method, to make sure that the target
1727 class implements the desired method. */
1729 argvec[0] = msg_send;
1731 argvec[2] = value_from_longest (long_type, responds_selector);
1732 argvec[3] = value_from_longest (long_type, selector);
1735 ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
1738 /* Function objc_msg_lookup returns a pointer. */
1740 ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
1742 if (value_as_long (ret) == 0)
1743 error (_("Target does not respond to this message selector."));
1745 /* Call "methodForSelector:" method, to get the address of a
1746 function method that implements this selector for this
1747 class. If we can find a symbol at that address, then we
1748 know the return type, parameter types etc. (that's a good
1751 argvec[0] = msg_send;
1753 argvec[2] = value_from_longest (long_type, method_selector);
1754 argvec[3] = value_from_longest (long_type, selector);
1757 ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
1761 ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
1764 /* ret should now be the selector. */
1766 addr = value_as_long (ret);
1769 struct symbol *sym = NULL;
1771 /* The address might point to a function descriptor;
1772 resolve it to the actual code address instead. */
1773 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1774 current_top_target ());
1776 /* Is it a high_level symbol? */
1777 sym = find_pc_function (addr);
1779 method = value_of_variable (sym, 0);
1782 /* If we found a method with symbol information, check to see
1783 if it returns a struct. Otherwise assume it doesn't. */
1788 struct type *val_type;
1790 funaddr = find_function_addr (method, &val_type);
1792 block_for_pc (funaddr);
1794 val_type = check_typedef (val_type);
1796 if ((val_type == NULL)
1797 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1799 if (expect_type != NULL)
1800 val_type = expect_type;
1803 struct_return = using_struct_return (exp->gdbarch, method,
1806 else if (expect_type != NULL)
1808 struct_return = using_struct_return (exp->gdbarch, NULL,
1809 check_typedef (expect_type));
1812 /* Found a function symbol. Now we will substitute its
1813 value in place of the message dispatcher (obj_msgSend),
1814 so that we call the method directly instead of thru
1815 the dispatcher. The main reason for doing this is that
1816 we can now evaluate the return value and parameter values
1817 according to their known data types, in case we need to
1818 do things like promotion, dereferencing, special handling
1819 of structs and doubles, etc.
1821 We want to use the type signature of 'method', but still
1822 jump to objc_msgSend() or objc_msgSend_stret() to better
1823 mimic the behavior of the runtime. */
1827 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1828 error (_("method address has symbol information "
1829 "with non-function type; skipping"));
1831 /* Create a function pointer of the appropriate type, and
1832 replace its value with the value of msg_send or
1833 msg_send_stret. We must use a pointer here, as
1834 msg_send and msg_send_stret are of pointer type, and
1835 the representation may be different on systems that use
1836 function descriptors. */
1839 = value_from_pointer (lookup_pointer_type (value_type (method)),
1840 value_as_address (msg_send_stret));
1843 = value_from_pointer (lookup_pointer_type (value_type (method)),
1844 value_as_address (msg_send));
1849 called_method = msg_send_stret;
1851 called_method = msg_send;
1854 if (noside == EVAL_SKIP)
1855 return eval_skip_value (exp);
1857 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1859 /* If the return type doesn't look like a function type,
1860 call an error. This can happen if somebody tries to
1861 turn a variable into a function call. This is here
1862 because people often want to call, eg, strcmp, which
1863 gdb doesn't know is a function. If gdb isn't asked for
1864 it's opinion (ie. through "whatis"), it won't offer
1867 struct type *callee_type = value_type (called_method);
1869 if (callee_type && TYPE_CODE (callee_type) == TYPE_CODE_PTR)
1870 callee_type = TYPE_TARGET_TYPE (callee_type);
1871 callee_type = TYPE_TARGET_TYPE (callee_type);
1875 if ((TYPE_CODE (callee_type) == TYPE_CODE_ERROR) && expect_type)
1876 return allocate_value (expect_type);
1878 return allocate_value (callee_type);
1881 error (_("Expression of type other than "
1882 "\"method returning ...\" used as a method"));
1885 /* Now depending on whether we found a symbol for the method,
1886 we will either call the runtime dispatcher or the method
1889 argvec[0] = called_method;
1891 argvec[2] = value_from_longest (long_type, selector);
1892 /* User-supplied arguments. */
1893 for (tem = 0; tem < nargs; tem++)
1894 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1895 argvec[tem + 3] = 0;
1897 auto call_args = gdb::make_array_view (argvec + 1, nargs + 2);
1899 if (gnu_runtime && (method != NULL))
1901 /* Function objc_msg_lookup returns a pointer. */
1902 deprecated_set_value_type (argvec[0],
1903 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1904 argvec[0] = call_function_by_hand (argvec[0], NULL, call_args);
1907 return call_function_by_hand (argvec[0], NULL, call_args);
1912 return evaluate_funcall (expect_type, exp, pos, noside);
1914 case OP_F77_UNDETERMINED_ARGLIST:
1916 /* Remember that in F77, functions, substring ops and
1917 array subscript operations cannot be disambiguated
1918 at parse time. We have made all array subscript operations,
1919 substring operations as well as function calls come here
1920 and we now have to discover what the heck this thing actually was.
1921 If it is a function, we process just as if we got an OP_FUNCALL. */
1923 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1926 /* First determine the type code we are dealing with. */
1927 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1928 type = check_typedef (value_type (arg1));
1929 code = TYPE_CODE (type);
1931 if (code == TYPE_CODE_PTR)
1933 /* Fortran always passes variable to subroutines as pointer.
1934 So we need to look into its target type to see if it is
1935 array, string or function. If it is, we need to switch
1936 to the target value the original one points to. */
1937 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1939 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1940 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1941 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1943 arg1 = value_ind (arg1);
1944 type = check_typedef (value_type (arg1));
1945 code = TYPE_CODE (type);
1951 case TYPE_CODE_ARRAY:
1952 if (exp->elts[*pos].opcode == OP_RANGE)
1953 return value_f90_subarray (arg1, exp, pos, noside);
1956 if (noside == EVAL_SKIP)
1958 skip_undetermined_arglist (nargs, exp, pos, noside);
1959 /* Return the dummy value with the correct type. */
1962 goto multi_f77_subscript;
1965 case TYPE_CODE_STRING:
1966 if (exp->elts[*pos].opcode == OP_RANGE)
1967 return value_f90_subarray (arg1, exp, pos, noside);
1970 if (noside == EVAL_SKIP)
1972 skip_undetermined_arglist (nargs, exp, pos, noside);
1973 /* Return the dummy value with the correct type. */
1976 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1977 return value_subscript (arg1, value_as_long (arg2));
1981 case TYPE_CODE_FUNC:
1982 case TYPE_CODE_INTERNAL_FUNCTION:
1983 /* It's a function call. */
1984 /* Allocate arg vector, including space for the function to be
1985 called in argvec[0] and a terminating NULL. */
1986 argvec = (struct value **)
1987 alloca (sizeof (struct value *) * (nargs + 2));
1990 for (; tem <= nargs; tem++)
1992 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1993 /* Arguments in Fortran are passed by address. Coerce the
1994 arguments here rather than in value_arg_coerce as otherwise
1995 the call to malloc to place the non-lvalue parameters in
1996 target memory is hit by this Fortran specific logic. This
1997 results in malloc being called with a pointer to an integer
1998 followed by an attempt to malloc the arguments to malloc in
1999 target memory. Infinite recursion ensues. */
2000 if (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC)
2003 = TYPE_FIELD_ARTIFICIAL (value_type (arg1), tem - 1);
2004 argvec[tem] = fortran_argument_convert (argvec[tem],
2008 argvec[tem] = 0; /* signal end of arglist */
2009 if (noside == EVAL_SKIP)
2010 return eval_skip_value (exp);
2011 return eval_call (exp, noside, nargs, argvec, NULL, expect_type);
2014 error (_("Cannot perform substring on this type"));
2018 /* We have a complex number, There should be 2 floating
2019 point numbers that compose it. */
2021 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2022 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2024 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
2026 case STRUCTOP_STRUCT:
2027 tem = longest_to_int (exp->elts[pc + 1].longconst);
2028 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
2029 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2030 if (noside == EVAL_SKIP)
2031 return eval_skip_value (exp);
2032 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
2034 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2035 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
2039 tem = longest_to_int (exp->elts[pc + 1].longconst);
2040 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
2041 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2042 if (noside == EVAL_SKIP)
2043 return eval_skip_value (exp);
2045 /* Check to see if operator '->' has been overloaded. If so replace
2046 arg1 with the value returned by evaluating operator->(). */
2047 while (unop_user_defined_p (op, arg1))
2049 struct value *value = NULL;
2052 value = value_x_unop (arg1, op, noside);
2055 CATCH (except, RETURN_MASK_ERROR)
2057 if (except.error == NOT_FOUND_ERROR)
2060 throw_exception (except);
2067 /* JYG: if print object is on we need to replace the base type
2068 with rtti type in order to continue on with successful
2069 lookup of member / method only available in the rtti type. */
2071 struct type *arg_type = value_type (arg1);
2072 struct type *real_type;
2073 int full, using_enc;
2075 struct value_print_options opts;
2077 get_user_print_options (&opts);
2078 if (opts.objectprint && TYPE_TARGET_TYPE (arg_type)
2079 && (TYPE_CODE (TYPE_TARGET_TYPE (arg_type)) == TYPE_CODE_STRUCT))
2081 real_type = value_rtti_indirect_type (arg1, &full, &top,
2084 arg1 = value_cast (real_type, arg1);
2088 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
2089 NULL, "structure pointer");
2090 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2091 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
2094 case STRUCTOP_MEMBER:
2096 if (op == STRUCTOP_MEMBER)
2097 arg1 = evaluate_subexp_for_address (exp, pos, noside);
2099 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2101 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2103 if (noside == EVAL_SKIP)
2104 return eval_skip_value (exp);
2106 type = check_typedef (value_type (arg2));
2107 switch (TYPE_CODE (type))
2109 case TYPE_CODE_METHODPTR:
2110 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2111 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
2114 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
2115 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
2116 return value_ind (arg2);
2119 case TYPE_CODE_MEMBERPTR:
2120 /* Now, convert these values to an address. */
2121 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
2124 mem_offset = value_as_long (arg2);
2126 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2127 value_as_long (arg1) + mem_offset);
2128 return value_ind (arg3);
2131 error (_("non-pointer-to-member value used "
2132 "in pointer-to-member construct"));
2137 type_instance_flags flags
2138 = (type_instance_flag_value) longest_to_int (exp->elts[pc + 1].longconst);
2139 nargs = longest_to_int (exp->elts[pc + 2].longconst);
2140 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
2141 for (ix = 0; ix < nargs; ++ix)
2142 arg_types[ix] = exp->elts[pc + 2 + ix + 1].type;
2144 fake_method fake_expect_type (flags, nargs, arg_types);
2145 *(pos) += 4 + nargs;
2146 return evaluate_subexp_standard (fake_expect_type.type (), exp, pos,
2151 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2152 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2153 if (noside == EVAL_SKIP)
2154 return eval_skip_value (exp);
2155 if (binop_user_defined_p (op, arg1, arg2))
2156 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2158 return value_concat (arg1, arg2);
2161 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2162 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2164 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2166 if (binop_user_defined_p (op, arg1, arg2))
2167 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2169 return value_assign (arg1, arg2);
2171 case BINOP_ASSIGN_MODIFY:
2173 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2174 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2175 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2177 op = exp->elts[pc + 1].opcode;
2178 if (binop_user_defined_p (op, arg1, arg2))
2179 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
2180 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2182 && is_integral_type (value_type (arg2)))
2183 arg2 = value_ptradd (arg1, value_as_long (arg2));
2184 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2186 && is_integral_type (value_type (arg2)))
2187 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2190 struct value *tmp = arg1;
2192 /* For shift and integer exponentiation operations,
2193 only promote the first argument. */
2194 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2195 && is_integral_type (value_type (arg2)))
2196 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2198 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2200 arg2 = value_binop (tmp, arg2, op);
2202 return value_assign (arg1, arg2);
2205 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2206 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2207 if (noside == EVAL_SKIP)
2208 return eval_skip_value (exp);
2209 if (binop_user_defined_p (op, arg1, arg2))
2210 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2211 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2212 && is_integral_type (value_type (arg2)))
2213 return value_ptradd (arg1, value_as_long (arg2));
2214 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2215 && is_integral_type (value_type (arg1)))
2216 return value_ptradd (arg2, value_as_long (arg1));
2219 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2220 return value_binop (arg1, arg2, BINOP_ADD);
2224 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2225 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2226 if (noside == EVAL_SKIP)
2227 return eval_skip_value (exp);
2228 if (binop_user_defined_p (op, arg1, arg2))
2229 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2230 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2231 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2233 /* FIXME -- should be ptrdiff_t */
2234 type = builtin_type (exp->gdbarch)->builtin_long;
2235 return value_from_longest (type, value_ptrdiff (arg1, arg2));
2237 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2238 && is_integral_type (value_type (arg2)))
2239 return value_ptradd (arg1, - value_as_long (arg2));
2242 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2243 return value_binop (arg1, arg2, BINOP_SUB);
2254 case BINOP_BITWISE_AND:
2255 case BINOP_BITWISE_IOR:
2256 case BINOP_BITWISE_XOR:
2257 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2258 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2259 if (noside == EVAL_SKIP)
2260 return eval_skip_value (exp);
2261 if (binop_user_defined_p (op, arg1, arg2))
2262 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2265 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2266 fudge arg2 to avoid division-by-zero, the caller is
2267 (theoretically) only looking for the type of the result. */
2268 if (noside == EVAL_AVOID_SIDE_EFFECTS
2269 /* ??? Do we really want to test for BINOP_MOD here?
2270 The implementation of value_binop gives it a well-defined
2273 || op == BINOP_INTDIV
2276 && value_logical_not (arg2))
2278 struct value *v_one, *retval;
2280 v_one = value_one (value_type (arg2));
2281 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2282 retval = value_binop (arg1, v_one, op);
2287 /* For shift and integer exponentiation operations,
2288 only promote the first argument. */
2289 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2290 && is_integral_type (value_type (arg2)))
2291 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2293 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2295 return value_binop (arg1, arg2, op);
2299 case BINOP_SUBSCRIPT:
2300 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2301 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2302 if (noside == EVAL_SKIP)
2303 return eval_skip_value (exp);
2304 if (binop_user_defined_p (op, arg1, arg2))
2305 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2308 /* If the user attempts to subscript something that is not an
2309 array or pointer type (like a plain int variable for example),
2310 then report this as an error. */
2312 arg1 = coerce_ref (arg1);
2313 type = check_typedef (value_type (arg1));
2314 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2315 && TYPE_CODE (type) != TYPE_CODE_PTR)
2317 if (TYPE_NAME (type))
2318 error (_("cannot subscript something of type `%s'"),
2321 error (_("cannot subscript requested type"));
2324 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2325 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2327 return value_subscript (arg1, value_as_long (arg2));
2329 case MULTI_SUBSCRIPT:
2331 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2332 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2335 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2336 /* FIXME: EVAL_SKIP handling may not be correct. */
2337 if (noside == EVAL_SKIP)
2341 return eval_skip_value (exp);
2343 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2344 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2346 /* If the user attempts to subscript something that has no target
2347 type (like a plain int variable for example), then report this
2350 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2353 arg1 = value_zero (type, VALUE_LVAL (arg1));
2359 error (_("cannot subscript something of type `%s'"),
2360 TYPE_NAME (value_type (arg1)));
2364 if (binop_user_defined_p (op, arg1, arg2))
2366 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2370 arg1 = coerce_ref (arg1);
2371 type = check_typedef (value_type (arg1));
2373 switch (TYPE_CODE (type))
2376 case TYPE_CODE_ARRAY:
2377 case TYPE_CODE_STRING:
2378 arg1 = value_subscript (arg1, value_as_long (arg2));
2382 if (TYPE_NAME (type))
2383 error (_("cannot subscript something of type `%s'"),
2386 error (_("cannot subscript requested type"));
2392 multi_f77_subscript:
2394 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2395 int ndimensions = 1, i;
2396 struct value *array = arg1;
2398 if (nargs > MAX_FORTRAN_DIMS)
2399 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2401 ndimensions = calc_f77_array_dims (type);
2403 if (nargs != ndimensions)
2404 error (_("Wrong number of subscripts"));
2406 gdb_assert (nargs > 0);
2408 /* Now that we know we have a legal array subscript expression
2409 let us actually find out where this element exists in the array. */
2411 /* Take array indices left to right. */
2412 for (i = 0; i < nargs; i++)
2414 /* Evaluate each subscript; it must be a legal integer in F77. */
2415 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2417 /* Fill in the subscript array. */
2419 subscript_array[i] = value_as_long (arg2);
2422 /* Internal type of array is arranged right to left. */
2423 for (i = nargs; i > 0; i--)
2425 struct type *array_type = check_typedef (value_type (array));
2426 LONGEST index = subscript_array[i - 1];
2428 array = value_subscripted_rvalue (array, index,
2429 f77_get_lowerbound (array_type));
2435 case BINOP_LOGICAL_AND:
2436 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2437 if (noside == EVAL_SKIP)
2439 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2440 return eval_skip_value (exp);
2444 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2447 if (binop_user_defined_p (op, arg1, arg2))
2449 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2450 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2454 tem = value_logical_not (arg1);
2455 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2456 (tem ? EVAL_SKIP : noside));
2457 type = language_bool_type (exp->language_defn, exp->gdbarch);
2458 return value_from_longest (type,
2459 (LONGEST) (!tem && !value_logical_not (arg2)));
2462 case BINOP_LOGICAL_OR:
2463 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2464 if (noside == EVAL_SKIP)
2466 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2467 return eval_skip_value (exp);
2471 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2474 if (binop_user_defined_p (op, arg1, arg2))
2476 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2477 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2481 tem = value_logical_not (arg1);
2482 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2483 (!tem ? EVAL_SKIP : noside));
2484 type = language_bool_type (exp->language_defn, exp->gdbarch);
2485 return value_from_longest (type,
2486 (LONGEST) (!tem || !value_logical_not (arg2)));
2490 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2491 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2492 if (noside == EVAL_SKIP)
2493 return eval_skip_value (exp);
2494 if (binop_user_defined_p (op, arg1, arg2))
2496 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2500 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2501 tem = value_equal (arg1, arg2);
2502 type = language_bool_type (exp->language_defn, exp->gdbarch);
2503 return value_from_longest (type, (LONGEST) tem);
2506 case BINOP_NOTEQUAL:
2507 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2508 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2509 if (noside == EVAL_SKIP)
2510 return eval_skip_value (exp);
2511 if (binop_user_defined_p (op, arg1, arg2))
2513 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2517 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2518 tem = value_equal (arg1, arg2);
2519 type = language_bool_type (exp->language_defn, exp->gdbarch);
2520 return value_from_longest (type, (LONGEST) ! tem);
2524 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2525 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2526 if (noside == EVAL_SKIP)
2527 return eval_skip_value (exp);
2528 if (binop_user_defined_p (op, arg1, arg2))
2530 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2534 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2535 tem = value_less (arg1, arg2);
2536 type = language_bool_type (exp->language_defn, exp->gdbarch);
2537 return value_from_longest (type, (LONGEST) tem);
2541 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2542 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2543 if (noside == EVAL_SKIP)
2544 return eval_skip_value (exp);
2545 if (binop_user_defined_p (op, arg1, arg2))
2547 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2551 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2552 tem = value_less (arg2, arg1);
2553 type = language_bool_type (exp->language_defn, exp->gdbarch);
2554 return value_from_longest (type, (LONGEST) tem);
2558 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2559 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2560 if (noside == EVAL_SKIP)
2561 return eval_skip_value (exp);
2562 if (binop_user_defined_p (op, arg1, arg2))
2564 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2568 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2569 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2570 type = language_bool_type (exp->language_defn, exp->gdbarch);
2571 return value_from_longest (type, (LONGEST) tem);
2575 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2576 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2577 if (noside == EVAL_SKIP)
2578 return eval_skip_value (exp);
2579 if (binop_user_defined_p (op, arg1, arg2))
2581 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2585 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2586 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2587 type = language_bool_type (exp->language_defn, exp->gdbarch);
2588 return value_from_longest (type, (LONGEST) tem);
2592 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2593 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2594 if (noside == EVAL_SKIP)
2595 return eval_skip_value (exp);
2596 type = check_typedef (value_type (arg2));
2597 if (TYPE_CODE (type) != TYPE_CODE_INT
2598 && TYPE_CODE (type) != TYPE_CODE_ENUM)
2599 error (_("Non-integral right operand for \"@\" operator."));
2600 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2602 return allocate_repeat_value (value_type (arg1),
2603 longest_to_int (value_as_long (arg2)));
2606 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2609 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2610 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2613 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2614 if (noside == EVAL_SKIP)
2615 return eval_skip_value (exp);
2616 if (unop_user_defined_p (op, arg1))
2617 return value_x_unop (arg1, op, noside);
2620 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2621 return value_pos (arg1);
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_neg (arg1);
2636 case UNOP_COMPLEMENT:
2637 /* C++: check for and handle destructor names. */
2639 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2640 if (noside == EVAL_SKIP)
2641 return eval_skip_value (exp);
2642 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2643 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2646 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2647 return value_complement (arg1);
2650 case UNOP_LOGICAL_NOT:
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 (op, arg1))
2655 return value_x_unop (arg1, op, noside);
2658 type = language_bool_type (exp->language_defn, exp->gdbarch);
2659 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2663 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2664 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2665 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2666 type = check_typedef (value_type (arg1));
2667 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2668 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2669 error (_("Attempt to dereference pointer "
2670 "to member without an object"));
2671 if (noside == EVAL_SKIP)
2672 return eval_skip_value (exp);
2673 if (unop_user_defined_p (op, arg1))
2674 return value_x_unop (arg1, op, noside);
2675 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2677 type = check_typedef (value_type (arg1));
2678 if (TYPE_CODE (type) == TYPE_CODE_PTR
2679 || TYPE_IS_REFERENCE (type)
2680 /* In C you can dereference an array to get the 1st elt. */
2681 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2683 return value_zero (TYPE_TARGET_TYPE (type),
2685 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2686 /* GDB allows dereferencing an int. */
2687 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2690 error (_("Attempt to take contents of a non-pointer value."));
2693 /* Allow * on an integer so we can cast it to whatever we want.
2694 This returns an int, which seems like the most C-like thing to
2695 do. "long long" variables are rare enough that
2696 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2697 if (TYPE_CODE (type) == TYPE_CODE_INT)
2698 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2699 (CORE_ADDR) value_as_address (arg1));
2700 return value_ind (arg1);
2703 /* C++: check for and handle pointer to members. */
2705 if (noside == EVAL_SKIP)
2707 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2708 return eval_skip_value (exp);
2712 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2719 if (noside == EVAL_SKIP)
2721 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2722 return eval_skip_value (exp);
2724 return evaluate_subexp_for_sizeof (exp, pos, noside);
2728 type = value_type (evaluate_subexp (NULL_TYPE, exp, pos,
2729 EVAL_AVOID_SIDE_EFFECTS));
2730 /* FIXME: This should be size_t. */
2731 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
2732 ULONGEST align = type_align (type);
2734 error (_("could not determine alignment of type"));
2735 return value_from_longest (size_type, align);
2740 type = exp->elts[pc + 1].type;
2741 return evaluate_subexp_for_cast (exp, pos, noside, type);
2743 case UNOP_CAST_TYPE:
2744 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2745 type = value_type (arg1);
2746 return evaluate_subexp_for_cast (exp, pos, noside, type);
2748 case UNOP_DYNAMIC_CAST:
2749 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2750 type = value_type (arg1);
2751 arg1 = evaluate_subexp (type, exp, pos, noside);
2752 if (noside == EVAL_SKIP)
2753 return eval_skip_value (exp);
2754 return value_dynamic_cast (type, arg1);
2756 case UNOP_REINTERPRET_CAST:
2757 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2758 type = value_type (arg1);
2759 arg1 = evaluate_subexp (type, exp, pos, noside);
2760 if (noside == EVAL_SKIP)
2761 return eval_skip_value (exp);
2762 return value_reinterpret_cast (type, arg1);
2766 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2767 if (noside == EVAL_SKIP)
2768 return eval_skip_value (exp);
2769 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2770 return value_zero (exp->elts[pc + 1].type, lval_memory);
2772 return value_at_lazy (exp->elts[pc + 1].type,
2773 value_as_address (arg1));
2775 case UNOP_MEMVAL_TYPE:
2776 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2777 type = value_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 (type, lval_memory);
2784 return value_at_lazy (type, value_as_address (arg1));
2786 case UNOP_PREINCREMENT:
2787 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2788 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2790 else if (unop_user_defined_p (op, arg1))
2792 return value_x_unop (arg1, op, noside);
2796 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2797 arg2 = value_ptradd (arg1, 1);
2800 struct value *tmp = arg1;
2802 arg2 = value_one (value_type (arg1));
2803 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2804 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2807 return value_assign (arg1, arg2);
2810 case UNOP_PREDECREMENT:
2811 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2812 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2814 else if (unop_user_defined_p (op, arg1))
2816 return value_x_unop (arg1, op, noside);
2820 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2821 arg2 = value_ptradd (arg1, -1);
2824 struct value *tmp = arg1;
2826 arg2 = value_one (value_type (arg1));
2827 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2828 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2831 return value_assign (arg1, arg2);
2834 case UNOP_POSTINCREMENT:
2835 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2836 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2838 else if (unop_user_defined_p (op, arg1))
2840 return value_x_unop (arg1, op, noside);
2844 arg3 = value_non_lval (arg1);
2846 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2847 arg2 = value_ptradd (arg1, 1);
2850 struct value *tmp = arg1;
2852 arg2 = value_one (value_type (arg1));
2853 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2854 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2857 value_assign (arg1, arg2);
2861 case UNOP_POSTDECREMENT:
2862 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2863 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2865 else if (unop_user_defined_p (op, arg1))
2867 return value_x_unop (arg1, op, noside);
2871 arg3 = value_non_lval (arg1);
2873 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2874 arg2 = value_ptradd (arg1, -1);
2877 struct value *tmp = arg1;
2879 arg2 = value_one (value_type (arg1));
2880 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2881 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2884 value_assign (arg1, arg2);
2890 return value_of_this (exp->language_defn);
2893 /* The value is not supposed to be used. This is here to make it
2894 easier to accommodate expressions that contain types. */
2896 if (noside == EVAL_SKIP)
2897 return eval_skip_value (exp);
2898 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2899 return allocate_value (exp->elts[pc + 1].type);
2901 error (_("Attempt to use a type name as an expression"));
2905 if (noside == EVAL_SKIP)
2907 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2908 return eval_skip_value (exp);
2910 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2912 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2913 struct value *result;
2915 result = evaluate_subexp (NULL_TYPE, exp, pos,
2916 EVAL_AVOID_SIDE_EFFECTS);
2918 /* 'decltype' has special semantics for lvalues. */
2919 if (op == OP_DECLTYPE
2920 && (sub_op == BINOP_SUBSCRIPT
2921 || sub_op == STRUCTOP_MEMBER
2922 || sub_op == STRUCTOP_MPTR
2923 || sub_op == UNOP_IND
2924 || sub_op == STRUCTOP_STRUCT
2925 || sub_op == STRUCTOP_PTR
2926 || sub_op == OP_SCOPE))
2928 type = value_type (result);
2930 if (!TYPE_IS_REFERENCE (type))
2932 type = lookup_lvalue_reference_type (type);
2933 result = allocate_value (type);
2940 error (_("Attempt to use a type as an expression"));
2944 struct value *result;
2945 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2947 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2948 result = evaluate_subexp (NULL_TYPE, exp, pos,
2949 EVAL_AVOID_SIDE_EFFECTS);
2951 result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2953 if (noside != EVAL_NORMAL)
2954 return allocate_value (cplus_typeid_type (exp->gdbarch));
2956 return cplus_typeid (result);
2960 /* Removing this case and compiling with gcc -Wall reveals that
2961 a lot of cases are hitting this case. Some of these should
2962 probably be removed from expression.h; others are legitimate
2963 expressions which are (apparently) not fully implemented.
2965 If there are any cases landing here which mean a user error,
2966 then they should be separate cases, with more descriptive
2969 error (_("GDB does not (yet) know how to "
2970 "evaluate that kind of expression"));
2973 gdb_assert_not_reached ("missed return?");
2976 /* Evaluate a subexpression of EXP, at index *POS,
2977 and return the address of that subexpression.
2978 Advance *POS over the subexpression.
2979 If the subexpression isn't an lvalue, get an error.
2980 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2981 then only the type of the result need be correct. */
2983 static struct value *
2984 evaluate_subexp_for_address (struct expression *exp, int *pos,
2994 op = exp->elts[pc].opcode;
3000 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
3002 /* We can't optimize out "&*" if there's a user-defined operator*. */
3003 if (unop_user_defined_p (op, x))
3005 x = value_x_unop (x, op, noside);
3006 goto default_case_after_eval;
3009 return coerce_array (x);
3013 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
3014 evaluate_subexp (NULL_TYPE, exp, pos, noside));
3016 case UNOP_MEMVAL_TYPE:
3021 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3022 type = value_type (x);
3023 return value_cast (lookup_pointer_type (type),
3024 evaluate_subexp (NULL_TYPE, exp, pos, noside));
3028 var = exp->elts[pc + 2].symbol;
3030 /* C++: The "address" of a reference should yield the address
3031 * of the object pointed to. Let value_addr() deal with it. */
3032 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var)))
3036 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3039 lookup_pointer_type (SYMBOL_TYPE (var));
3040 enum address_class sym_class = SYMBOL_CLASS (var);
3042 if (sym_class == LOC_CONST
3043 || sym_class == LOC_CONST_BYTES
3044 || sym_class == LOC_REGISTER)
3045 error (_("Attempt to take address of register or constant."));
3048 value_zero (type, not_lval);
3051 return address_of_variable (var, exp->elts[pc + 1].block);
3053 case OP_VAR_MSYM_VALUE:
3057 value *val = evaluate_var_msym_value (noside,
3058 exp->elts[pc + 1].objfile,
3059 exp->elts[pc + 2].msymbol);
3060 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3062 struct type *type = lookup_pointer_type (value_type (val));
3063 return value_zero (type, not_lval);
3066 return value_addr (val);
3070 tem = longest_to_int (exp->elts[pc + 2].longconst);
3071 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
3072 x = value_aggregate_elt (exp->elts[pc + 1].type,
3073 &exp->elts[pc + 3].string,
3076 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
3081 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
3082 default_case_after_eval:
3083 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3085 struct type *type = check_typedef (value_type (x));
3087 if (TYPE_IS_REFERENCE (type))
3088 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
3090 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
3091 return value_zero (lookup_pointer_type (value_type (x)),
3094 error (_("Attempt to take address of "
3095 "value not located in memory."));
3097 return value_addr (x);
3101 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3102 When used in contexts where arrays will be coerced anyway, this is
3103 equivalent to `evaluate_subexp' but much faster because it avoids
3104 actually fetching array contents (perhaps obsolete now that we have
3107 Note that we currently only do the coercion for C expressions, where
3108 arrays are zero based and the coercion is correct. For other languages,
3109 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3110 to decide if coercion is appropriate. */
3113 evaluate_subexp_with_coercion (struct expression *exp,
3114 int *pos, enum noside noside)
3123 op = exp->elts[pc].opcode;
3128 var = exp->elts[pc + 2].symbol;
3129 type = check_typedef (SYMBOL_TYPE (var));
3130 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
3131 && !TYPE_VECTOR (type)
3132 && CAST_IS_CONVERSION (exp->language_defn))
3135 val = address_of_variable (var, exp->elts[pc + 1].block);
3136 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
3142 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
3146 /* Evaluate a subexpression of EXP, at index *POS,
3147 and return a value for the size of that subexpression.
3148 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3149 we allow side-effects on the operand if its type is a variable
3152 static struct value *
3153 evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
3156 /* FIXME: This should be size_t. */
3157 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3164 op = exp->elts[pc].opcode;
3168 /* This case is handled specially
3169 so that we avoid creating a value for the result type.
3170 If the result type is very big, it's desirable not to
3171 create a value unnecessarily. */
3174 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3175 type = check_typedef (value_type (val));
3176 if (TYPE_CODE (type) != TYPE_CODE_PTR
3177 && !TYPE_IS_REFERENCE (type)
3178 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3179 error (_("Attempt to take contents of a non-pointer value."));
3180 type = TYPE_TARGET_TYPE (type);
3181 if (is_dynamic_type (type))
3182 type = value_type (value_ind (val));
3183 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3187 type = exp->elts[pc + 1].type;
3190 case UNOP_MEMVAL_TYPE:
3192 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3193 type = value_type (val);
3197 type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
3198 if (is_dynamic_type (type))
3200 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3201 type = value_type (val);
3202 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
3203 && is_dynamic_type (TYPE_INDEX_TYPE (type))
3204 && TYPE_HIGH_BOUND_UNDEFINED (TYPE_INDEX_TYPE (type)))
3205 return allocate_optimized_out_value (size_type);
3211 case OP_VAR_MSYM_VALUE:
3215 minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
3216 value *mval = evaluate_var_msym_value (noside,
3217 exp->elts[pc + 1].objfile,
3220 type = value_type (mval);
3221 if (TYPE_CODE (type) == TYPE_CODE_ERROR)
3222 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
3224 return value_from_longest (size_type, TYPE_LENGTH (type));
3228 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3229 type of the subscript is a variable length array type. In this case we
3230 must re-evaluate the right hand side of the subcription to allow
3232 case BINOP_SUBSCRIPT:
3233 if (noside == EVAL_NORMAL)
3235 int npc = (*pos) + 1;
3237 val = evaluate_subexp (NULL_TYPE, exp, &npc, EVAL_AVOID_SIDE_EFFECTS);
3238 type = check_typedef (value_type (val));
3239 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3241 type = check_typedef (TYPE_TARGET_TYPE (type));
3242 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3244 type = TYPE_INDEX_TYPE (type);
3245 /* Only re-evaluate the right hand side if the resulting type
3246 is a variable length type. */
3247 if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
3249 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3250 return value_from_longest
3251 (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
3260 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3261 type = value_type (val);
3265 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3266 "When applied to a reference or a reference type, the result is
3267 the size of the referenced type." */
3268 type = check_typedef (type);
3269 if (exp->language_defn->la_language == language_cplus
3270 && (TYPE_IS_REFERENCE (type)))
3271 type = check_typedef (TYPE_TARGET_TYPE (type));
3272 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3275 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3276 for that subexpression cast to TO_TYPE. Advance *POS over the
3280 evaluate_subexp_for_cast (expression *exp, int *pos,
3282 struct type *to_type)
3286 /* Don't let symbols be evaluated with evaluate_subexp because that
3287 throws an "unknown type" error for no-debug data symbols.
3288 Instead, we want the cast to reinterpret the symbol. */
3289 if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE
3290 || exp->elts[pc].opcode == OP_VAR_VALUE)
3295 if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE)
3297 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3298 return value_zero (to_type, not_lval);
3300 val = evaluate_var_msym_value (noside,
3301 exp->elts[pc + 1].objfile,
3302 exp->elts[pc + 2].msymbol);
3305 val = evaluate_var_value (noside,
3306 exp->elts[pc + 1].block,
3307 exp->elts[pc + 2].symbol);
3309 if (noside == EVAL_SKIP)
3310 return eval_skip_value (exp);
3312 val = value_cast (to_type, val);
3314 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3315 if (VALUE_LVAL (val) == lval_memory)
3317 if (value_lazy (val))
3318 value_fetch_lazy (val);
3319 VALUE_LVAL (val) = not_lval;
3324 value *val = evaluate_subexp (to_type, exp, pos, noside);
3325 if (noside == EVAL_SKIP)
3326 return eval_skip_value (exp);
3327 return value_cast (to_type, val);
3330 /* Parse a type expression in the string [P..P+LENGTH). */
3333 parse_and_eval_type (char *p, int length)
3335 char *tmp = (char *) alloca (length + 4);
3338 memcpy (tmp + 1, p, length);
3339 tmp[length + 1] = ')';
3340 tmp[length + 2] = '0';
3341 tmp[length + 3] = '\0';
3342 expression_up expr = parse_expression (tmp);
3343 if (expr->elts[0].opcode != UNOP_CAST)
3344 error (_("Internal error in eval_type."));
3345 return expr->elts[1].type;
3349 calc_f77_array_dims (struct type *array_type)
3352 struct type *tmp_type;
3354 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3355 error (_("Can't get dimensions for a non-array type"));
3357 tmp_type = array_type;
3359 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3361 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)