1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2018 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_ptid))
78 stack_temporaries.emplace (inferior_ptid);
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_ptid))
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, (struct block *) 0, 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)
219 throw_exception (ex);
225 new_mark = value_mark ();
226 if (mark == new_mark)
231 /* Make sure it's not lazy, so that after the target stops again we
232 have a non-lazy previous value to compare with. */
235 if (!value_lazy (result))
242 value_fetch_lazy (result);
245 CATCH (except, RETURN_MASK_ERROR)
254 /* Return the chain of intermediate values. We use this to
255 decide which addresses to watch. */
256 *val_chain = value_release_to_mark (mark);
260 /* Extract a field operation from an expression. If the subexpression
261 of EXP starting at *SUBEXP is not a structure dereference
262 operation, return NULL. Otherwise, return the name of the
263 dereferenced field, and advance *SUBEXP to point to the
264 subexpression of the left-hand-side of the dereference. This is
265 used when completing field names. */
268 extract_field_op (struct expression *exp, int *subexp)
273 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
274 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
276 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
277 result = &exp->elts[*subexp + 2].string;
278 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
282 /* This function evaluates brace-initializers (in C/C++) for
285 static struct value *
286 evaluate_struct_tuple (struct value *struct_val,
287 struct expression *exp,
288 int *pos, enum noside noside, int nargs)
290 struct type *struct_type = check_typedef (value_type (struct_val));
291 struct type *field_type;
296 struct value *val = NULL;
301 /* Skip static fields. */
302 while (fieldno < TYPE_NFIELDS (struct_type)
303 && field_is_static (&TYPE_FIELD (struct_type,
306 if (fieldno >= TYPE_NFIELDS (struct_type))
307 error (_("too many initializers"));
308 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
309 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
310 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
311 error (_("don't know which variant you want to set"));
313 /* Here, struct_type is the type of the inner struct,
314 while substruct_type is the type of the inner struct.
315 These are the same for normal structures, but a variant struct
316 contains anonymous union fields that contain substruct fields.
317 The value fieldno is the index of the top-level (normal or
318 anonymous union) field in struct_field, while the value
319 subfieldno is the index of the actual real (named inner) field
320 in substruct_type. */
322 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
324 val = evaluate_subexp (field_type, exp, pos, noside);
326 /* Now actually set the field in struct_val. */
328 /* Assign val to field fieldno. */
329 if (value_type (val) != field_type)
330 val = value_cast (field_type, val);
332 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
333 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
334 addr = value_contents_writeable (struct_val) + bitpos / 8;
336 modify_field (struct_type, addr,
337 value_as_long (val), bitpos % 8, bitsize);
339 memcpy (addr, value_contents (val),
340 TYPE_LENGTH (value_type (val)));
346 /* Recursive helper function for setting elements of array tuples.
347 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
348 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
349 Evaluates index expresions and sets the specified element(s) of
350 ARRAY to ELEMENT. Returns last index value. */
353 init_array_element (struct value *array, struct value *element,
354 struct expression *exp, int *pos,
355 enum noside noside, LONGEST low_bound, LONGEST high_bound)
358 int element_size = TYPE_LENGTH (value_type (element));
360 if (exp->elts[*pos].opcode == BINOP_COMMA)
363 init_array_element (array, element, exp, pos, noside,
364 low_bound, high_bound);
365 return init_array_element (array, element,
366 exp, pos, noside, low_bound, high_bound);
370 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
371 if (index < low_bound || index > high_bound)
372 error (_("tuple index out of range"));
373 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
374 value_contents (element), element_size);
379 static struct value *
380 value_f90_subarray (struct value *array,
381 struct expression *exp, int *pos, enum noside noside)
384 LONGEST low_bound, high_bound;
385 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
386 enum range_type range_type
387 = (enum range_type) longest_to_int (exp->elts[pc].longconst);
391 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
392 low_bound = TYPE_LOW_BOUND (range);
394 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
396 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
397 high_bound = TYPE_HIGH_BOUND (range);
399 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
401 return value_slice (array, low_bound, high_bound - low_bound + 1);
405 /* Promote value ARG1 as appropriate before performing a unary operation
407 If the result is not appropriate for any particular language then it
408 needs to patch this function. */
411 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
416 *arg1 = coerce_ref (*arg1);
417 type1 = check_typedef (value_type (*arg1));
419 if (is_integral_type (type1))
421 switch (language->la_language)
424 /* Perform integral promotion for ANSI C/C++.
425 If not appropropriate for any particular language
426 it needs to modify this function. */
428 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
430 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
431 *arg1 = value_cast (builtin_int, *arg1);
438 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
439 operation on those two operands.
440 If the result is not appropriate for any particular language then it
441 needs to patch this function. */
444 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
445 struct value **arg1, struct value **arg2)
447 struct type *promoted_type = NULL;
451 *arg1 = coerce_ref (*arg1);
452 *arg2 = coerce_ref (*arg2);
454 type1 = check_typedef (value_type (*arg1));
455 type2 = check_typedef (value_type (*arg2));
457 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
458 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
459 && !is_integral_type (type1))
460 || (TYPE_CODE (type2) != TYPE_CODE_FLT
461 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
462 && !is_integral_type (type2)))
465 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
466 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
468 /* No promotion required. */
470 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
471 || TYPE_CODE (type2) == TYPE_CODE_FLT)
473 switch (language->la_language)
479 case language_opencl:
480 /* No promotion required. */
484 /* For other languages the result type is unchanged from gdb
485 version 6.7 for backward compatibility.
486 If either arg was long double, make sure that value is also long
487 double. Otherwise use double. */
488 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
489 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
490 promoted_type = builtin_type (gdbarch)->builtin_long_double;
492 promoted_type = builtin_type (gdbarch)->builtin_double;
496 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
497 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
499 /* No promotion required. */
502 /* Integral operations here. */
503 /* FIXME: Also mixed integral/booleans, with result an integer. */
505 const struct builtin_type *builtin = builtin_type (gdbarch);
506 unsigned int promoted_len1 = TYPE_LENGTH (type1);
507 unsigned int promoted_len2 = TYPE_LENGTH (type2);
508 int is_unsigned1 = TYPE_UNSIGNED (type1);
509 int is_unsigned2 = TYPE_UNSIGNED (type2);
510 unsigned int result_len;
511 int unsigned_operation;
513 /* Determine type length and signedness after promotion for
515 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
518 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
520 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
523 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
526 if (promoted_len1 > promoted_len2)
528 unsigned_operation = is_unsigned1;
529 result_len = promoted_len1;
531 else if (promoted_len2 > promoted_len1)
533 unsigned_operation = is_unsigned2;
534 result_len = promoted_len2;
538 unsigned_operation = is_unsigned1 || is_unsigned2;
539 result_len = promoted_len1;
542 switch (language->la_language)
548 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
550 promoted_type = (unsigned_operation
551 ? builtin->builtin_unsigned_int
552 : builtin->builtin_int);
554 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
556 promoted_type = (unsigned_operation
557 ? builtin->builtin_unsigned_long
558 : builtin->builtin_long);
562 promoted_type = (unsigned_operation
563 ? builtin->builtin_unsigned_long_long
564 : builtin->builtin_long_long);
567 case language_opencl:
568 if (result_len <= TYPE_LENGTH (lookup_signed_typename
569 (language, gdbarch, "int")))
573 ? lookup_unsigned_typename (language, gdbarch, "int")
574 : lookup_signed_typename (language, gdbarch, "int"));
576 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
577 (language, gdbarch, "long")))
581 ? lookup_unsigned_typename (language, gdbarch, "long")
582 : lookup_signed_typename (language, gdbarch,"long"));
586 /* For other languages the result type is unchanged from gdb
587 version 6.7 for backward compatibility.
588 If either arg was long long, make sure that value is also long
589 long. Otherwise use long. */
590 if (unsigned_operation)
592 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
593 promoted_type = builtin->builtin_unsigned_long_long;
595 promoted_type = builtin->builtin_unsigned_long;
599 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
600 promoted_type = builtin->builtin_long_long;
602 promoted_type = builtin->builtin_long;
610 /* Promote both operands to common type. */
611 *arg1 = value_cast (promoted_type, *arg1);
612 *arg2 = value_cast (promoted_type, *arg2);
617 ptrmath_type_p (const struct language_defn *lang, struct type *type)
619 type = check_typedef (type);
620 if (TYPE_IS_REFERENCE (type))
621 type = TYPE_TARGET_TYPE (type);
623 switch (TYPE_CODE (type))
629 case TYPE_CODE_ARRAY:
630 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
637 /* Represents a fake method with the given parameter types. This is
638 used by the parser to construct a temporary "expected" type for
639 method overload resolution. FLAGS is used as instance flags of the
640 new type, in order to be able to make the new type represent a
641 const/volatile overload. */
646 fake_method (type_instance_flags flags,
647 int num_types, struct type **param_types);
650 /* The constructed type. */
651 struct type *type () { return &m_type; }
654 struct type m_type {};
655 main_type m_main_type {};
658 fake_method::fake_method (type_instance_flags flags,
659 int num_types, struct type **param_types)
661 struct type *type = &m_type;
663 TYPE_MAIN_TYPE (type) = &m_main_type;
664 TYPE_LENGTH (type) = 1;
665 TYPE_CODE (type) = TYPE_CODE_METHOD;
666 TYPE_CHAIN (type) = type;
667 TYPE_INSTANCE_FLAGS (type) = flags;
670 if (param_types[num_types - 1] == NULL)
673 TYPE_VARARGS (type) = 1;
675 else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
679 /* Caller should have ensured this. */
680 gdb_assert (num_types == 0);
681 TYPE_PROTOTYPED (type) = 1;
685 TYPE_NFIELDS (type) = num_types;
686 TYPE_FIELDS (type) = (struct field *)
687 TYPE_ZALLOC (type, sizeof (struct field) * num_types);
689 while (num_types-- > 0)
690 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
693 fake_method::~fake_method ()
695 xfree (TYPE_FIELDS (&m_type));
698 /* Helper for evaluating an OP_VAR_VALUE. */
701 evaluate_var_value (enum noside noside, const block *blk, symbol *var)
703 /* JYG: We used to just return value_zero of the symbol type if
704 we're asked to avoid side effects. Otherwise we return
705 value_of_variable (...). However I'm not sure if
706 value_of_variable () has any side effect. We need a full value
707 object returned here for whatis_exp () to call evaluate_type ()
708 and then pass the full value to value_rtti_target_type () if we
709 are dealing with a pointer or reference to a base class and print
712 struct value *ret = NULL;
716 ret = value_of_variable (var, blk);
719 CATCH (except, RETURN_MASK_ERROR)
721 if (noside != EVAL_AVOID_SIDE_EFFECTS)
722 throw_exception (except);
724 ret = value_zero (SYMBOL_TYPE (var), not_lval);
731 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
734 evaluate_var_msym_value (enum noside noside,
735 struct objfile *objfile, minimal_symbol *msymbol)
738 type *the_type = find_minsym_type_and_address (msymbol, objfile, &address);
740 if (noside == EVAL_AVOID_SIDE_EFFECTS && !TYPE_GNU_IFUNC (the_type))
741 return value_zero (the_type, not_lval);
743 return value_at_lazy (the_type, address);
746 /* Helper for returning a value when handling EVAL_SKIP. */
749 eval_skip_value (expression *exp)
751 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
754 /* Evaluate a function call. The function to be called is in
755 ARGVEC[0] and the arguments passed to the function are in
756 ARGVEC[1..NARGS]. FUNCTION_NAME is the name of the function, if
757 known. DEFAULT_RETURN_TYPE is used as the function's return type
758 if the return type is unknown. */
761 eval_call (expression *exp, enum noside noside,
762 int nargs, value **argvec,
763 const char *function_name,
764 type *default_return_type)
766 if (argvec[0] == NULL)
767 error (_("Cannot evaluate function -- may be inlined"));
768 if (noside == EVAL_AVOID_SIDE_EFFECTS)
770 /* If the return type doesn't look like a function type,
771 call an error. This can happen if somebody tries to turn
772 a variable into a function call. */
774 type *ftype = value_type (argvec[0]);
776 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
778 /* We don't know anything about what the internal
779 function might return, but we have to return
781 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
784 else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
787 = result_type_of_xmethod (argvec[0], nargs, argvec + 1);
789 if (return_type == NULL)
790 error (_("Xmethod is missing return type."));
791 return value_zero (return_type, not_lval);
793 else if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
794 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
796 if (TYPE_GNU_IFUNC (ftype))
798 CORE_ADDR address = value_address (argvec[0]);
799 type *resolved_type = find_gnu_ifunc_target_type (address);
801 if (resolved_type != NULL)
802 ftype = resolved_type;
805 type *return_type = TYPE_TARGET_TYPE (ftype);
807 if (return_type == NULL)
808 return_type = default_return_type;
810 if (return_type == NULL)
811 error_call_unknown_return_type (function_name);
813 return allocate_value (return_type);
816 error (_("Expression of type other than "
817 "\"Function returning ...\" used as function"));
819 switch (TYPE_CODE (value_type (argvec[0])))
821 case TYPE_CODE_INTERNAL_FUNCTION:
822 return call_internal_function (exp->gdbarch, exp->language_defn,
823 argvec[0], nargs, argvec + 1);
824 case TYPE_CODE_XMETHOD:
825 return call_xmethod (argvec[0], nargs, argvec + 1);
827 return call_function_by_hand (argvec[0], default_return_type,
832 /* Helper for evaluating an OP_FUNCALL. */
835 evaluate_funcall (type *expect_type, expression *exp, int *pos,
843 symbol *function = NULL;
844 char *function_name = NULL;
845 const char *var_func_name = NULL;
850 exp_opcode op = exp->elts[*pos].opcode;
851 int nargs = longest_to_int (exp->elts[pc].longconst);
852 /* Allocate arg vector, including space for the function to be
853 called in argvec[0], a potential `this', and a terminating
855 value **argvec = (value **) alloca (sizeof (value *) * (nargs + 3));
856 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
858 /* First, evaluate the structure into arg2. */
861 if (op == STRUCTOP_MEMBER)
863 arg2 = evaluate_subexp_for_address (exp, pos, noside);
867 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
870 /* If the function is a virtual function, then the aggregate
871 value (providing the structure) plays its part by providing
872 the vtable. Otherwise, it is just along for the ride: call
873 the function directly. */
875 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
877 type *a1_type = check_typedef (value_type (arg1));
878 if (noside == EVAL_SKIP)
879 tem = 1; /* Set it to the right arg index so that all
880 arguments can also be skipped. */
881 else if (TYPE_CODE (a1_type) == TYPE_CODE_METHODPTR)
883 if (noside == EVAL_AVOID_SIDE_EFFECTS)
884 arg1 = value_zero (TYPE_TARGET_TYPE (a1_type), not_lval);
886 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
888 /* Now, say which argument to start evaluating from. */
893 else if (TYPE_CODE (a1_type) == TYPE_CODE_MEMBERPTR)
895 struct type *type_ptr
896 = lookup_pointer_type (TYPE_SELF_TYPE (a1_type));
897 struct type *target_type_ptr
898 = lookup_pointer_type (TYPE_TARGET_TYPE (a1_type));
900 /* Now, convert these values to an address. */
901 arg2 = value_cast (type_ptr, arg2);
903 long mem_offset = value_as_long (arg1);
905 arg1 = value_from_pointer (target_type_ptr,
906 value_as_long (arg2) + mem_offset);
907 arg1 = value_ind (arg1);
911 error (_("Non-pointer-to-member value used in pointer-to-member "
914 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
916 /* Hair for method invocations. */
920 /* First, evaluate the structure into arg2. */
922 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
923 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
925 if (op == STRUCTOP_STRUCT)
927 /* If v is a variable in a register, and the user types
928 v.method (), this will produce an error, because v has no
931 A possible way around this would be to allocate a copy of
932 the variable on the stack, copy in the contents, call the
933 function, and copy out the contents. I.e. convert this
934 from call by reference to call by copy-return (or
935 whatever it's called). However, this does not work
936 because it is not the same: the method being called could
937 stash a copy of the address, and then future uses through
938 that address (after the method returns) would be expected
939 to use the variable itself, not some copy of it. */
940 arg2 = evaluate_subexp_for_address (exp, pos, noside);
944 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
946 /* Check to see if the operator '->' has been overloaded.
947 If the operator has been overloaded replace arg2 with the
948 value returned by the custom operator and continue
950 while (unop_user_defined_p (op, arg2))
952 struct value *value = NULL;
955 value = value_x_unop (arg2, op, noside);
958 CATCH (except, RETURN_MASK_ERROR)
960 if (except.error == NOT_FOUND_ERROR)
963 throw_exception (except);
970 /* Now, say which argument to start evaluating from. */
973 else if (op == OP_SCOPE
974 && overload_resolution
975 && (exp->language_defn->la_language == language_cplus))
977 /* Unpack it locally so we can properly handle overload
983 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
984 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
985 struct type *type = exp->elts[pc2 + 1].type;
986 name = &exp->elts[pc2 + 3].string;
989 function_name = NULL;
990 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
992 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
994 get_selected_block (0),
996 if (function == NULL)
997 error (_("No symbol \"%s\" in namespace \"%s\"."),
998 name, TYPE_TAG_NAME (type));
1001 /* arg2 is left as NULL on purpose. */
1005 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1006 || TYPE_CODE (type) == TYPE_CODE_UNION);
1007 function_name = name;
1009 /* We need a properly typed value for method lookup. For
1010 static methods arg2 is otherwise unused. */
1011 arg2 = value_zero (type, lval_memory);
1016 else if (op == OP_ADL_FUNC)
1018 /* Save the function position and move pos so that the arguments
1019 can be evaluated. */
1025 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1026 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1030 /* Non-method function call. */
1034 /* If this is a C++ function wait until overload resolution. */
1035 if (op == OP_VAR_VALUE
1036 && overload_resolution
1037 && (exp->language_defn->la_language == language_cplus))
1039 (*pos) += 4; /* Skip the evaluation of the symbol. */
1044 if (op == OP_VAR_MSYM_VALUE)
1046 minimal_symbol *msym = exp->elts[*pos + 2].msymbol;
1047 var_func_name = MSYMBOL_PRINT_NAME (msym);
1049 else if (op == OP_VAR_VALUE)
1051 symbol *sym = exp->elts[*pos + 2].symbol;
1052 var_func_name = SYMBOL_PRINT_NAME (sym);
1055 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1056 type *type = value_type (argvec[0]);
1057 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1058 type = TYPE_TARGET_TYPE (type);
1059 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1061 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1063 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1071 /* Evaluate arguments (if not already done, e.g., namespace::func()
1072 and overload-resolution is off). */
1073 for (; tem <= nargs; tem++)
1075 /* Ensure that array expressions are coerced into pointer
1077 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1080 /* Signal end of arglist. */
1083 if (noside == EVAL_SKIP)
1084 return eval_skip_value (exp);
1086 if (op == OP_ADL_FUNC)
1088 struct symbol *symp;
1091 int string_pc = save_pos1 + 3;
1093 /* Extract the function name. */
1094 name_len = longest_to_int (exp->elts[string_pc].longconst);
1095 func_name = (char *) alloca (name_len + 1);
1096 strcpy (func_name, &exp->elts[string_pc + 1].string);
1098 find_overload_match (&argvec[1], nargs, func_name,
1099 NON_METHOD, /* not method */
1100 NULL, NULL, /* pass NULL symbol since
1101 symbol is unknown */
1102 NULL, &symp, NULL, 0, noside);
1104 /* Now fix the expression being evaluated. */
1105 exp->elts[save_pos1 + 2].symbol = symp;
1106 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1109 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1110 || (op == OP_SCOPE && function_name != NULL))
1112 int static_memfuncp;
1115 /* Method invocation: stuff "this" as first parameter. If the
1116 method turns out to be static we undo this below. */
1121 /* Name of method from expression. */
1122 tstr = &exp->elts[pc2 + 2].string;
1125 tstr = function_name;
1127 if (overload_resolution && (exp->language_defn->la_language
1130 /* Language is C++, do some overload resolution before
1132 struct value *valp = NULL;
1134 (void) find_overload_match (&argvec[1], nargs, tstr,
1135 METHOD, /* method */
1136 &arg2, /* the object */
1138 &static_memfuncp, 0, noside);
1140 if (op == OP_SCOPE && !static_memfuncp)
1142 /* For the time being, we don't handle this. */
1143 error (_("Call to overloaded function %s requires "
1147 argvec[1] = arg2; /* the ``this'' pointer */
1148 argvec[0] = valp; /* Use the method found after overload
1152 /* Non-C++ case -- or no overload resolution. */
1154 struct value *temp = arg2;
1156 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1158 op == STRUCTOP_STRUCT
1159 ? "structure" : "structure pointer");
1160 /* value_struct_elt updates temp with the correct value of
1161 the ``this'' pointer if necessary, so modify argvec[1] to
1162 reflect any ``this'' changes. */
1164 = value_from_longest (lookup_pointer_type(value_type (temp)),
1165 value_address (temp)
1166 + value_embedded_offset (temp));
1167 argvec[1] = arg2; /* the ``this'' pointer */
1170 /* Take out `this' if needed. */
1171 if (static_memfuncp)
1173 argvec[1] = argvec[0];
1178 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1180 /* Pointer to member. argvec[1] is already set up. */
1183 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1185 /* Non-member function being called. */
1186 /* fn: This can only be done for C++ functions. A C-style
1187 function in a C++ program, for instance, does not have the
1188 fields that are expected here. */
1190 if (overload_resolution && (exp->language_defn->la_language
1193 /* Language is C++, do some overload resolution before
1195 struct symbol *symp;
1198 /* If a scope has been specified disable ADL. */
1202 if (op == OP_VAR_VALUE)
1203 function = exp->elts[save_pos1+2].symbol;
1205 (void) find_overload_match (&argvec[1], nargs,
1206 NULL, /* no need for name */
1207 NON_METHOD, /* not method */
1208 NULL, function, /* the function */
1209 NULL, &symp, NULL, no_adl, noside);
1211 if (op == OP_VAR_VALUE)
1213 /* Now fix the expression being evaluated. */
1214 exp->elts[save_pos1+2].symbol = symp;
1215 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1219 argvec[0] = value_of_variable (symp, get_selected_block (0));
1223 /* Not C++, or no overload resolution allowed. */
1224 /* Nothing to be done; argvec already correctly set up. */
1229 /* It is probably a C-style function. */
1230 /* Nothing to be done; argvec already correctly set up. */
1233 return eval_call (exp, noside, nargs, argvec, var_func_name, expect_type);
1237 evaluate_subexp_standard (struct type *expect_type,
1238 struct expression *exp, int *pos,
1242 int tem, tem2, tem3;
1244 struct value *arg1 = NULL;
1245 struct value *arg2 = NULL;
1249 struct value **argvec;
1253 struct type **arg_types;
1256 op = exp->elts[pc].opcode;
1261 tem = longest_to_int (exp->elts[pc + 2].longconst);
1262 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
1263 if (noside == EVAL_SKIP)
1264 return eval_skip_value (exp);
1265 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
1266 &exp->elts[pc + 3].string,
1267 expect_type, 0, noside);
1269 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
1274 return value_from_longest (exp->elts[pc + 1].type,
1275 exp->elts[pc + 2].longconst);
1279 return value_from_contents (exp->elts[pc + 1].type,
1280 exp->elts[pc + 2].floatconst);
1285 if (noside == EVAL_SKIP)
1286 return eval_skip_value (exp);
1289 symbol *var = exp->elts[pc + 2].symbol;
1290 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR)
1291 error_unknown_type (SYMBOL_PRINT_NAME (var));
1293 return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
1296 case OP_VAR_MSYM_VALUE:
1300 minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
1301 value *val = evaluate_var_msym_value (noside,
1302 exp->elts[pc + 1].objfile,
1305 type = value_type (val);
1306 if (TYPE_CODE (type) == TYPE_CODE_ERROR
1307 && (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0))
1308 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
1312 case OP_VAR_ENTRY_VALUE:
1314 if (noside == EVAL_SKIP)
1315 return eval_skip_value (exp);
1318 struct symbol *sym = exp->elts[pc + 1].symbol;
1319 struct frame_info *frame;
1321 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1322 return value_zero (SYMBOL_TYPE (sym), not_lval);
1324 if (SYMBOL_COMPUTED_OPS (sym) == NULL
1325 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
1326 error (_("Symbol \"%s\" does not have any specific entry value"),
1327 SYMBOL_PRINT_NAME (sym));
1329 frame = get_selected_frame (NULL);
1330 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
1333 case OP_FUNC_STATIC_VAR:
1334 tem = longest_to_int (exp->elts[pc + 1].longconst);
1335 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1336 if (noside == EVAL_SKIP)
1337 return eval_skip_value (exp);
1340 value *func = evaluate_subexp_standard (NULL, exp, pos, noside);
1341 CORE_ADDR addr = value_address (func);
1343 const block *blk = block_for_pc (addr);
1344 const char *var = &exp->elts[pc + 2].string;
1346 struct block_symbol sym = lookup_symbol (var, blk, VAR_DOMAIN, NULL);
1348 if (sym.symbol == NULL)
1349 error (_("No symbol \"%s\" in specified context."), var);
1351 return evaluate_var_value (noside, sym.block, sym.symbol);
1357 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
1361 const char *name = &exp->elts[pc + 2].string;
1365 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
1366 regno = user_reg_map_name_to_regnum (exp->gdbarch,
1367 name, strlen (name));
1369 error (_("Register $%s not available."), name);
1371 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
1372 a value with the appropriate register type. Unfortunately,
1373 we don't have easy access to the type of user registers.
1374 So for these registers, we fetch the register value regardless
1375 of the evaluation mode. */
1376 if (noside == EVAL_AVOID_SIDE_EFFECTS
1377 && regno < gdbarch_num_regs (exp->gdbarch)
1378 + gdbarch_num_pseudo_regs (exp->gdbarch))
1379 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
1381 val = value_of_register (regno, get_selected_frame (NULL));
1383 error (_("Value of register %s not available."), name);
1389 type = language_bool_type (exp->language_defn, exp->gdbarch);
1390 return value_from_longest (type, exp->elts[pc + 1].longconst);
1392 case OP_INTERNALVAR:
1394 return value_of_internalvar (exp->gdbarch,
1395 exp->elts[pc + 1].internalvar);
1398 tem = longest_to_int (exp->elts[pc + 1].longconst);
1399 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1400 if (noside == EVAL_SKIP)
1401 return eval_skip_value (exp);
1402 type = language_string_char_type (exp->language_defn, exp->gdbarch);
1403 return value_string (&exp->elts[pc + 2].string, tem, type);
1405 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
1406 NSString constant. */
1407 tem = longest_to_int (exp->elts[pc + 1].longconst);
1408 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1409 if (noside == EVAL_SKIP)
1410 return eval_skip_value (exp);
1411 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
1415 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
1416 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
1417 nargs = tem3 - tem2 + 1;
1418 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
1420 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1421 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
1423 struct value *rec = allocate_value (expect_type);
1425 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
1426 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
1429 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1430 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
1432 struct type *range_type = TYPE_INDEX_TYPE (type);
1433 struct type *element_type = TYPE_TARGET_TYPE (type);
1434 struct value *array = allocate_value (expect_type);
1435 int element_size = TYPE_LENGTH (check_typedef (element_type));
1436 LONGEST low_bound, high_bound, index;
1438 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
1441 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
1444 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
1445 for (tem = nargs; --nargs >= 0;)
1447 struct value *element;
1450 element = evaluate_subexp (element_type, exp, pos, noside);
1451 if (value_type (element) != element_type)
1452 element = value_cast (element_type, element);
1455 int continue_pc = *pos;
1458 index = init_array_element (array, element, exp, pos, noside,
1459 low_bound, high_bound);
1464 if (index > high_bound)
1465 /* To avoid memory corruption. */
1466 error (_("Too many array elements"));
1467 memcpy (value_contents_raw (array)
1468 + (index - low_bound) * element_size,
1469 value_contents (element),
1477 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1478 && TYPE_CODE (type) == TYPE_CODE_SET)
1480 struct value *set = allocate_value (expect_type);
1481 gdb_byte *valaddr = value_contents_raw (set);
1482 struct type *element_type = TYPE_INDEX_TYPE (type);
1483 struct type *check_type = element_type;
1484 LONGEST low_bound, high_bound;
1486 /* Get targettype of elementtype. */
1487 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
1488 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
1489 check_type = TYPE_TARGET_TYPE (check_type);
1491 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
1492 error (_("(power)set type with unknown size"));
1493 memset (valaddr, '\0', TYPE_LENGTH (type));
1494 for (tem = 0; tem < nargs; tem++)
1496 LONGEST range_low, range_high;
1497 struct type *range_low_type, *range_high_type;
1498 struct value *elem_val;
1500 elem_val = evaluate_subexp (element_type, exp, pos, noside);
1501 range_low_type = range_high_type = value_type (elem_val);
1502 range_low = range_high = value_as_long (elem_val);
1504 /* Check types of elements to avoid mixture of elements from
1505 different types. Also check if type of element is "compatible"
1506 with element type of powerset. */
1507 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
1508 range_low_type = TYPE_TARGET_TYPE (range_low_type);
1509 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
1510 range_high_type = TYPE_TARGET_TYPE (range_high_type);
1511 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
1512 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
1513 && (range_low_type != range_high_type)))
1514 /* different element modes. */
1515 error (_("POWERSET tuple elements of different mode"));
1516 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
1517 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
1518 && range_low_type != check_type))
1519 error (_("incompatible POWERSET tuple elements"));
1520 if (range_low > range_high)
1522 warning (_("empty POWERSET tuple range"));
1525 if (range_low < low_bound || range_high > high_bound)
1526 error (_("POWERSET tuple element out of range"));
1527 range_low -= low_bound;
1528 range_high -= low_bound;
1529 for (; range_low <= range_high; range_low++)
1531 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
1533 if (gdbarch_bits_big_endian (exp->gdbarch))
1534 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
1535 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1542 argvec = XALLOCAVEC (struct value *, nargs);
1543 for (tem = 0; tem < nargs; tem++)
1545 /* Ensure that array expressions are coerced into pointer
1547 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1549 if (noside == EVAL_SKIP)
1550 return eval_skip_value (exp);
1551 return value_array (tem2, tem3, argvec);
1555 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1557 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1559 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1561 if (noside == EVAL_SKIP)
1562 return eval_skip_value (exp);
1563 return value_slice (array, lowbound, upper - lowbound + 1);
1567 /* Skip third and second args to evaluate the first one. */
1568 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1569 if (value_logical_not (arg1))
1571 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1572 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1576 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1577 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1581 case OP_OBJC_SELECTOR:
1582 { /* Objective C @selector operator. */
1583 char *sel = &exp->elts[pc + 2].string;
1584 int len = longest_to_int (exp->elts[pc + 1].longconst);
1585 struct type *selector_type;
1587 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1588 if (noside == EVAL_SKIP)
1589 return eval_skip_value (exp);
1592 sel[len] = 0; /* Make sure it's terminated. */
1594 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1595 return value_from_longest (selector_type,
1596 lookup_child_selector (exp->gdbarch, sel));
1599 case OP_OBJC_MSGCALL:
1600 { /* Objective C message (method) call. */
1602 CORE_ADDR responds_selector = 0;
1603 CORE_ADDR method_selector = 0;
1605 CORE_ADDR selector = 0;
1607 int struct_return = 0;
1608 enum noside sub_no_side = EVAL_NORMAL;
1610 struct value *msg_send = NULL;
1611 struct value *msg_send_stret = NULL;
1612 int gnu_runtime = 0;
1614 struct value *target = NULL;
1615 struct value *method = NULL;
1616 struct value *called_method = NULL;
1618 struct type *selector_type = NULL;
1619 struct type *long_type;
1621 struct value *ret = NULL;
1624 selector = exp->elts[pc + 1].longconst;
1625 nargs = exp->elts[pc + 2].longconst;
1626 argvec = XALLOCAVEC (struct value *, nargs + 5);
1630 long_type = builtin_type (exp->gdbarch)->builtin_long;
1631 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1633 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1634 sub_no_side = EVAL_NORMAL;
1636 sub_no_side = noside;
1638 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1640 if (value_as_long (target) == 0)
1641 return value_from_longest (long_type, 0);
1643 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
1646 /* Find the method dispatch (Apple runtime) or method lookup
1647 (GNU runtime) function for Objective-C. These will be used
1648 to lookup the symbol information for the method. If we
1649 can't find any symbol information, then we'll use these to
1650 call the method, otherwise we can call the method
1651 directly. The msg_send_stret function is used in the special
1652 case of a method that returns a structure (Apple runtime
1656 struct type *type = selector_type;
1658 type = lookup_function_type (type);
1659 type = lookup_pointer_type (type);
1660 type = lookup_function_type (type);
1661 type = lookup_pointer_type (type);
1663 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1665 = find_function_in_inferior ("objc_msg_lookup", NULL);
1667 msg_send = value_from_pointer (type, value_as_address (msg_send));
1668 msg_send_stret = value_from_pointer (type,
1669 value_as_address (msg_send_stret));
1673 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1674 /* Special dispatcher for methods returning structs. */
1676 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1679 /* Verify the target object responds to this method. The
1680 standard top-level 'Object' class uses a different name for
1681 the verification method than the non-standard, but more
1682 often used, 'NSObject' class. Make sure we check for both. */
1685 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1686 if (responds_selector == 0)
1688 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1690 if (responds_selector == 0)
1691 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1694 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1695 if (method_selector == 0)
1697 = lookup_child_selector (exp->gdbarch, "methodFor:");
1699 if (method_selector == 0)
1700 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1702 /* Call the verification method, to make sure that the target
1703 class implements the desired method. */
1705 argvec[0] = msg_send;
1707 argvec[2] = value_from_longest (long_type, responds_selector);
1708 argvec[3] = value_from_longest (long_type, selector);
1711 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1714 /* Function objc_msg_lookup returns a pointer. */
1716 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1718 if (value_as_long (ret) == 0)
1719 error (_("Target does not respond to this message selector."));
1721 /* Call "methodForSelector:" method, to get the address of a
1722 function method that implements this selector for this
1723 class. If we can find a symbol at that address, then we
1724 know the return type, parameter types etc. (that's a good
1727 argvec[0] = msg_send;
1729 argvec[2] = value_from_longest (long_type, method_selector);
1730 argvec[3] = value_from_longest (long_type, selector);
1733 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1737 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1740 /* ret should now be the selector. */
1742 addr = value_as_long (ret);
1745 struct symbol *sym = NULL;
1747 /* The address might point to a function descriptor;
1748 resolve it to the actual code address instead. */
1749 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1752 /* Is it a high_level symbol? */
1753 sym = find_pc_function (addr);
1755 method = value_of_variable (sym, 0);
1758 /* If we found a method with symbol information, check to see
1759 if it returns a struct. Otherwise assume it doesn't. */
1764 struct type *val_type;
1766 funaddr = find_function_addr (method, &val_type);
1768 block_for_pc (funaddr);
1770 val_type = check_typedef (val_type);
1772 if ((val_type == NULL)
1773 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1775 if (expect_type != NULL)
1776 val_type = expect_type;
1779 struct_return = using_struct_return (exp->gdbarch, method,
1782 else if (expect_type != NULL)
1784 struct_return = using_struct_return (exp->gdbarch, NULL,
1785 check_typedef (expect_type));
1788 /* Found a function symbol. Now we will substitute its
1789 value in place of the message dispatcher (obj_msgSend),
1790 so that we call the method directly instead of thru
1791 the dispatcher. The main reason for doing this is that
1792 we can now evaluate the return value and parameter values
1793 according to their known data types, in case we need to
1794 do things like promotion, dereferencing, special handling
1795 of structs and doubles, etc.
1797 We want to use the type signature of 'method', but still
1798 jump to objc_msgSend() or objc_msgSend_stret() to better
1799 mimic the behavior of the runtime. */
1803 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1804 error (_("method address has symbol information "
1805 "with non-function type; skipping"));
1807 /* Create a function pointer of the appropriate type, and
1808 replace its value with the value of msg_send or
1809 msg_send_stret. We must use a pointer here, as
1810 msg_send and msg_send_stret are of pointer type, and
1811 the representation may be different on systems that use
1812 function descriptors. */
1815 = value_from_pointer (lookup_pointer_type (value_type (method)),
1816 value_as_address (msg_send_stret));
1819 = value_from_pointer (lookup_pointer_type (value_type (method)),
1820 value_as_address (msg_send));
1825 called_method = msg_send_stret;
1827 called_method = msg_send;
1830 if (noside == EVAL_SKIP)
1831 return eval_skip_value (exp);
1833 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1835 /* If the return type doesn't look like a function type,
1836 call an error. This can happen if somebody tries to
1837 turn a variable into a function call. This is here
1838 because people often want to call, eg, strcmp, which
1839 gdb doesn't know is a function. If gdb isn't asked for
1840 it's opinion (ie. through "whatis"), it won't offer
1843 struct type *type = value_type (called_method);
1845 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1846 type = TYPE_TARGET_TYPE (type);
1847 type = TYPE_TARGET_TYPE (type);
1851 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1852 return allocate_value (expect_type);
1854 return allocate_value (type);
1857 error (_("Expression of type other than "
1858 "\"method returning ...\" used as a method"));
1861 /* Now depending on whether we found a symbol for the method,
1862 we will either call the runtime dispatcher or the method
1865 argvec[0] = called_method;
1867 argvec[2] = value_from_longest (long_type, selector);
1868 /* User-supplied arguments. */
1869 for (tem = 0; tem < nargs; tem++)
1870 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1871 argvec[tem + 3] = 0;
1873 if (gnu_runtime && (method != NULL))
1875 /* Function objc_msg_lookup returns a pointer. */
1876 deprecated_set_value_type (argvec[0],
1877 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1879 = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
1882 ret = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
1888 return evaluate_funcall (expect_type, exp, pos, noside);
1890 case OP_F77_UNDETERMINED_ARGLIST:
1892 /* Remember that in F77, functions, substring ops and
1893 array subscript operations cannot be disambiguated
1894 at parse time. We have made all array subscript operations,
1895 substring operations as well as function calls come here
1896 and we now have to discover what the heck this thing actually was.
1897 If it is a function, we process just as if we got an OP_FUNCALL. */
1899 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1902 /* First determine the type code we are dealing with. */
1903 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1904 type = check_typedef (value_type (arg1));
1905 code = TYPE_CODE (type);
1907 if (code == TYPE_CODE_PTR)
1909 /* Fortran always passes variable to subroutines as pointer.
1910 So we need to look into its target type to see if it is
1911 array, string or function. If it is, we need to switch
1912 to the target value the original one points to. */
1913 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1915 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1916 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1917 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1919 arg1 = value_ind (arg1);
1920 type = check_typedef (value_type (arg1));
1921 code = TYPE_CODE (type);
1927 case TYPE_CODE_ARRAY:
1928 if (exp->elts[*pos].opcode == OP_RANGE)
1929 return value_f90_subarray (arg1, exp, pos, noside);
1931 goto multi_f77_subscript;
1933 case TYPE_CODE_STRING:
1934 if (exp->elts[*pos].opcode == OP_RANGE)
1935 return value_f90_subarray (arg1, exp, pos, noside);
1938 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1939 return value_subscript (arg1, value_as_long (arg2));
1943 case TYPE_CODE_FUNC:
1944 /* It's a function call. */
1945 /* Allocate arg vector, including space for the function to be
1946 called in argvec[0] and a terminating NULL. */
1947 argvec = (struct value **)
1948 alloca (sizeof (struct value *) * (nargs + 2));
1951 for (; tem <= nargs; tem++)
1952 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1953 argvec[tem] = 0; /* signal end of arglist */
1954 if (noside == EVAL_SKIP)
1955 return eval_skip_value (exp);
1956 return eval_call (exp, noside, nargs, argvec, NULL, expect_type);
1959 error (_("Cannot perform substring on this type"));
1963 /* We have a complex number, There should be 2 floating
1964 point numbers that compose it. */
1966 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1967 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1969 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1971 case STRUCTOP_STRUCT:
1972 tem = longest_to_int (exp->elts[pc + 1].longconst);
1973 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1974 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1975 if (noside == EVAL_SKIP)
1976 return eval_skip_value (exp);
1977 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1979 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1980 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
1984 tem = longest_to_int (exp->elts[pc + 1].longconst);
1985 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1986 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1987 if (noside == EVAL_SKIP)
1988 return eval_skip_value (exp);
1990 /* Check to see if operator '->' has been overloaded. If so replace
1991 arg1 with the value returned by evaluating operator->(). */
1992 while (unop_user_defined_p (op, arg1))
1994 struct value *value = NULL;
1997 value = value_x_unop (arg1, op, noside);
2000 CATCH (except, RETURN_MASK_ERROR)
2002 if (except.error == NOT_FOUND_ERROR)
2005 throw_exception (except);
2012 /* JYG: if print object is on we need to replace the base type
2013 with rtti type in order to continue on with successful
2014 lookup of member / method only available in the rtti type. */
2016 struct type *type = value_type (arg1);
2017 struct type *real_type;
2018 int full, using_enc;
2020 struct value_print_options opts;
2022 get_user_print_options (&opts);
2023 if (opts.objectprint && TYPE_TARGET_TYPE(type)
2024 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
2026 real_type = value_rtti_indirect_type (arg1, &full, &top,
2029 arg1 = value_cast (real_type, arg1);
2033 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
2034 NULL, "structure pointer");
2035 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2036 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
2039 case STRUCTOP_MEMBER:
2041 if (op == STRUCTOP_MEMBER)
2042 arg1 = evaluate_subexp_for_address (exp, pos, noside);
2044 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2046 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2048 if (noside == EVAL_SKIP)
2049 return eval_skip_value (exp);
2051 type = check_typedef (value_type (arg2));
2052 switch (TYPE_CODE (type))
2054 case TYPE_CODE_METHODPTR:
2055 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2056 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
2059 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
2060 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
2061 return value_ind (arg2);
2064 case TYPE_CODE_MEMBERPTR:
2065 /* Now, convert these values to an address. */
2066 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
2069 mem_offset = value_as_long (arg2);
2071 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2072 value_as_long (arg1) + mem_offset);
2073 return value_ind (arg3);
2076 error (_("non-pointer-to-member value used "
2077 "in pointer-to-member construct"));
2082 type_instance_flags flags
2083 = (type_instance_flag_value) longest_to_int (exp->elts[pc + 1].longconst);
2084 nargs = longest_to_int (exp->elts[pc + 2].longconst);
2085 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
2086 for (ix = 0; ix < nargs; ++ix)
2087 arg_types[ix] = exp->elts[pc + 2 + ix + 1].type;
2089 fake_method expect_type (flags, nargs, arg_types);
2090 *(pos) += 4 + nargs;
2091 return evaluate_subexp_standard (expect_type.type (), exp, pos, noside);
2095 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2096 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2097 if (noside == EVAL_SKIP)
2098 return eval_skip_value (exp);
2099 if (binop_user_defined_p (op, arg1, arg2))
2100 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2102 return value_concat (arg1, arg2);
2105 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2106 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2108 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2110 if (binop_user_defined_p (op, arg1, arg2))
2111 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2113 return value_assign (arg1, arg2);
2115 case BINOP_ASSIGN_MODIFY:
2117 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2118 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2119 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2121 op = exp->elts[pc + 1].opcode;
2122 if (binop_user_defined_p (op, arg1, arg2))
2123 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
2124 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2126 && is_integral_type (value_type (arg2)))
2127 arg2 = value_ptradd (arg1, value_as_long (arg2));
2128 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2130 && is_integral_type (value_type (arg2)))
2131 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2134 struct value *tmp = arg1;
2136 /* For shift and integer exponentiation operations,
2137 only promote the first argument. */
2138 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2139 && is_integral_type (value_type (arg2)))
2140 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2142 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2144 arg2 = value_binop (tmp, arg2, op);
2146 return value_assign (arg1, arg2);
2149 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2150 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2151 if (noside == EVAL_SKIP)
2152 return eval_skip_value (exp);
2153 if (binop_user_defined_p (op, arg1, arg2))
2154 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2155 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2156 && is_integral_type (value_type (arg2)))
2157 return value_ptradd (arg1, value_as_long (arg2));
2158 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2159 && is_integral_type (value_type (arg1)))
2160 return value_ptradd (arg2, value_as_long (arg1));
2163 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2164 return value_binop (arg1, arg2, BINOP_ADD);
2168 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2169 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2170 if (noside == EVAL_SKIP)
2171 return eval_skip_value (exp);
2172 if (binop_user_defined_p (op, arg1, arg2))
2173 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2174 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2175 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2177 /* FIXME -- should be ptrdiff_t */
2178 type = builtin_type (exp->gdbarch)->builtin_long;
2179 return value_from_longest (type, value_ptrdiff (arg1, arg2));
2181 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2182 && is_integral_type (value_type (arg2)))
2183 return value_ptradd (arg1, - value_as_long (arg2));
2186 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2187 return value_binop (arg1, arg2, BINOP_SUB);
2198 case BINOP_BITWISE_AND:
2199 case BINOP_BITWISE_IOR:
2200 case BINOP_BITWISE_XOR:
2201 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2202 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2203 if (noside == EVAL_SKIP)
2204 return eval_skip_value (exp);
2205 if (binop_user_defined_p (op, arg1, arg2))
2206 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2209 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2210 fudge arg2 to avoid division-by-zero, the caller is
2211 (theoretically) only looking for the type of the result. */
2212 if (noside == EVAL_AVOID_SIDE_EFFECTS
2213 /* ??? Do we really want to test for BINOP_MOD here?
2214 The implementation of value_binop gives it a well-defined
2217 || op == BINOP_INTDIV
2220 && value_logical_not (arg2))
2222 struct value *v_one, *retval;
2224 v_one = value_one (value_type (arg2));
2225 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2226 retval = value_binop (arg1, v_one, op);
2231 /* For shift and integer exponentiation operations,
2232 only promote the first argument. */
2233 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2234 && is_integral_type (value_type (arg2)))
2235 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2237 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2239 return value_binop (arg1, arg2, op);
2243 case BINOP_SUBSCRIPT:
2244 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2245 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2246 if (noside == EVAL_SKIP)
2247 return eval_skip_value (exp);
2248 if (binop_user_defined_p (op, arg1, arg2))
2249 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2252 /* If the user attempts to subscript something that is not an
2253 array or pointer type (like a plain int variable for example),
2254 then report this as an error. */
2256 arg1 = coerce_ref (arg1);
2257 type = check_typedef (value_type (arg1));
2258 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2259 && TYPE_CODE (type) != TYPE_CODE_PTR)
2261 if (TYPE_NAME (type))
2262 error (_("cannot subscript something of type `%s'"),
2265 error (_("cannot subscript requested type"));
2268 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2269 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2271 return value_subscript (arg1, value_as_long (arg2));
2273 case MULTI_SUBSCRIPT:
2275 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2276 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2279 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2280 /* FIXME: EVAL_SKIP handling may not be correct. */
2281 if (noside == EVAL_SKIP)
2285 return eval_skip_value (exp);
2287 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2288 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2290 /* If the user attempts to subscript something that has no target
2291 type (like a plain int variable for example), then report this
2294 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2297 arg1 = value_zero (type, VALUE_LVAL (arg1));
2303 error (_("cannot subscript something of type `%s'"),
2304 TYPE_NAME (value_type (arg1)));
2308 if (binop_user_defined_p (op, arg1, arg2))
2310 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2314 arg1 = coerce_ref (arg1);
2315 type = check_typedef (value_type (arg1));
2317 switch (TYPE_CODE (type))
2320 case TYPE_CODE_ARRAY:
2321 case TYPE_CODE_STRING:
2322 arg1 = value_subscript (arg1, value_as_long (arg2));
2326 if (TYPE_NAME (type))
2327 error (_("cannot subscript something of type `%s'"),
2330 error (_("cannot subscript requested type"));
2336 multi_f77_subscript:
2338 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2339 int ndimensions = 1, i;
2340 struct value *array = arg1;
2342 if (nargs > MAX_FORTRAN_DIMS)
2343 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2345 ndimensions = calc_f77_array_dims (type);
2347 if (nargs != ndimensions)
2348 error (_("Wrong number of subscripts"));
2350 gdb_assert (nargs > 0);
2352 /* Now that we know we have a legal array subscript expression
2353 let us actually find out where this element exists in the array. */
2355 /* Take array indices left to right. */
2356 for (i = 0; i < nargs; i++)
2358 /* Evaluate each subscript; it must be a legal integer in F77. */
2359 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2361 /* Fill in the subscript array. */
2363 subscript_array[i] = value_as_long (arg2);
2366 /* Internal type of array is arranged right to left. */
2367 for (i = nargs; i > 0; i--)
2369 struct type *array_type = check_typedef (value_type (array));
2370 LONGEST index = subscript_array[i - 1];
2372 array = value_subscripted_rvalue (array, index,
2373 f77_get_lowerbound (array_type));
2379 case BINOP_LOGICAL_AND:
2380 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2381 if (noside == EVAL_SKIP)
2383 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2384 return eval_skip_value (exp);
2388 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2391 if (binop_user_defined_p (op, arg1, arg2))
2393 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2394 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2398 tem = value_logical_not (arg1);
2399 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2400 (tem ? EVAL_SKIP : noside));
2401 type = language_bool_type (exp->language_defn, exp->gdbarch);
2402 return value_from_longest (type,
2403 (LONGEST) (!tem && !value_logical_not (arg2)));
2406 case BINOP_LOGICAL_OR:
2407 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2408 if (noside == EVAL_SKIP)
2410 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2411 return eval_skip_value (exp);
2415 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2418 if (binop_user_defined_p (op, arg1, arg2))
2420 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2421 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2425 tem = value_logical_not (arg1);
2426 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2427 (!tem ? EVAL_SKIP : noside));
2428 type = language_bool_type (exp->language_defn, exp->gdbarch);
2429 return value_from_longest (type,
2430 (LONGEST) (!tem || !value_logical_not (arg2)));
2434 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2435 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2436 if (noside == EVAL_SKIP)
2437 return eval_skip_value (exp);
2438 if (binop_user_defined_p (op, arg1, arg2))
2440 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2444 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2445 tem = value_equal (arg1, arg2);
2446 type = language_bool_type (exp->language_defn, exp->gdbarch);
2447 return value_from_longest (type, (LONGEST) tem);
2450 case BINOP_NOTEQUAL:
2451 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2452 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2453 if (noside == EVAL_SKIP)
2454 return eval_skip_value (exp);
2455 if (binop_user_defined_p (op, arg1, arg2))
2457 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2461 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2462 tem = value_equal (arg1, arg2);
2463 type = language_bool_type (exp->language_defn, exp->gdbarch);
2464 return value_from_longest (type, (LONGEST) ! tem);
2468 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2469 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2470 if (noside == EVAL_SKIP)
2471 return eval_skip_value (exp);
2472 if (binop_user_defined_p (op, arg1, arg2))
2474 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2478 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2479 tem = value_less (arg1, arg2);
2480 type = language_bool_type (exp->language_defn, exp->gdbarch);
2481 return value_from_longest (type, (LONGEST) tem);
2485 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2486 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2487 if (noside == EVAL_SKIP)
2488 return eval_skip_value (exp);
2489 if (binop_user_defined_p (op, arg1, arg2))
2491 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2495 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2496 tem = value_less (arg2, arg1);
2497 type = language_bool_type (exp->language_defn, exp->gdbarch);
2498 return value_from_longest (type, (LONGEST) tem);
2502 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2503 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2504 if (noside == EVAL_SKIP)
2505 return eval_skip_value (exp);
2506 if (binop_user_defined_p (op, arg1, arg2))
2508 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2512 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2513 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2514 type = language_bool_type (exp->language_defn, exp->gdbarch);
2515 return value_from_longest (type, (LONGEST) tem);
2519 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2520 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2521 if (noside == EVAL_SKIP)
2522 return eval_skip_value (exp);
2523 if (binop_user_defined_p (op, arg1, arg2))
2525 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2529 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2530 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2531 type = language_bool_type (exp->language_defn, exp->gdbarch);
2532 return value_from_longest (type, (LONGEST) tem);
2536 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2537 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2538 if (noside == EVAL_SKIP)
2539 return eval_skip_value (exp);
2540 type = check_typedef (value_type (arg2));
2541 if (TYPE_CODE (type) != TYPE_CODE_INT
2542 && TYPE_CODE (type) != TYPE_CODE_ENUM)
2543 error (_("Non-integral right operand for \"@\" operator."));
2544 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2546 return allocate_repeat_value (value_type (arg1),
2547 longest_to_int (value_as_long (arg2)));
2550 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2553 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2554 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2557 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2558 if (noside == EVAL_SKIP)
2559 return eval_skip_value (exp);
2560 if (unop_user_defined_p (op, arg1))
2561 return value_x_unop (arg1, op, noside);
2564 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2565 return value_pos (arg1);
2569 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2570 if (noside == EVAL_SKIP)
2571 return eval_skip_value (exp);
2572 if (unop_user_defined_p (op, arg1))
2573 return value_x_unop (arg1, op, noside);
2576 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2577 return value_neg (arg1);
2580 case UNOP_COMPLEMENT:
2581 /* C++: check for and handle destructor names. */
2583 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2584 if (noside == EVAL_SKIP)
2585 return eval_skip_value (exp);
2586 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2587 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2590 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2591 return value_complement (arg1);
2594 case UNOP_LOGICAL_NOT:
2595 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2596 if (noside == EVAL_SKIP)
2597 return eval_skip_value (exp);
2598 if (unop_user_defined_p (op, arg1))
2599 return value_x_unop (arg1, op, noside);
2602 type = language_bool_type (exp->language_defn, exp->gdbarch);
2603 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2607 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2608 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2609 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2610 type = check_typedef (value_type (arg1));
2611 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2612 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2613 error (_("Attempt to dereference pointer "
2614 "to member without an object"));
2615 if (noside == EVAL_SKIP)
2616 return eval_skip_value (exp);
2617 if (unop_user_defined_p (op, arg1))
2618 return value_x_unop (arg1, op, noside);
2619 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2621 type = check_typedef (value_type (arg1));
2622 if (TYPE_CODE (type) == TYPE_CODE_PTR
2623 || TYPE_IS_REFERENCE (type)
2624 /* In C you can dereference an array to get the 1st elt. */
2625 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2627 return value_zero (TYPE_TARGET_TYPE (type),
2629 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2630 /* GDB allows dereferencing an int. */
2631 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2634 error (_("Attempt to take contents of a non-pointer value."));
2637 /* Allow * on an integer so we can cast it to whatever we want.
2638 This returns an int, which seems like the most C-like thing to
2639 do. "long long" variables are rare enough that
2640 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2641 if (TYPE_CODE (type) == TYPE_CODE_INT)
2642 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2643 (CORE_ADDR) value_as_address (arg1));
2644 return value_ind (arg1);
2647 /* C++: check for and handle pointer to members. */
2649 if (noside == EVAL_SKIP)
2651 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2652 return eval_skip_value (exp);
2656 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2663 if (noside == EVAL_SKIP)
2665 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2666 return eval_skip_value (exp);
2668 return evaluate_subexp_for_sizeof (exp, pos, noside);
2672 type = exp->elts[pc + 1].type;
2673 return evaluate_subexp_for_cast (exp, pos, noside, type);
2675 case UNOP_CAST_TYPE:
2676 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2677 type = value_type (arg1);
2678 return evaluate_subexp_for_cast (exp, pos, noside, type);
2680 case UNOP_DYNAMIC_CAST:
2681 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2682 type = value_type (arg1);
2683 arg1 = evaluate_subexp (type, exp, pos, noside);
2684 if (noside == EVAL_SKIP)
2685 return eval_skip_value (exp);
2686 return value_dynamic_cast (type, arg1);
2688 case UNOP_REINTERPRET_CAST:
2689 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2690 type = value_type (arg1);
2691 arg1 = evaluate_subexp (type, exp, pos, noside);
2692 if (noside == EVAL_SKIP)
2693 return eval_skip_value (exp);
2694 return value_reinterpret_cast (type, arg1);
2698 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2699 if (noside == EVAL_SKIP)
2700 return eval_skip_value (exp);
2701 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2702 return value_zero (exp->elts[pc + 1].type, lval_memory);
2704 return value_at_lazy (exp->elts[pc + 1].type,
2705 value_as_address (arg1));
2707 case UNOP_MEMVAL_TYPE:
2708 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2709 type = value_type (arg1);
2710 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2711 if (noside == EVAL_SKIP)
2712 return eval_skip_value (exp);
2713 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2714 return value_zero (type, lval_memory);
2716 return value_at_lazy (type, value_as_address (arg1));
2718 case UNOP_PREINCREMENT:
2719 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2720 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2722 else if (unop_user_defined_p (op, arg1))
2724 return value_x_unop (arg1, op, noside);
2728 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2729 arg2 = value_ptradd (arg1, 1);
2732 struct value *tmp = arg1;
2734 arg2 = value_one (value_type (arg1));
2735 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2736 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2739 return value_assign (arg1, arg2);
2742 case UNOP_PREDECREMENT:
2743 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2744 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2746 else if (unop_user_defined_p (op, arg1))
2748 return value_x_unop (arg1, op, noside);
2752 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2753 arg2 = value_ptradd (arg1, -1);
2756 struct value *tmp = arg1;
2758 arg2 = value_one (value_type (arg1));
2759 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2760 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2763 return value_assign (arg1, arg2);
2766 case UNOP_POSTINCREMENT:
2767 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2768 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2770 else if (unop_user_defined_p (op, arg1))
2772 return value_x_unop (arg1, op, noside);
2776 arg3 = value_non_lval (arg1);
2778 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2779 arg2 = value_ptradd (arg1, 1);
2782 struct value *tmp = arg1;
2784 arg2 = value_one (value_type (arg1));
2785 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2786 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2789 value_assign (arg1, arg2);
2793 case UNOP_POSTDECREMENT:
2794 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2795 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2797 else if (unop_user_defined_p (op, arg1))
2799 return value_x_unop (arg1, op, noside);
2803 arg3 = value_non_lval (arg1);
2805 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2806 arg2 = value_ptradd (arg1, -1);
2809 struct value *tmp = arg1;
2811 arg2 = value_one (value_type (arg1));
2812 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2813 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2816 value_assign (arg1, arg2);
2822 return value_of_this (exp->language_defn);
2825 /* The value is not supposed to be used. This is here to make it
2826 easier to accommodate expressions that contain types. */
2828 if (noside == EVAL_SKIP)
2829 return eval_skip_value (exp);
2830 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2831 return allocate_value (exp->elts[pc + 1].type);
2833 error (_("Attempt to use a type name as an expression"));
2837 if (noside == EVAL_SKIP)
2839 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2840 return eval_skip_value (exp);
2842 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2844 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2845 struct value *result;
2847 result = evaluate_subexp (NULL_TYPE, exp, pos,
2848 EVAL_AVOID_SIDE_EFFECTS);
2850 /* 'decltype' has special semantics for lvalues. */
2851 if (op == OP_DECLTYPE
2852 && (sub_op == BINOP_SUBSCRIPT
2853 || sub_op == STRUCTOP_MEMBER
2854 || sub_op == STRUCTOP_MPTR
2855 || sub_op == UNOP_IND
2856 || sub_op == STRUCTOP_STRUCT
2857 || sub_op == STRUCTOP_PTR
2858 || sub_op == OP_SCOPE))
2860 struct type *type = value_type (result);
2862 if (!TYPE_IS_REFERENCE (type))
2864 type = lookup_lvalue_reference_type (type);
2865 result = allocate_value (type);
2872 error (_("Attempt to use a type as an expression"));
2876 struct value *result;
2877 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2879 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2880 result = evaluate_subexp (NULL_TYPE, exp, pos,
2881 EVAL_AVOID_SIDE_EFFECTS);
2883 result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2885 if (noside != EVAL_NORMAL)
2886 return allocate_value (cplus_typeid_type (exp->gdbarch));
2888 return cplus_typeid (result);
2892 /* Removing this case and compiling with gcc -Wall reveals that
2893 a lot of cases are hitting this case. Some of these should
2894 probably be removed from expression.h; others are legitimate
2895 expressions which are (apparently) not fully implemented.
2897 If there are any cases landing here which mean a user error,
2898 then they should be separate cases, with more descriptive
2901 error (_("GDB does not (yet) know how to "
2902 "evaluate that kind of expression"));
2905 gdb_assert_not_reached ("missed return?");
2908 /* Evaluate a subexpression of EXP, at index *POS,
2909 and return the address of that subexpression.
2910 Advance *POS over the subexpression.
2911 If the subexpression isn't an lvalue, get an error.
2912 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2913 then only the type of the result need be correct. */
2915 static struct value *
2916 evaluate_subexp_for_address (struct expression *exp, int *pos,
2926 op = exp->elts[pc].opcode;
2932 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2934 /* We can't optimize out "&*" if there's a user-defined operator*. */
2935 if (unop_user_defined_p (op, x))
2937 x = value_x_unop (x, op, noside);
2938 goto default_case_after_eval;
2941 return coerce_array (x);
2945 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2946 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2948 case UNOP_MEMVAL_TYPE:
2953 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2954 type = value_type (x);
2955 return value_cast (lookup_pointer_type (type),
2956 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2960 var = exp->elts[pc + 2].symbol;
2962 /* C++: The "address" of a reference should yield the address
2963 * of the object pointed to. Let value_addr() deal with it. */
2964 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var)))
2968 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2971 lookup_pointer_type (SYMBOL_TYPE (var));
2972 enum address_class sym_class = SYMBOL_CLASS (var);
2974 if (sym_class == LOC_CONST
2975 || sym_class == LOC_CONST_BYTES
2976 || sym_class == LOC_REGISTER)
2977 error (_("Attempt to take address of register or constant."));
2980 value_zero (type, not_lval);
2983 return address_of_variable (var, exp->elts[pc + 1].block);
2985 case OP_VAR_MSYM_VALUE:
2989 value *val = evaluate_var_msym_value (noside,
2990 exp->elts[pc + 1].objfile,
2991 exp->elts[pc + 2].msymbol);
2992 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2994 struct type *type = lookup_pointer_type (value_type (val));
2995 return value_zero (type, not_lval);
2998 return value_addr (val);
3002 tem = longest_to_int (exp->elts[pc + 2].longconst);
3003 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
3004 x = value_aggregate_elt (exp->elts[pc + 1].type,
3005 &exp->elts[pc + 3].string,
3008 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
3013 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
3014 default_case_after_eval:
3015 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3017 struct type *type = check_typedef (value_type (x));
3019 if (TYPE_IS_REFERENCE (type))
3020 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
3022 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
3023 return value_zero (lookup_pointer_type (value_type (x)),
3026 error (_("Attempt to take address of "
3027 "value not located in memory."));
3029 return value_addr (x);
3033 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
3034 When used in contexts where arrays will be coerced anyway, this is
3035 equivalent to `evaluate_subexp' but much faster because it avoids
3036 actually fetching array contents (perhaps obsolete now that we have
3039 Note that we currently only do the coercion for C expressions, where
3040 arrays are zero based and the coercion is correct. For other languages,
3041 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
3042 to decide if coercion is appropriate. */
3045 evaluate_subexp_with_coercion (struct expression *exp,
3046 int *pos, enum noside noside)
3055 op = exp->elts[pc].opcode;
3060 var = exp->elts[pc + 2].symbol;
3061 type = check_typedef (SYMBOL_TYPE (var));
3062 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
3063 && !TYPE_VECTOR (type)
3064 && CAST_IS_CONVERSION (exp->language_defn))
3067 val = address_of_variable (var, exp->elts[pc + 1].block);
3068 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
3074 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
3078 /* Evaluate a subexpression of EXP, at index *POS,
3079 and return a value for the size of that subexpression.
3080 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3081 we allow side-effects on the operand if its type is a variable
3084 static struct value *
3085 evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
3088 /* FIXME: This should be size_t. */
3089 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3096 op = exp->elts[pc].opcode;
3100 /* This case is handled specially
3101 so that we avoid creating a value for the result type.
3102 If the result type is very big, it's desirable not to
3103 create a value unnecessarily. */
3106 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3107 type = check_typedef (value_type (val));
3108 if (TYPE_CODE (type) != TYPE_CODE_PTR
3109 && !TYPE_IS_REFERENCE (type)
3110 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3111 error (_("Attempt to take contents of a non-pointer value."));
3112 type = TYPE_TARGET_TYPE (type);
3113 if (is_dynamic_type (type))
3114 type = value_type (value_ind (val));
3115 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3119 type = exp->elts[pc + 1].type;
3122 case UNOP_MEMVAL_TYPE:
3124 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3125 type = value_type (val);
3129 type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
3130 if (is_dynamic_type (type))
3132 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3133 type = value_type (val);
3139 case OP_VAR_MSYM_VALUE:
3143 minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
3144 value *val = evaluate_var_msym_value (noside,
3145 exp->elts[pc + 1].objfile,
3148 type = value_type (val);
3149 if (TYPE_CODE (type) == TYPE_CODE_ERROR)
3150 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
3152 return value_from_longest (size_type, TYPE_LENGTH (type));
3156 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3157 type of the subscript is a variable length array type. In this case we
3158 must re-evaluate the right hand side of the subcription to allow
3160 case BINOP_SUBSCRIPT:
3161 if (noside == EVAL_NORMAL)
3163 int pc = (*pos) + 1;
3165 val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
3166 type = check_typedef (value_type (val));
3167 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3169 type = check_typedef (TYPE_TARGET_TYPE (type));
3170 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3172 type = TYPE_INDEX_TYPE (type);
3173 /* Only re-evaluate the right hand side if the resulting type
3174 is a variable length type. */
3175 if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
3177 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3178 return value_from_longest
3179 (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
3188 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3189 type = value_type (val);
3193 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3194 "When applied to a reference or a reference type, the result is
3195 the size of the referenced type." */
3196 type = check_typedef (type);
3197 if (exp->language_defn->la_language == language_cplus
3198 && (TYPE_IS_REFERENCE (type)))
3199 type = check_typedef (TYPE_TARGET_TYPE (type));
3200 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3203 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3204 for that subexpression cast to TO_TYPE. Advance *POS over the
3208 evaluate_subexp_for_cast (expression *exp, int *pos,
3210 struct type *to_type)
3214 /* Don't let symbols be evaluated with evaluate_subexp because that
3215 throws an "unknown type" error for no-debug data symbols.
3216 Instead, we want the cast to reinterpret the symbol. */
3217 if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE
3218 || exp->elts[pc].opcode == OP_VAR_VALUE)
3223 if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE)
3225 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3226 return value_zero (to_type, not_lval);
3228 val = evaluate_var_msym_value (noside,
3229 exp->elts[pc + 1].objfile,
3230 exp->elts[pc + 2].msymbol);
3233 val = evaluate_var_value (noside,
3234 exp->elts[pc + 1].block,
3235 exp->elts[pc + 2].symbol);
3237 if (noside == EVAL_SKIP)
3238 return eval_skip_value (exp);
3240 val = value_cast (to_type, val);
3242 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3243 if (VALUE_LVAL (val) == lval_memory)
3245 if (value_lazy (val))
3246 value_fetch_lazy (val);
3247 VALUE_LVAL (val) = not_lval;
3252 value *val = evaluate_subexp (to_type, exp, pos, noside);
3253 if (noside == EVAL_SKIP)
3254 return eval_skip_value (exp);
3255 return value_cast (to_type, val);
3258 /* Parse a type expression in the string [P..P+LENGTH). */
3261 parse_and_eval_type (char *p, int length)
3263 char *tmp = (char *) alloca (length + 4);
3266 memcpy (tmp + 1, p, length);
3267 tmp[length + 1] = ')';
3268 tmp[length + 2] = '0';
3269 tmp[length + 3] = '\0';
3270 expression_up expr = parse_expression (tmp);
3271 if (expr->elts[0].opcode != UNOP_CAST)
3272 error (_("Internal error in eval_type."));
3273 return expr->elts[1].type;
3277 calc_f77_array_dims (struct type *array_type)
3280 struct type *tmp_type;
3282 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3283 error (_("Can't get dimensions for a non-array type"));
3285 tmp_type = array_type;
3287 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3289 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)