1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdbthread.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
29 #include "f-lang.h" /* For array bound stuff. */
32 #include "objc-lang.h"
34 #include "parser-defs.h"
35 #include "cp-support.h"
38 #include "user-regs.h"
40 #include "gdb_obstack.h"
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)
72 struct cleanup *cleanups;
74 int cleanup_temps = 0;
76 if (*pos == 0 && target_has_execution
77 && exp->language_defn->la_language == language_cplus
78 && !thread_stack_temporaries_enabled_p (inferior_ptid))
80 cleanups = enable_thread_stack_temporaries (inferior_ptid);
84 retval = (*exp->language_defn->la_exp_desc->evaluate_exp)
85 (expect_type, exp, pos, noside);
89 if (value_in_thread_stack_temporaries (retval, inferior_ptid))
90 retval = value_non_lval (retval);
91 do_cleanups (cleanups);
97 /* Parse the string EXP as a C expression, evaluate it,
98 and return the result as a number. */
101 parse_and_eval_address (const char *exp)
103 expression_up expr = parse_expression (exp);
105 return value_as_address (evaluate_expression (expr.get ()));
108 /* Like parse_and_eval_address, but treats the value of the expression
109 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
111 parse_and_eval_long (const char *exp)
113 expression_up expr = parse_expression (exp);
115 return value_as_long (evaluate_expression (expr.get ()));
119 parse_and_eval (const char *exp)
121 expression_up expr = parse_expression (exp);
123 return evaluate_expression (expr.get ());
126 /* Parse up to a comma (or to a closeparen)
127 in the string EXPP as an expression, evaluate it, and return the value.
128 EXPP is advanced to point to the comma. */
131 parse_to_comma_and_eval (const char **expp)
133 expression_up expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
135 return evaluate_expression (expr.get ());
138 /* Evaluate an expression in internal prefix form
139 such as is constructed by parse.y.
141 See expression.h for info on the format of an expression. */
144 evaluate_expression (struct expression *exp)
148 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
151 /* Evaluate an expression, avoiding all memory references
152 and getting a value whose type alone is correct. */
155 evaluate_type (struct expression *exp)
159 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
162 /* Evaluate a subexpression, avoiding all memory references and
163 getting a value whose type alone is correct. */
166 evaluate_subexpression_type (struct expression *exp, int subexp)
168 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
171 /* Find the current value of a watchpoint on EXP. Return the value in
172 *VALP and *RESULTP and the chain of intermediate and final values
173 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
176 If PRESERVE_ERRORS is true, then exceptions are passed through.
177 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
178 occurs while evaluating the expression, *RESULTP will be set to
179 NULL. *RESULTP may be a lazy value, if the result could not be
180 read from memory. It is used to determine whether a value is
181 user-specified (we should watch the whole value) or intermediate
182 (we should watch only the bit used to locate the final value).
184 If the final value, or any intermediate value, could not be read
185 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
186 set to any referenced values. *VALP will never be a lazy value.
187 This is the value which we store in struct breakpoint.
189 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
190 value chain. The caller must free the values individually. If
191 VAL_CHAIN is NULL, all generated values will be left on the value
195 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
196 struct value **resultp, struct value **val_chain,
199 struct value *mark, *new_mark, *result;
207 /* Evaluate the expression. */
208 mark = value_mark ();
213 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
215 CATCH (ex, RETURN_MASK_ALL)
217 /* Ignore memory errors if we want watchpoints pointing at
218 inaccessible memory to still be created; otherwise, throw the
219 error to some higher catcher. */
223 if (!preserve_errors)
226 throw_exception (ex);
232 new_mark = value_mark ();
233 if (mark == new_mark)
238 /* Make sure it's not lazy, so that after the target stops again we
239 have a non-lazy previous value to compare with. */
242 if (!value_lazy (result))
249 value_fetch_lazy (result);
252 CATCH (except, RETURN_MASK_ERROR)
261 /* Return the chain of intermediate values. We use this to
262 decide which addresses to watch. */
263 *val_chain = new_mark;
264 value_release_to_mark (mark);
268 /* Extract a field operation from an expression. If the subexpression
269 of EXP starting at *SUBEXP is not a structure dereference
270 operation, return NULL. Otherwise, return the name of the
271 dereferenced field, and advance *SUBEXP to point to the
272 subexpression of the left-hand-side of the dereference. This is
273 used when completing field names. */
276 extract_field_op (struct expression *exp, int *subexp)
281 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
282 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
284 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
285 result = &exp->elts[*subexp + 2].string;
286 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
290 /* This function evaluates brace-initializers (in C/C++) for
293 static struct value *
294 evaluate_struct_tuple (struct value *struct_val,
295 struct expression *exp,
296 int *pos, enum noside noside, int nargs)
298 struct type *struct_type = check_typedef (value_type (struct_val));
299 struct type *field_type;
304 struct value *val = NULL;
309 /* Skip static fields. */
310 while (fieldno < TYPE_NFIELDS (struct_type)
311 && field_is_static (&TYPE_FIELD (struct_type,
314 if (fieldno >= TYPE_NFIELDS (struct_type))
315 error (_("too many initializers"));
316 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
317 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
318 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
319 error (_("don't know which variant you want to set"));
321 /* Here, struct_type is the type of the inner struct,
322 while substruct_type is the type of the inner struct.
323 These are the same for normal structures, but a variant struct
324 contains anonymous union fields that contain substruct fields.
325 The value fieldno is the index of the top-level (normal or
326 anonymous union) field in struct_field, while the value
327 subfieldno is the index of the actual real (named inner) field
328 in substruct_type. */
330 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
332 val = evaluate_subexp (field_type, exp, pos, noside);
334 /* Now actually set the field in struct_val. */
336 /* Assign val to field fieldno. */
337 if (value_type (val) != field_type)
338 val = value_cast (field_type, val);
340 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
341 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
342 addr = value_contents_writeable (struct_val) + bitpos / 8;
344 modify_field (struct_type, addr,
345 value_as_long (val), bitpos % 8, bitsize);
347 memcpy (addr, value_contents (val),
348 TYPE_LENGTH (value_type (val)));
354 /* Recursive helper function for setting elements of array tuples.
355 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
356 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
357 Evaluates index expresions and sets the specified element(s) of
358 ARRAY to ELEMENT. Returns last index value. */
361 init_array_element (struct value *array, struct value *element,
362 struct expression *exp, int *pos,
363 enum noside noside, LONGEST low_bound, LONGEST high_bound)
366 int element_size = TYPE_LENGTH (value_type (element));
368 if (exp->elts[*pos].opcode == BINOP_COMMA)
371 init_array_element (array, element, exp, pos, noside,
372 low_bound, high_bound);
373 return init_array_element (array, element,
374 exp, pos, noside, low_bound, high_bound);
378 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
379 if (index < low_bound || index > high_bound)
380 error (_("tuple index out of range"));
381 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
382 value_contents (element), element_size);
387 static struct value *
388 value_f90_subarray (struct value *array,
389 struct expression *exp, int *pos, enum noside noside)
392 LONGEST low_bound, high_bound;
393 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
394 enum range_type range_type
395 = (enum range_type) longest_to_int (exp->elts[pc].longconst);
399 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
400 low_bound = TYPE_LOW_BOUND (range);
402 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
404 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
405 high_bound = TYPE_HIGH_BOUND (range);
407 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
409 return value_slice (array, low_bound, high_bound - low_bound + 1);
413 /* Promote value ARG1 as appropriate before performing a unary operation
415 If the result is not appropriate for any particular language then it
416 needs to patch this function. */
419 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
424 *arg1 = coerce_ref (*arg1);
425 type1 = check_typedef (value_type (*arg1));
427 if (is_integral_type (type1))
429 switch (language->la_language)
432 /* Perform integral promotion for ANSI C/C++.
433 If not appropropriate for any particular language
434 it needs to modify this function. */
436 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
438 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
439 *arg1 = value_cast (builtin_int, *arg1);
446 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
447 operation on those two operands.
448 If the result is not appropriate for any particular language then it
449 needs to patch this function. */
452 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
453 struct value **arg1, struct value **arg2)
455 struct type *promoted_type = NULL;
459 *arg1 = coerce_ref (*arg1);
460 *arg2 = coerce_ref (*arg2);
462 type1 = check_typedef (value_type (*arg1));
463 type2 = check_typedef (value_type (*arg2));
465 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
466 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
467 && !is_integral_type (type1))
468 || (TYPE_CODE (type2) != TYPE_CODE_FLT
469 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
470 && !is_integral_type (type2)))
473 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
474 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
476 /* No promotion required. */
478 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
479 || TYPE_CODE (type2) == TYPE_CODE_FLT)
481 switch (language->la_language)
487 case language_opencl:
488 /* No promotion required. */
492 /* For other languages the result type is unchanged from gdb
493 version 6.7 for backward compatibility.
494 If either arg was long double, make sure that value is also long
495 double. Otherwise use double. */
496 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
497 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
498 promoted_type = builtin_type (gdbarch)->builtin_long_double;
500 promoted_type = builtin_type (gdbarch)->builtin_double;
504 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
505 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
507 /* No promotion required. */
510 /* Integral operations here. */
511 /* FIXME: Also mixed integral/booleans, with result an integer. */
513 const struct builtin_type *builtin = builtin_type (gdbarch);
514 unsigned int promoted_len1 = TYPE_LENGTH (type1);
515 unsigned int promoted_len2 = TYPE_LENGTH (type2);
516 int is_unsigned1 = TYPE_UNSIGNED (type1);
517 int is_unsigned2 = TYPE_UNSIGNED (type2);
518 unsigned int result_len;
519 int unsigned_operation;
521 /* Determine type length and signedness after promotion for
523 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
526 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
528 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
531 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
534 if (promoted_len1 > promoted_len2)
536 unsigned_operation = is_unsigned1;
537 result_len = promoted_len1;
539 else if (promoted_len2 > promoted_len1)
541 unsigned_operation = is_unsigned2;
542 result_len = promoted_len2;
546 unsigned_operation = is_unsigned1 || is_unsigned2;
547 result_len = promoted_len1;
550 switch (language->la_language)
556 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
558 promoted_type = (unsigned_operation
559 ? builtin->builtin_unsigned_int
560 : builtin->builtin_int);
562 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
564 promoted_type = (unsigned_operation
565 ? builtin->builtin_unsigned_long
566 : builtin->builtin_long);
570 promoted_type = (unsigned_operation
571 ? builtin->builtin_unsigned_long_long
572 : builtin->builtin_long_long);
575 case language_opencl:
576 if (result_len <= TYPE_LENGTH (lookup_signed_typename
577 (language, gdbarch, "int")))
581 ? lookup_unsigned_typename (language, gdbarch, "int")
582 : lookup_signed_typename (language, gdbarch, "int"));
584 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
585 (language, gdbarch, "long")))
589 ? lookup_unsigned_typename (language, gdbarch, "long")
590 : lookup_signed_typename (language, gdbarch,"long"));
594 /* For other languages the result type is unchanged from gdb
595 version 6.7 for backward compatibility.
596 If either arg was long long, make sure that value is also long
597 long. Otherwise use long. */
598 if (unsigned_operation)
600 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
601 promoted_type = builtin->builtin_unsigned_long_long;
603 promoted_type = builtin->builtin_unsigned_long;
607 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
608 promoted_type = builtin->builtin_long_long;
610 promoted_type = builtin->builtin_long;
618 /* Promote both operands to common type. */
619 *arg1 = value_cast (promoted_type, *arg1);
620 *arg2 = value_cast (promoted_type, *arg2);
625 ptrmath_type_p (const struct language_defn *lang, struct type *type)
627 type = check_typedef (type);
628 if (TYPE_IS_REFERENCE (type))
629 type = TYPE_TARGET_TYPE (type);
631 switch (TYPE_CODE (type))
637 case TYPE_CODE_ARRAY:
638 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
645 /* Constructs a fake method with the given parameter types. This
646 function is used by the parser to construct an "expected" type for
647 method overload resolution. FLAGS is used as instance flags of the
648 new type, in order to be able to make the new type represent a
649 const/volatile overload. */
652 make_params (type_instance_flags flags,
653 int num_types, struct type **param_types)
655 struct type *type = XCNEW (struct type);
656 TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
657 TYPE_LENGTH (type) = 1;
658 TYPE_CODE (type) = TYPE_CODE_METHOD;
659 TYPE_CHAIN (type) = type;
660 TYPE_INSTANCE_FLAGS (type) = flags;
663 if (param_types[num_types - 1] == NULL)
666 TYPE_VARARGS (type) = 1;
668 else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
672 /* Caller should have ensured this. */
673 gdb_assert (num_types == 0);
674 TYPE_PROTOTYPED (type) = 1;
678 TYPE_NFIELDS (type) = num_types;
679 TYPE_FIELDS (type) = (struct field *)
680 TYPE_ZALLOC (type, sizeof (struct field) * num_types);
682 while (num_types-- > 0)
683 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
688 /* Helper for evaluating an OP_VAR_VALUE. */
691 evaluate_var_value (enum noside noside, const block *blk, symbol *var)
693 /* JYG: We used to just return value_zero of the symbol type if
694 we're asked to avoid side effects. Otherwise we return
695 value_of_variable (...). However I'm not sure if
696 value_of_variable () has any side effect. We need a full value
697 object returned here for whatis_exp () to call evaluate_type ()
698 and then pass the full value to value_rtti_target_type () if we
699 are dealing with a pointer or reference to a base class and print
702 struct value *ret = NULL;
706 ret = value_of_variable (var, blk);
709 CATCH (except, RETURN_MASK_ERROR)
711 if (noside != EVAL_AVOID_SIDE_EFFECTS)
712 throw_exception (except);
714 ret = value_zero (SYMBOL_TYPE (var), not_lval);
721 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
724 evaluate_var_msym_value (enum noside noside,
725 struct objfile *objfile, minimal_symbol *msymbol)
727 if (noside == EVAL_AVOID_SIDE_EFFECTS)
729 type *the_type = find_minsym_type_and_address (msymbol, objfile, NULL);
730 return value_zero (the_type, not_lval);
735 type *the_type = find_minsym_type_and_address (msymbol, objfile, &address);
736 return value_at_lazy (the_type, address);
740 /* Helper for returning a value when handling EVAL_SKIP. */
743 eval_skip_value (expression *exp)
745 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
748 /* Evaluate a function call. The function to be called is in
749 ARGVEC[0] and the arguments passed to the function are in
750 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
751 known. DEFAULT_RETURN_TYPE is used as the function's return type
752 if the return type is unknown. */
755 eval_call (expression *exp, enum noside noside,
756 int nargs, value **argvec,
757 const char *function_name,
758 type *default_return_type)
760 if (argvec[0] == NULL)
761 error (_("Cannot evaluate function -- may be inlined"));
762 if (noside == EVAL_AVOID_SIDE_EFFECTS)
764 /* If the return type doesn't look like a function type,
765 call an error. This can happen if somebody tries to turn
766 a variable into a function call. */
768 type *ftype = value_type (argvec[0]);
770 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
772 /* We don't know anything about what the internal
773 function might return, but we have to return
775 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
778 else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
781 = result_type_of_xmethod (argvec[0], nargs, argvec + 1);
783 if (return_type == NULL)
784 error (_("Xmethod is missing return type."));
785 return value_zero (return_type, not_lval);
787 else if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
788 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
790 type *return_type = TYPE_TARGET_TYPE (ftype);
792 if (return_type == NULL)
793 return_type = default_return_type;
795 if (return_type == NULL)
796 error_call_unknown_return_type (function_name);
798 return allocate_value (return_type);
801 error (_("Expression of type other than "
802 "\"Function returning ...\" used as function"));
804 switch (TYPE_CODE (value_type (argvec[0])))
806 case TYPE_CODE_INTERNAL_FUNCTION:
807 return call_internal_function (exp->gdbarch, exp->language_defn,
808 argvec[0], nargs, argvec + 1);
809 case TYPE_CODE_XMETHOD:
810 return call_xmethod (argvec[0], nargs, argvec + 1);
812 return call_function_by_hand (argvec[0], default_return_type,
817 /* Helper for evaluating an OP_FUNCALL. */
820 evaluate_funcall (type *expect_type, expression *exp, int *pos,
828 symbol *function = NULL;
829 char *function_name = NULL;
830 const char *var_func_name = NULL;
835 exp_opcode op = exp->elts[*pos].opcode;
836 int nargs = longest_to_int (exp->elts[pc].longconst);
837 /* Allocate arg vector, including space for the function to be
838 called in argvec[0], a potential `this', and a terminating
840 value **argvec = (value **) alloca (sizeof (value *) * (nargs + 3));
841 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
843 /* First, evaluate the structure into arg2. */
846 if (op == STRUCTOP_MEMBER)
848 arg2 = evaluate_subexp_for_address (exp, pos, noside);
852 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
855 /* If the function is a virtual function, then the aggregate
856 value (providing the structure) plays its part by providing
857 the vtable. Otherwise, it is just along for the ride: call
858 the function directly. */
860 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
862 type *a1_type = check_typedef (value_type (arg1));
863 if (noside == EVAL_SKIP)
864 tem = 1; /* Set it to the right arg index so that all
865 arguments can also be skipped. */
866 else if (TYPE_CODE (a1_type) == TYPE_CODE_METHODPTR)
868 if (noside == EVAL_AVOID_SIDE_EFFECTS)
869 arg1 = value_zero (TYPE_TARGET_TYPE (a1_type), not_lval);
871 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
873 /* Now, say which argument to start evaluating from. */
878 else if (TYPE_CODE (a1_type) == TYPE_CODE_MEMBERPTR)
880 struct type *type_ptr
881 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type));
882 struct type *target_type_ptr
883 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type));
885 /* Now, convert these values to an address. */
886 arg2 = value_cast (type_ptr, arg2);
888 long mem_offset = value_as_long (arg1);
890 arg1 = value_from_pointer (target_type_ptr,
891 value_as_long (arg2) + mem_offset);
892 arg1 = value_ind (arg1);
896 error (_("Non-pointer-to-member value used in pointer-to-member "
899 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
901 /* Hair for method invocations. */
905 /* First, evaluate the structure into arg2. */
907 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
908 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
910 if (op == STRUCTOP_STRUCT)
912 /* If v is a variable in a register, and the user types
913 v.method (), this will produce an error, because v has no
916 A possible way around this would be to allocate a copy of
917 the variable on the stack, copy in the contents, call the
918 function, and copy out the contents. I.e. convert this
919 from call by reference to call by copy-return (or
920 whatever it's called). However, this does not work
921 because it is not the same: the method being called could
922 stash a copy of the address, and then future uses through
923 that address (after the method returns) would be expected
924 to use the variable itself, not some copy of it. */
925 arg2 = evaluate_subexp_for_address (exp, pos, noside);
929 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
931 /* Check to see if the operator '->' has been overloaded.
932 If the operator has been overloaded replace arg2 with the
933 value returned by the custom operator and continue
935 while (unop_user_defined_p (op, arg2))
937 struct value *value = NULL;
940 value = value_x_unop (arg2, op, noside);
943 CATCH (except, RETURN_MASK_ERROR)
945 if (except.error == NOT_FOUND_ERROR)
948 throw_exception (except);
955 /* Now, say which argument to start evaluating from. */
958 else if (op == OP_SCOPE
959 && overload_resolution
960 && (exp->language_defn->la_language == language_cplus))
962 /* Unpack it locally so we can properly handle overload
968 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
969 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
970 struct type *type = exp->elts[pc2 + 1].type;
971 name = &exp->elts[pc2 + 3].string;
974 function_name = NULL;
975 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
977 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
979 get_selected_block (0),
981 if (function == NULL)
982 error (_("No symbol \"%s\" in namespace \"%s\"."),
983 name, TYPE_TAG_NAME (type));
986 /* arg2 is left as NULL on purpose. */
990 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
991 || TYPE_CODE (type) == TYPE_CODE_UNION);
992 function_name = name;
994 /* We need a properly typed value for method lookup. For
995 static methods arg2 is otherwise unused. */
996 arg2 = value_zero (type, lval_memory);
1001 else if (op == OP_ADL_FUNC)
1003 /* Save the function position and move pos so that the arguments
1004 can be evaluated. */
1010 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1011 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1015 /* Non-method function call. */
1019 /* If this is a C++ function wait until overload resolution. */
1020 if (op == OP_VAR_VALUE
1021 && overload_resolution
1022 && (exp->language_defn->la_language == language_cplus))
1024 (*pos) += 4; /* Skip the evaluation of the symbol. */
1029 if (op == OP_VAR_MSYM_VALUE)
1031 symbol *sym = exp->elts[*pos + 2].symbol;
1032 var_func_name = SYMBOL_PRINT_NAME (sym);
1034 else if (op == OP_VAR_VALUE)
1036 minimal_symbol *msym = exp->elts[*pos + 2].msymbol;
1037 var_func_name = MSYMBOL_PRINT_NAME (msym);
1040 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1041 type *type = value_type (argvec[0]);
1042 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1043 type = TYPE_TARGET_TYPE (type);
1044 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1046 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1048 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1056 /* Evaluate arguments (if not already done, e.g., namespace::func()
1057 and overload-resolution is off). */
1058 for (; tem <= nargs; tem++)
1060 /* Ensure that array expressions are coerced into pointer
1062 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1065 /* Signal end of arglist. */
1068 if (noside == EVAL_SKIP)
1069 return eval_skip_value (exp);
1071 if (op == OP_ADL_FUNC)
1073 struct symbol *symp;
1076 int string_pc = save_pos1 + 3;
1078 /* Extract the function name. */
1079 name_len = longest_to_int (exp->elts[string_pc].longconst);
1080 func_name = (char *) alloca (name_len + 1);
1081 strcpy (func_name, &exp->elts[string_pc + 1].string);
1083 find_overload_match (&argvec[1], nargs, func_name,
1084 NON_METHOD, /* not method */
1085 NULL, NULL, /* pass NULL symbol since
1086 symbol is unknown */
1087 NULL, &symp, NULL, 0, noside);
1089 /* Now fix the expression being evaluated. */
1090 exp->elts[save_pos1 + 2].symbol = symp;
1091 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1094 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1095 || (op == OP_SCOPE && function_name != NULL))
1097 int static_memfuncp;
1100 /* Method invocation: stuff "this" as first parameter. If the
1101 method turns out to be static we undo this below. */
1106 /* Name of method from expression. */
1107 tstr = &exp->elts[pc2 + 2].string;
1110 tstr = function_name;
1112 if (overload_resolution && (exp->language_defn->la_language
1115 /* Language is C++, do some overload resolution before
1117 struct value *valp = NULL;
1119 (void) find_overload_match (&argvec[1], nargs, tstr,
1120 METHOD, /* method */
1121 &arg2, /* the object */
1123 &static_memfuncp, 0, noside);
1125 if (op == OP_SCOPE && !static_memfuncp)
1127 /* For the time being, we don't handle this. */
1128 error (_("Call to overloaded function %s requires "
1132 argvec[1] = arg2; /* the ``this'' pointer */
1133 argvec[0] = valp; /* Use the method found after overload
1137 /* Non-C++ case -- or no overload resolution. */
1139 struct value *temp = arg2;
1141 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1143 op == STRUCTOP_STRUCT
1144 ? "structure" : "structure pointer");
1145 /* value_struct_elt updates temp with the correct value of
1146 the ``this'' pointer if necessary, so modify argvec[1] to
1147 reflect any ``this'' changes. */
1149 = value_from_longest (lookup_pointer_type(value_type (temp)),
1150 value_address (temp)
1151 + value_embedded_offset (temp));
1152 argvec[1] = arg2; /* the ``this'' pointer */
1155 /* Take out `this' if needed. */
1156 if (static_memfuncp)
1158 argvec[1] = argvec[0];
1163 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1165 /* Pointer to member. argvec[1] is already set up. */
1168 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1170 /* Non-member function being called. */
1171 /* fn: This can only be done for C++ functions. A C-style
1172 function in a C++ program, for instance, does not have the
1173 fields that are expected here. */
1175 if (overload_resolution && (exp->language_defn->la_language
1178 /* Language is C++, do some overload resolution before
1180 struct symbol *symp;
1183 /* If a scope has been specified disable ADL. */
1187 if (op == OP_VAR_VALUE)
1188 function = exp->elts[save_pos1+2].symbol;
1190 (void) find_overload_match (&argvec[1], nargs,
1191 NULL, /* no need for name */
1192 NON_METHOD, /* not method */
1193 NULL, function, /* the function */
1194 NULL, &symp, NULL, no_adl, noside);
1196 if (op == OP_VAR_VALUE)
1198 /* Now fix the expression being evaluated. */
1199 exp->elts[save_pos1+2].symbol = symp;
1200 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1204 argvec[0] = value_of_variable (symp, get_selected_block (0));
1208 /* Not C++, or no overload resolution allowed. */
1209 /* Nothing to be done; argvec already correctly set up. */
1214 /* It is probably a C-style function. */
1215 /* Nothing to be done; argvec already correctly set up. */
1218 return eval_call (exp, noside, nargs, argvec, var_func_name, expect_type);
1222 evaluate_subexp_standard (struct type *expect_type,
1223 struct expression *exp, int *pos,
1227 int tem, tem2, tem3;
1229 struct value *arg1 = NULL;
1230 struct value *arg2 = NULL;
1234 struct value **argvec;
1238 struct type **arg_types;
1241 op = exp->elts[pc].opcode;
1246 tem = longest_to_int (exp->elts[pc + 2].longconst);
1247 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
1248 if (noside == EVAL_SKIP)
1249 return eval_skip_value (exp);
1250 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
1251 &exp->elts[pc + 3].string,
1252 expect_type, 0, noside);
1254 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
1259 return value_from_longest (exp->elts[pc + 1].type,
1260 exp->elts[pc + 2].longconst);
1264 return value_from_double (exp->elts[pc + 1].type,
1265 exp->elts[pc + 2].doubleconst);
1269 return value_from_decfloat (exp->elts[pc + 1].type,
1270 exp->elts[pc + 2].decfloatconst);
1275 if (noside == EVAL_SKIP)
1276 return eval_skip_value (exp);
1279 symbol *var = exp->elts[pc + 2].symbol;
1280 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR)
1281 error_unknown_type (SYMBOL_PRINT_NAME (var));
1283 return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
1286 case OP_VAR_MSYM_VALUE:
1290 minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
1291 value *val = evaluate_var_msym_value (noside,
1292 exp->elts[pc + 1].objfile,
1295 type = value_type (val);
1296 if (TYPE_CODE (type) == TYPE_CODE_ERROR
1297 && (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0))
1298 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
1302 case OP_VAR_ENTRY_VALUE:
1304 if (noside == EVAL_SKIP)
1305 return eval_skip_value (exp);
1308 struct symbol *sym = exp->elts[pc + 1].symbol;
1309 struct frame_info *frame;
1311 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1312 return value_zero (SYMBOL_TYPE (sym), not_lval);
1314 if (SYMBOL_COMPUTED_OPS (sym) == NULL
1315 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
1316 error (_("Symbol \"%s\" does not have any specific entry value"),
1317 SYMBOL_PRINT_NAME (sym));
1319 frame = get_selected_frame (NULL);
1320 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
1323 case OP_FUNC_STATIC_VAR:
1324 tem = longest_to_int (exp->elts[pc + 1].longconst);
1325 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1326 if (noside == EVAL_SKIP)
1327 return eval_skip_value (exp);
1330 value *func = evaluate_subexp_standard (NULL, exp, pos, noside);
1331 CORE_ADDR addr = value_address (func);
1333 const block *blk = block_for_pc (addr);
1334 const char *var = &exp->elts[pc + 2].string;
1336 struct block_symbol sym = lookup_symbol (var, blk, VAR_DOMAIN, NULL);
1338 if (sym.symbol == NULL)
1339 error (_("No symbol \"%s\" in specified context."), var);
1341 return evaluate_var_value (noside, sym.block, sym.symbol);
1347 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
1351 const char *name = &exp->elts[pc + 2].string;
1355 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
1356 regno = user_reg_map_name_to_regnum (exp->gdbarch,
1357 name, strlen (name));
1359 error (_("Register $%s not available."), name);
1361 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1362 a value with the appropriate register type. Unfortunately,
1363 we don't have easy access to the type of user registers.
1364 So for these registers, we fetch the register value regardless
1365 of the evaluation mode. */
1366 if (noside == EVAL_AVOID_SIDE_EFFECTS
1367 && regno < gdbarch_num_regs (exp->gdbarch)
1368 + gdbarch_num_pseudo_regs (exp->gdbarch))
1369 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
1371 val = value_of_register (regno, get_selected_frame (NULL));
1373 error (_("Value of register %s not available."), name);
1379 type = language_bool_type (exp->language_defn, exp->gdbarch);
1380 return value_from_longest (type, exp->elts[pc + 1].longconst);
1382 case OP_INTERNALVAR:
1384 return value_of_internalvar (exp->gdbarch,
1385 exp->elts[pc + 1].internalvar);
1388 tem = longest_to_int (exp->elts[pc + 1].longconst);
1389 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1390 if (noside == EVAL_SKIP)
1391 return eval_skip_value (exp);
1392 type = language_string_char_type (exp->language_defn, exp->gdbarch);
1393 return value_string (&exp->elts[pc + 2].string, tem, type);
1395 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
1396 NSString constant. */
1397 tem = longest_to_int (exp->elts[pc + 1].longconst);
1398 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1399 if (noside == EVAL_SKIP)
1400 return eval_skip_value (exp);
1401 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
1405 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
1406 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
1407 nargs = tem3 - tem2 + 1;
1408 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
1410 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1411 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
1413 struct value *rec = allocate_value (expect_type);
1415 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
1416 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
1419 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1420 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
1422 struct type *range_type = TYPE_INDEX_TYPE (type);
1423 struct type *element_type = TYPE_TARGET_TYPE (type);
1424 struct value *array = allocate_value (expect_type);
1425 int element_size = TYPE_LENGTH (check_typedef (element_type));
1426 LONGEST low_bound, high_bound, index;
1428 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
1431 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
1434 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
1435 for (tem = nargs; --nargs >= 0;)
1437 struct value *element;
1440 element = evaluate_subexp (element_type, exp, pos, noside);
1441 if (value_type (element) != element_type)
1442 element = value_cast (element_type, element);
1445 int continue_pc = *pos;
1448 index = init_array_element (array, element, exp, pos, noside,
1449 low_bound, high_bound);
1454 if (index > high_bound)
1455 /* To avoid memory corruption. */
1456 error (_("Too many array elements"));
1457 memcpy (value_contents_raw (array)
1458 + (index - low_bound) * element_size,
1459 value_contents (element),
1467 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1468 && TYPE_CODE (type) == TYPE_CODE_SET)
1470 struct value *set = allocate_value (expect_type);
1471 gdb_byte *valaddr = value_contents_raw (set);
1472 struct type *element_type = TYPE_INDEX_TYPE (type);
1473 struct type *check_type = element_type;
1474 LONGEST low_bound, high_bound;
1476 /* Get targettype of elementtype. */
1477 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
1478 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
1479 check_type = TYPE_TARGET_TYPE (check_type);
1481 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
1482 error (_("(power)set type with unknown size"));
1483 memset (valaddr, '\0', TYPE_LENGTH (type));
1484 for (tem = 0; tem < nargs; tem++)
1486 LONGEST range_low, range_high;
1487 struct type *range_low_type, *range_high_type;
1488 struct value *elem_val;
1490 elem_val = evaluate_subexp (element_type, exp, pos, noside);
1491 range_low_type = range_high_type = value_type (elem_val);
1492 range_low = range_high = value_as_long (elem_val);
1494 /* Check types of elements to avoid mixture of elements from
1495 different types. Also check if type of element is "compatible"
1496 with element type of powerset. */
1497 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
1498 range_low_type = TYPE_TARGET_TYPE (range_low_type);
1499 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
1500 range_high_type = TYPE_TARGET_TYPE (range_high_type);
1501 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
1502 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
1503 && (range_low_type != range_high_type)))
1504 /* different element modes. */
1505 error (_("POWERSET tuple elements of different mode"));
1506 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
1507 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
1508 && range_low_type != check_type))
1509 error (_("incompatible POWERSET tuple elements"));
1510 if (range_low > range_high)
1512 warning (_("empty POWERSET tuple range"));
1515 if (range_low < low_bound || range_high > high_bound)
1516 error (_("POWERSET tuple element out of range"));
1517 range_low -= low_bound;
1518 range_high -= low_bound;
1519 for (; range_low <= range_high; range_low++)
1521 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
1523 if (gdbarch_bits_big_endian (exp->gdbarch))
1524 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
1525 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1532 argvec = XALLOCAVEC (struct value *, nargs);
1533 for (tem = 0; tem < nargs; tem++)
1535 /* Ensure that array expressions are coerced into pointer
1537 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1539 if (noside == EVAL_SKIP)
1540 return eval_skip_value (exp);
1541 return value_array (tem2, tem3, argvec);
1545 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1547 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1549 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1551 if (noside == EVAL_SKIP)
1552 return eval_skip_value (exp);
1553 return value_slice (array, lowbound, upper - lowbound + 1);
1557 /* Skip third and second args to evaluate the first one. */
1558 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1559 if (value_logical_not (arg1))
1561 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1562 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1566 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1567 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1571 case OP_OBJC_SELECTOR:
1572 { /* Objective C @selector operator. */
1573 char *sel = &exp->elts[pc + 2].string;
1574 int len = longest_to_int (exp->elts[pc + 1].longconst);
1575 struct type *selector_type;
1577 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1578 if (noside == EVAL_SKIP)
1579 return eval_skip_value (exp);
1582 sel[len] = 0; /* Make sure it's terminated. */
1584 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1585 return value_from_longest (selector_type,
1586 lookup_child_selector (exp->gdbarch, sel));
1589 case OP_OBJC_MSGCALL:
1590 { /* Objective C message (method) call. */
1592 CORE_ADDR responds_selector = 0;
1593 CORE_ADDR method_selector = 0;
1595 CORE_ADDR selector = 0;
1597 int struct_return = 0;
1598 enum noside sub_no_side = EVAL_NORMAL;
1600 struct value *msg_send = NULL;
1601 struct value *msg_send_stret = NULL;
1602 int gnu_runtime = 0;
1604 struct value *target = NULL;
1605 struct value *method = NULL;
1606 struct value *called_method = NULL;
1608 struct type *selector_type = NULL;
1609 struct type *long_type;
1611 struct value *ret = NULL;
1614 selector = exp->elts[pc + 1].longconst;
1615 nargs = exp->elts[pc + 2].longconst;
1616 argvec = XALLOCAVEC (struct value *, nargs + 5);
1620 long_type = builtin_type (exp->gdbarch)->builtin_long;
1621 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1623 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1624 sub_no_side = EVAL_NORMAL;
1626 sub_no_side = noside;
1628 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1630 if (value_as_long (target) == 0)
1631 return value_from_longest (long_type, 0);
1633 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
1636 /* Find the method dispatch (Apple runtime) or method lookup
1637 (GNU runtime) function for Objective-C. These will be used
1638 to lookup the symbol information for the method. If we
1639 can't find any symbol information, then we'll use these to
1640 call the method, otherwise we can call the method
1641 directly. The msg_send_stret function is used in the special
1642 case of a method that returns a structure (Apple runtime
1646 struct type *type = selector_type;
1648 type = lookup_function_type (type);
1649 type = lookup_pointer_type (type);
1650 type = lookup_function_type (type);
1651 type = lookup_pointer_type (type);
1653 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1655 = find_function_in_inferior ("objc_msg_lookup", NULL);
1657 msg_send = value_from_pointer (type, value_as_address (msg_send));
1658 msg_send_stret = value_from_pointer (type,
1659 value_as_address (msg_send_stret));
1663 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1664 /* Special dispatcher for methods returning structs. */
1666 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1669 /* Verify the target object responds to this method. The
1670 standard top-level 'Object' class uses a different name for
1671 the verification method than the non-standard, but more
1672 often used, 'NSObject' class. Make sure we check for both. */
1675 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1676 if (responds_selector == 0)
1678 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1680 if (responds_selector == 0)
1681 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1684 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1685 if (method_selector == 0)
1687 = lookup_child_selector (exp->gdbarch, "methodFor:");
1689 if (method_selector == 0)
1690 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1692 /* Call the verification method, to make sure that the target
1693 class implements the desired method. */
1695 argvec[0] = msg_send;
1697 argvec[2] = value_from_longest (long_type, responds_selector);
1698 argvec[3] = value_from_longest (long_type, selector);
1701 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1704 /* Function objc_msg_lookup returns a pointer. */
1706 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1708 if (value_as_long (ret) == 0)
1709 error (_("Target does not respond to this message selector."));
1711 /* Call "methodForSelector:" method, to get the address of a
1712 function method that implements this selector for this
1713 class. If we can find a symbol at that address, then we
1714 know the return type, parameter types etc. (that's a good
1717 argvec[0] = msg_send;
1719 argvec[2] = value_from_longest (long_type, method_selector);
1720 argvec[3] = value_from_longest (long_type, selector);
1723 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1727 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1730 /* ret should now be the selector. */
1732 addr = value_as_long (ret);
1735 struct symbol *sym = NULL;
1737 /* The address might point to a function descriptor;
1738 resolve it to the actual code address instead. */
1739 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1742 /* Is it a high_level symbol? */
1743 sym = find_pc_function (addr);
1745 method = value_of_variable (sym, 0);
1748 /* If we found a method with symbol information, check to see
1749 if it returns a struct. Otherwise assume it doesn't. */
1754 struct type *val_type;
1756 funaddr = find_function_addr (method, &val_type);
1758 block_for_pc (funaddr);
1760 val_type = check_typedef (val_type);
1762 if ((val_type == NULL)
1763 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1765 if (expect_type != NULL)
1766 val_type = expect_type;
1769 struct_return = using_struct_return (exp->gdbarch, method,
1772 else if (expect_type != NULL)
1774 struct_return = using_struct_return (exp->gdbarch, NULL,
1775 check_typedef (expect_type));
1778 /* Found a function symbol. Now we will substitute its
1779 value in place of the message dispatcher (obj_msgSend),
1780 so that we call the method directly instead of thru
1781 the dispatcher. The main reason for doing this is that
1782 we can now evaluate the return value and parameter values
1783 according to their known data types, in case we need to
1784 do things like promotion, dereferencing, special handling
1785 of structs and doubles, etc.
1787 We want to use the type signature of 'method', but still
1788 jump to objc_msgSend() or objc_msgSend_stret() to better
1789 mimic the behavior of the runtime. */
1793 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1794 error (_("method address has symbol information "
1795 "with non-function type; skipping"));
1797 /* Create a function pointer of the appropriate type, and
1798 replace its value with the value of msg_send or
1799 msg_send_stret. We must use a pointer here, as
1800 msg_send and msg_send_stret are of pointer type, and
1801 the representation may be different on systems that use
1802 function descriptors. */
1805 = value_from_pointer (lookup_pointer_type (value_type (method)),
1806 value_as_address (msg_send_stret));
1809 = value_from_pointer (lookup_pointer_type (value_type (method)),
1810 value_as_address (msg_send));
1815 called_method = msg_send_stret;
1817 called_method = msg_send;
1820 if (noside == EVAL_SKIP)
1821 return eval_skip_value (exp);
1823 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1825 /* If the return type doesn't look like a function type,
1826 call an error. This can happen if somebody tries to
1827 turn a variable into a function call. This is here
1828 because people often want to call, eg, strcmp, which
1829 gdb doesn't know is a function. If gdb isn't asked for
1830 it's opinion (ie. through "whatis"), it won't offer
1833 struct type *type = value_type (called_method);
1835 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1836 type = TYPE_TARGET_TYPE (type);
1837 type = TYPE_TARGET_TYPE (type);
1841 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1842 return allocate_value (expect_type);
1844 return allocate_value (type);
1847 error (_("Expression of type other than "
1848 "\"method returning ...\" used as a method"));
1851 /* Now depending on whether we found a symbol for the method,
1852 we will either call the runtime dispatcher or the method
1855 argvec[0] = called_method;
1857 argvec[2] = value_from_longest (long_type, selector);
1858 /* User-supplied arguments. */
1859 for (tem = 0; tem < nargs; tem++)
1860 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1861 argvec[tem + 3] = 0;
1863 if (gnu_runtime && (method != NULL))
1865 /* Function objc_msg_lookup returns a pointer. */
1866 deprecated_set_value_type (argvec[0],
1867 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1869 = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
1872 ret = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
1878 return evaluate_funcall (expect_type, exp, pos, noside);
1880 case OP_F77_UNDETERMINED_ARGLIST:
1882 /* Remember that in F77, functions, substring ops and
1883 array subscript operations cannot be disambiguated
1884 at parse time. We have made all array subscript operations,
1885 substring operations as well as function calls come here
1886 and we now have to discover what the heck this thing actually was.
1887 If it is a function, we process just as if we got an OP_FUNCALL. */
1889 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1892 /* First determine the type code we are dealing with. */
1893 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1894 type = check_typedef (value_type (arg1));
1895 code = TYPE_CODE (type);
1897 if (code == TYPE_CODE_PTR)
1899 /* Fortran always passes variable to subroutines as pointer.
1900 So we need to look into its target type to see if it is
1901 array, string or function. If it is, we need to switch
1902 to the target value the original one points to. */
1903 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1905 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1906 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1907 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1909 arg1 = value_ind (arg1);
1910 type = check_typedef (value_type (arg1));
1911 code = TYPE_CODE (type);
1917 case TYPE_CODE_ARRAY:
1918 if (exp->elts[*pos].opcode == OP_RANGE)
1919 return value_f90_subarray (arg1, exp, pos, noside);
1921 goto multi_f77_subscript;
1923 case TYPE_CODE_STRING:
1924 if (exp->elts[*pos].opcode == OP_RANGE)
1925 return value_f90_subarray (arg1, exp, pos, noside);
1928 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1929 return value_subscript (arg1, value_as_long (arg2));
1933 case TYPE_CODE_FUNC:
1934 /* It's a function call. */
1935 /* Allocate arg vector, including space for the function to be
1936 called in argvec[0] and a terminating NULL. */
1937 argvec = (struct value **)
1938 alloca (sizeof (struct value *) * (nargs + 2));
1941 for (; tem <= nargs; tem++)
1942 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1943 argvec[tem] = 0; /* signal end of arglist */
1944 if (noside == EVAL_SKIP)
1945 return eval_skip_value (exp);
1946 return eval_call (exp, noside, nargs, argvec, NULL, expect_type);
1949 error (_("Cannot perform substring on this type"));
1953 /* We have a complex number, There should be 2 floating
1954 point numbers that compose it. */
1956 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1957 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1959 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1961 case STRUCTOP_STRUCT:
1962 tem = longest_to_int (exp->elts[pc + 1].longconst);
1963 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1964 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1965 if (noside == EVAL_SKIP)
1966 return eval_skip_value (exp);
1967 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1969 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1970 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
1974 tem = longest_to_int (exp->elts[pc + 1].longconst);
1975 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1976 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1977 if (noside == EVAL_SKIP)
1978 return eval_skip_value (exp);
1980 /* Check to see if operator '->' has been overloaded. If so replace
1981 arg1 with the value returned by evaluating operator->(). */
1982 while (unop_user_defined_p (op, arg1))
1984 struct value *value = NULL;
1987 value = value_x_unop (arg1, op, noside);
1990 CATCH (except, RETURN_MASK_ERROR)
1992 if (except.error == NOT_FOUND_ERROR)
1995 throw_exception (except);
2002 /* JYG: if print object is on we need to replace the base type
2003 with rtti type in order to continue on with successful
2004 lookup of member / method only available in the rtti type. */
2006 struct type *type = value_type (arg1);
2007 struct type *real_type;
2008 int full, using_enc;
2010 struct value_print_options opts;
2012 get_user_print_options (&opts);
2013 if (opts.objectprint && TYPE_TARGET_TYPE(type)
2014 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
2016 real_type = value_rtti_indirect_type (arg1, &full, &top,
2019 arg1 = value_cast (real_type, arg1);
2023 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
2024 NULL, "structure pointer");
2025 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2026 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
2029 case STRUCTOP_MEMBER:
2031 if (op == STRUCTOP_MEMBER)
2032 arg1 = evaluate_subexp_for_address (exp, pos, noside);
2034 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2036 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2038 if (noside == EVAL_SKIP)
2039 return eval_skip_value (exp);
2041 type = check_typedef (value_type (arg2));
2042 switch (TYPE_CODE (type))
2044 case TYPE_CODE_METHODPTR:
2045 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2046 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
2049 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
2050 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
2051 return value_ind (arg2);
2054 case TYPE_CODE_MEMBERPTR:
2055 /* Now, convert these values to an address. */
2056 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
2059 mem_offset = value_as_long (arg2);
2061 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2062 value_as_long (arg1) + mem_offset);
2063 return value_ind (arg3);
2066 error (_("non-pointer-to-member value used "
2067 "in pointer-to-member construct"));
2072 type_instance_flags flags
2073 = (type_instance_flag_value) longest_to_int (exp->elts[pc + 1].longconst);
2074 nargs = longest_to_int (exp->elts[pc + 2].longconst);
2075 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
2076 for (ix = 0; ix < nargs; ++ix)
2077 arg_types[ix] = exp->elts[pc + 2 + ix + 1].type;
2079 expect_type = make_params (flags, nargs, arg_types);
2080 *(pos) += 4 + nargs;
2081 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
2082 xfree (TYPE_FIELDS (expect_type));
2083 xfree (TYPE_MAIN_TYPE (expect_type));
2084 xfree (expect_type);
2089 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2090 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2091 if (noside == EVAL_SKIP)
2092 return eval_skip_value (exp);
2093 if (binop_user_defined_p (op, arg1, arg2))
2094 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2096 return value_concat (arg1, arg2);
2099 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2100 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2102 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2104 if (binop_user_defined_p (op, arg1, arg2))
2105 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2107 return value_assign (arg1, arg2);
2109 case BINOP_ASSIGN_MODIFY:
2111 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2112 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2113 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2115 op = exp->elts[pc + 1].opcode;
2116 if (binop_user_defined_p (op, arg1, arg2))
2117 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
2118 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2120 && is_integral_type (value_type (arg2)))
2121 arg2 = value_ptradd (arg1, value_as_long (arg2));
2122 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2124 && is_integral_type (value_type (arg2)))
2125 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2128 struct value *tmp = arg1;
2130 /* For shift and integer exponentiation operations,
2131 only promote the first argument. */
2132 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2133 && is_integral_type (value_type (arg2)))
2134 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2136 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2138 arg2 = value_binop (tmp, arg2, op);
2140 return value_assign (arg1, arg2);
2143 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2144 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2145 if (noside == EVAL_SKIP)
2146 return eval_skip_value (exp);
2147 if (binop_user_defined_p (op, arg1, arg2))
2148 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2149 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2150 && is_integral_type (value_type (arg2)))
2151 return value_ptradd (arg1, value_as_long (arg2));
2152 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2153 && is_integral_type (value_type (arg1)))
2154 return value_ptradd (arg2, value_as_long (arg1));
2157 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2158 return value_binop (arg1, arg2, BINOP_ADD);
2162 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2163 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2164 if (noside == EVAL_SKIP)
2165 return eval_skip_value (exp);
2166 if (binop_user_defined_p (op, arg1, arg2))
2167 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2168 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2169 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2171 /* FIXME -- should be ptrdiff_t */
2172 type = builtin_type (exp->gdbarch)->builtin_long;
2173 return value_from_longest (type, value_ptrdiff (arg1, arg2));
2175 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2176 && is_integral_type (value_type (arg2)))
2177 return value_ptradd (arg1, - value_as_long (arg2));
2180 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2181 return value_binop (arg1, arg2, BINOP_SUB);
2192 case BINOP_BITWISE_AND:
2193 case BINOP_BITWISE_IOR:
2194 case BINOP_BITWISE_XOR:
2195 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2196 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2197 if (noside == EVAL_SKIP)
2198 return eval_skip_value (exp);
2199 if (binop_user_defined_p (op, arg1, arg2))
2200 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2203 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2204 fudge arg2 to avoid division-by-zero, the caller is
2205 (theoretically) only looking for the type of the result. */
2206 if (noside == EVAL_AVOID_SIDE_EFFECTS
2207 /* ??? Do we really want to test for BINOP_MOD here?
2208 The implementation of value_binop gives it a well-defined
2211 || op == BINOP_INTDIV
2214 && value_logical_not (arg2))
2216 struct value *v_one, *retval;
2218 v_one = value_one (value_type (arg2));
2219 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2220 retval = value_binop (arg1, v_one, op);
2225 /* For shift and integer exponentiation operations,
2226 only promote the first argument. */
2227 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2228 && is_integral_type (value_type (arg2)))
2229 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2231 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2233 return value_binop (arg1, arg2, op);
2237 case BINOP_SUBSCRIPT:
2238 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2239 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2240 if (noside == EVAL_SKIP)
2241 return eval_skip_value (exp);
2242 if (binop_user_defined_p (op, arg1, arg2))
2243 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2246 /* If the user attempts to subscript something that is not an
2247 array or pointer type (like a plain int variable for example),
2248 then report this as an error. */
2250 arg1 = coerce_ref (arg1);
2251 type = check_typedef (value_type (arg1));
2252 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2253 && TYPE_CODE (type) != TYPE_CODE_PTR)
2255 if (TYPE_NAME (type))
2256 error (_("cannot subscript something of type `%s'"),
2259 error (_("cannot subscript requested type"));
2262 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2263 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2265 return value_subscript (arg1, value_as_long (arg2));
2267 case MULTI_SUBSCRIPT:
2269 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2270 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2273 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2274 /* FIXME: EVAL_SKIP handling may not be correct. */
2275 if (noside == EVAL_SKIP)
2279 return eval_skip_value (exp);
2281 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2282 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2284 /* If the user attempts to subscript something that has no target
2285 type (like a plain int variable for example), then report this
2288 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2291 arg1 = value_zero (type, VALUE_LVAL (arg1));
2297 error (_("cannot subscript something of type `%s'"),
2298 TYPE_NAME (value_type (arg1)));
2302 if (binop_user_defined_p (op, arg1, arg2))
2304 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2308 arg1 = coerce_ref (arg1);
2309 type = check_typedef (value_type (arg1));
2311 switch (TYPE_CODE (type))
2314 case TYPE_CODE_ARRAY:
2315 case TYPE_CODE_STRING:
2316 arg1 = value_subscript (arg1, value_as_long (arg2));
2320 if (TYPE_NAME (type))
2321 error (_("cannot subscript something of type `%s'"),
2324 error (_("cannot subscript requested type"));
2330 multi_f77_subscript:
2332 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2333 int ndimensions = 1, i;
2334 struct value *array = arg1;
2336 if (nargs > MAX_FORTRAN_DIMS)
2337 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2339 ndimensions = calc_f77_array_dims (type);
2341 if (nargs != ndimensions)
2342 error (_("Wrong number of subscripts"));
2344 gdb_assert (nargs > 0);
2346 /* Now that we know we have a legal array subscript expression
2347 let us actually find out where this element exists in the array. */
2349 /* Take array indices left to right. */
2350 for (i = 0; i < nargs; i++)
2352 /* Evaluate each subscript; it must be a legal integer in F77. */
2353 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2355 /* Fill in the subscript array. */
2357 subscript_array[i] = value_as_long (arg2);
2360 /* Internal type of array is arranged right to left. */
2361 for (i = nargs; i > 0; i--)
2363 struct type *array_type = check_typedef (value_type (array));
2364 LONGEST index = subscript_array[i - 1];
2366 array = value_subscripted_rvalue (array, index,
2367 f77_get_lowerbound (array_type));
2373 case BINOP_LOGICAL_AND:
2374 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2375 if (noside == EVAL_SKIP)
2377 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2378 return eval_skip_value (exp);
2382 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2385 if (binop_user_defined_p (op, arg1, arg2))
2387 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2388 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2392 tem = value_logical_not (arg1);
2393 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2394 (tem ? EVAL_SKIP : noside));
2395 type = language_bool_type (exp->language_defn, exp->gdbarch);
2396 return value_from_longest (type,
2397 (LONGEST) (!tem && !value_logical_not (arg2)));
2400 case BINOP_LOGICAL_OR:
2401 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2402 if (noside == EVAL_SKIP)
2404 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2405 return eval_skip_value (exp);
2409 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2412 if (binop_user_defined_p (op, arg1, arg2))
2414 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2415 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2419 tem = value_logical_not (arg1);
2420 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2421 (!tem ? EVAL_SKIP : noside));
2422 type = language_bool_type (exp->language_defn, exp->gdbarch);
2423 return value_from_longest (type,
2424 (LONGEST) (!tem || !value_logical_not (arg2)));
2428 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2429 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2430 if (noside == EVAL_SKIP)
2431 return eval_skip_value (exp);
2432 if (binop_user_defined_p (op, arg1, arg2))
2434 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2438 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2439 tem = value_equal (arg1, arg2);
2440 type = language_bool_type (exp->language_defn, exp->gdbarch);
2441 return value_from_longest (type, (LONGEST) tem);
2444 case BINOP_NOTEQUAL:
2445 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2446 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2447 if (noside == EVAL_SKIP)
2448 return eval_skip_value (exp);
2449 if (binop_user_defined_p (op, arg1, arg2))
2451 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2455 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2456 tem = value_equal (arg1, arg2);
2457 type = language_bool_type (exp->language_defn, exp->gdbarch);
2458 return value_from_longest (type, (LONGEST) ! tem);
2462 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2463 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2464 if (noside == EVAL_SKIP)
2465 return eval_skip_value (exp);
2466 if (binop_user_defined_p (op, arg1, arg2))
2468 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2472 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2473 tem = value_less (arg1, arg2);
2474 type = language_bool_type (exp->language_defn, exp->gdbarch);
2475 return value_from_longest (type, (LONGEST) tem);
2479 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2480 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2481 if (noside == EVAL_SKIP)
2482 return eval_skip_value (exp);
2483 if (binop_user_defined_p (op, arg1, arg2))
2485 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2489 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2490 tem = value_less (arg2, arg1);
2491 type = language_bool_type (exp->language_defn, exp->gdbarch);
2492 return value_from_longest (type, (LONGEST) tem);
2496 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2497 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2498 if (noside == EVAL_SKIP)
2499 return eval_skip_value (exp);
2500 if (binop_user_defined_p (op, arg1, arg2))
2502 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2506 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2507 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2508 type = language_bool_type (exp->language_defn, exp->gdbarch);
2509 return value_from_longest (type, (LONGEST) tem);
2513 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2514 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2515 if (noside == EVAL_SKIP)
2516 return eval_skip_value (exp);
2517 if (binop_user_defined_p (op, arg1, arg2))
2519 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2523 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2524 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2525 type = language_bool_type (exp->language_defn, exp->gdbarch);
2526 return value_from_longest (type, (LONGEST) tem);
2530 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2531 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2532 if (noside == EVAL_SKIP)
2533 return eval_skip_value (exp);
2534 type = check_typedef (value_type (arg2));
2535 if (TYPE_CODE (type) != TYPE_CODE_INT
2536 && TYPE_CODE (type) != TYPE_CODE_ENUM)
2537 error (_("Non-integral right operand for \"@\" operator."));
2538 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2540 return allocate_repeat_value (value_type (arg1),
2541 longest_to_int (value_as_long (arg2)));
2544 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2547 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2548 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2551 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2552 if (noside == EVAL_SKIP)
2553 return eval_skip_value (exp);
2554 if (unop_user_defined_p (op, arg1))
2555 return value_x_unop (arg1, op, noside);
2558 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2559 return value_pos (arg1);
2563 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2564 if (noside == EVAL_SKIP)
2565 return eval_skip_value (exp);
2566 if (unop_user_defined_p (op, arg1))
2567 return value_x_unop (arg1, op, noside);
2570 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2571 return value_neg (arg1);
2574 case UNOP_COMPLEMENT:
2575 /* C++: check for and handle destructor names. */
2577 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2578 if (noside == EVAL_SKIP)
2579 return eval_skip_value (exp);
2580 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2581 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2584 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2585 return value_complement (arg1);
2588 case UNOP_LOGICAL_NOT:
2589 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2590 if (noside == EVAL_SKIP)
2591 return eval_skip_value (exp);
2592 if (unop_user_defined_p (op, arg1))
2593 return value_x_unop (arg1, op, noside);
2596 type = language_bool_type (exp->language_defn, exp->gdbarch);
2597 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2601 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2602 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2603 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2604 type = check_typedef (value_type (arg1));
2605 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2606 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2607 error (_("Attempt to dereference pointer "
2608 "to member without an object"));
2609 if (noside == EVAL_SKIP)
2610 return eval_skip_value (exp);
2611 if (unop_user_defined_p (op, arg1))
2612 return value_x_unop (arg1, op, noside);
2613 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2615 type = check_typedef (value_type (arg1));
2616 if (TYPE_CODE (type) == TYPE_CODE_PTR
2617 || TYPE_IS_REFERENCE (type)
2618 /* In C you can dereference an array to get the 1st elt. */
2619 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2621 return value_zero (TYPE_TARGET_TYPE (type),
2623 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2624 /* GDB allows dereferencing an int. */
2625 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2628 error (_("Attempt to take contents of a non-pointer value."));
2631 /* Allow * on an integer so we can cast it to whatever we want.
2632 This returns an int, which seems like the most C-like thing to
2633 do. "long long" variables are rare enough that
2634 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2635 if (TYPE_CODE (type) == TYPE_CODE_INT)
2636 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2637 (CORE_ADDR) value_as_address (arg1));
2638 return value_ind (arg1);
2641 /* C++: check for and handle pointer to members. */
2643 if (noside == EVAL_SKIP)
2645 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2646 return eval_skip_value (exp);
2650 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2657 if (noside == EVAL_SKIP)
2659 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2660 return eval_skip_value (exp);
2662 return evaluate_subexp_for_sizeof (exp, pos, noside);
2666 type = exp->elts[pc + 1].type;
2667 return evaluate_subexp_for_cast (exp, pos, noside, type);
2669 case UNOP_CAST_TYPE:
2670 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2671 type = value_type (arg1);
2672 return evaluate_subexp_for_cast (exp, pos, noside, type);
2674 case UNOP_DYNAMIC_CAST:
2675 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2676 type = value_type (arg1);
2677 arg1 = evaluate_subexp (type, exp, pos, noside);
2678 if (noside == EVAL_SKIP)
2679 return eval_skip_value (exp);
2680 return value_dynamic_cast (type, arg1);
2682 case UNOP_REINTERPRET_CAST:
2683 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2684 type = value_type (arg1);
2685 arg1 = evaluate_subexp (type, exp, pos, noside);
2686 if (noside == EVAL_SKIP)
2687 return eval_skip_value (exp);
2688 return value_reinterpret_cast (type, arg1);
2692 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2693 if (noside == EVAL_SKIP)
2694 return eval_skip_value (exp);
2695 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2696 return value_zero (exp->elts[pc + 1].type, lval_memory);
2698 return value_at_lazy (exp->elts[pc + 1].type,
2699 value_as_address (arg1));
2701 case UNOP_MEMVAL_TYPE:
2702 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2703 type = value_type (arg1);
2704 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2705 if (noside == EVAL_SKIP)
2706 return eval_skip_value (exp);
2707 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2708 return value_zero (type, lval_memory);
2710 return value_at_lazy (type, value_as_address (arg1));
2712 case UNOP_PREINCREMENT:
2713 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2714 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2716 else if (unop_user_defined_p (op, arg1))
2718 return value_x_unop (arg1, op, noside);
2722 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2723 arg2 = value_ptradd (arg1, 1);
2726 struct value *tmp = arg1;
2728 arg2 = value_one (value_type (arg1));
2729 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2730 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2733 return value_assign (arg1, arg2);
2736 case UNOP_PREDECREMENT:
2737 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2738 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2740 else if (unop_user_defined_p (op, arg1))
2742 return value_x_unop (arg1, op, noside);
2746 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2747 arg2 = value_ptradd (arg1, -1);
2750 struct value *tmp = arg1;
2752 arg2 = value_one (value_type (arg1));
2753 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2754 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2757 return value_assign (arg1, arg2);
2760 case UNOP_POSTINCREMENT:
2761 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2762 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2764 else if (unop_user_defined_p (op, arg1))
2766 return value_x_unop (arg1, op, noside);
2770 arg3 = value_non_lval (arg1);
2772 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2773 arg2 = value_ptradd (arg1, 1);
2776 struct value *tmp = arg1;
2778 arg2 = value_one (value_type (arg1));
2779 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2780 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2783 value_assign (arg1, arg2);
2787 case UNOP_POSTDECREMENT:
2788 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2789 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2791 else if (unop_user_defined_p (op, arg1))
2793 return value_x_unop (arg1, op, noside);
2797 arg3 = value_non_lval (arg1);
2799 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2800 arg2 = value_ptradd (arg1, -1);
2803 struct value *tmp = arg1;
2805 arg2 = value_one (value_type (arg1));
2806 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2807 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2810 value_assign (arg1, arg2);
2816 return value_of_this (exp->language_defn);
2819 /* The value is not supposed to be used. This is here to make it
2820 easier to accommodate expressions that contain types. */
2822 if (noside == EVAL_SKIP)
2823 return eval_skip_value (exp);
2824 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2825 return allocate_value (exp->elts[pc + 1].type);
2827 error (_("Attempt to use a type name as an expression"));
2831 if (noside == EVAL_SKIP)
2833 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2834 return eval_skip_value (exp);
2836 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2838 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2839 struct value *result;
2841 result = evaluate_subexp (NULL_TYPE, exp, pos,
2842 EVAL_AVOID_SIDE_EFFECTS);
2844 /* 'decltype' has special semantics for lvalues. */
2845 if (op == OP_DECLTYPE
2846 && (sub_op == BINOP_SUBSCRIPT
2847 || sub_op == STRUCTOP_MEMBER
2848 || sub_op == STRUCTOP_MPTR
2849 || sub_op == UNOP_IND
2850 || sub_op == STRUCTOP_STRUCT
2851 || sub_op == STRUCTOP_PTR
2852 || sub_op == OP_SCOPE))
2854 struct type *type = value_type (result);
2856 if (!TYPE_IS_REFERENCE (type))
2858 type = lookup_lvalue_reference_type (type);
2859 result = allocate_value (type);
2866 error (_("Attempt to use a type as an expression"));
2870 struct value *result;
2871 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2873 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2874 result = evaluate_subexp (NULL_TYPE, exp, pos,
2875 EVAL_AVOID_SIDE_EFFECTS);
2877 result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2879 if (noside != EVAL_NORMAL)
2880 return allocate_value (cplus_typeid_type (exp->gdbarch));
2882 return cplus_typeid (result);
2886 /* Removing this case and compiling with gcc -Wall reveals that
2887 a lot of cases are hitting this case. Some of these should
2888 probably be removed from expression.h; others are legitimate
2889 expressions which are (apparently) not fully implemented.
2891 If there are any cases landing here which mean a user error,
2892 then they should be separate cases, with more descriptive
2895 error (_("GDB does not (yet) know how to "
2896 "evaluate that kind of expression"));
2899 gdb_assert_not_reached ("missed return?");
2902 /* Evaluate a subexpression of EXP, at index *POS,
2903 and return the address of that subexpression.
2904 Advance *POS over the subexpression.
2905 If the subexpression isn't an lvalue, get an error.
2906 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2907 then only the type of the result need be correct. */
2909 static struct value *
2910 evaluate_subexp_for_address (struct expression *exp, int *pos,
2920 op = exp->elts[pc].opcode;
2926 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2928 /* We can't optimize out "&*" if there's a user-defined operator*. */
2929 if (unop_user_defined_p (op, x))
2931 x = value_x_unop (x, op, noside);
2932 goto default_case_after_eval;
2935 return coerce_array (x);
2939 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2940 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2942 case UNOP_MEMVAL_TYPE:
2947 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2948 type = value_type (x);
2949 return value_cast (lookup_pointer_type (type),
2950 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2954 var = exp->elts[pc + 2].symbol;
2956 /* C++: The "address" of a reference should yield the address
2957 * of the object pointed to. Let value_addr() deal with it. */
2958 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var)))
2962 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2965 lookup_pointer_type (SYMBOL_TYPE (var));
2966 enum address_class sym_class = SYMBOL_CLASS (var);
2968 if (sym_class == LOC_CONST
2969 || sym_class == LOC_CONST_BYTES
2970 || sym_class == LOC_REGISTER)
2971 error (_("Attempt to take address of register or constant."));
2974 value_zero (type, not_lval);
2977 return address_of_variable (var, exp->elts[pc + 1].block);
2979 case OP_VAR_MSYM_VALUE:
2983 value *val = evaluate_var_msym_value (noside,
2984 exp->elts[pc + 1].objfile,
2985 exp->elts[pc + 2].msymbol);
2986 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2988 struct type *type = lookup_pointer_type (value_type (val));
2989 return value_zero (type, not_lval);
2992 return value_addr (val);
2996 tem = longest_to_int (exp->elts[pc + 2].longconst);
2997 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2998 x = value_aggregate_elt (exp->elts[pc + 1].type,
2999 &exp->elts[pc + 3].string,
3002 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
3007 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
3008 default_case_after_eval:
3009 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3011 struct type *type = check_typedef (value_type (x));
3013 if (TYPE_IS_REFERENCE (type))
3014 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
3016 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
3017 return value_zero (lookup_pointer_type (value_type (x)),
3020 error (_("Attempt to take address of "
3021 "value not located in memory."));
3023 return value_addr (x);
3027 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3028 When used in contexts where arrays will be coerced anyway, this is
3029 equivalent to `evaluate_subexp' but much faster because it avoids
3030 actually fetching array contents (perhaps obsolete now that we have
3033 Note that we currently only do the coercion for C expressions, where
3034 arrays are zero based and the coercion is correct. For other languages,
3035 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3036 to decide if coercion is appropriate. */
3039 evaluate_subexp_with_coercion (struct expression *exp,
3040 int *pos, enum noside noside)
3049 op = exp->elts[pc].opcode;
3054 var = exp->elts[pc + 2].symbol;
3055 type = check_typedef (SYMBOL_TYPE (var));
3056 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
3057 && !TYPE_VECTOR (type)
3058 && CAST_IS_CONVERSION (exp->language_defn))
3061 val = address_of_variable (var, exp->elts[pc + 1].block);
3062 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
3068 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
3072 /* Evaluate a subexpression of EXP, at index *POS,
3073 and return a value for the size of that subexpression.
3074 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3075 we allow side-effects on the operand if its type is a variable
3078 static struct value *
3079 evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
3082 /* FIXME: This should be size_t. */
3083 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3090 op = exp->elts[pc].opcode;
3094 /* This case is handled specially
3095 so that we avoid creating a value for the result type.
3096 If the result type is very big, it's desirable not to
3097 create a value unnecessarily. */
3100 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3101 type = check_typedef (value_type (val));
3102 if (TYPE_CODE (type) != TYPE_CODE_PTR
3103 && !TYPE_IS_REFERENCE (type)
3104 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3105 error (_("Attempt to take contents of a non-pointer value."));
3106 type = TYPE_TARGET_TYPE (type);
3107 if (is_dynamic_type (type))
3108 type = value_type (value_ind (val));
3109 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3113 type = exp->elts[pc + 1].type;
3116 case UNOP_MEMVAL_TYPE:
3118 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3119 type = value_type (val);
3123 type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
3124 if (is_dynamic_type (type))
3126 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3127 type = value_type (val);
3133 case OP_VAR_MSYM_VALUE:
3137 minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
3138 value *val = evaluate_var_msym_value (noside,
3139 exp->elts[pc + 1].objfile,
3142 type = value_type (val);
3143 if (TYPE_CODE (type) == TYPE_CODE_ERROR)
3144 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
3146 return value_from_longest (size_type, TYPE_LENGTH (type));
3150 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3151 type of the subscript is a variable length array type. In this case we
3152 must re-evaluate the right hand side of the subcription to allow
3154 case BINOP_SUBSCRIPT:
3155 if (noside == EVAL_NORMAL)
3157 int pc = (*pos) + 1;
3159 val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
3160 type = check_typedef (value_type (val));
3161 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3163 type = check_typedef (TYPE_TARGET_TYPE (type));
3164 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3166 type = TYPE_INDEX_TYPE (type);
3167 /* Only re-evaluate the right hand side if the resulting type
3168 is a variable length type. */
3169 if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
3171 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3172 return value_from_longest
3173 (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
3182 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3183 type = value_type (val);
3187 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3188 "When applied to a reference or a reference type, the result is
3189 the size of the referenced type." */
3190 type = check_typedef (type);
3191 if (exp->language_defn->la_language == language_cplus
3192 && (TYPE_IS_REFERENCE (type)))
3193 type = check_typedef (TYPE_TARGET_TYPE (type));
3194 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3197 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3198 for that subexpression cast to TO_TYPE. Advance *POS over the
3202 evaluate_subexp_for_cast (expression *exp, int *pos,
3204 struct type *to_type)
3208 /* Don't let symbols be evaluated with evaluate_subexp because that
3209 throws an "unknown type" error for no-debug data symbols.
3210 Instead, we want the cast to reinterpret the symbol. */
3211 if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE
3212 || exp->elts[pc].opcode == OP_VAR_VALUE)
3217 if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE)
3219 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3220 return value_zero (to_type, not_lval);
3222 val = evaluate_var_msym_value (noside,
3223 exp->elts[pc + 1].objfile,
3224 exp->elts[pc + 2].msymbol);
3227 val = evaluate_var_value (noside,
3228 exp->elts[pc + 1].block,
3229 exp->elts[pc + 2].symbol);
3231 if (noside == EVAL_SKIP)
3232 return eval_skip_value (exp);
3234 val = value_cast (to_type, val);
3236 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3237 if (VALUE_LVAL (val) == lval_memory)
3239 if (value_lazy (val))
3240 value_fetch_lazy (val);
3241 VALUE_LVAL (val) = not_lval;
3246 value *val = evaluate_subexp (to_type, exp, pos, noside);
3247 if (noside == EVAL_SKIP)
3248 return eval_skip_value (exp);
3249 return value_cast (to_type, val);
3252 /* Parse a type expression in the string [P..P+LENGTH). */
3255 parse_and_eval_type (char *p, int length)
3257 char *tmp = (char *) alloca (length + 4);
3260 memcpy (tmp + 1, p, length);
3261 tmp[length + 1] = ')';
3262 tmp[length + 2] = '0';
3263 tmp[length + 3] = '\0';
3264 expression_up expr = parse_expression (tmp);
3265 if (expr->elts[0].opcode != UNOP_CAST)
3266 error (_("Internal error in eval_type."));
3267 return expr->elts[1].type;
3271 calc_f77_array_dims (struct type *array_type)
3274 struct type *tmp_type;
3276 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3277 error (_("Can't get dimensions for a non-array type"));
3279 tmp_type = array_type;
3281 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3283 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)