1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2014 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"
44 #include "gdb_assert.h"
48 /* This is defined in valops.c */
49 extern int overload_resolution;
51 /* Prototypes for local functions. */
53 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
55 static struct value *evaluate_subexp_for_address (struct expression *,
58 static struct value *evaluate_struct_tuple (struct value *,
59 struct expression *, int *,
62 static LONGEST init_array_element (struct value *, struct value *,
63 struct expression *, int *, enum noside,
67 evaluate_subexp (struct type *expect_type, struct expression *exp,
68 int *pos, enum noside noside)
70 return (*exp->language_defn->la_exp_desc->evaluate_exp)
71 (expect_type, exp, pos, noside);
74 /* Parse the string EXP as a C expression, evaluate it,
75 and return the result as a number. */
78 parse_and_eval_address (const char *exp)
80 struct expression *expr = parse_expression (exp);
82 struct cleanup *old_chain =
83 make_cleanup (free_current_contents, &expr);
85 addr = value_as_address (evaluate_expression (expr));
86 do_cleanups (old_chain);
90 /* Like parse_and_eval_address, but treats the value of the expression
91 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
93 parse_and_eval_long (const char *exp)
95 struct expression *expr = parse_expression (exp);
97 struct cleanup *old_chain =
98 make_cleanup (free_current_contents, &expr);
100 retval = value_as_long (evaluate_expression (expr));
101 do_cleanups (old_chain);
106 parse_and_eval (const char *exp)
108 struct expression *expr = parse_expression (exp);
110 struct cleanup *old_chain =
111 make_cleanup (free_current_contents, &expr);
113 val = evaluate_expression (expr);
114 do_cleanups (old_chain);
118 /* Parse up to a comma (or to a closeparen)
119 in the string EXPP as an expression, evaluate it, and return the value.
120 EXPP is advanced to point to the comma. */
123 parse_to_comma_and_eval (const char **expp)
125 struct expression *expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
127 struct cleanup *old_chain =
128 make_cleanup (free_current_contents, &expr);
130 val = evaluate_expression (expr);
131 do_cleanups (old_chain);
135 /* Evaluate an expression in internal prefix form
136 such as is constructed by parse.y.
138 See expression.h for info on the format of an expression. */
141 evaluate_expression (struct expression *exp)
145 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
148 /* Evaluate an expression, avoiding all memory references
149 and getting a value whose type alone is correct. */
152 evaluate_type (struct expression *exp)
156 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
159 /* Evaluate a subexpression, avoiding all memory references and
160 getting a value whose type alone is correct. */
163 evaluate_subexpression_type (struct expression *exp, int subexp)
165 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
168 /* Find the current value of a watchpoint on EXP. Return the value in
169 *VALP and *RESULTP and the chain of intermediate and final values
170 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
173 If PRESERVE_ERRORS is true, then exceptions are passed through.
174 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
175 occurs while evaluating the expression, *RESULTP will be set to
176 NULL. *RESULTP may be a lazy value, if the result could not be
177 read from memory. It is used to determine whether a value is
178 user-specified (we should watch the whole value) or intermediate
179 (we should watch only the bit used to locate the final value).
181 If the final value, or any intermediate value, could not be read
182 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
183 set to any referenced values. *VALP will never be a lazy value.
184 This is the value which we store in struct breakpoint.
186 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
187 value chain. The caller must free the values individually. If
188 VAL_CHAIN is NULL, all generated values will be left on the value
192 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
193 struct value **resultp, struct value **val_chain,
196 struct value *mark, *new_mark, *result;
197 volatile struct gdb_exception ex;
205 /* Evaluate the expression. */
206 mark = value_mark ();
209 TRY_CATCH (ex, RETURN_MASK_ALL)
211 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
215 /* Ignore memory errors if we want watchpoints pointing at
216 inaccessible memory to still be created; otherwise, throw the
217 error to some higher catcher. */
221 if (!preserve_errors)
224 throw_exception (ex);
229 new_mark = value_mark ();
230 if (mark == new_mark)
235 /* Make sure it's not lazy, so that after the target stops again we
236 have a non-lazy previous value to compare with. */
239 if (!value_lazy (result))
243 volatile struct gdb_exception except;
245 TRY_CATCH (except, RETURN_MASK_ERROR)
247 value_fetch_lazy (result);
255 /* Return the chain of intermediate values. We use this to
256 decide which addresses to watch. */
257 *val_chain = new_mark;
258 value_release_to_mark (mark);
262 /* Extract a field operation from an expression. If the subexpression
263 of EXP starting at *SUBEXP is not a structure dereference
264 operation, return NULL. Otherwise, return the name of the
265 dereferenced field, and advance *SUBEXP to point to the
266 subexpression of the left-hand-side of the dereference. This is
267 used when completing field names. */
270 extract_field_op (struct expression *exp, int *subexp)
275 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
276 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
278 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
279 result = &exp->elts[*subexp + 2].string;
280 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
284 /* This function evaluates brace-initializers (in C/C++) for
287 static struct value *
288 evaluate_struct_tuple (struct value *struct_val,
289 struct expression *exp,
290 int *pos, enum noside noside, int nargs)
292 struct type *struct_type = check_typedef (value_type (struct_val));
293 struct type *field_type;
298 struct value *val = NULL;
303 /* Skip static fields. */
304 while (fieldno < TYPE_NFIELDS (struct_type)
305 && field_is_static (&TYPE_FIELD (struct_type,
308 if (fieldno >= TYPE_NFIELDS (struct_type))
309 error (_("too many initializers"));
310 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
311 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
312 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
313 error (_("don't know which variant you want to set"));
315 /* Here, struct_type is the type of the inner struct,
316 while substruct_type is the type of the inner struct.
317 These are the same for normal structures, but a variant struct
318 contains anonymous union fields that contain substruct fields.
319 The value fieldno is the index of the top-level (normal or
320 anonymous union) field in struct_field, while the value
321 subfieldno is the index of the actual real (named inner) field
322 in substruct_type. */
324 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
326 val = evaluate_subexp (field_type, exp, pos, noside);
328 /* Now actually set the field in struct_val. */
330 /* Assign val to field fieldno. */
331 if (value_type (val) != field_type)
332 val = value_cast (field_type, val);
334 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
335 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
336 addr = value_contents_writeable (struct_val) + bitpos / 8;
338 modify_field (struct_type, addr,
339 value_as_long (val), bitpos % 8, bitsize);
341 memcpy (addr, value_contents (val),
342 TYPE_LENGTH (value_type (val)));
348 /* Recursive helper function for setting elements of array tuples for
349 (the deleted) Chill. The target is ARRAY (which has bounds
350 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
351 and NOSIDE are as usual. Evaluates index expresions and sets the
352 specified element(s) of ARRAY to ELEMENT. Returns last index
356 init_array_element (struct value *array, struct value *element,
357 struct expression *exp, int *pos,
358 enum noside noside, LONGEST low_bound, LONGEST high_bound)
361 int element_size = TYPE_LENGTH (value_type (element));
363 if (exp->elts[*pos].opcode == BINOP_COMMA)
366 init_array_element (array, element, exp, pos, noside,
367 low_bound, high_bound);
368 return init_array_element (array, element,
369 exp, pos, noside, low_bound, high_bound);
371 else if (exp->elts[*pos].opcode == BINOP_RANGE)
376 low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
377 high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
378 if (low < low_bound || high > high_bound)
379 error (_("tuple range index out of range"));
380 for (index = low; index <= high; index++)
382 memcpy (value_contents_raw (array)
383 + (index - low_bound) * element_size,
384 value_contents (element), element_size);
389 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
390 if (index < low_bound || index > high_bound)
391 error (_("tuple index out of range"));
392 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
393 value_contents (element), element_size);
398 static struct value *
399 value_f90_subarray (struct value *array,
400 struct expression *exp, int *pos, enum noside noside)
403 LONGEST low_bound, high_bound;
404 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
405 enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);
409 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
410 low_bound = TYPE_LOW_BOUND (range);
412 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
414 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
415 high_bound = TYPE_HIGH_BOUND (range);
417 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
419 return value_slice (array, low_bound, high_bound - low_bound + 1);
423 /* Promote value ARG1 as appropriate before performing a unary operation
425 If the result is not appropriate for any particular language then it
426 needs to patch this function. */
429 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
434 *arg1 = coerce_ref (*arg1);
435 type1 = check_typedef (value_type (*arg1));
437 if (is_integral_type (type1))
439 switch (language->la_language)
442 /* Perform integral promotion for ANSI C/C++.
443 If not appropropriate for any particular language
444 it needs to modify this function. */
446 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
448 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
449 *arg1 = value_cast (builtin_int, *arg1);
456 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
457 operation on those two operands.
458 If the result is not appropriate for any particular language then it
459 needs to patch this function. */
462 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
463 struct value **arg1, struct value **arg2)
465 struct type *promoted_type = NULL;
469 *arg1 = coerce_ref (*arg1);
470 *arg2 = coerce_ref (*arg2);
472 type1 = check_typedef (value_type (*arg1));
473 type2 = check_typedef (value_type (*arg2));
475 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
476 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
477 && !is_integral_type (type1))
478 || (TYPE_CODE (type2) != TYPE_CODE_FLT
479 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
480 && !is_integral_type (type2)))
483 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
484 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
486 /* No promotion required. */
488 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
489 || TYPE_CODE (type2) == TYPE_CODE_FLT)
491 switch (language->la_language)
497 case language_opencl:
498 /* No promotion required. */
502 /* For other languages the result type is unchanged from gdb
503 version 6.7 for backward compatibility.
504 If either arg was long double, make sure that value is also long
505 double. Otherwise use double. */
506 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
507 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
508 promoted_type = builtin_type (gdbarch)->builtin_long_double;
510 promoted_type = builtin_type (gdbarch)->builtin_double;
514 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
515 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
517 /* No promotion required. */
520 /* Integral operations here. */
521 /* FIXME: Also mixed integral/booleans, with result an integer. */
523 const struct builtin_type *builtin = builtin_type (gdbarch);
524 unsigned int promoted_len1 = TYPE_LENGTH (type1);
525 unsigned int promoted_len2 = TYPE_LENGTH (type2);
526 int is_unsigned1 = TYPE_UNSIGNED (type1);
527 int is_unsigned2 = TYPE_UNSIGNED (type2);
528 unsigned int result_len;
529 int unsigned_operation;
531 /* Determine type length and signedness after promotion for
533 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
536 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
538 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
541 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
544 if (promoted_len1 > promoted_len2)
546 unsigned_operation = is_unsigned1;
547 result_len = promoted_len1;
549 else if (promoted_len2 > promoted_len1)
551 unsigned_operation = is_unsigned2;
552 result_len = promoted_len2;
556 unsigned_operation = is_unsigned1 || is_unsigned2;
557 result_len = promoted_len1;
560 switch (language->la_language)
566 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
568 promoted_type = (unsigned_operation
569 ? builtin->builtin_unsigned_int
570 : builtin->builtin_int);
572 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
574 promoted_type = (unsigned_operation
575 ? builtin->builtin_unsigned_long
576 : builtin->builtin_long);
580 promoted_type = (unsigned_operation
581 ? builtin->builtin_unsigned_long_long
582 : builtin->builtin_long_long);
585 case language_opencl:
586 if (result_len <= TYPE_LENGTH (lookup_signed_typename
587 (language, gdbarch, "int")))
591 ? lookup_unsigned_typename (language, gdbarch, "int")
592 : lookup_signed_typename (language, gdbarch, "int"));
594 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
595 (language, gdbarch, "long")))
599 ? lookup_unsigned_typename (language, gdbarch, "long")
600 : lookup_signed_typename (language, gdbarch,"long"));
604 /* For other languages the result type is unchanged from gdb
605 version 6.7 for backward compatibility.
606 If either arg was long long, make sure that value is also long
607 long. Otherwise use long. */
608 if (unsigned_operation)
610 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
611 promoted_type = builtin->builtin_unsigned_long_long;
613 promoted_type = builtin->builtin_unsigned_long;
617 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
618 promoted_type = builtin->builtin_long_long;
620 promoted_type = builtin->builtin_long;
628 /* Promote both operands to common type. */
629 *arg1 = value_cast (promoted_type, *arg1);
630 *arg2 = value_cast (promoted_type, *arg2);
635 ptrmath_type_p (const struct language_defn *lang, struct type *type)
637 type = check_typedef (type);
638 if (TYPE_CODE (type) == TYPE_CODE_REF)
639 type = TYPE_TARGET_TYPE (type);
641 switch (TYPE_CODE (type))
647 case TYPE_CODE_ARRAY:
648 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
655 /* Constructs a fake method with the given parameter types.
656 This function is used by the parser to construct an "expected"
657 type for method overload resolution. */
660 make_params (int num_types, struct type **param_types)
662 struct type *type = XCNEW (struct type);
663 TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
664 TYPE_LENGTH (type) = 1;
665 TYPE_CODE (type) = TYPE_CODE_METHOD;
666 TYPE_VPTR_FIELDNO (type) = -1;
667 TYPE_CHAIN (type) = type;
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];
696 evaluate_subexp_standard (struct type *expect_type,
697 struct expression *exp, int *pos,
702 int pc, pc2 = 0, oldpos;
703 struct value *arg1 = NULL;
704 struct value *arg2 = NULL;
708 struct value **argvec;
712 struct type **arg_types;
714 struct symbol *function = NULL;
715 char *function_name = NULL;
718 op = exp->elts[pc].opcode;
723 tem = longest_to_int (exp->elts[pc + 2].longconst);
724 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
725 if (noside == EVAL_SKIP)
727 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
728 &exp->elts[pc + 3].string,
729 expect_type, 0, noside);
731 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
736 return value_from_longest (exp->elts[pc + 1].type,
737 exp->elts[pc + 2].longconst);
741 return value_from_double (exp->elts[pc + 1].type,
742 exp->elts[pc + 2].doubleconst);
746 return value_from_decfloat (exp->elts[pc + 1].type,
747 exp->elts[pc + 2].decfloatconst);
752 if (noside == EVAL_SKIP)
755 /* JYG: We used to just return value_zero of the symbol type
756 if we're asked to avoid side effects. Otherwise we return
757 value_of_variable (...). However I'm not sure if
758 value_of_variable () has any side effect.
759 We need a full value object returned here for whatis_exp ()
760 to call evaluate_type () and then pass the full value to
761 value_rtti_target_type () if we are dealing with a pointer
762 or reference to a base class and print object is on. */
765 volatile struct gdb_exception except;
766 struct value *ret = NULL;
768 TRY_CATCH (except, RETURN_MASK_ERROR)
770 ret = value_of_variable (exp->elts[pc + 2].symbol,
771 exp->elts[pc + 1].block);
774 if (except.reason < 0)
776 if (noside == EVAL_AVOID_SIDE_EFFECTS)
777 ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
780 throw_exception (except);
786 case OP_VAR_ENTRY_VALUE:
788 if (noside == EVAL_SKIP)
792 struct symbol *sym = exp->elts[pc + 1].symbol;
793 struct frame_info *frame;
795 if (noside == EVAL_AVOID_SIDE_EFFECTS)
796 return value_zero (SYMBOL_TYPE (sym), not_lval);
798 if (SYMBOL_COMPUTED_OPS (sym) == NULL
799 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
800 error (_("Symbol \"%s\" does not have any specific entry value"),
801 SYMBOL_PRINT_NAME (sym));
803 frame = get_selected_frame (NULL);
804 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
810 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
814 const char *name = &exp->elts[pc + 2].string;
818 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
819 regno = user_reg_map_name_to_regnum (exp->gdbarch,
820 name, strlen (name));
822 error (_("Register $%s not available."), name);
824 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
825 a value with the appropriate register type. Unfortunately,
826 we don't have easy access to the type of user registers.
827 So for these registers, we fetch the register value regardless
828 of the evaluation mode. */
829 if (noside == EVAL_AVOID_SIDE_EFFECTS
830 && regno < gdbarch_num_regs (exp->gdbarch)
831 + gdbarch_num_pseudo_regs (exp->gdbarch))
832 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
834 val = value_of_register (regno, get_selected_frame (NULL));
836 error (_("Value of register %s not available."), name);
842 type = language_bool_type (exp->language_defn, exp->gdbarch);
843 return value_from_longest (type, exp->elts[pc + 1].longconst);
847 return value_of_internalvar (exp->gdbarch,
848 exp->elts[pc + 1].internalvar);
851 tem = longest_to_int (exp->elts[pc + 1].longconst);
852 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
853 if (noside == EVAL_SKIP)
855 type = language_string_char_type (exp->language_defn, exp->gdbarch);
856 return value_string (&exp->elts[pc + 2].string, tem, type);
858 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
859 NSString constant. */
860 tem = longest_to_int (exp->elts[pc + 1].longconst);
861 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
862 if (noside == EVAL_SKIP)
866 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
870 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
871 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
872 nargs = tem3 - tem2 + 1;
873 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
875 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
876 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
878 struct value *rec = allocate_value (expect_type);
880 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
881 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
884 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
885 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
887 struct type *range_type = TYPE_INDEX_TYPE (type);
888 struct type *element_type = TYPE_TARGET_TYPE (type);
889 struct value *array = allocate_value (expect_type);
890 int element_size = TYPE_LENGTH (check_typedef (element_type));
891 LONGEST low_bound, high_bound, index;
893 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
896 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
899 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
900 for (tem = nargs; --nargs >= 0;)
902 struct value *element;
905 if (exp->elts[*pos].opcode == BINOP_RANGE)
908 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
910 element = evaluate_subexp (element_type, exp, pos, noside);
911 if (value_type (element) != element_type)
912 element = value_cast (element_type, element);
915 int continue_pc = *pos;
918 index = init_array_element (array, element, exp, pos, noside,
919 low_bound, high_bound);
924 if (index > high_bound)
925 /* To avoid memory corruption. */
926 error (_("Too many array elements"));
927 memcpy (value_contents_raw (array)
928 + (index - low_bound) * element_size,
929 value_contents (element),
937 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
938 && TYPE_CODE (type) == TYPE_CODE_SET)
940 struct value *set = allocate_value (expect_type);
941 gdb_byte *valaddr = value_contents_raw (set);
942 struct type *element_type = TYPE_INDEX_TYPE (type);
943 struct type *check_type = element_type;
944 LONGEST low_bound, high_bound;
946 /* Get targettype of elementtype. */
947 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
948 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
949 check_type = TYPE_TARGET_TYPE (check_type);
951 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
952 error (_("(power)set type with unknown size"));
953 memset (valaddr, '\0', TYPE_LENGTH (type));
954 for (tem = 0; tem < nargs; tem++)
956 LONGEST range_low, range_high;
957 struct type *range_low_type, *range_high_type;
958 struct value *elem_val;
960 if (exp->elts[*pos].opcode == BINOP_RANGE)
963 elem_val = evaluate_subexp (element_type, exp, pos, noside);
964 range_low_type = value_type (elem_val);
965 range_low = value_as_long (elem_val);
966 elem_val = evaluate_subexp (element_type, exp, pos, noside);
967 range_high_type = value_type (elem_val);
968 range_high = value_as_long (elem_val);
972 elem_val = evaluate_subexp (element_type, exp, pos, noside);
973 range_low_type = range_high_type = value_type (elem_val);
974 range_low = range_high = value_as_long (elem_val);
976 /* Check types of elements to avoid mixture of elements from
977 different types. Also check if type of element is "compatible"
978 with element type of powerset. */
979 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
980 range_low_type = TYPE_TARGET_TYPE (range_low_type);
981 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
982 range_high_type = TYPE_TARGET_TYPE (range_high_type);
983 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
984 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
985 && (range_low_type != range_high_type)))
986 /* different element modes. */
987 error (_("POWERSET tuple elements of different mode"));
988 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
989 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
990 && range_low_type != check_type))
991 error (_("incompatible POWERSET tuple elements"));
992 if (range_low > range_high)
994 warning (_("empty POWERSET tuple range"));
997 if (range_low < low_bound || range_high > high_bound)
998 error (_("POWERSET tuple element out of range"));
999 range_low -= low_bound;
1000 range_high -= low_bound;
1001 for (; range_low <= range_high; range_low++)
1003 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
1005 if (gdbarch_bits_big_endian (exp->gdbarch))
1006 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
1007 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1014 argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
1015 for (tem = 0; tem < nargs; tem++)
1017 /* Ensure that array expressions are coerced into pointer
1019 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1021 if (noside == EVAL_SKIP)
1023 return value_array (tem2, tem3, argvec);
1027 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1029 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1031 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1033 if (noside == EVAL_SKIP)
1035 return value_slice (array, lowbound, upper - lowbound + 1);
1039 /* Skip third and second args to evaluate the first one. */
1040 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1041 if (value_logical_not (arg1))
1043 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1044 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1048 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1049 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1053 case OP_OBJC_SELECTOR:
1054 { /* Objective C @selector operator. */
1055 char *sel = &exp->elts[pc + 2].string;
1056 int len = longest_to_int (exp->elts[pc + 1].longconst);
1057 struct type *selector_type;
1059 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1060 if (noside == EVAL_SKIP)
1064 sel[len] = 0; /* Make sure it's terminated. */
1066 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1067 return value_from_longest (selector_type,
1068 lookup_child_selector (exp->gdbarch, sel));
1071 case OP_OBJC_MSGCALL:
1072 { /* Objective C message (method) call. */
1074 CORE_ADDR responds_selector = 0;
1075 CORE_ADDR method_selector = 0;
1077 CORE_ADDR selector = 0;
1079 int struct_return = 0;
1080 int sub_no_side = 0;
1082 struct value *msg_send = NULL;
1083 struct value *msg_send_stret = NULL;
1084 int gnu_runtime = 0;
1086 struct value *target = NULL;
1087 struct value *method = NULL;
1088 struct value *called_method = NULL;
1090 struct type *selector_type = NULL;
1091 struct type *long_type;
1093 struct value *ret = NULL;
1096 selector = exp->elts[pc + 1].longconst;
1097 nargs = exp->elts[pc + 2].longconst;
1098 argvec = (struct value **) alloca (sizeof (struct value *)
1103 long_type = builtin_type (exp->gdbarch)->builtin_long;
1104 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1106 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1107 sub_no_side = EVAL_NORMAL;
1109 sub_no_side = noside;
1111 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1113 if (value_as_long (target) == 0)
1114 return value_from_longest (long_type, 0);
1116 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1119 /* Find the method dispatch (Apple runtime) or method lookup
1120 (GNU runtime) function for Objective-C. These will be used
1121 to lookup the symbol information for the method. If we
1122 can't find any symbol information, then we'll use these to
1123 call the method, otherwise we can call the method
1124 directly. The msg_send_stret function is used in the special
1125 case of a method that returns a structure (Apple runtime
1129 struct type *type = selector_type;
1131 type = lookup_function_type (type);
1132 type = lookup_pointer_type (type);
1133 type = lookup_function_type (type);
1134 type = lookup_pointer_type (type);
1136 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1138 = find_function_in_inferior ("objc_msg_lookup", NULL);
1140 msg_send = value_from_pointer (type, value_as_address (msg_send));
1141 msg_send_stret = value_from_pointer (type,
1142 value_as_address (msg_send_stret));
1146 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1147 /* Special dispatcher for methods returning structs. */
1149 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1152 /* Verify the target object responds to this method. The
1153 standard top-level 'Object' class uses a different name for
1154 the verification method than the non-standard, but more
1155 often used, 'NSObject' class. Make sure we check for both. */
1158 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1159 if (responds_selector == 0)
1161 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1163 if (responds_selector == 0)
1164 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1167 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1168 if (method_selector == 0)
1170 = lookup_child_selector (exp->gdbarch, "methodFor:");
1172 if (method_selector == 0)
1173 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1175 /* Call the verification method, to make sure that the target
1176 class implements the desired method. */
1178 argvec[0] = msg_send;
1180 argvec[2] = value_from_longest (long_type, responds_selector);
1181 argvec[3] = value_from_longest (long_type, selector);
1184 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1187 /* Function objc_msg_lookup returns a pointer. */
1189 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1191 if (value_as_long (ret) == 0)
1192 error (_("Target does not respond to this message selector."));
1194 /* Call "methodForSelector:" method, to get the address of a
1195 function method that implements this selector for this
1196 class. If we can find a symbol at that address, then we
1197 know the return type, parameter types etc. (that's a good
1200 argvec[0] = msg_send;
1202 argvec[2] = value_from_longest (long_type, method_selector);
1203 argvec[3] = value_from_longest (long_type, selector);
1206 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1210 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1213 /* ret should now be the selector. */
1215 addr = value_as_long (ret);
1218 struct symbol *sym = NULL;
1220 /* The address might point to a function descriptor;
1221 resolve it to the actual code address instead. */
1222 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1225 /* Is it a high_level symbol? */
1226 sym = find_pc_function (addr);
1228 method = value_of_variable (sym, 0);
1231 /* If we found a method with symbol information, check to see
1232 if it returns a struct. Otherwise assume it doesn't. */
1237 struct type *val_type;
1239 funaddr = find_function_addr (method, &val_type);
1241 block_for_pc (funaddr);
1243 CHECK_TYPEDEF (val_type);
1245 if ((val_type == NULL)
1246 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1248 if (expect_type != NULL)
1249 val_type = expect_type;
1252 struct_return = using_struct_return (exp->gdbarch, method,
1255 else if (expect_type != NULL)
1257 struct_return = using_struct_return (exp->gdbarch, NULL,
1258 check_typedef (expect_type));
1261 /* Found a function symbol. Now we will substitute its
1262 value in place of the message dispatcher (obj_msgSend),
1263 so that we call the method directly instead of thru
1264 the dispatcher. The main reason for doing this is that
1265 we can now evaluate the return value and parameter values
1266 according to their known data types, in case we need to
1267 do things like promotion, dereferencing, special handling
1268 of structs and doubles, etc.
1270 We want to use the type signature of 'method', but still
1271 jump to objc_msgSend() or objc_msgSend_stret() to better
1272 mimic the behavior of the runtime. */
1276 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1277 error (_("method address has symbol information "
1278 "with non-function type; skipping"));
1280 /* Create a function pointer of the appropriate type, and
1281 replace its value with the value of msg_send or
1282 msg_send_stret. We must use a pointer here, as
1283 msg_send and msg_send_stret are of pointer type, and
1284 the representation may be different on systems that use
1285 function descriptors. */
1288 = value_from_pointer (lookup_pointer_type (value_type (method)),
1289 value_as_address (msg_send_stret));
1292 = value_from_pointer (lookup_pointer_type (value_type (method)),
1293 value_as_address (msg_send));
1298 called_method = msg_send_stret;
1300 called_method = msg_send;
1303 if (noside == EVAL_SKIP)
1306 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1308 /* If the return type doesn't look like a function type,
1309 call an error. This can happen if somebody tries to
1310 turn a variable into a function call. This is here
1311 because people often want to call, eg, strcmp, which
1312 gdb doesn't know is a function. If gdb isn't asked for
1313 it's opinion (ie. through "whatis"), it won't offer
1316 struct type *type = value_type (called_method);
1318 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1319 type = TYPE_TARGET_TYPE (type);
1320 type = TYPE_TARGET_TYPE (type);
1324 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1325 return allocate_value (expect_type);
1327 return allocate_value (type);
1330 error (_("Expression of type other than "
1331 "\"method returning ...\" used as a method"));
1334 /* Now depending on whether we found a symbol for the method,
1335 we will either call the runtime dispatcher or the method
1338 argvec[0] = called_method;
1340 argvec[2] = value_from_longest (long_type, selector);
1341 /* User-supplied arguments. */
1342 for (tem = 0; tem < nargs; tem++)
1343 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1344 argvec[tem + 3] = 0;
1346 if (gnu_runtime && (method != NULL))
1348 /* Function objc_msg_lookup returns a pointer. */
1349 deprecated_set_value_type (argvec[0],
1350 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1352 = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1355 ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1362 op = exp->elts[*pos].opcode;
1363 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1364 /* Allocate arg vector, including space for the function to be
1365 called in argvec[0] and a terminating NULL. */
1366 argvec = (struct value **)
1367 alloca (sizeof (struct value *) * (nargs + 3));
1368 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1370 /* First, evaluate the structure into arg2. */
1373 if (noside == EVAL_SKIP)
1376 if (op == STRUCTOP_MEMBER)
1378 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1382 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1385 /* If the function is a virtual function, then the
1386 aggregate value (providing the structure) plays
1387 its part by providing the vtable. Otherwise,
1388 it is just along for the ride: call the function
1391 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1393 type = check_typedef (value_type (arg1));
1394 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR)
1396 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1397 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval);
1399 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1401 /* Now, say which argument to start evaluating from. */
1406 else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
1408 struct type *type_ptr
1409 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type));
1410 struct type *target_type_ptr
1411 = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1413 /* Now, convert these values to an address. */
1414 arg2 = value_cast (type_ptr, arg2);
1416 mem_offset = value_as_long (arg1);
1418 arg1 = value_from_pointer (target_type_ptr,
1419 value_as_long (arg2) + mem_offset);
1420 arg1 = value_ind (arg1);
1424 error (_("Non-pointer-to-member value used in pointer-to-member "
1427 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1429 /* Hair for method invocations. */
1433 /* First, evaluate the structure into arg2. */
1435 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1436 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1437 if (noside == EVAL_SKIP)
1440 if (op == STRUCTOP_STRUCT)
1442 /* If v is a variable in a register, and the user types
1443 v.method (), this will produce an error, because v has
1446 A possible way around this would be to allocate a
1447 copy of the variable on the stack, copy in the
1448 contents, call the function, and copy out the
1449 contents. I.e. convert this from call by reference
1450 to call by copy-return (or whatever it's called).
1451 However, this does not work because it is not the
1452 same: the method being called could stash a copy of
1453 the address, and then future uses through that address
1454 (after the method returns) would be expected to
1455 use the variable itself, not some copy of it. */
1456 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1460 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1462 /* Check to see if the operator '->' has been
1463 overloaded. If the operator has been overloaded
1464 replace arg2 with the value returned by the custom
1465 operator and continue evaluation. */
1466 while (unop_user_defined_p (op, arg2))
1468 volatile struct gdb_exception except;
1469 struct value *value = NULL;
1470 TRY_CATCH (except, RETURN_MASK_ERROR)
1472 value = value_x_unop (arg2, op, noside);
1475 if (except.reason < 0)
1477 if (except.error == NOT_FOUND_ERROR)
1480 throw_exception (except);
1485 /* Now, say which argument to start evaluating from. */
1488 else if (op == OP_SCOPE
1489 && overload_resolution
1490 && (exp->language_defn->la_language == language_cplus))
1492 /* Unpack it locally so we can properly handle overload
1498 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
1499 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
1500 type = exp->elts[pc2 + 1].type;
1501 name = &exp->elts[pc2 + 3].string;
1504 function_name = NULL;
1505 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
1507 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
1509 get_selected_block (0),
1511 if (function == NULL)
1512 error (_("No symbol \"%s\" in namespace \"%s\"."),
1513 name, TYPE_TAG_NAME (type));
1519 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1520 || TYPE_CODE (type) == TYPE_CODE_UNION);
1521 function_name = name;
1523 arg2 = value_zero (type, lval_memory);
1528 else if (op == OP_ADL_FUNC)
1530 /* Save the function position and move pos so that the arguments
1531 can be evaluated. */
1537 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1538 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1542 /* Non-method function call. */
1546 /* If this is a C++ function wait until overload resolution. */
1547 if (op == OP_VAR_VALUE
1548 && overload_resolution
1549 && (exp->language_defn->la_language == language_cplus))
1551 (*pos) += 4; /* Skip the evaluation of the symbol. */
1556 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1557 type = value_type (argvec[0]);
1558 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1559 type = TYPE_TARGET_TYPE (type);
1560 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1562 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1564 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1572 /* Evaluate arguments. */
1573 for (; tem <= nargs; tem++)
1575 /* Ensure that array expressions are coerced into pointer
1577 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1580 /* Signal end of arglist. */
1582 if (op == OP_ADL_FUNC)
1584 struct symbol *symp;
1587 int string_pc = save_pos1 + 3;
1589 /* Extract the function name. */
1590 name_len = longest_to_int (exp->elts[string_pc].longconst);
1591 func_name = (char *) alloca (name_len + 1);
1592 strcpy (func_name, &exp->elts[string_pc + 1].string);
1594 find_overload_match (&argvec[1], nargs, func_name,
1595 NON_METHOD, /* not method */
1596 NULL, NULL, /* pass NULL symbol since
1597 symbol is unknown */
1598 NULL, &symp, NULL, 0);
1600 /* Now fix the expression being evaluated. */
1601 exp->elts[save_pos1 + 2].symbol = symp;
1602 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1605 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1606 || (op == OP_SCOPE && function_name != NULL))
1608 int static_memfuncp;
1611 /* Method invocation : stuff "this" as first parameter. */
1616 /* Name of method from expression. */
1617 tstr = &exp->elts[pc2 + 2].string;
1620 tstr = function_name;
1622 if (overload_resolution && (exp->language_defn->la_language
1625 /* Language is C++, do some overload resolution before
1627 struct value *valp = NULL;
1629 (void) find_overload_match (&argvec[1], nargs, tstr,
1630 METHOD, /* method */
1631 &arg2, /* the object */
1633 &static_memfuncp, 0);
1635 if (op == OP_SCOPE && !static_memfuncp)
1637 /* For the time being, we don't handle this. */
1638 error (_("Call to overloaded function %s requires "
1642 argvec[1] = arg2; /* the ``this'' pointer */
1643 argvec[0] = valp; /* Use the method found after overload
1647 /* Non-C++ case -- or no overload resolution. */
1649 struct value *temp = arg2;
1651 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1653 op == STRUCTOP_STRUCT
1654 ? "structure" : "structure pointer");
1655 /* value_struct_elt updates temp with the correct value
1656 of the ``this'' pointer if necessary, so modify argvec[1] to
1657 reflect any ``this'' changes. */
1659 = value_from_longest (lookup_pointer_type(value_type (temp)),
1660 value_address (temp)
1661 + value_embedded_offset (temp));
1662 argvec[1] = arg2; /* the ``this'' pointer */
1665 if (static_memfuncp)
1667 argvec[1] = argvec[0];
1672 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1674 /* Pointer to member. argvec[1] is already set up. */
1677 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1679 /* Non-member function being called. */
1680 /* fn: This can only be done for C++ functions. A C-style function
1681 in a C++ program, for instance, does not have the fields that
1682 are expected here. */
1684 if (overload_resolution && (exp->language_defn->la_language
1687 /* Language is C++, do some overload resolution before
1689 struct symbol *symp;
1692 /* If a scope has been specified disable ADL. */
1696 if (op == OP_VAR_VALUE)
1697 function = exp->elts[save_pos1+2].symbol;
1699 (void) find_overload_match (&argvec[1], nargs,
1700 NULL, /* no need for name */
1701 NON_METHOD, /* not method */
1702 NULL, function, /* the function */
1703 NULL, &symp, NULL, no_adl);
1705 if (op == OP_VAR_VALUE)
1707 /* Now fix the expression being evaluated. */
1708 exp->elts[save_pos1+2].symbol = symp;
1709 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1713 argvec[0] = value_of_variable (symp, get_selected_block (0));
1717 /* Not C++, or no overload resolution allowed. */
1718 /* Nothing to be done; argvec already correctly set up. */
1723 /* It is probably a C-style function. */
1724 /* Nothing to be done; argvec already correctly set up. */
1729 if (noside == EVAL_SKIP)
1731 if (argvec[0] == NULL)
1732 error (_("Cannot evaluate function -- may be inlined"));
1733 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1735 /* If the return type doesn't look like a function type, call an
1736 error. This can happen if somebody tries to turn a variable into
1737 a function call. This is here because people often want to
1738 call, eg, strcmp, which gdb doesn't know is a function. If
1739 gdb isn't asked for it's opinion (ie. through "whatis"),
1740 it won't offer it. */
1742 struct type *ftype = value_type (argvec[0]);
1744 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
1746 /* We don't know anything about what the internal
1747 function might return, but we have to return
1749 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
1752 else if (TYPE_GNU_IFUNC (ftype))
1753 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype)));
1754 else if (TYPE_TARGET_TYPE (ftype))
1755 return allocate_value (TYPE_TARGET_TYPE (ftype));
1757 error (_("Expression of type other than "
1758 "\"Function returning ...\" used as function"));
1760 if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_INTERNAL_FUNCTION)
1761 return call_internal_function (exp->gdbarch, exp->language_defn,
1762 argvec[0], nargs, argvec + 1);
1764 return call_function_by_hand (argvec[0], nargs, argvec + 1);
1765 /* pai: FIXME save value from call_function_by_hand, then adjust
1766 pc by adjust_fn_pc if +ve. */
1768 case OP_F77_UNDETERMINED_ARGLIST:
1770 /* Remember that in F77, functions, substring ops and
1771 array subscript operations cannot be disambiguated
1772 at parse time. We have made all array subscript operations,
1773 substring operations as well as function calls come here
1774 and we now have to discover what the heck this thing actually was.
1775 If it is a function, we process just as if we got an OP_FUNCALL. */
1777 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1780 /* First determine the type code we are dealing with. */
1781 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1782 type = check_typedef (value_type (arg1));
1783 code = TYPE_CODE (type);
1785 if (code == TYPE_CODE_PTR)
1787 /* Fortran always passes variable to subroutines as pointer.
1788 So we need to look into its target type to see if it is
1789 array, string or function. If it is, we need to switch
1790 to the target value the original one points to. */
1791 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1793 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1794 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1795 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1797 arg1 = value_ind (arg1);
1798 type = check_typedef (value_type (arg1));
1799 code = TYPE_CODE (type);
1805 case TYPE_CODE_ARRAY:
1806 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1807 return value_f90_subarray (arg1, exp, pos, noside);
1809 goto multi_f77_subscript;
1811 case TYPE_CODE_STRING:
1812 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1813 return value_f90_subarray (arg1, exp, pos, noside);
1816 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1817 return value_subscript (arg1, value_as_long (arg2));
1821 case TYPE_CODE_FUNC:
1822 /* It's a function call. */
1823 /* Allocate arg vector, including space for the function to be
1824 called in argvec[0] and a terminating NULL. */
1825 argvec = (struct value **)
1826 alloca (sizeof (struct value *) * (nargs + 2));
1829 for (; tem <= nargs; tem++)
1830 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1831 argvec[tem] = 0; /* signal end of arglist */
1835 error (_("Cannot perform substring on this type"));
1839 /* We have a complex number, There should be 2 floating
1840 point numbers that compose it. */
1842 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1843 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1845 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1847 case STRUCTOP_STRUCT:
1848 tem = longest_to_int (exp->elts[pc + 1].longconst);
1849 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1850 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1851 if (noside == EVAL_SKIP)
1853 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1855 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1856 arg3 = value_zero (value_type (arg3), not_lval);
1860 tem = longest_to_int (exp->elts[pc + 1].longconst);
1861 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1862 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1863 if (noside == EVAL_SKIP)
1866 /* Check to see if operator '->' has been overloaded. If so replace
1867 arg1 with the value returned by evaluating operator->(). */
1868 while (unop_user_defined_p (op, arg1))
1870 volatile struct gdb_exception except;
1871 struct value *value = NULL;
1872 TRY_CATCH (except, RETURN_MASK_ERROR)
1874 value = value_x_unop (arg1, op, noside);
1877 if (except.reason < 0)
1879 if (except.error == NOT_FOUND_ERROR)
1882 throw_exception (except);
1887 /* JYG: if print object is on we need to replace the base type
1888 with rtti type in order to continue on with successful
1889 lookup of member / method only available in the rtti type. */
1891 struct type *type = value_type (arg1);
1892 struct type *real_type;
1893 int full, top, using_enc;
1894 struct value_print_options opts;
1896 get_user_print_options (&opts);
1897 if (opts.objectprint && TYPE_TARGET_TYPE(type)
1898 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
1900 real_type = value_rtti_indirect_type (arg1, &full, &top,
1903 arg1 = value_cast (real_type, arg1);
1907 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1908 NULL, "structure pointer");
1909 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1910 arg3 = value_zero (value_type (arg3), not_lval);
1913 case STRUCTOP_MEMBER:
1915 if (op == STRUCTOP_MEMBER)
1916 arg1 = evaluate_subexp_for_address (exp, pos, noside);
1918 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1920 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1922 if (noside == EVAL_SKIP)
1925 type = check_typedef (value_type (arg2));
1926 switch (TYPE_CODE (type))
1928 case TYPE_CODE_METHODPTR:
1929 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1930 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1933 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
1934 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
1935 return value_ind (arg2);
1938 case TYPE_CODE_MEMBERPTR:
1939 /* Now, convert these values to an address. */
1940 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
1943 mem_offset = value_as_long (arg2);
1945 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1946 value_as_long (arg1) + mem_offset);
1947 return value_ind (arg3);
1950 error (_("non-pointer-to-member value used "
1951 "in pointer-to-member construct"));
1955 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1956 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
1957 for (ix = 0; ix < nargs; ++ix)
1958 arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
1960 expect_type = make_params (nargs, arg_types);
1961 *(pos) += 3 + nargs;
1962 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
1963 xfree (TYPE_FIELDS (expect_type));
1964 xfree (TYPE_MAIN_TYPE (expect_type));
1965 xfree (expect_type);
1969 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1970 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1971 if (noside == EVAL_SKIP)
1973 if (binop_user_defined_p (op, arg1, arg2))
1974 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1976 return value_concat (arg1, arg2);
1979 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1980 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1982 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1984 if (binop_user_defined_p (op, arg1, arg2))
1985 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1987 return value_assign (arg1, arg2);
1989 case BINOP_ASSIGN_MODIFY:
1991 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1992 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1993 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1995 op = exp->elts[pc + 1].opcode;
1996 if (binop_user_defined_p (op, arg1, arg2))
1997 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
1998 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2000 && is_integral_type (value_type (arg2)))
2001 arg2 = value_ptradd (arg1, value_as_long (arg2));
2002 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2004 && is_integral_type (value_type (arg2)))
2005 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2008 struct value *tmp = arg1;
2010 /* For shift and integer exponentiation operations,
2011 only promote the first argument. */
2012 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2013 && is_integral_type (value_type (arg2)))
2014 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2016 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2018 arg2 = value_binop (tmp, arg2, op);
2020 return value_assign (arg1, arg2);
2023 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2024 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2025 if (noside == EVAL_SKIP)
2027 if (binop_user_defined_p (op, arg1, arg2))
2028 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2029 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2030 && is_integral_type (value_type (arg2)))
2031 return value_ptradd (arg1, value_as_long (arg2));
2032 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2033 && is_integral_type (value_type (arg1)))
2034 return value_ptradd (arg2, value_as_long (arg1));
2037 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2038 return value_binop (arg1, arg2, BINOP_ADD);
2042 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2043 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2044 if (noside == EVAL_SKIP)
2046 if (binop_user_defined_p (op, arg1, arg2))
2047 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2048 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2049 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2051 /* FIXME -- should be ptrdiff_t */
2052 type = builtin_type (exp->gdbarch)->builtin_long;
2053 return value_from_longest (type, value_ptrdiff (arg1, arg2));
2055 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2056 && is_integral_type (value_type (arg2)))
2057 return value_ptradd (arg1, - value_as_long (arg2));
2060 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2061 return value_binop (arg1, arg2, BINOP_SUB);
2072 case BINOP_BITWISE_AND:
2073 case BINOP_BITWISE_IOR:
2074 case BINOP_BITWISE_XOR:
2075 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2076 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2077 if (noside == EVAL_SKIP)
2079 if (binop_user_defined_p (op, arg1, arg2))
2080 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2083 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2084 fudge arg2 to avoid division-by-zero, the caller is
2085 (theoretically) only looking for the type of the result. */
2086 if (noside == EVAL_AVOID_SIDE_EFFECTS
2087 /* ??? Do we really want to test for BINOP_MOD here?
2088 The implementation of value_binop gives it a well-defined
2091 || op == BINOP_INTDIV
2094 && value_logical_not (arg2))
2096 struct value *v_one, *retval;
2098 v_one = value_one (value_type (arg2));
2099 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2100 retval = value_binop (arg1, v_one, op);
2105 /* For shift and integer exponentiation operations,
2106 only promote the first argument. */
2107 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2108 && is_integral_type (value_type (arg2)))
2109 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2111 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2113 return value_binop (arg1, arg2, op);
2118 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2119 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2120 if (noside == EVAL_SKIP)
2122 error (_("':' operator used in invalid context"));
2124 case BINOP_SUBSCRIPT:
2125 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2126 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2127 if (noside == EVAL_SKIP)
2129 if (binop_user_defined_p (op, arg1, arg2))
2130 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2133 /* If the user attempts to subscript something that is not an
2134 array or pointer type (like a plain int variable for example),
2135 then report this as an error. */
2137 arg1 = coerce_ref (arg1);
2138 type = check_typedef (value_type (arg1));
2139 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2140 && TYPE_CODE (type) != TYPE_CODE_PTR)
2142 if (TYPE_NAME (type))
2143 error (_("cannot subscript something of type `%s'"),
2146 error (_("cannot subscript requested type"));
2149 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2150 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2152 return value_subscript (arg1, value_as_long (arg2));
2156 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2157 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2158 if (noside == EVAL_SKIP)
2160 type = language_bool_type (exp->language_defn, exp->gdbarch);
2161 return value_from_longest (type, (LONGEST) value_in (arg1, arg2));
2163 case MULTI_SUBSCRIPT:
2165 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2166 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2169 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2170 /* FIXME: EVAL_SKIP handling may not be correct. */
2171 if (noside == EVAL_SKIP)
2182 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2183 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2185 /* If the user attempts to subscript something that has no target
2186 type (like a plain int variable for example), then report this
2189 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2192 arg1 = value_zero (type, VALUE_LVAL (arg1));
2198 error (_("cannot subscript something of type `%s'"),
2199 TYPE_NAME (value_type (arg1)));
2203 if (binop_user_defined_p (op, arg1, arg2))
2205 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2209 arg1 = coerce_ref (arg1);
2210 type = check_typedef (value_type (arg1));
2212 switch (TYPE_CODE (type))
2215 case TYPE_CODE_ARRAY:
2216 case TYPE_CODE_STRING:
2217 arg1 = value_subscript (arg1, value_as_long (arg2));
2221 if (TYPE_NAME (type))
2222 error (_("cannot subscript something of type `%s'"),
2225 error (_("cannot subscript requested type"));
2231 multi_f77_subscript:
2233 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2234 int ndimensions = 1, i;
2235 struct value *array = arg1;
2237 if (nargs > MAX_FORTRAN_DIMS)
2238 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2240 ndimensions = calc_f77_array_dims (type);
2242 if (nargs != ndimensions)
2243 error (_("Wrong number of subscripts"));
2245 gdb_assert (nargs > 0);
2247 /* Now that we know we have a legal array subscript expression
2248 let us actually find out where this element exists in the array. */
2250 /* Take array indices left to right. */
2251 for (i = 0; i < nargs; i++)
2253 /* Evaluate each subscript; it must be a legal integer in F77. */
2254 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2256 /* Fill in the subscript array. */
2258 subscript_array[i] = value_as_long (arg2);
2261 /* Internal type of array is arranged right to left. */
2262 for (i = nargs; i > 0; i--)
2264 struct type *array_type = check_typedef (value_type (array));
2265 LONGEST index = subscript_array[i - 1];
2267 array = value_subscripted_rvalue (array, index,
2268 f77_get_lowerbound (array_type));
2274 case BINOP_LOGICAL_AND:
2275 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2276 if (noside == EVAL_SKIP)
2278 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2283 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2286 if (binop_user_defined_p (op, arg1, arg2))
2288 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2289 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2293 tem = value_logical_not (arg1);
2294 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2295 (tem ? EVAL_SKIP : noside));
2296 type = language_bool_type (exp->language_defn, exp->gdbarch);
2297 return value_from_longest (type,
2298 (LONGEST) (!tem && !value_logical_not (arg2)));
2301 case BINOP_LOGICAL_OR:
2302 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2303 if (noside == EVAL_SKIP)
2305 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2310 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2313 if (binop_user_defined_p (op, arg1, arg2))
2315 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2316 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2320 tem = value_logical_not (arg1);
2321 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2322 (!tem ? EVAL_SKIP : noside));
2323 type = language_bool_type (exp->language_defn, exp->gdbarch);
2324 return value_from_longest (type,
2325 (LONGEST) (!tem || !value_logical_not (arg2)));
2329 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2330 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2331 if (noside == EVAL_SKIP)
2333 if (binop_user_defined_p (op, arg1, arg2))
2335 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2339 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2340 tem = value_equal (arg1, arg2);
2341 type = language_bool_type (exp->language_defn, exp->gdbarch);
2342 return value_from_longest (type, (LONGEST) tem);
2345 case BINOP_NOTEQUAL:
2346 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2347 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2348 if (noside == EVAL_SKIP)
2350 if (binop_user_defined_p (op, arg1, arg2))
2352 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2356 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2357 tem = value_equal (arg1, arg2);
2358 type = language_bool_type (exp->language_defn, exp->gdbarch);
2359 return value_from_longest (type, (LONGEST) ! tem);
2363 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2364 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2365 if (noside == EVAL_SKIP)
2367 if (binop_user_defined_p (op, arg1, arg2))
2369 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2373 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2374 tem = value_less (arg1, arg2);
2375 type = language_bool_type (exp->language_defn, exp->gdbarch);
2376 return value_from_longest (type, (LONGEST) tem);
2380 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2381 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2382 if (noside == EVAL_SKIP)
2384 if (binop_user_defined_p (op, arg1, arg2))
2386 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2390 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2391 tem = value_less (arg2, arg1);
2392 type = language_bool_type (exp->language_defn, exp->gdbarch);
2393 return value_from_longest (type, (LONGEST) tem);
2397 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2398 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2399 if (noside == EVAL_SKIP)
2401 if (binop_user_defined_p (op, arg1, arg2))
2403 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2407 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2408 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2409 type = language_bool_type (exp->language_defn, exp->gdbarch);
2410 return value_from_longest (type, (LONGEST) tem);
2414 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2415 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2416 if (noside == EVAL_SKIP)
2418 if (binop_user_defined_p (op, arg1, arg2))
2420 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2424 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2425 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2426 type = language_bool_type (exp->language_defn, exp->gdbarch);
2427 return value_from_longest (type, (LONGEST) tem);
2431 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2432 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2433 if (noside == EVAL_SKIP)
2435 type = check_typedef (value_type (arg2));
2436 if (TYPE_CODE (type) != TYPE_CODE_INT)
2437 error (_("Non-integral right operand for \"@\" operator."));
2438 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2440 return allocate_repeat_value (value_type (arg1),
2441 longest_to_int (value_as_long (arg2)));
2444 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2447 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2448 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2451 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2452 if (noside == EVAL_SKIP)
2454 if (unop_user_defined_p (op, arg1))
2455 return value_x_unop (arg1, op, noside);
2458 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2459 return value_pos (arg1);
2463 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2464 if (noside == EVAL_SKIP)
2466 if (unop_user_defined_p (op, arg1))
2467 return value_x_unop (arg1, op, noside);
2470 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2471 return value_neg (arg1);
2474 case UNOP_COMPLEMENT:
2475 /* C++: check for and handle destructor names. */
2476 op = exp->elts[*pos].opcode;
2478 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2479 if (noside == EVAL_SKIP)
2481 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2482 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2485 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2486 return value_complement (arg1);
2489 case UNOP_LOGICAL_NOT:
2490 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2491 if (noside == EVAL_SKIP)
2493 if (unop_user_defined_p (op, arg1))
2494 return value_x_unop (arg1, op, noside);
2497 type = language_bool_type (exp->language_defn, exp->gdbarch);
2498 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2502 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2503 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2504 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2505 type = check_typedef (value_type (arg1));
2506 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2507 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2508 error (_("Attempt to dereference pointer "
2509 "to member without an object"));
2510 if (noside == EVAL_SKIP)
2512 if (unop_user_defined_p (op, arg1))
2513 return value_x_unop (arg1, op, noside);
2514 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2516 type = check_typedef (value_type (arg1));
2517 if (TYPE_CODE (type) == TYPE_CODE_PTR
2518 || TYPE_CODE (type) == TYPE_CODE_REF
2519 /* In C you can dereference an array to get the 1st elt. */
2520 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2522 return value_zero (TYPE_TARGET_TYPE (type),
2524 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2525 /* GDB allows dereferencing an int. */
2526 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2529 error (_("Attempt to take contents of a non-pointer value."));
2532 /* Allow * on an integer so we can cast it to whatever we want.
2533 This returns an int, which seems like the most C-like thing to
2534 do. "long long" variables are rare enough that
2535 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2536 if (TYPE_CODE (type) == TYPE_CODE_INT)
2537 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2538 (CORE_ADDR) value_as_address (arg1));
2539 return value_ind (arg1);
2542 /* C++: check for and handle pointer to members. */
2544 op = exp->elts[*pos].opcode;
2546 if (noside == EVAL_SKIP)
2548 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2553 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2560 if (noside == EVAL_SKIP)
2562 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2565 return evaluate_subexp_for_sizeof (exp, pos);
2569 type = exp->elts[pc + 1].type;
2570 arg1 = evaluate_subexp (type, exp, pos, noside);
2571 if (noside == EVAL_SKIP)
2573 if (type != value_type (arg1))
2574 arg1 = value_cast (type, arg1);
2577 case UNOP_CAST_TYPE:
2578 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2579 type = value_type (arg1);
2580 arg1 = evaluate_subexp (type, exp, pos, noside);
2581 if (noside == EVAL_SKIP)
2583 if (type != value_type (arg1))
2584 arg1 = value_cast (type, arg1);
2587 case UNOP_DYNAMIC_CAST:
2588 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2589 type = value_type (arg1);
2590 arg1 = evaluate_subexp (type, exp, pos, noside);
2591 if (noside == EVAL_SKIP)
2593 return value_dynamic_cast (type, arg1);
2595 case UNOP_REINTERPRET_CAST:
2596 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2597 type = value_type (arg1);
2598 arg1 = evaluate_subexp (type, exp, pos, noside);
2599 if (noside == EVAL_SKIP)
2601 return value_reinterpret_cast (type, arg1);
2605 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2606 if (noside == EVAL_SKIP)
2608 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2609 return value_zero (exp->elts[pc + 1].type, lval_memory);
2611 return value_at_lazy (exp->elts[pc + 1].type,
2612 value_as_address (arg1));
2614 case UNOP_MEMVAL_TYPE:
2615 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2616 type = value_type (arg1);
2617 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2618 if (noside == EVAL_SKIP)
2620 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2621 return value_zero (type, lval_memory);
2623 return value_at_lazy (type, value_as_address (arg1));
2625 case UNOP_MEMVAL_TLS:
2627 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2628 if (noside == EVAL_SKIP)
2630 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2631 return value_zero (exp->elts[pc + 2].type, lval_memory);
2636 tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2637 value_as_address (arg1));
2638 return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
2641 case UNOP_PREINCREMENT:
2642 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2643 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2645 else if (unop_user_defined_p (op, arg1))
2647 return value_x_unop (arg1, op, noside);
2651 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2652 arg2 = value_ptradd (arg1, 1);
2655 struct value *tmp = arg1;
2657 arg2 = value_one (value_type (arg1));
2658 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2659 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2662 return value_assign (arg1, arg2);
2665 case UNOP_PREDECREMENT:
2666 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2667 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2669 else if (unop_user_defined_p (op, arg1))
2671 return value_x_unop (arg1, op, noside);
2675 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2676 arg2 = value_ptradd (arg1, -1);
2679 struct value *tmp = arg1;
2681 arg2 = value_one (value_type (arg1));
2682 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2683 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2686 return value_assign (arg1, arg2);
2689 case UNOP_POSTINCREMENT:
2690 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2691 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2693 else if (unop_user_defined_p (op, arg1))
2695 return value_x_unop (arg1, op, noside);
2699 arg3 = value_non_lval (arg1);
2701 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2702 arg2 = value_ptradd (arg1, 1);
2705 struct value *tmp = arg1;
2707 arg2 = value_one (value_type (arg1));
2708 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2709 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2712 value_assign (arg1, arg2);
2716 case UNOP_POSTDECREMENT:
2717 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2718 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2720 else if (unop_user_defined_p (op, arg1))
2722 return value_x_unop (arg1, op, noside);
2726 arg3 = value_non_lval (arg1);
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_SUB);
2739 value_assign (arg1, arg2);
2745 return value_of_this (exp->language_defn);
2748 /* The value is not supposed to be used. This is here to make it
2749 easier to accommodate expressions that contain types. */
2751 if (noside == EVAL_SKIP)
2753 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2755 struct type *type = exp->elts[pc + 1].type;
2757 /* If this is a typedef, then find its immediate target. We
2758 use check_typedef to resolve stubs, but we ignore its
2759 result because we do not want to dig past all
2761 check_typedef (type);
2762 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2763 type = TYPE_TARGET_TYPE (type);
2764 return allocate_value (type);
2767 error (_("Attempt to use a type name as an expression"));
2771 if (noside == EVAL_SKIP)
2773 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2776 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2778 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2779 struct value *result;
2781 result = evaluate_subexp (NULL_TYPE, exp, pos,
2782 EVAL_AVOID_SIDE_EFFECTS);
2784 /* 'decltype' has special semantics for lvalues. */
2785 if (op == OP_DECLTYPE
2786 && (sub_op == BINOP_SUBSCRIPT
2787 || sub_op == STRUCTOP_MEMBER
2788 || sub_op == STRUCTOP_MPTR
2789 || sub_op == UNOP_IND
2790 || sub_op == STRUCTOP_STRUCT
2791 || sub_op == STRUCTOP_PTR
2792 || sub_op == OP_SCOPE))
2794 struct type *type = value_type (result);
2796 if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF)
2798 type = lookup_reference_type (type);
2799 result = allocate_value (type);
2806 error (_("Attempt to use a type as an expression"));
2810 struct value *result;
2811 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2813 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2814 result = evaluate_subexp (NULL_TYPE, exp, pos,
2815 EVAL_AVOID_SIDE_EFFECTS);
2817 result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2819 if (noside != EVAL_NORMAL)
2820 return allocate_value (cplus_typeid_type (exp->gdbarch));
2822 return cplus_typeid (result);
2826 /* Removing this case and compiling with gcc -Wall reveals that
2827 a lot of cases are hitting this case. Some of these should
2828 probably be removed from expression.h; others are legitimate
2829 expressions which are (apparently) not fully implemented.
2831 If there are any cases landing here which mean a user error,
2832 then they should be separate cases, with more descriptive
2835 error (_("GDB does not (yet) know how to "
2836 "evaluate that kind of expression"));
2840 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
2843 /* Evaluate a subexpression of EXP, at index *POS,
2844 and return the address of that subexpression.
2845 Advance *POS over the subexpression.
2846 If the subexpression isn't an lvalue, get an error.
2847 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2848 then only the type of the result need be correct. */
2850 static struct value *
2851 evaluate_subexp_for_address (struct expression *exp, int *pos,
2861 op = exp->elts[pc].opcode;
2867 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2869 /* We can't optimize out "&*" if there's a user-defined operator*. */
2870 if (unop_user_defined_p (op, x))
2872 x = value_x_unop (x, op, noside);
2873 goto default_case_after_eval;
2876 return coerce_array (x);
2880 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2881 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2883 case UNOP_MEMVAL_TYPE:
2888 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2889 type = value_type (x);
2890 return value_cast (lookup_pointer_type (type),
2891 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2895 var = exp->elts[pc + 2].symbol;
2897 /* C++: The "address" of a reference should yield the address
2898 * of the object pointed to. Let value_addr() deal with it. */
2899 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
2903 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2906 lookup_pointer_type (SYMBOL_TYPE (var));
2907 enum address_class sym_class = SYMBOL_CLASS (var);
2909 if (sym_class == LOC_CONST
2910 || sym_class == LOC_CONST_BYTES
2911 || sym_class == LOC_REGISTER)
2912 error (_("Attempt to take address of register or constant."));
2915 value_zero (type, not_lval);
2918 return address_of_variable (var, exp->elts[pc + 1].block);
2921 tem = longest_to_int (exp->elts[pc + 2].longconst);
2922 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2923 x = value_aggregate_elt (exp->elts[pc + 1].type,
2924 &exp->elts[pc + 3].string,
2927 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2932 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2933 default_case_after_eval:
2934 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2936 struct type *type = check_typedef (value_type (x));
2938 if (TYPE_CODE (type) == TYPE_CODE_REF)
2939 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2941 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2942 return value_zero (lookup_pointer_type (value_type (x)),
2945 error (_("Attempt to take address of "
2946 "value not located in memory."));
2948 return value_addr (x);
2952 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2953 When used in contexts where arrays will be coerced anyway, this is
2954 equivalent to `evaluate_subexp' but much faster because it avoids
2955 actually fetching array contents (perhaps obsolete now that we have
2958 Note that we currently only do the coercion for C expressions, where
2959 arrays are zero based and the coercion is correct. For other languages,
2960 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2961 to decide if coercion is appropriate. */
2964 evaluate_subexp_with_coercion (struct expression *exp,
2965 int *pos, enum noside noside)
2974 op = exp->elts[pc].opcode;
2979 var = exp->elts[pc + 2].symbol;
2980 type = check_typedef (SYMBOL_TYPE (var));
2981 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
2982 && !TYPE_VECTOR (type)
2983 && CAST_IS_CONVERSION (exp->language_defn))
2986 val = address_of_variable (var, exp->elts[pc + 1].block);
2987 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2993 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2997 /* Evaluate a subexpression of EXP, at index *POS,
2998 and return a value for the size of that subexpression.
2999 Advance *POS over the subexpression. */
3001 static struct value *
3002 evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
3004 /* FIXME: This should be size_t. */
3005 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3012 op = exp->elts[pc].opcode;
3016 /* This case is handled specially
3017 so that we avoid creating a value for the result type.
3018 If the result type is very big, it's desirable not to
3019 create a value unnecessarily. */
3022 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3023 type = check_typedef (value_type (val));
3024 if (TYPE_CODE (type) != TYPE_CODE_PTR
3025 && TYPE_CODE (type) != TYPE_CODE_REF
3026 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3027 error (_("Attempt to take contents of a non-pointer value."));
3028 type = check_typedef (TYPE_TARGET_TYPE (type));
3029 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3033 type = check_typedef (exp->elts[pc + 1].type);
3034 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3036 case UNOP_MEMVAL_TYPE:
3038 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3039 type = check_typedef (value_type (val));
3040 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3044 type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
3046 value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3049 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3050 return value_from_longest (size_type,
3051 (LONGEST) TYPE_LENGTH (value_type (val)));
3055 /* Parse a type expression in the string [P..P+LENGTH). */
3058 parse_and_eval_type (char *p, int length)
3060 char *tmp = (char *) alloca (length + 4);
3061 struct expression *expr;
3064 memcpy (tmp + 1, p, length);
3065 tmp[length + 1] = ')';
3066 tmp[length + 2] = '0';
3067 tmp[length + 3] = '\0';
3068 expr = parse_expression (tmp);
3069 if (expr->elts[0].opcode != UNOP_CAST)
3070 error (_("Internal error in eval_type."));
3071 return expr->elts[1].type;
3075 calc_f77_array_dims (struct type *array_type)
3078 struct type *tmp_type;
3080 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3081 error (_("Can't get dimensions for a non-array type"));
3083 tmp_type = array_type;
3085 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3087 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)