1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2013 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/>. */
25 #include "expression.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"
37 #include "exceptions.h"
39 #include "user-regs.h"
41 #include "gdb_obstack.h"
43 #include "python/python.h"
45 #include "gdb_assert.h"
49 /* This is defined in valops.c */
50 extern int overload_resolution;
52 /* Prototypes for local functions. */
54 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
56 static struct value *evaluate_subexp_for_address (struct expression *,
59 static struct value *evaluate_struct_tuple (struct value *,
60 struct expression *, int *,
63 static LONGEST init_array_element (struct value *, struct value *,
64 struct expression *, int *, enum noside,
68 evaluate_subexp (struct type *expect_type, struct expression *exp,
69 int *pos, enum noside noside)
71 return (*exp->language_defn->la_exp_desc->evaluate_exp)
72 (expect_type, exp, pos, noside);
75 /* Parse the string EXP as a C expression, evaluate it,
76 and return the result as a number. */
79 parse_and_eval_address (const char *exp)
81 struct expression *expr = parse_expression (exp);
83 struct cleanup *old_chain =
84 make_cleanup (free_current_contents, &expr);
86 addr = value_as_address (evaluate_expression (expr));
87 do_cleanups (old_chain);
91 /* Like parse_and_eval_address, but treats the value of the expression
92 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
94 parse_and_eval_long (const char *exp)
96 struct expression *expr = parse_expression (exp);
98 struct cleanup *old_chain =
99 make_cleanup (free_current_contents, &expr);
101 retval = value_as_long (evaluate_expression (expr));
102 do_cleanups (old_chain);
107 parse_and_eval (const char *exp)
109 struct expression *expr = parse_expression (exp);
111 struct cleanup *old_chain =
112 make_cleanup (free_current_contents, &expr);
114 val = evaluate_expression (expr);
115 do_cleanups (old_chain);
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 struct expression *expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
128 struct cleanup *old_chain =
129 make_cleanup (free_current_contents, &expr);
131 val = evaluate_expression (expr);
132 do_cleanups (old_chain);
136 /* Evaluate an expression in internal prefix form
137 such as is constructed by parse.y.
139 See expression.h for info on the format of an expression. */
142 evaluate_expression (struct expression *exp)
146 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
149 /* Evaluate an expression, avoiding all memory references
150 and getting a value whose type alone is correct. */
153 evaluate_type (struct expression *exp)
157 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
160 /* Evaluate a subexpression, avoiding all memory references and
161 getting a value whose type alone is correct. */
164 evaluate_subexpression_type (struct expression *exp, int subexp)
166 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
169 /* Find the current value of a watchpoint on EXP. Return the value in
170 *VALP and *RESULTP and the chain of intermediate and final values
171 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
174 If PRESERVE_ERRORS is true, then exceptions are passed through.
175 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
176 occurs while evaluating the expression, *RESULTP will be set to
177 NULL. *RESULTP may be a lazy value, if the result could not be
178 read from memory. It is used to determine whether a value is
179 user-specified (we should watch the whole value) or intermediate
180 (we should watch only the bit used to locate the final value).
182 If the final value, or any intermediate value, could not be read
183 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
184 set to any referenced values. *VALP will never be a lazy value.
185 This is the value which we store in struct breakpoint.
187 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
188 value chain. The caller must free the values individually. If
189 VAL_CHAIN is NULL, all generated values will be left on the value
193 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
194 struct value **resultp, struct value **val_chain,
197 struct value *mark, *new_mark, *result;
198 volatile struct gdb_exception ex;
206 /* Evaluate the expression. */
207 mark = value_mark ();
210 TRY_CATCH (ex, RETURN_MASK_ALL)
212 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
216 /* Ignore memory errors if we want watchpoints pointing at
217 inaccessible memory to still be created; otherwise, throw the
218 error to some higher catcher. */
222 if (!preserve_errors)
225 throw_exception (ex);
230 new_mark = value_mark ();
231 if (mark == new_mark)
236 /* Make sure it's not lazy, so that after the target stops again we
237 have a non-lazy previous value to compare with. */
240 if (!value_lazy (result))
244 volatile struct gdb_exception except;
246 TRY_CATCH (except, RETURN_MASK_ERROR)
248 value_fetch_lazy (result);
256 /* Return the chain of intermediate values. We use this to
257 decide which addresses to watch. */
258 *val_chain = new_mark;
259 value_release_to_mark (mark);
263 /* Extract a field operation from an expression. If the subexpression
264 of EXP starting at *SUBEXP is not a structure dereference
265 operation, return NULL. Otherwise, return the name of the
266 dereferenced field, and advance *SUBEXP to point to the
267 subexpression of the left-hand-side of the dereference. This is
268 used when completing field names. */
271 extract_field_op (struct expression *exp, int *subexp)
276 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
277 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
279 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
280 result = &exp->elts[*subexp + 2].string;
281 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
285 /* This function evaluates brace-initializers (in C/C++) for
288 static struct value *
289 evaluate_struct_tuple (struct value *struct_val,
290 struct expression *exp,
291 int *pos, enum noside noside, int nargs)
293 struct type *struct_type = check_typedef (value_type (struct_val));
294 struct type *field_type;
299 struct value *val = NULL;
304 /* Skip static fields. */
305 while (fieldno < TYPE_NFIELDS (struct_type)
306 && field_is_static (&TYPE_FIELD (struct_type,
309 if (fieldno >= TYPE_NFIELDS (struct_type))
310 error (_("too many initializers"));
311 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
312 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
313 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
314 error (_("don't know which variant you want to set"));
316 /* Here, struct_type is the type of the inner struct,
317 while substruct_type is the type of the inner struct.
318 These are the same for normal structures, but a variant struct
319 contains anonymous union fields that contain substruct fields.
320 The value fieldno is the index of the top-level (normal or
321 anonymous union) field in struct_field, while the value
322 subfieldno is the index of the actual real (named inner) field
323 in substruct_type. */
325 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
327 val = evaluate_subexp (field_type, exp, pos, noside);
329 /* Now actually set the field in struct_val. */
331 /* Assign val to field fieldno. */
332 if (value_type (val) != field_type)
333 val = value_cast (field_type, val);
335 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
336 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
337 addr = value_contents_writeable (struct_val) + bitpos / 8;
339 modify_field (struct_type, addr,
340 value_as_long (val), bitpos % 8, bitsize);
342 memcpy (addr, value_contents (val),
343 TYPE_LENGTH (value_type (val)));
349 /* Recursive helper function for setting elements of array tuples for
350 (the deleted) Chill. The target is ARRAY (which has bounds
351 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
352 and NOSIDE are as usual. Evaluates index expresions and sets the
353 specified element(s) of ARRAY to ELEMENT. Returns last index
357 init_array_element (struct value *array, struct value *element,
358 struct expression *exp, int *pos,
359 enum noside noside, LONGEST low_bound, LONGEST high_bound)
362 int element_size = TYPE_LENGTH (value_type (element));
364 if (exp->elts[*pos].opcode == BINOP_COMMA)
367 init_array_element (array, element, exp, pos, noside,
368 low_bound, high_bound);
369 return init_array_element (array, element,
370 exp, pos, noside, low_bound, high_bound);
372 else if (exp->elts[*pos].opcode == BINOP_RANGE)
377 low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
378 high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
379 if (low < low_bound || high > high_bound)
380 error (_("tuple range index out of range"));
381 for (index = low; index <= high; index++)
383 memcpy (value_contents_raw (array)
384 + (index - low_bound) * element_size,
385 value_contents (element), element_size);
390 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
391 if (index < low_bound || index > high_bound)
392 error (_("tuple index out of range"));
393 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
394 value_contents (element), element_size);
399 static struct value *
400 value_f90_subarray (struct value *array,
401 struct expression *exp, int *pos, enum noside noside)
404 LONGEST low_bound, high_bound;
405 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
406 enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);
410 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
411 low_bound = TYPE_LOW_BOUND (range);
413 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
415 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
416 high_bound = TYPE_HIGH_BOUND (range);
418 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
420 return value_slice (array, low_bound, high_bound - low_bound + 1);
424 /* Promote value ARG1 as appropriate before performing a unary operation
426 If the result is not appropriate for any particular language then it
427 needs to patch this function. */
430 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
435 *arg1 = coerce_ref (*arg1);
436 type1 = check_typedef (value_type (*arg1));
438 if (is_integral_type (type1))
440 switch (language->la_language)
443 /* Perform integral promotion for ANSI C/C++.
444 If not appropropriate for any particular language
445 it needs to modify this function. */
447 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
449 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
450 *arg1 = value_cast (builtin_int, *arg1);
457 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
458 operation on those two operands.
459 If the result is not appropriate for any particular language then it
460 needs to patch this function. */
463 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
464 struct value **arg1, struct value **arg2)
466 struct type *promoted_type = NULL;
470 *arg1 = coerce_ref (*arg1);
471 *arg2 = coerce_ref (*arg2);
473 type1 = check_typedef (value_type (*arg1));
474 type2 = check_typedef (value_type (*arg2));
476 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
477 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
478 && !is_integral_type (type1))
479 || (TYPE_CODE (type2) != TYPE_CODE_FLT
480 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
481 && !is_integral_type (type2)))
484 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
485 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
487 /* No promotion required. */
489 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
490 || TYPE_CODE (type2) == TYPE_CODE_FLT)
492 switch (language->la_language)
498 case language_opencl:
499 /* No promotion required. */
503 /* For other languages the result type is unchanged from gdb
504 version 6.7 for backward compatibility.
505 If either arg was long double, make sure that value is also long
506 double. Otherwise use double. */
507 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
508 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
509 promoted_type = builtin_type (gdbarch)->builtin_long_double;
511 promoted_type = builtin_type (gdbarch)->builtin_double;
515 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
516 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
518 /* No promotion required. */
521 /* Integral operations here. */
522 /* FIXME: Also mixed integral/booleans, with result an integer. */
524 const struct builtin_type *builtin = builtin_type (gdbarch);
525 unsigned int promoted_len1 = TYPE_LENGTH (type1);
526 unsigned int promoted_len2 = TYPE_LENGTH (type2);
527 int is_unsigned1 = TYPE_UNSIGNED (type1);
528 int is_unsigned2 = TYPE_UNSIGNED (type2);
529 unsigned int result_len;
530 int unsigned_operation;
532 /* Determine type length and signedness after promotion for
534 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
537 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
539 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
542 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
545 if (promoted_len1 > promoted_len2)
547 unsigned_operation = is_unsigned1;
548 result_len = promoted_len1;
550 else if (promoted_len2 > promoted_len1)
552 unsigned_operation = is_unsigned2;
553 result_len = promoted_len2;
557 unsigned_operation = is_unsigned1 || is_unsigned2;
558 result_len = promoted_len1;
561 switch (language->la_language)
567 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
569 promoted_type = (unsigned_operation
570 ? builtin->builtin_unsigned_int
571 : builtin->builtin_int);
573 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
575 promoted_type = (unsigned_operation
576 ? builtin->builtin_unsigned_long
577 : builtin->builtin_long);
581 promoted_type = (unsigned_operation
582 ? builtin->builtin_unsigned_long_long
583 : builtin->builtin_long_long);
586 case language_opencl:
587 if (result_len <= TYPE_LENGTH (lookup_signed_typename
588 (language, gdbarch, "int")))
592 ? lookup_unsigned_typename (language, gdbarch, "int")
593 : lookup_signed_typename (language, gdbarch, "int"));
595 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
596 (language, gdbarch, "long")))
600 ? lookup_unsigned_typename (language, gdbarch, "long")
601 : lookup_signed_typename (language, gdbarch,"long"));
605 /* For other languages the result type is unchanged from gdb
606 version 6.7 for backward compatibility.
607 If either arg was long long, make sure that value is also long
608 long. Otherwise use long. */
609 if (unsigned_operation)
611 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
612 promoted_type = builtin->builtin_unsigned_long_long;
614 promoted_type = builtin->builtin_unsigned_long;
618 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
619 promoted_type = builtin->builtin_long_long;
621 promoted_type = builtin->builtin_long;
629 /* Promote both operands to common type. */
630 *arg1 = value_cast (promoted_type, *arg1);
631 *arg2 = value_cast (promoted_type, *arg2);
636 ptrmath_type_p (const struct language_defn *lang, struct type *type)
638 type = check_typedef (type);
639 if (TYPE_CODE (type) == TYPE_CODE_REF)
640 type = TYPE_TARGET_TYPE (type);
642 switch (TYPE_CODE (type))
648 case TYPE_CODE_ARRAY:
649 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
656 /* Constructs a fake method with the given parameter types.
657 This function is used by the parser to construct an "expected"
658 type for method overload resolution. */
661 make_params (int num_types, struct type **param_types)
663 struct type *type = XZALLOC (struct type);
664 TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
665 TYPE_LENGTH (type) = 1;
666 TYPE_CODE (type) = TYPE_CODE_METHOD;
667 TYPE_VPTR_FIELDNO (type) = -1;
668 TYPE_CHAIN (type) = type;
671 if (param_types[num_types - 1] == NULL)
674 TYPE_VARARGS (type) = 1;
676 else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
680 /* Caller should have ensured this. */
681 gdb_assert (num_types == 0);
682 TYPE_PROTOTYPED (type) = 1;
686 TYPE_NFIELDS (type) = num_types;
687 TYPE_FIELDS (type) = (struct field *)
688 TYPE_ZALLOC (type, sizeof (struct field) * num_types);
690 while (num_types-- > 0)
691 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
697 evaluate_subexp_standard (struct type *expect_type,
698 struct expression *exp, int *pos,
703 int pc, pc2 = 0, oldpos;
704 struct value *arg1 = NULL;
705 struct value *arg2 = NULL;
709 struct value **argvec;
713 struct type **arg_types;
715 struct symbol *function = NULL;
716 char *function_name = NULL;
719 op = exp->elts[pc].opcode;
724 tem = longest_to_int (exp->elts[pc + 2].longconst);
725 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
726 if (noside == EVAL_SKIP)
728 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
729 &exp->elts[pc + 3].string,
730 expect_type, 0, noside);
732 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
737 return value_from_longest (exp->elts[pc + 1].type,
738 exp->elts[pc + 2].longconst);
742 return value_from_double (exp->elts[pc + 1].type,
743 exp->elts[pc + 2].doubleconst);
747 return value_from_decfloat (exp->elts[pc + 1].type,
748 exp->elts[pc + 2].decfloatconst);
753 if (noside == EVAL_SKIP)
756 /* JYG: We used to just return value_zero of the symbol type
757 if we're asked to avoid side effects. Otherwise we return
758 value_of_variable (...). However I'm not sure if
759 value_of_variable () has any side effect.
760 We need a full value object returned here for whatis_exp ()
761 to call evaluate_type () and then pass the full value to
762 value_rtti_target_type () if we are dealing with a pointer
763 or reference to a base class and print object is on. */
766 volatile struct gdb_exception except;
767 struct value *ret = NULL;
769 TRY_CATCH (except, RETURN_MASK_ERROR)
771 ret = value_of_variable (exp->elts[pc + 2].symbol,
772 exp->elts[pc + 1].block);
775 if (except.reason < 0)
777 if (noside == EVAL_AVOID_SIDE_EFFECTS)
778 ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
781 throw_exception (except);
787 case OP_VAR_ENTRY_VALUE:
789 if (noside == EVAL_SKIP)
793 struct symbol *sym = exp->elts[pc + 1].symbol;
794 struct frame_info *frame;
796 if (noside == EVAL_AVOID_SIDE_EFFECTS)
797 return value_zero (SYMBOL_TYPE (sym), not_lval);
799 if (SYMBOL_COMPUTED_OPS (sym) == NULL
800 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
801 error (_("Symbol \"%s\" does not have any specific entry value"),
802 SYMBOL_PRINT_NAME (sym));
804 frame = get_selected_frame (NULL);
805 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
811 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
815 const char *name = &exp->elts[pc + 2].string;
819 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
820 regno = user_reg_map_name_to_regnum (exp->gdbarch,
821 name, strlen (name));
823 error (_("Register $%s not available."), name);
825 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
826 a value with the appropriate register type. Unfortunately,
827 we don't have easy access to the type of user registers.
828 So for these registers, we fetch the register value regardless
829 of the evaluation mode. */
830 if (noside == EVAL_AVOID_SIDE_EFFECTS
831 && regno < gdbarch_num_regs (exp->gdbarch)
832 + gdbarch_num_pseudo_regs (exp->gdbarch))
833 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
835 val = value_of_register (regno, get_selected_frame (NULL));
837 error (_("Value of register %s not available."), name);
843 type = language_bool_type (exp->language_defn, exp->gdbarch);
844 return value_from_longest (type, exp->elts[pc + 1].longconst);
848 return value_of_internalvar (exp->gdbarch,
849 exp->elts[pc + 1].internalvar);
852 tem = longest_to_int (exp->elts[pc + 1].longconst);
853 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
854 if (noside == EVAL_SKIP)
856 type = language_string_char_type (exp->language_defn, exp->gdbarch);
857 return value_string (&exp->elts[pc + 2].string, tem, type);
859 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
860 NSString constant. */
861 tem = longest_to_int (exp->elts[pc + 1].longconst);
862 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
863 if (noside == EVAL_SKIP)
867 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
871 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
872 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
873 nargs = tem3 - tem2 + 1;
874 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
876 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
877 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
879 struct value *rec = allocate_value (expect_type);
881 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
882 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
885 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
886 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
888 struct type *range_type = TYPE_INDEX_TYPE (type);
889 struct type *element_type = TYPE_TARGET_TYPE (type);
890 struct value *array = allocate_value (expect_type);
891 int element_size = TYPE_LENGTH (check_typedef (element_type));
892 LONGEST low_bound, high_bound, index;
894 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
897 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
900 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
901 for (tem = nargs; --nargs >= 0;)
903 struct value *element;
906 if (exp->elts[*pos].opcode == BINOP_RANGE)
909 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
911 element = evaluate_subexp (element_type, exp, pos, noside);
912 if (value_type (element) != element_type)
913 element = value_cast (element_type, element);
916 int continue_pc = *pos;
919 index = init_array_element (array, element, exp, pos, noside,
920 low_bound, high_bound);
925 if (index > high_bound)
926 /* To avoid memory corruption. */
927 error (_("Too many array elements"));
928 memcpy (value_contents_raw (array)
929 + (index - low_bound) * element_size,
930 value_contents (element),
938 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
939 && TYPE_CODE (type) == TYPE_CODE_SET)
941 struct value *set = allocate_value (expect_type);
942 gdb_byte *valaddr = value_contents_raw (set);
943 struct type *element_type = TYPE_INDEX_TYPE (type);
944 struct type *check_type = element_type;
945 LONGEST low_bound, high_bound;
947 /* Get targettype of elementtype. */
948 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
949 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
950 check_type = TYPE_TARGET_TYPE (check_type);
952 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
953 error (_("(power)set type with unknown size"));
954 memset (valaddr, '\0', TYPE_LENGTH (type));
955 for (tem = 0; tem < nargs; tem++)
957 LONGEST range_low, range_high;
958 struct type *range_low_type, *range_high_type;
959 struct value *elem_val;
961 if (exp->elts[*pos].opcode == BINOP_RANGE)
964 elem_val = evaluate_subexp (element_type, exp, pos, noside);
965 range_low_type = value_type (elem_val);
966 range_low = value_as_long (elem_val);
967 elem_val = evaluate_subexp (element_type, exp, pos, noside);
968 range_high_type = value_type (elem_val);
969 range_high = value_as_long (elem_val);
973 elem_val = evaluate_subexp (element_type, exp, pos, noside);
974 range_low_type = range_high_type = value_type (elem_val);
975 range_low = range_high = value_as_long (elem_val);
977 /* Check types of elements to avoid mixture of elements from
978 different types. Also check if type of element is "compatible"
979 with element type of powerset. */
980 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
981 range_low_type = TYPE_TARGET_TYPE (range_low_type);
982 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
983 range_high_type = TYPE_TARGET_TYPE (range_high_type);
984 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
985 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
986 && (range_low_type != range_high_type)))
987 /* different element modes. */
988 error (_("POWERSET tuple elements of different mode"));
989 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
990 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
991 && range_low_type != check_type))
992 error (_("incompatible POWERSET tuple elements"));
993 if (range_low > range_high)
995 warning (_("empty POWERSET tuple range"));
998 if (range_low < low_bound || range_high > high_bound)
999 error (_("POWERSET tuple element out of range"));
1000 range_low -= low_bound;
1001 range_high -= low_bound;
1002 for (; range_low <= range_high; range_low++)
1004 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
1006 if (gdbarch_bits_big_endian (exp->gdbarch))
1007 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
1008 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1015 argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
1016 for (tem = 0; tem < nargs; tem++)
1018 /* Ensure that array expressions are coerced into pointer
1020 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1022 if (noside == EVAL_SKIP)
1024 return value_array (tem2, tem3, argvec);
1028 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1030 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1032 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1034 if (noside == EVAL_SKIP)
1036 return value_slice (array, lowbound, upper - lowbound + 1);
1040 /* Skip third and second args to evaluate the first one. */
1041 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1042 if (value_logical_not (arg1))
1044 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1045 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1049 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1050 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1054 case OP_OBJC_SELECTOR:
1055 { /* Objective C @selector operator. */
1056 char *sel = &exp->elts[pc + 2].string;
1057 int len = longest_to_int (exp->elts[pc + 1].longconst);
1058 struct type *selector_type;
1060 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1061 if (noside == EVAL_SKIP)
1065 sel[len] = 0; /* Make sure it's terminated. */
1067 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1068 return value_from_longest (selector_type,
1069 lookup_child_selector (exp->gdbarch, sel));
1072 case OP_OBJC_MSGCALL:
1073 { /* Objective C message (method) call. */
1075 CORE_ADDR responds_selector = 0;
1076 CORE_ADDR method_selector = 0;
1078 CORE_ADDR selector = 0;
1080 int struct_return = 0;
1081 int sub_no_side = 0;
1083 struct value *msg_send = NULL;
1084 struct value *msg_send_stret = NULL;
1085 int gnu_runtime = 0;
1087 struct value *target = NULL;
1088 struct value *method = NULL;
1089 struct value *called_method = NULL;
1091 struct type *selector_type = NULL;
1092 struct type *long_type;
1094 struct value *ret = NULL;
1097 selector = exp->elts[pc + 1].longconst;
1098 nargs = exp->elts[pc + 2].longconst;
1099 argvec = (struct value **) alloca (sizeof (struct value *)
1104 long_type = builtin_type (exp->gdbarch)->builtin_long;
1105 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1107 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1108 sub_no_side = EVAL_NORMAL;
1110 sub_no_side = noside;
1112 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1114 if (value_as_long (target) == 0)
1115 return value_from_longest (long_type, 0);
1117 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1120 /* Find the method dispatch (Apple runtime) or method lookup
1121 (GNU runtime) function for Objective-C. These will be used
1122 to lookup the symbol information for the method. If we
1123 can't find any symbol information, then we'll use these to
1124 call the method, otherwise we can call the method
1125 directly. The msg_send_stret function is used in the special
1126 case of a method that returns a structure (Apple runtime
1130 struct type *type = selector_type;
1132 type = lookup_function_type (type);
1133 type = lookup_pointer_type (type);
1134 type = lookup_function_type (type);
1135 type = lookup_pointer_type (type);
1137 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1139 = find_function_in_inferior ("objc_msg_lookup", NULL);
1141 msg_send = value_from_pointer (type, value_as_address (msg_send));
1142 msg_send_stret = value_from_pointer (type,
1143 value_as_address (msg_send_stret));
1147 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1148 /* Special dispatcher for methods returning structs. */
1150 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1153 /* Verify the target object responds to this method. The
1154 standard top-level 'Object' class uses a different name for
1155 the verification method than the non-standard, but more
1156 often used, 'NSObject' class. Make sure we check for both. */
1159 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1160 if (responds_selector == 0)
1162 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1164 if (responds_selector == 0)
1165 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1168 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1169 if (method_selector == 0)
1171 = lookup_child_selector (exp->gdbarch, "methodFor:");
1173 if (method_selector == 0)
1174 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1176 /* Call the verification method, to make sure that the target
1177 class implements the desired method. */
1179 argvec[0] = msg_send;
1181 argvec[2] = value_from_longest (long_type, responds_selector);
1182 argvec[3] = value_from_longest (long_type, selector);
1185 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1188 /* Function objc_msg_lookup returns a pointer. */
1190 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1192 if (value_as_long (ret) == 0)
1193 error (_("Target does not respond to this message selector."));
1195 /* Call "methodForSelector:" method, to get the address of a
1196 function method that implements this selector for this
1197 class. If we can find a symbol at that address, then we
1198 know the return type, parameter types etc. (that's a good
1201 argvec[0] = msg_send;
1203 argvec[2] = value_from_longest (long_type, method_selector);
1204 argvec[3] = value_from_longest (long_type, selector);
1207 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1211 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1214 /* ret should now be the selector. */
1216 addr = value_as_long (ret);
1219 struct symbol *sym = NULL;
1221 /* The address might point to a function descriptor;
1222 resolve it to the actual code address instead. */
1223 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1226 /* Is it a high_level symbol? */
1227 sym = find_pc_function (addr);
1229 method = value_of_variable (sym, 0);
1232 /* If we found a method with symbol information, check to see
1233 if it returns a struct. Otherwise assume it doesn't. */
1238 struct type *val_type;
1240 funaddr = find_function_addr (method, &val_type);
1242 block_for_pc (funaddr);
1244 CHECK_TYPEDEF (val_type);
1246 if ((val_type == NULL)
1247 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1249 if (expect_type != NULL)
1250 val_type = expect_type;
1253 struct_return = using_struct_return (exp->gdbarch, method,
1256 else if (expect_type != NULL)
1258 struct_return = using_struct_return (exp->gdbarch, NULL,
1259 check_typedef (expect_type));
1262 /* Found a function symbol. Now we will substitute its
1263 value in place of the message dispatcher (obj_msgSend),
1264 so that we call the method directly instead of thru
1265 the dispatcher. The main reason for doing this is that
1266 we can now evaluate the return value and parameter values
1267 according to their known data types, in case we need to
1268 do things like promotion, dereferencing, special handling
1269 of structs and doubles, etc.
1271 We want to use the type signature of 'method', but still
1272 jump to objc_msgSend() or objc_msgSend_stret() to better
1273 mimic the behavior of the runtime. */
1277 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1278 error (_("method address has symbol information "
1279 "with non-function type; skipping"));
1281 /* Create a function pointer of the appropriate type, and
1282 replace its value with the value of msg_send or
1283 msg_send_stret. We must use a pointer here, as
1284 msg_send and msg_send_stret are of pointer type, and
1285 the representation may be different on systems that use
1286 function descriptors. */
1289 = value_from_pointer (lookup_pointer_type (value_type (method)),
1290 value_as_address (msg_send_stret));
1293 = value_from_pointer (lookup_pointer_type (value_type (method)),
1294 value_as_address (msg_send));
1299 called_method = msg_send_stret;
1301 called_method = msg_send;
1304 if (noside == EVAL_SKIP)
1307 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1309 /* If the return type doesn't look like a function type,
1310 call an error. This can happen if somebody tries to
1311 turn a variable into a function call. This is here
1312 because people often want to call, eg, strcmp, which
1313 gdb doesn't know is a function. If gdb isn't asked for
1314 it's opinion (ie. through "whatis"), it won't offer
1317 struct type *type = value_type (called_method);
1319 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1320 type = TYPE_TARGET_TYPE (type);
1321 type = TYPE_TARGET_TYPE (type);
1325 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1326 return allocate_value (expect_type);
1328 return allocate_value (type);
1331 error (_("Expression of type other than "
1332 "\"method returning ...\" used as a method"));
1335 /* Now depending on whether we found a symbol for the method,
1336 we will either call the runtime dispatcher or the method
1339 argvec[0] = called_method;
1341 argvec[2] = value_from_longest (long_type, selector);
1342 /* User-supplied arguments. */
1343 for (tem = 0; tem < nargs; tem++)
1344 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1345 argvec[tem + 3] = 0;
1347 if (gnu_runtime && (method != NULL))
1349 /* Function objc_msg_lookup returns a pointer. */
1350 deprecated_set_value_type (argvec[0],
1351 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1353 = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1356 ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1363 op = exp->elts[*pos].opcode;
1364 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1365 /* Allocate arg vector, including space for the function to be
1366 called in argvec[0] and a terminating NULL. */
1367 argvec = (struct value **)
1368 alloca (sizeof (struct value *) * (nargs + 3));
1369 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1371 /* First, evaluate the structure into arg2. */
1374 if (noside == EVAL_SKIP)
1377 if (op == STRUCTOP_MEMBER)
1379 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1383 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1386 /* If the function is a virtual function, then the
1387 aggregate value (providing the structure) plays
1388 its part by providing the vtable. Otherwise,
1389 it is just along for the ride: call the function
1392 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1394 type = check_typedef (value_type (arg1));
1395 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR)
1397 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1398 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval);
1400 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1402 /* Now, say which argument to start evaluating from. */
1407 else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
1409 struct type *type_ptr
1410 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type));
1411 struct type *target_type_ptr
1412 = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1414 /* Now, convert these values to an address. */
1415 arg2 = value_cast (type_ptr, arg2);
1417 mem_offset = value_as_long (arg1);
1419 arg1 = value_from_pointer (target_type_ptr,
1420 value_as_long (arg2) + mem_offset);
1421 arg1 = value_ind (arg1);
1425 error (_("Non-pointer-to-member value used in pointer-to-member "
1428 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1430 /* Hair for method invocations. */
1434 /* First, evaluate the structure into arg2. */
1436 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1437 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1438 if (noside == EVAL_SKIP)
1441 if (op == STRUCTOP_STRUCT)
1443 /* If v is a variable in a register, and the user types
1444 v.method (), this will produce an error, because v has
1447 A possible way around this would be to allocate a
1448 copy of the variable on the stack, copy in the
1449 contents, call the function, and copy out the
1450 contents. I.e. convert this from call by reference
1451 to call by copy-return (or whatever it's called).
1452 However, this does not work because it is not the
1453 same: the method being called could stash a copy of
1454 the address, and then future uses through that address
1455 (after the method returns) would be expected to
1456 use the variable itself, not some copy of it. */
1457 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1461 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1463 /* Check to see if the operator '->' has been
1464 overloaded. If the operator has been overloaded
1465 replace arg2 with the value returned by the custom
1466 operator and continue evaluation. */
1467 while (unop_user_defined_p (op, arg2))
1469 volatile struct gdb_exception except;
1470 struct value *value = NULL;
1471 TRY_CATCH (except, RETURN_MASK_ERROR)
1473 value = value_x_unop (arg2, op, noside);
1476 if (except.reason < 0)
1478 if (except.error == NOT_FOUND_ERROR)
1481 throw_exception (except);
1486 /* Now, say which argument to start evaluating from. */
1489 else if (op == OP_SCOPE
1490 && overload_resolution
1491 && (exp->language_defn->la_language == language_cplus))
1493 /* Unpack it locally so we can properly handle overload
1499 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
1500 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
1501 type = exp->elts[pc2 + 1].type;
1502 name = &exp->elts[pc2 + 3].string;
1505 function_name = NULL;
1506 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
1508 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
1510 get_selected_block (0),
1512 if (function == NULL)
1513 error (_("No symbol \"%s\" in namespace \"%s\"."),
1514 name, TYPE_TAG_NAME (type));
1520 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1521 || TYPE_CODE (type) == TYPE_CODE_UNION);
1522 function_name = name;
1524 arg2 = value_zero (type, lval_memory);
1529 else if (op == OP_ADL_FUNC)
1531 /* Save the function position and move pos so that the arguments
1532 can be evaluated. */
1538 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1539 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1543 /* Non-method function call. */
1547 /* If this is a C++ function wait until overload resolution. */
1548 if (op == OP_VAR_VALUE
1549 && overload_resolution
1550 && (exp->language_defn->la_language == language_cplus))
1552 (*pos) += 4; /* Skip the evaluation of the symbol. */
1557 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1558 type = value_type (argvec[0]);
1559 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1560 type = TYPE_TARGET_TYPE (type);
1561 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1563 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1565 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1573 /* Evaluate arguments. */
1574 for (; tem <= nargs; tem++)
1576 /* Ensure that array expressions are coerced into pointer
1578 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1581 /* Signal end of arglist. */
1583 if (op == OP_ADL_FUNC)
1585 struct symbol *symp;
1588 int string_pc = save_pos1 + 3;
1590 /* Extract the function name. */
1591 name_len = longest_to_int (exp->elts[string_pc].longconst);
1592 func_name = (char *) alloca (name_len + 1);
1593 strcpy (func_name, &exp->elts[string_pc + 1].string);
1595 find_overload_match (&argvec[1], nargs, func_name,
1596 NON_METHOD, /* not method */
1597 NULL, NULL, /* pass NULL symbol since
1598 symbol is unknown */
1599 NULL, &symp, NULL, 0);
1601 /* Now fix the expression being evaluated. */
1602 exp->elts[save_pos1 + 2].symbol = symp;
1603 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1606 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1607 || (op == OP_SCOPE && function_name != NULL))
1609 int static_memfuncp;
1612 /* Method invocation : stuff "this" as first parameter. */
1617 /* Name of method from expression. */
1618 tstr = &exp->elts[pc2 + 2].string;
1621 tstr = function_name;
1623 if (overload_resolution && (exp->language_defn->la_language
1626 /* Language is C++, do some overload resolution before
1628 struct value *valp = NULL;
1630 (void) find_overload_match (&argvec[1], nargs, tstr,
1631 METHOD, /* method */
1632 &arg2, /* the object */
1634 &static_memfuncp, 0);
1636 if (op == OP_SCOPE && !static_memfuncp)
1638 /* For the time being, we don't handle this. */
1639 error (_("Call to overloaded function %s requires "
1643 argvec[1] = arg2; /* the ``this'' pointer */
1644 argvec[0] = valp; /* Use the method found after overload
1648 /* Non-C++ case -- or no overload resolution. */
1650 struct value *temp = arg2;
1652 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1654 op == STRUCTOP_STRUCT
1655 ? "structure" : "structure pointer");
1656 /* value_struct_elt updates temp with the correct value
1657 of the ``this'' pointer if necessary, so modify argvec[1] to
1658 reflect any ``this'' changes. */
1660 = value_from_longest (lookup_pointer_type(value_type (temp)),
1661 value_address (temp)
1662 + value_embedded_offset (temp));
1663 argvec[1] = arg2; /* the ``this'' pointer */
1666 if (static_memfuncp)
1668 argvec[1] = argvec[0];
1673 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1675 /* Pointer to member. argvec[1] is already set up. */
1678 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1680 /* Non-member function being called. */
1681 /* fn: This can only be done for C++ functions. A C-style function
1682 in a C++ program, for instance, does not have the fields that
1683 are expected here. */
1685 if (overload_resolution && (exp->language_defn->la_language
1688 /* Language is C++, do some overload resolution before
1690 struct symbol *symp;
1693 /* If a scope has been specified disable ADL. */
1697 if (op == OP_VAR_VALUE)
1698 function = exp->elts[save_pos1+2].symbol;
1700 (void) find_overload_match (&argvec[1], nargs,
1701 NULL, /* no need for name */
1702 NON_METHOD, /* not method */
1703 NULL, function, /* the function */
1704 NULL, &symp, NULL, no_adl);
1706 if (op == OP_VAR_VALUE)
1708 /* Now fix the expression being evaluated. */
1709 exp->elts[save_pos1+2].symbol = symp;
1710 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1714 argvec[0] = value_of_variable (symp, get_selected_block (0));
1718 /* Not C++, or no overload resolution allowed. */
1719 /* Nothing to be done; argvec already correctly set up. */
1724 /* It is probably a C-style function. */
1725 /* Nothing to be done; argvec already correctly set up. */
1730 if (noside == EVAL_SKIP)
1732 if (argvec[0] == NULL)
1733 error (_("Cannot evaluate function -- may be inlined"));
1734 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1736 /* If the return type doesn't look like a function type, call an
1737 error. This can happen if somebody tries to turn a variable into
1738 a function call. This is here because people often want to
1739 call, eg, strcmp, which gdb doesn't know is a function. If
1740 gdb isn't asked for it's opinion (ie. through "whatis"),
1741 it won't offer it. */
1743 struct type *ftype = value_type (argvec[0]);
1745 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
1747 /* We don't know anything about what the internal
1748 function might return, but we have to return
1750 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
1753 else if (TYPE_GNU_IFUNC (ftype))
1754 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype)));
1755 else if (TYPE_TARGET_TYPE (ftype))
1756 return allocate_value (TYPE_TARGET_TYPE (ftype));
1758 error (_("Expression of type other than "
1759 "\"Function returning ...\" used as function"));
1761 if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_INTERNAL_FUNCTION)
1762 return call_internal_function (exp->gdbarch, exp->language_defn,
1763 argvec[0], nargs, argvec + 1);
1765 return call_function_by_hand (argvec[0], nargs, argvec + 1);
1766 /* pai: FIXME save value from call_function_by_hand, then adjust
1767 pc by adjust_fn_pc if +ve. */
1769 case OP_F77_UNDETERMINED_ARGLIST:
1771 /* Remember that in F77, functions, substring ops and
1772 array subscript operations cannot be disambiguated
1773 at parse time. We have made all array subscript operations,
1774 substring operations as well as function calls come here
1775 and we now have to discover what the heck this thing actually was.
1776 If it is a function, we process just as if we got an OP_FUNCALL. */
1778 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1781 /* First determine the type code we are dealing with. */
1782 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1783 type = check_typedef (value_type (arg1));
1784 code = TYPE_CODE (type);
1786 if (code == TYPE_CODE_PTR)
1788 /* Fortran always passes variable to subroutines as pointer.
1789 So we need to look into its target type to see if it is
1790 array, string or function. If it is, we need to switch
1791 to the target value the original one points to. */
1792 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1794 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1795 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1796 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1798 arg1 = value_ind (arg1);
1799 type = check_typedef (value_type (arg1));
1800 code = TYPE_CODE (type);
1806 case TYPE_CODE_ARRAY:
1807 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1808 return value_f90_subarray (arg1, exp, pos, noside);
1810 goto multi_f77_subscript;
1812 case TYPE_CODE_STRING:
1813 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1814 return value_f90_subarray (arg1, exp, pos, noside);
1817 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1818 return value_subscript (arg1, value_as_long (arg2));
1822 case TYPE_CODE_FUNC:
1823 /* It's a function call. */
1824 /* Allocate arg vector, including space for the function to be
1825 called in argvec[0] and a terminating NULL. */
1826 argvec = (struct value **)
1827 alloca (sizeof (struct value *) * (nargs + 2));
1830 for (; tem <= nargs; tem++)
1831 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1832 argvec[tem] = 0; /* signal end of arglist */
1836 error (_("Cannot perform substring on this type"));
1840 /* We have a complex number, There should be 2 floating
1841 point numbers that compose it. */
1843 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1844 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1846 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1848 case STRUCTOP_STRUCT:
1849 tem = longest_to_int (exp->elts[pc + 1].longconst);
1850 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1851 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1852 if (noside == EVAL_SKIP)
1854 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1856 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1857 arg3 = value_zero (value_type (arg3), not_lval);
1861 tem = longest_to_int (exp->elts[pc + 1].longconst);
1862 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1863 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1864 if (noside == EVAL_SKIP)
1867 /* Check to see if operator '->' has been overloaded. If so replace
1868 arg1 with the value returned by evaluating operator->(). */
1869 while (unop_user_defined_p (op, arg1))
1871 volatile struct gdb_exception except;
1872 struct value *value = NULL;
1873 TRY_CATCH (except, RETURN_MASK_ERROR)
1875 value = value_x_unop (arg1, op, noside);
1878 if (except.reason < 0)
1880 if (except.error == NOT_FOUND_ERROR)
1883 throw_exception (except);
1888 /* JYG: if print object is on we need to replace the base type
1889 with rtti type in order to continue on with successful
1890 lookup of member / method only available in the rtti type. */
1892 struct type *type = value_type (arg1);
1893 struct type *real_type;
1894 int full, top, using_enc;
1895 struct value_print_options opts;
1897 get_user_print_options (&opts);
1898 if (opts.objectprint && TYPE_TARGET_TYPE(type)
1899 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
1901 real_type = value_rtti_indirect_type (arg1, &full, &top,
1904 arg1 = value_cast (real_type, arg1);
1908 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1909 NULL, "structure pointer");
1910 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1911 arg3 = value_zero (value_type (arg3), not_lval);
1914 case STRUCTOP_MEMBER:
1916 if (op == STRUCTOP_MEMBER)
1917 arg1 = evaluate_subexp_for_address (exp, pos, noside);
1919 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1921 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1923 if (noside == EVAL_SKIP)
1926 type = check_typedef (value_type (arg2));
1927 switch (TYPE_CODE (type))
1929 case TYPE_CODE_METHODPTR:
1930 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1931 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1934 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
1935 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
1936 return value_ind (arg2);
1939 case TYPE_CODE_MEMBERPTR:
1940 /* Now, convert these values to an address. */
1941 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
1944 mem_offset = value_as_long (arg2);
1946 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1947 value_as_long (arg1) + mem_offset);
1948 return value_ind (arg3);
1951 error (_("non-pointer-to-member value used "
1952 "in pointer-to-member construct"));
1956 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1957 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
1958 for (ix = 0; ix < nargs; ++ix)
1959 arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
1961 expect_type = make_params (nargs, arg_types);
1962 *(pos) += 3 + nargs;
1963 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
1964 xfree (TYPE_FIELDS (expect_type));
1965 xfree (TYPE_MAIN_TYPE (expect_type));
1966 xfree (expect_type);
1970 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1971 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1972 if (noside == EVAL_SKIP)
1974 if (binop_user_defined_p (op, arg1, arg2))
1975 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1977 return value_concat (arg1, arg2);
1980 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1981 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1983 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1985 if (binop_user_defined_p (op, arg1, arg2))
1986 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1988 return value_assign (arg1, arg2);
1990 case BINOP_ASSIGN_MODIFY:
1992 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1993 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1994 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1996 op = exp->elts[pc + 1].opcode;
1997 if (binop_user_defined_p (op, arg1, arg2))
1998 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
1999 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2001 && is_integral_type (value_type (arg2)))
2002 arg2 = value_ptradd (arg1, value_as_long (arg2));
2003 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2005 && is_integral_type (value_type (arg2)))
2006 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2009 struct value *tmp = arg1;
2011 /* For shift and integer exponentiation operations,
2012 only promote the first argument. */
2013 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2014 && is_integral_type (value_type (arg2)))
2015 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2017 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2019 arg2 = value_binop (tmp, arg2, op);
2021 return value_assign (arg1, arg2);
2024 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2025 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2026 if (noside == EVAL_SKIP)
2028 if (binop_user_defined_p (op, arg1, arg2))
2029 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2030 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2031 && is_integral_type (value_type (arg2)))
2032 return value_ptradd (arg1, value_as_long (arg2));
2033 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2034 && is_integral_type (value_type (arg1)))
2035 return value_ptradd (arg2, value_as_long (arg1));
2038 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2039 return value_binop (arg1, arg2, BINOP_ADD);
2043 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2044 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2045 if (noside == EVAL_SKIP)
2047 if (binop_user_defined_p (op, arg1, arg2))
2048 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2049 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2050 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2052 /* FIXME -- should be ptrdiff_t */
2053 type = builtin_type (exp->gdbarch)->builtin_long;
2054 return value_from_longest (type, value_ptrdiff (arg1, arg2));
2056 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2057 && is_integral_type (value_type (arg2)))
2058 return value_ptradd (arg1, - value_as_long (arg2));
2061 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2062 return value_binop (arg1, arg2, BINOP_SUB);
2073 case BINOP_BITWISE_AND:
2074 case BINOP_BITWISE_IOR:
2075 case BINOP_BITWISE_XOR:
2076 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2077 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2078 if (noside == EVAL_SKIP)
2080 if (binop_user_defined_p (op, arg1, arg2))
2081 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2084 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2085 fudge arg2 to avoid division-by-zero, the caller is
2086 (theoretically) only looking for the type of the result. */
2087 if (noside == EVAL_AVOID_SIDE_EFFECTS
2088 /* ??? Do we really want to test for BINOP_MOD here?
2089 The implementation of value_binop gives it a well-defined
2092 || op == BINOP_INTDIV
2095 && value_logical_not (arg2))
2097 struct value *v_one, *retval;
2099 v_one = value_one (value_type (arg2));
2100 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2101 retval = value_binop (arg1, v_one, op);
2106 /* For shift and integer exponentiation operations,
2107 only promote the first argument. */
2108 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2109 && is_integral_type (value_type (arg2)))
2110 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2112 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2114 return value_binop (arg1, arg2, op);
2119 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2120 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2121 if (noside == EVAL_SKIP)
2123 error (_("':' operator used in invalid context"));
2125 case BINOP_SUBSCRIPT:
2126 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2127 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2128 if (noside == EVAL_SKIP)
2130 if (binop_user_defined_p (op, arg1, arg2))
2131 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2134 /* If the user attempts to subscript something that is not an
2135 array or pointer type (like a plain int variable for example),
2136 then report this as an error. */
2138 arg1 = coerce_ref (arg1);
2139 type = check_typedef (value_type (arg1));
2140 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2141 && TYPE_CODE (type) != TYPE_CODE_PTR)
2143 if (TYPE_NAME (type))
2144 error (_("cannot subscript something of type `%s'"),
2147 error (_("cannot subscript requested type"));
2150 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2151 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2153 return value_subscript (arg1, value_as_long (arg2));
2157 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2158 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2159 if (noside == EVAL_SKIP)
2161 type = language_bool_type (exp->language_defn, exp->gdbarch);
2162 return value_from_longest (type, (LONGEST) value_in (arg1, arg2));
2164 case MULTI_SUBSCRIPT:
2166 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2167 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2170 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2171 /* FIXME: EVAL_SKIP handling may not be correct. */
2172 if (noside == EVAL_SKIP)
2183 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2184 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2186 /* If the user attempts to subscript something that has no target
2187 type (like a plain int variable for example), then report this
2190 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2193 arg1 = value_zero (type, VALUE_LVAL (arg1));
2199 error (_("cannot subscript something of type `%s'"),
2200 TYPE_NAME (value_type (arg1)));
2204 if (binop_user_defined_p (op, arg1, arg2))
2206 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2210 arg1 = coerce_ref (arg1);
2211 type = check_typedef (value_type (arg1));
2213 switch (TYPE_CODE (type))
2216 case TYPE_CODE_ARRAY:
2217 case TYPE_CODE_STRING:
2218 arg1 = value_subscript (arg1, value_as_long (arg2));
2222 if (TYPE_NAME (type))
2223 error (_("cannot subscript something of type `%s'"),
2226 error (_("cannot subscript requested type"));
2232 multi_f77_subscript:
2234 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2235 int ndimensions = 1, i;
2236 struct value *array = arg1;
2238 if (nargs > MAX_FORTRAN_DIMS)
2239 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2241 ndimensions = calc_f77_array_dims (type);
2243 if (nargs != ndimensions)
2244 error (_("Wrong number of subscripts"));
2246 gdb_assert (nargs > 0);
2248 /* Now that we know we have a legal array subscript expression
2249 let us actually find out where this element exists in the array. */
2251 /* Take array indices left to right. */
2252 for (i = 0; i < nargs; i++)
2254 /* Evaluate each subscript; it must be a legal integer in F77. */
2255 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2257 /* Fill in the subscript array. */
2259 subscript_array[i] = value_as_long (arg2);
2262 /* Internal type of array is arranged right to left. */
2263 for (i = nargs; i > 0; i--)
2265 struct type *array_type = check_typedef (value_type (array));
2266 LONGEST index = subscript_array[i - 1];
2268 array = value_subscripted_rvalue (array, index,
2269 f77_get_lowerbound (array_type));
2275 case BINOP_LOGICAL_AND:
2276 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2277 if (noside == EVAL_SKIP)
2279 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2284 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2287 if (binop_user_defined_p (op, arg1, arg2))
2289 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2290 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2294 tem = value_logical_not (arg1);
2295 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2296 (tem ? EVAL_SKIP : noside));
2297 type = language_bool_type (exp->language_defn, exp->gdbarch);
2298 return value_from_longest (type,
2299 (LONGEST) (!tem && !value_logical_not (arg2)));
2302 case BINOP_LOGICAL_OR:
2303 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2304 if (noside == EVAL_SKIP)
2306 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2311 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2314 if (binop_user_defined_p (op, arg1, arg2))
2316 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2317 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2321 tem = value_logical_not (arg1);
2322 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2323 (!tem ? EVAL_SKIP : noside));
2324 type = language_bool_type (exp->language_defn, exp->gdbarch);
2325 return value_from_longest (type,
2326 (LONGEST) (!tem || !value_logical_not (arg2)));
2330 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2331 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2332 if (noside == EVAL_SKIP)
2334 if (binop_user_defined_p (op, arg1, arg2))
2336 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2340 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2341 tem = value_equal (arg1, arg2);
2342 type = language_bool_type (exp->language_defn, exp->gdbarch);
2343 return value_from_longest (type, (LONGEST) tem);
2346 case BINOP_NOTEQUAL:
2347 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2348 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2349 if (noside == EVAL_SKIP)
2351 if (binop_user_defined_p (op, arg1, arg2))
2353 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2357 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2358 tem = value_equal (arg1, arg2);
2359 type = language_bool_type (exp->language_defn, exp->gdbarch);
2360 return value_from_longest (type, (LONGEST) ! tem);
2364 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2365 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2366 if (noside == EVAL_SKIP)
2368 if (binop_user_defined_p (op, arg1, arg2))
2370 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2374 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2375 tem = value_less (arg1, arg2);
2376 type = language_bool_type (exp->language_defn, exp->gdbarch);
2377 return value_from_longest (type, (LONGEST) tem);
2381 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2382 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2383 if (noside == EVAL_SKIP)
2385 if (binop_user_defined_p (op, arg1, arg2))
2387 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2391 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2392 tem = value_less (arg2, arg1);
2393 type = language_bool_type (exp->language_defn, exp->gdbarch);
2394 return value_from_longest (type, (LONGEST) tem);
2398 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2399 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2400 if (noside == EVAL_SKIP)
2402 if (binop_user_defined_p (op, arg1, arg2))
2404 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2408 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2409 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2410 type = language_bool_type (exp->language_defn, exp->gdbarch);
2411 return value_from_longest (type, (LONGEST) tem);
2415 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2416 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2417 if (noside == EVAL_SKIP)
2419 if (binop_user_defined_p (op, arg1, arg2))
2421 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2425 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2426 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2427 type = language_bool_type (exp->language_defn, exp->gdbarch);
2428 return value_from_longest (type, (LONGEST) tem);
2432 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2433 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2434 if (noside == EVAL_SKIP)
2436 type = check_typedef (value_type (arg2));
2437 if (TYPE_CODE (type) != TYPE_CODE_INT)
2438 error (_("Non-integral right operand for \"@\" operator."));
2439 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2441 return allocate_repeat_value (value_type (arg1),
2442 longest_to_int (value_as_long (arg2)));
2445 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2448 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2449 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2452 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2453 if (noside == EVAL_SKIP)
2455 if (unop_user_defined_p (op, arg1))
2456 return value_x_unop (arg1, op, noside);
2459 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2460 return value_pos (arg1);
2464 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2465 if (noside == EVAL_SKIP)
2467 if (unop_user_defined_p (op, arg1))
2468 return value_x_unop (arg1, op, noside);
2471 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2472 return value_neg (arg1);
2475 case UNOP_COMPLEMENT:
2476 /* C++: check for and handle destructor names. */
2477 op = exp->elts[*pos].opcode;
2479 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2480 if (noside == EVAL_SKIP)
2482 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2483 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2486 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2487 return value_complement (arg1);
2490 case UNOP_LOGICAL_NOT:
2491 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2492 if (noside == EVAL_SKIP)
2494 if (unop_user_defined_p (op, arg1))
2495 return value_x_unop (arg1, op, noside);
2498 type = language_bool_type (exp->language_defn, exp->gdbarch);
2499 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2503 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2504 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2505 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2506 type = check_typedef (value_type (arg1));
2507 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2508 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2509 error (_("Attempt to dereference pointer "
2510 "to member without an object"));
2511 if (noside == EVAL_SKIP)
2513 if (unop_user_defined_p (op, arg1))
2514 return value_x_unop (arg1, op, noside);
2515 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2517 type = check_typedef (value_type (arg1));
2518 if (TYPE_CODE (type) == TYPE_CODE_PTR
2519 || TYPE_CODE (type) == TYPE_CODE_REF
2520 /* In C you can dereference an array to get the 1st elt. */
2521 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2523 return value_zero (TYPE_TARGET_TYPE (type),
2525 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2526 /* GDB allows dereferencing an int. */
2527 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2530 error (_("Attempt to take contents of a non-pointer value."));
2533 /* Allow * on an integer so we can cast it to whatever we want.
2534 This returns an int, which seems like the most C-like thing to
2535 do. "long long" variables are rare enough that
2536 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2537 if (TYPE_CODE (type) == TYPE_CODE_INT)
2538 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2539 (CORE_ADDR) value_as_address (arg1));
2540 return value_ind (arg1);
2543 /* C++: check for and handle pointer to members. */
2545 op = exp->elts[*pos].opcode;
2547 if (noside == EVAL_SKIP)
2549 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2554 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2561 if (noside == EVAL_SKIP)
2563 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2566 return evaluate_subexp_for_sizeof (exp, pos);
2570 type = exp->elts[pc + 1].type;
2571 arg1 = evaluate_subexp (type, exp, pos, noside);
2572 if (noside == EVAL_SKIP)
2574 if (type != value_type (arg1))
2575 arg1 = value_cast (type, arg1);
2578 case UNOP_CAST_TYPE:
2579 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2580 type = value_type (arg1);
2581 arg1 = evaluate_subexp (type, exp, pos, noside);
2582 if (noside == EVAL_SKIP)
2584 if (type != value_type (arg1))
2585 arg1 = value_cast (type, arg1);
2588 case UNOP_DYNAMIC_CAST:
2589 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2590 type = value_type (arg1);
2591 arg1 = evaluate_subexp (type, exp, pos, noside);
2592 if (noside == EVAL_SKIP)
2594 return value_dynamic_cast (type, arg1);
2596 case UNOP_REINTERPRET_CAST:
2597 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2598 type = value_type (arg1);
2599 arg1 = evaluate_subexp (type, exp, pos, noside);
2600 if (noside == EVAL_SKIP)
2602 return value_reinterpret_cast (type, arg1);
2606 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2607 if (noside == EVAL_SKIP)
2609 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2610 return value_zero (exp->elts[pc + 1].type, lval_memory);
2612 return value_at_lazy (exp->elts[pc + 1].type,
2613 value_as_address (arg1));
2615 case UNOP_MEMVAL_TYPE:
2616 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2617 type = value_type (arg1);
2618 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2619 if (noside == EVAL_SKIP)
2621 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2622 return value_zero (type, lval_memory);
2624 return value_at_lazy (type, value_as_address (arg1));
2626 case UNOP_MEMVAL_TLS:
2628 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2629 if (noside == EVAL_SKIP)
2631 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2632 return value_zero (exp->elts[pc + 2].type, lval_memory);
2637 tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2638 value_as_address (arg1));
2639 return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
2642 case UNOP_PREINCREMENT:
2643 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2644 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2646 else if (unop_user_defined_p (op, arg1))
2648 return value_x_unop (arg1, op, noside);
2652 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2653 arg2 = value_ptradd (arg1, 1);
2656 struct value *tmp = arg1;
2658 arg2 = value_one (value_type (arg1));
2659 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2660 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2663 return value_assign (arg1, arg2);
2666 case UNOP_PREDECREMENT:
2667 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2668 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2670 else if (unop_user_defined_p (op, arg1))
2672 return value_x_unop (arg1, op, noside);
2676 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2677 arg2 = value_ptradd (arg1, -1);
2680 struct value *tmp = arg1;
2682 arg2 = value_one (value_type (arg1));
2683 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2684 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2687 return value_assign (arg1, arg2);
2690 case UNOP_POSTINCREMENT:
2691 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2692 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2694 else if (unop_user_defined_p (op, arg1))
2696 return value_x_unop (arg1, op, noside);
2700 arg3 = value_non_lval (arg1);
2702 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2703 arg2 = value_ptradd (arg1, 1);
2706 struct value *tmp = arg1;
2708 arg2 = value_one (value_type (arg1));
2709 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2710 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2713 value_assign (arg1, arg2);
2717 case UNOP_POSTDECREMENT:
2718 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2719 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2721 else if (unop_user_defined_p (op, arg1))
2723 return value_x_unop (arg1, op, noside);
2727 arg3 = value_non_lval (arg1);
2729 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2730 arg2 = value_ptradd (arg1, -1);
2733 struct value *tmp = arg1;
2735 arg2 = value_one (value_type (arg1));
2736 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2737 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2740 value_assign (arg1, arg2);
2746 return value_of_this (exp->language_defn);
2749 /* The value is not supposed to be used. This is here to make it
2750 easier to accommodate expressions that contain types. */
2752 if (noside == EVAL_SKIP)
2754 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2756 struct type *type = exp->elts[pc + 1].type;
2758 /* If this is a typedef, then find its immediate target. We
2759 use check_typedef to resolve stubs, but we ignore its
2760 result because we do not want to dig past all
2762 check_typedef (type);
2763 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2764 type = TYPE_TARGET_TYPE (type);
2765 return allocate_value (type);
2768 error (_("Attempt to use a type name as an expression"));
2772 if (noside == EVAL_SKIP)
2774 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2777 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2779 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2780 struct value *result;
2782 result = evaluate_subexp (NULL_TYPE, exp, pos,
2783 EVAL_AVOID_SIDE_EFFECTS);
2785 /* 'decltype' has special semantics for lvalues. */
2786 if (op == OP_DECLTYPE
2787 && (sub_op == BINOP_SUBSCRIPT
2788 || sub_op == STRUCTOP_MEMBER
2789 || sub_op == STRUCTOP_MPTR
2790 || sub_op == UNOP_IND
2791 || sub_op == STRUCTOP_STRUCT
2792 || sub_op == STRUCTOP_PTR
2793 || sub_op == OP_SCOPE))
2795 struct type *type = value_type (result);
2797 if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF)
2799 type = lookup_reference_type (type);
2800 result = allocate_value (type);
2807 error (_("Attempt to use a type as an expression"));
2811 struct value *result;
2812 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2814 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2815 result = evaluate_subexp (NULL_TYPE, exp, pos,
2816 EVAL_AVOID_SIDE_EFFECTS);
2818 result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2820 if (noside != EVAL_NORMAL)
2821 return allocate_value (cplus_typeid_type (exp->gdbarch));
2823 return cplus_typeid (result);
2827 /* Removing this case and compiling with gcc -Wall reveals that
2828 a lot of cases are hitting this case. Some of these should
2829 probably be removed from expression.h; others are legitimate
2830 expressions which are (apparently) not fully implemented.
2832 If there are any cases landing here which mean a user error,
2833 then they should be separate cases, with more descriptive
2836 error (_("GDB does not (yet) know how to "
2837 "evaluate that kind of expression"));
2841 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
2844 /* Evaluate a subexpression of EXP, at index *POS,
2845 and return the address of that subexpression.
2846 Advance *POS over the subexpression.
2847 If the subexpression isn't an lvalue, get an error.
2848 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2849 then only the type of the result need be correct. */
2851 static struct value *
2852 evaluate_subexp_for_address (struct expression *exp, int *pos,
2862 op = exp->elts[pc].opcode;
2868 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2870 /* We can't optimize out "&*" if there's a user-defined operator*. */
2871 if (unop_user_defined_p (op, x))
2873 x = value_x_unop (x, op, noside);
2874 goto default_case_after_eval;
2877 return coerce_array (x);
2881 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2882 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2884 case UNOP_MEMVAL_TYPE:
2889 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2890 type = value_type (x);
2891 return value_cast (lookup_pointer_type (type),
2892 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2896 var = exp->elts[pc + 2].symbol;
2898 /* C++: The "address" of a reference should yield the address
2899 * of the object pointed to. Let value_addr() deal with it. */
2900 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
2904 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2907 lookup_pointer_type (SYMBOL_TYPE (var));
2908 enum address_class sym_class = SYMBOL_CLASS (var);
2910 if (sym_class == LOC_CONST
2911 || sym_class == LOC_CONST_BYTES
2912 || sym_class == LOC_REGISTER)
2913 error (_("Attempt to take address of register or constant."));
2916 value_zero (type, not_lval);
2919 return address_of_variable (var, exp->elts[pc + 1].block);
2922 tem = longest_to_int (exp->elts[pc + 2].longconst);
2923 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2924 x = value_aggregate_elt (exp->elts[pc + 1].type,
2925 &exp->elts[pc + 3].string,
2928 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2933 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2934 default_case_after_eval:
2935 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2937 struct type *type = check_typedef (value_type (x));
2939 if (TYPE_CODE (type) == TYPE_CODE_REF)
2940 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2942 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2943 return value_zero (lookup_pointer_type (value_type (x)),
2946 error (_("Attempt to take address of "
2947 "value not located in memory."));
2949 return value_addr (x);
2953 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2954 When used in contexts where arrays will be coerced anyway, this is
2955 equivalent to `evaluate_subexp' but much faster because it avoids
2956 actually fetching array contents (perhaps obsolete now that we have
2959 Note that we currently only do the coercion for C expressions, where
2960 arrays are zero based and the coercion is correct. For other languages,
2961 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2962 to decide if coercion is appropriate. */
2965 evaluate_subexp_with_coercion (struct expression *exp,
2966 int *pos, enum noside noside)
2975 op = exp->elts[pc].opcode;
2980 var = exp->elts[pc + 2].symbol;
2981 type = check_typedef (SYMBOL_TYPE (var));
2982 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
2983 && !TYPE_VECTOR (type)
2984 && CAST_IS_CONVERSION (exp->language_defn))
2987 val = address_of_variable (var, exp->elts[pc + 1].block);
2988 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2994 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2998 /* Evaluate a subexpression of EXP, at index *POS,
2999 and return a value for the size of that subexpression.
3000 Advance *POS over the subexpression. */
3002 static struct value *
3003 evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
3005 /* FIXME: This should be size_t. */
3006 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3013 op = exp->elts[pc].opcode;
3017 /* This case is handled specially
3018 so that we avoid creating a value for the result type.
3019 If the result type is very big, it's desirable not to
3020 create a value unnecessarily. */
3023 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3024 type = check_typedef (value_type (val));
3025 if (TYPE_CODE (type) != TYPE_CODE_PTR
3026 && TYPE_CODE (type) != TYPE_CODE_REF
3027 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3028 error (_("Attempt to take contents of a non-pointer value."));
3029 type = check_typedef (TYPE_TARGET_TYPE (type));
3030 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3034 type = check_typedef (exp->elts[pc + 1].type);
3035 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3037 case UNOP_MEMVAL_TYPE:
3039 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3040 type = check_typedef (value_type (val));
3041 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3045 type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
3047 value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3050 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3051 return value_from_longest (size_type,
3052 (LONGEST) TYPE_LENGTH (value_type (val)));
3056 /* Parse a type expression in the string [P..P+LENGTH). */
3059 parse_and_eval_type (char *p, int length)
3061 char *tmp = (char *) alloca (length + 4);
3062 struct expression *expr;
3065 memcpy (tmp + 1, p, length);
3066 tmp[length + 1] = ')';
3067 tmp[length + 2] = '0';
3068 tmp[length + 3] = '\0';
3069 expr = parse_expression (tmp);
3070 if (expr->elts[0].opcode != UNOP_CAST)
3071 error (_("Internal error in eval_type."));
3072 return expr->elts[1].type;
3076 calc_f77_array_dims (struct type *array_type)
3079 struct type *tmp_type;
3081 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3082 error (_("Can't get dimensions for a non-array type"));
3084 tmp_type = array_type;
3086 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3088 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)