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/>. */
24 #include "expression.h"
27 #include "language.h" /* For CAST_IS_CONVERSION. */
28 #include "f-lang.h" /* For array bound stuff. */
31 #include "objc-lang.h"
33 #include "parser-defs.h"
34 #include "cp-support.h"
37 #include "user-regs.h"
39 #include "gdb_obstack.h"
43 /* This is defined in valops.c */
44 extern int overload_resolution;
46 /* Prototypes for local functions. */
48 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *,
51 static struct value *evaluate_subexp_for_address (struct expression *,
54 static struct value *evaluate_struct_tuple (struct value *,
55 struct expression *, int *,
58 static LONGEST init_array_element (struct value *, struct value *,
59 struct expression *, int *, enum noside,
63 evaluate_subexp (struct type *expect_type, struct expression *exp,
64 int *pos, enum noside noside)
66 return (*exp->language_defn->la_exp_desc->evaluate_exp)
67 (expect_type, exp, pos, noside);
70 /* Parse the string EXP as a C expression, evaluate it,
71 and return the result as a number. */
74 parse_and_eval_address (const char *exp)
76 struct expression *expr = parse_expression (exp);
78 struct cleanup *old_chain =
79 make_cleanup (free_current_contents, &expr);
81 addr = value_as_address (evaluate_expression (expr));
82 do_cleanups (old_chain);
86 /* Like parse_and_eval_address, but treats the value of the expression
87 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
89 parse_and_eval_long (const char *exp)
91 struct expression *expr = parse_expression (exp);
93 struct cleanup *old_chain =
94 make_cleanup (free_current_contents, &expr);
96 retval = value_as_long (evaluate_expression (expr));
97 do_cleanups (old_chain);
102 parse_and_eval (const char *exp)
104 struct expression *expr = parse_expression (exp);
106 struct cleanup *old_chain =
107 make_cleanup (free_current_contents, &expr);
109 val = evaluate_expression (expr);
110 do_cleanups (old_chain);
114 /* Parse up to a comma (or to a closeparen)
115 in the string EXPP as an expression, evaluate it, and return the value.
116 EXPP is advanced to point to the comma. */
119 parse_to_comma_and_eval (const char **expp)
121 struct expression *expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
123 struct cleanup *old_chain =
124 make_cleanup (free_current_contents, &expr);
126 val = evaluate_expression (expr);
127 do_cleanups (old_chain);
131 /* Evaluate an expression in internal prefix form
132 such as is constructed by parse.y.
134 See expression.h for info on the format of an expression. */
137 evaluate_expression (struct expression *exp)
141 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
144 /* Evaluate an expression, avoiding all memory references
145 and getting a value whose type alone is correct. */
148 evaluate_type (struct expression *exp)
152 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
155 /* Evaluate a subexpression, avoiding all memory references and
156 getting a value whose type alone is correct. */
159 evaluate_subexpression_type (struct expression *exp, int subexp)
161 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
164 /* Find the current value of a watchpoint on EXP. Return the value in
165 *VALP and *RESULTP and the chain of intermediate and final values
166 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
169 If PRESERVE_ERRORS is true, then exceptions are passed through.
170 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
171 occurs while evaluating the expression, *RESULTP will be set to
172 NULL. *RESULTP may be a lazy value, if the result could not be
173 read from memory. It is used to determine whether a value is
174 user-specified (we should watch the whole value) or intermediate
175 (we should watch only the bit used to locate the final value).
177 If the final value, or any intermediate value, could not be read
178 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
179 set to any referenced values. *VALP will never be a lazy value.
180 This is the value which we store in struct breakpoint.
182 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
183 value chain. The caller must free the values individually. If
184 VAL_CHAIN is NULL, all generated values will be left on the value
188 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
189 struct value **resultp, struct value **val_chain,
192 struct value *mark, *new_mark, *result;
193 volatile struct gdb_exception ex;
201 /* Evaluate the expression. */
202 mark = value_mark ();
205 TRY_CATCH (ex, RETURN_MASK_ALL)
207 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
211 /* Ignore memory errors if we want watchpoints pointing at
212 inaccessible memory to still be created; otherwise, throw the
213 error to some higher catcher. */
217 if (!preserve_errors)
220 throw_exception (ex);
225 new_mark = value_mark ();
226 if (mark == new_mark)
231 /* Make sure it's not lazy, so that after the target stops again we
232 have a non-lazy previous value to compare with. */
235 if (!value_lazy (result))
239 volatile struct gdb_exception except;
241 TRY_CATCH (except, RETURN_MASK_ERROR)
243 value_fetch_lazy (result);
251 /* Return the chain of intermediate values. We use this to
252 decide which addresses to watch. */
253 *val_chain = new_mark;
254 value_release_to_mark (mark);
258 /* Extract a field operation from an expression. If the subexpression
259 of EXP starting at *SUBEXP is not a structure dereference
260 operation, return NULL. Otherwise, return the name of the
261 dereferenced field, and advance *SUBEXP to point to the
262 subexpression of the left-hand-side of the dereference. This is
263 used when completing field names. */
266 extract_field_op (struct expression *exp, int *subexp)
271 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
272 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
274 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
275 result = &exp->elts[*subexp + 2].string;
276 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
280 /* This function evaluates brace-initializers (in C/C++) for
283 static struct value *
284 evaluate_struct_tuple (struct value *struct_val,
285 struct expression *exp,
286 int *pos, enum noside noside, int nargs)
288 struct type *struct_type = check_typedef (value_type (struct_val));
289 struct type *field_type;
294 struct value *val = NULL;
299 /* Skip static fields. */
300 while (fieldno < TYPE_NFIELDS (struct_type)
301 && field_is_static (&TYPE_FIELD (struct_type,
304 if (fieldno >= TYPE_NFIELDS (struct_type))
305 error (_("too many initializers"));
306 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
307 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
308 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
309 error (_("don't know which variant you want to set"));
311 /* Here, struct_type is the type of the inner struct,
312 while substruct_type is the type of the inner struct.
313 These are the same for normal structures, but a variant struct
314 contains anonymous union fields that contain substruct fields.
315 The value fieldno is the index of the top-level (normal or
316 anonymous union) field in struct_field, while the value
317 subfieldno is the index of the actual real (named inner) field
318 in substruct_type. */
320 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
322 val = evaluate_subexp (field_type, exp, pos, noside);
324 /* Now actually set the field in struct_val. */
326 /* Assign val to field fieldno. */
327 if (value_type (val) != field_type)
328 val = value_cast (field_type, val);
330 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
331 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
332 addr = value_contents_writeable (struct_val) + bitpos / 8;
334 modify_field (struct_type, addr,
335 value_as_long (val), bitpos % 8, bitsize);
337 memcpy (addr, value_contents (val),
338 TYPE_LENGTH (value_type (val)));
344 /* Recursive helper function for setting elements of array tuples.
345 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
346 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
347 Evaluates index expresions and sets the specified element(s) of
348 ARRAY to ELEMENT. Returns last index value. */
351 init_array_element (struct value *array, struct value *element,
352 struct expression *exp, int *pos,
353 enum noside noside, LONGEST low_bound, LONGEST high_bound)
356 int element_size = TYPE_LENGTH (value_type (element));
358 if (exp->elts[*pos].opcode == BINOP_COMMA)
361 init_array_element (array, element, exp, pos, noside,
362 low_bound, high_bound);
363 return init_array_element (array, element,
364 exp, pos, noside, low_bound, high_bound);
368 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
369 if (index < low_bound || index > high_bound)
370 error (_("tuple index out of range"));
371 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
372 value_contents (element), element_size);
377 static struct value *
378 value_f90_subarray (struct value *array,
379 struct expression *exp, int *pos, enum noside noside)
382 LONGEST low_bound, high_bound;
383 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
384 enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);
388 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
389 low_bound = TYPE_LOW_BOUND (range);
391 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
393 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
394 high_bound = TYPE_HIGH_BOUND (range);
396 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
398 return value_slice (array, low_bound, high_bound - low_bound + 1);
402 /* Promote value ARG1 as appropriate before performing a unary operation
404 If the result is not appropriate for any particular language then it
405 needs to patch this function. */
408 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
413 *arg1 = coerce_ref (*arg1);
414 type1 = check_typedef (value_type (*arg1));
416 if (is_integral_type (type1))
418 switch (language->la_language)
421 /* Perform integral promotion for ANSI C/C++.
422 If not appropropriate for any particular language
423 it needs to modify this function. */
425 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
427 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
428 *arg1 = value_cast (builtin_int, *arg1);
435 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
436 operation on those two operands.
437 If the result is not appropriate for any particular language then it
438 needs to patch this function. */
441 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
442 struct value **arg1, struct value **arg2)
444 struct type *promoted_type = NULL;
448 *arg1 = coerce_ref (*arg1);
449 *arg2 = coerce_ref (*arg2);
451 type1 = check_typedef (value_type (*arg1));
452 type2 = check_typedef (value_type (*arg2));
454 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
455 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
456 && !is_integral_type (type1))
457 || (TYPE_CODE (type2) != TYPE_CODE_FLT
458 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
459 && !is_integral_type (type2)))
462 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
463 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
465 /* No promotion required. */
467 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
468 || TYPE_CODE (type2) == TYPE_CODE_FLT)
470 switch (language->la_language)
476 case language_opencl:
477 /* No promotion required. */
481 /* For other languages the result type is unchanged from gdb
482 version 6.7 for backward compatibility.
483 If either arg was long double, make sure that value is also long
484 double. Otherwise use double. */
485 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
486 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
487 promoted_type = builtin_type (gdbarch)->builtin_long_double;
489 promoted_type = builtin_type (gdbarch)->builtin_double;
493 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
494 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
496 /* No promotion required. */
499 /* Integral operations here. */
500 /* FIXME: Also mixed integral/booleans, with result an integer. */
502 const struct builtin_type *builtin = builtin_type (gdbarch);
503 unsigned int promoted_len1 = TYPE_LENGTH (type1);
504 unsigned int promoted_len2 = TYPE_LENGTH (type2);
505 int is_unsigned1 = TYPE_UNSIGNED (type1);
506 int is_unsigned2 = TYPE_UNSIGNED (type2);
507 unsigned int result_len;
508 int unsigned_operation;
510 /* Determine type length and signedness after promotion for
512 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
515 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
517 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
520 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
523 if (promoted_len1 > promoted_len2)
525 unsigned_operation = is_unsigned1;
526 result_len = promoted_len1;
528 else if (promoted_len2 > promoted_len1)
530 unsigned_operation = is_unsigned2;
531 result_len = promoted_len2;
535 unsigned_operation = is_unsigned1 || is_unsigned2;
536 result_len = promoted_len1;
539 switch (language->la_language)
545 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
547 promoted_type = (unsigned_operation
548 ? builtin->builtin_unsigned_int
549 : builtin->builtin_int);
551 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
553 promoted_type = (unsigned_operation
554 ? builtin->builtin_unsigned_long
555 : builtin->builtin_long);
559 promoted_type = (unsigned_operation
560 ? builtin->builtin_unsigned_long_long
561 : builtin->builtin_long_long);
564 case language_opencl:
565 if (result_len <= TYPE_LENGTH (lookup_signed_typename
566 (language, gdbarch, "int")))
570 ? lookup_unsigned_typename (language, gdbarch, "int")
571 : lookup_signed_typename (language, gdbarch, "int"));
573 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
574 (language, gdbarch, "long")))
578 ? lookup_unsigned_typename (language, gdbarch, "long")
579 : lookup_signed_typename (language, gdbarch,"long"));
583 /* For other languages the result type is unchanged from gdb
584 version 6.7 for backward compatibility.
585 If either arg was long long, make sure that value is also long
586 long. Otherwise use long. */
587 if (unsigned_operation)
589 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
590 promoted_type = builtin->builtin_unsigned_long_long;
592 promoted_type = builtin->builtin_unsigned_long;
596 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
597 promoted_type = builtin->builtin_long_long;
599 promoted_type = builtin->builtin_long;
607 /* Promote both operands to common type. */
608 *arg1 = value_cast (promoted_type, *arg1);
609 *arg2 = value_cast (promoted_type, *arg2);
614 ptrmath_type_p (const struct language_defn *lang, struct type *type)
616 type = check_typedef (type);
617 if (TYPE_CODE (type) == TYPE_CODE_REF)
618 type = TYPE_TARGET_TYPE (type);
620 switch (TYPE_CODE (type))
626 case TYPE_CODE_ARRAY:
627 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
634 /* Constructs a fake method with the given parameter types.
635 This function is used by the parser to construct an "expected"
636 type for method overload resolution. */
639 make_params (int num_types, struct type **param_types)
641 struct type *type = XCNEW (struct type);
642 TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
643 TYPE_LENGTH (type) = 1;
644 TYPE_CODE (type) = TYPE_CODE_METHOD;
645 TYPE_VPTR_FIELDNO (type) = -1;
646 TYPE_CHAIN (type) = type;
649 if (param_types[num_types - 1] == NULL)
652 TYPE_VARARGS (type) = 1;
654 else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
658 /* Caller should have ensured this. */
659 gdb_assert (num_types == 0);
660 TYPE_PROTOTYPED (type) = 1;
664 TYPE_NFIELDS (type) = num_types;
665 TYPE_FIELDS (type) = (struct field *)
666 TYPE_ZALLOC (type, sizeof (struct field) * num_types);
668 while (num_types-- > 0)
669 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
675 evaluate_subexp_standard (struct type *expect_type,
676 struct expression *exp, int *pos,
681 int pc, pc2 = 0, oldpos;
682 struct value *arg1 = NULL;
683 struct value *arg2 = NULL;
687 struct value **argvec;
691 struct type **arg_types;
693 struct symbol *function = NULL;
694 char *function_name = NULL;
697 op = exp->elts[pc].opcode;
702 tem = longest_to_int (exp->elts[pc + 2].longconst);
703 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
704 if (noside == EVAL_SKIP)
706 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
707 &exp->elts[pc + 3].string,
708 expect_type, 0, noside);
710 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
715 return value_from_longest (exp->elts[pc + 1].type,
716 exp->elts[pc + 2].longconst);
720 return value_from_double (exp->elts[pc + 1].type,
721 exp->elts[pc + 2].doubleconst);
725 return value_from_decfloat (exp->elts[pc + 1].type,
726 exp->elts[pc + 2].decfloatconst);
731 if (noside == EVAL_SKIP)
734 /* JYG: We used to just return value_zero of the symbol type
735 if we're asked to avoid side effects. Otherwise we return
736 value_of_variable (...). However I'm not sure if
737 value_of_variable () has any side effect.
738 We need a full value object returned here for whatis_exp ()
739 to call evaluate_type () and then pass the full value to
740 value_rtti_target_type () if we are dealing with a pointer
741 or reference to a base class and print object is on. */
744 volatile struct gdb_exception except;
745 struct value *ret = NULL;
747 TRY_CATCH (except, RETURN_MASK_ERROR)
749 ret = value_of_variable (exp->elts[pc + 2].symbol,
750 exp->elts[pc + 1].block);
753 if (except.reason < 0)
755 if (noside == EVAL_AVOID_SIDE_EFFECTS)
756 ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
759 throw_exception (except);
765 case OP_VAR_ENTRY_VALUE:
767 if (noside == EVAL_SKIP)
771 struct symbol *sym = exp->elts[pc + 1].symbol;
772 struct frame_info *frame;
774 if (noside == EVAL_AVOID_SIDE_EFFECTS)
775 return value_zero (SYMBOL_TYPE (sym), not_lval);
777 if (SYMBOL_COMPUTED_OPS (sym) == NULL
778 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
779 error (_("Symbol \"%s\" does not have any specific entry value"),
780 SYMBOL_PRINT_NAME (sym));
782 frame = get_selected_frame (NULL);
783 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
789 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
793 const char *name = &exp->elts[pc + 2].string;
797 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
798 regno = user_reg_map_name_to_regnum (exp->gdbarch,
799 name, strlen (name));
801 error (_("Register $%s not available."), name);
803 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
804 a value with the appropriate register type. Unfortunately,
805 we don't have easy access to the type of user registers.
806 So for these registers, we fetch the register value regardless
807 of the evaluation mode. */
808 if (noside == EVAL_AVOID_SIDE_EFFECTS
809 && regno < gdbarch_num_regs (exp->gdbarch)
810 + gdbarch_num_pseudo_regs (exp->gdbarch))
811 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
813 val = value_of_register (regno, get_selected_frame (NULL));
815 error (_("Value of register %s not available."), name);
821 type = language_bool_type (exp->language_defn, exp->gdbarch);
822 return value_from_longest (type, exp->elts[pc + 1].longconst);
826 return value_of_internalvar (exp->gdbarch,
827 exp->elts[pc + 1].internalvar);
830 tem = longest_to_int (exp->elts[pc + 1].longconst);
831 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
832 if (noside == EVAL_SKIP)
834 type = language_string_char_type (exp->language_defn, exp->gdbarch);
835 return value_string (&exp->elts[pc + 2].string, tem, type);
837 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
838 NSString constant. */
839 tem = longest_to_int (exp->elts[pc + 1].longconst);
840 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
841 if (noside == EVAL_SKIP)
845 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
849 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
850 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
851 nargs = tem3 - tem2 + 1;
852 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
854 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
855 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
857 struct value *rec = allocate_value (expect_type);
859 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
860 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
863 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
864 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
866 struct type *range_type = TYPE_INDEX_TYPE (type);
867 struct type *element_type = TYPE_TARGET_TYPE (type);
868 struct value *array = allocate_value (expect_type);
869 int element_size = TYPE_LENGTH (check_typedef (element_type));
870 LONGEST low_bound, high_bound, index;
872 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
875 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
878 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
879 for (tem = nargs; --nargs >= 0;)
881 struct value *element;
884 element = evaluate_subexp (element_type, exp, pos, noside);
885 if (value_type (element) != element_type)
886 element = value_cast (element_type, element);
889 int continue_pc = *pos;
892 index = init_array_element (array, element, exp, pos, noside,
893 low_bound, high_bound);
898 if (index > high_bound)
899 /* To avoid memory corruption. */
900 error (_("Too many array elements"));
901 memcpy (value_contents_raw (array)
902 + (index - low_bound) * element_size,
903 value_contents (element),
911 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
912 && TYPE_CODE (type) == TYPE_CODE_SET)
914 struct value *set = allocate_value (expect_type);
915 gdb_byte *valaddr = value_contents_raw (set);
916 struct type *element_type = TYPE_INDEX_TYPE (type);
917 struct type *check_type = element_type;
918 LONGEST low_bound, high_bound;
920 /* Get targettype of elementtype. */
921 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
922 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
923 check_type = TYPE_TARGET_TYPE (check_type);
925 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
926 error (_("(power)set type with unknown size"));
927 memset (valaddr, '\0', TYPE_LENGTH (type));
928 for (tem = 0; tem < nargs; tem++)
930 LONGEST range_low, range_high;
931 struct type *range_low_type, *range_high_type;
932 struct value *elem_val;
934 elem_val = evaluate_subexp (element_type, exp, pos, noside);
935 range_low_type = range_high_type = value_type (elem_val);
936 range_low = range_high = value_as_long (elem_val);
938 /* Check types of elements to avoid mixture of elements from
939 different types. Also check if type of element is "compatible"
940 with element type of powerset. */
941 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
942 range_low_type = TYPE_TARGET_TYPE (range_low_type);
943 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
944 range_high_type = TYPE_TARGET_TYPE (range_high_type);
945 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
946 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
947 && (range_low_type != range_high_type)))
948 /* different element modes. */
949 error (_("POWERSET tuple elements of different mode"));
950 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
951 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
952 && range_low_type != check_type))
953 error (_("incompatible POWERSET tuple elements"));
954 if (range_low > range_high)
956 warning (_("empty POWERSET tuple range"));
959 if (range_low < low_bound || range_high > high_bound)
960 error (_("POWERSET tuple element out of range"));
961 range_low -= low_bound;
962 range_high -= low_bound;
963 for (; range_low <= range_high; range_low++)
965 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
967 if (gdbarch_bits_big_endian (exp->gdbarch))
968 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
969 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
976 argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
977 for (tem = 0; tem < nargs; tem++)
979 /* Ensure that array expressions are coerced into pointer
981 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
983 if (noside == EVAL_SKIP)
985 return value_array (tem2, tem3, argvec);
989 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
991 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
993 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
995 if (noside == EVAL_SKIP)
997 return value_slice (array, lowbound, upper - lowbound + 1);
1001 /* Skip third and second args to evaluate the first one. */
1002 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1003 if (value_logical_not (arg1))
1005 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1006 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1010 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1011 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1015 case OP_OBJC_SELECTOR:
1016 { /* Objective C @selector operator. */
1017 char *sel = &exp->elts[pc + 2].string;
1018 int len = longest_to_int (exp->elts[pc + 1].longconst);
1019 struct type *selector_type;
1021 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1022 if (noside == EVAL_SKIP)
1026 sel[len] = 0; /* Make sure it's terminated. */
1028 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1029 return value_from_longest (selector_type,
1030 lookup_child_selector (exp->gdbarch, sel));
1033 case OP_OBJC_MSGCALL:
1034 { /* Objective C message (method) call. */
1036 CORE_ADDR responds_selector = 0;
1037 CORE_ADDR method_selector = 0;
1039 CORE_ADDR selector = 0;
1041 int struct_return = 0;
1042 int sub_no_side = 0;
1044 struct value *msg_send = NULL;
1045 struct value *msg_send_stret = NULL;
1046 int gnu_runtime = 0;
1048 struct value *target = NULL;
1049 struct value *method = NULL;
1050 struct value *called_method = NULL;
1052 struct type *selector_type = NULL;
1053 struct type *long_type;
1055 struct value *ret = NULL;
1058 selector = exp->elts[pc + 1].longconst;
1059 nargs = exp->elts[pc + 2].longconst;
1060 argvec = (struct value **) alloca (sizeof (struct value *)
1065 long_type = builtin_type (exp->gdbarch)->builtin_long;
1066 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1068 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1069 sub_no_side = EVAL_NORMAL;
1071 sub_no_side = noside;
1073 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1075 if (value_as_long (target) == 0)
1076 return value_from_longest (long_type, 0);
1078 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
1081 /* Find the method dispatch (Apple runtime) or method lookup
1082 (GNU runtime) function for Objective-C. These will be used
1083 to lookup the symbol information for the method. If we
1084 can't find any symbol information, then we'll use these to
1085 call the method, otherwise we can call the method
1086 directly. The msg_send_stret function is used in the special
1087 case of a method that returns a structure (Apple runtime
1091 struct type *type = selector_type;
1093 type = lookup_function_type (type);
1094 type = lookup_pointer_type (type);
1095 type = lookup_function_type (type);
1096 type = lookup_pointer_type (type);
1098 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1100 = find_function_in_inferior ("objc_msg_lookup", NULL);
1102 msg_send = value_from_pointer (type, value_as_address (msg_send));
1103 msg_send_stret = value_from_pointer (type,
1104 value_as_address (msg_send_stret));
1108 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1109 /* Special dispatcher for methods returning structs. */
1111 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1114 /* Verify the target object responds to this method. The
1115 standard top-level 'Object' class uses a different name for
1116 the verification method than the non-standard, but more
1117 often used, 'NSObject' class. Make sure we check for both. */
1120 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1121 if (responds_selector == 0)
1123 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1125 if (responds_selector == 0)
1126 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1129 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1130 if (method_selector == 0)
1132 = lookup_child_selector (exp->gdbarch, "methodFor:");
1134 if (method_selector == 0)
1135 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1137 /* Call the verification method, to make sure that the target
1138 class implements the desired method. */
1140 argvec[0] = msg_send;
1142 argvec[2] = value_from_longest (long_type, responds_selector);
1143 argvec[3] = value_from_longest (long_type, selector);
1146 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1149 /* Function objc_msg_lookup returns a pointer. */
1151 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1153 if (value_as_long (ret) == 0)
1154 error (_("Target does not respond to this message selector."));
1156 /* Call "methodForSelector:" method, to get the address of a
1157 function method that implements this selector for this
1158 class. If we can find a symbol at that address, then we
1159 know the return type, parameter types etc. (that's a good
1162 argvec[0] = msg_send;
1164 argvec[2] = value_from_longest (long_type, method_selector);
1165 argvec[3] = value_from_longest (long_type, selector);
1168 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1172 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1175 /* ret should now be the selector. */
1177 addr = value_as_long (ret);
1180 struct symbol *sym = NULL;
1182 /* The address might point to a function descriptor;
1183 resolve it to the actual code address instead. */
1184 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1187 /* Is it a high_level symbol? */
1188 sym = find_pc_function (addr);
1190 method = value_of_variable (sym, 0);
1193 /* If we found a method with symbol information, check to see
1194 if it returns a struct. Otherwise assume it doesn't. */
1199 struct type *val_type;
1201 funaddr = find_function_addr (method, &val_type);
1203 block_for_pc (funaddr);
1205 CHECK_TYPEDEF (val_type);
1207 if ((val_type == NULL)
1208 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1210 if (expect_type != NULL)
1211 val_type = expect_type;
1214 struct_return = using_struct_return (exp->gdbarch, method,
1217 else if (expect_type != NULL)
1219 struct_return = using_struct_return (exp->gdbarch, NULL,
1220 check_typedef (expect_type));
1223 /* Found a function symbol. Now we will substitute its
1224 value in place of the message dispatcher (obj_msgSend),
1225 so that we call the method directly instead of thru
1226 the dispatcher. The main reason for doing this is that
1227 we can now evaluate the return value and parameter values
1228 according to their known data types, in case we need to
1229 do things like promotion, dereferencing, special handling
1230 of structs and doubles, etc.
1232 We want to use the type signature of 'method', but still
1233 jump to objc_msgSend() or objc_msgSend_stret() to better
1234 mimic the behavior of the runtime. */
1238 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1239 error (_("method address has symbol information "
1240 "with non-function type; skipping"));
1242 /* Create a function pointer of the appropriate type, and
1243 replace its value with the value of msg_send or
1244 msg_send_stret. We must use a pointer here, as
1245 msg_send and msg_send_stret are of pointer type, and
1246 the representation may be different on systems that use
1247 function descriptors. */
1250 = value_from_pointer (lookup_pointer_type (value_type (method)),
1251 value_as_address (msg_send_stret));
1254 = value_from_pointer (lookup_pointer_type (value_type (method)),
1255 value_as_address (msg_send));
1260 called_method = msg_send_stret;
1262 called_method = msg_send;
1265 if (noside == EVAL_SKIP)
1268 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1270 /* If the return type doesn't look like a function type,
1271 call an error. This can happen if somebody tries to
1272 turn a variable into a function call. This is here
1273 because people often want to call, eg, strcmp, which
1274 gdb doesn't know is a function. If gdb isn't asked for
1275 it's opinion (ie. through "whatis"), it won't offer
1278 struct type *type = value_type (called_method);
1280 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1281 type = TYPE_TARGET_TYPE (type);
1282 type = TYPE_TARGET_TYPE (type);
1286 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1287 return allocate_value (expect_type);
1289 return allocate_value (type);
1292 error (_("Expression of type other than "
1293 "\"method returning ...\" used as a method"));
1296 /* Now depending on whether we found a symbol for the method,
1297 we will either call the runtime dispatcher or the method
1300 argvec[0] = called_method;
1302 argvec[2] = value_from_longest (long_type, selector);
1303 /* User-supplied arguments. */
1304 for (tem = 0; tem < nargs; tem++)
1305 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1306 argvec[tem + 3] = 0;
1308 if (gnu_runtime && (method != NULL))
1310 /* Function objc_msg_lookup returns a pointer. */
1311 deprecated_set_value_type (argvec[0],
1312 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1314 = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1317 ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1324 op = exp->elts[*pos].opcode;
1325 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1326 /* Allocate arg vector, including space for the function to be
1327 called in argvec[0], a potential `this', and a terminating NULL. */
1328 argvec = (struct value **)
1329 alloca (sizeof (struct value *) * (nargs + 3));
1330 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1332 /* First, evaluate the structure into arg2. */
1335 if (op == STRUCTOP_MEMBER)
1337 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1341 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1344 /* If the function is a virtual function, then the
1345 aggregate value (providing the structure) plays
1346 its part by providing the vtable. Otherwise,
1347 it is just along for the ride: call the function
1350 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1352 type = check_typedef (value_type (arg1));
1353 if (noside == EVAL_SKIP)
1354 tem = 1; /* Set it to the right arg index so that all arguments
1355 can also be skipped. */
1356 else if (TYPE_CODE (type) == TYPE_CODE_METHODPTR)
1358 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1359 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval);
1361 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1363 /* Now, say which argument to start evaluating from. */
1368 else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
1370 struct type *type_ptr
1371 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type));
1372 struct type *target_type_ptr
1373 = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1375 /* Now, convert these values to an address. */
1376 arg2 = value_cast (type_ptr, arg2);
1378 mem_offset = value_as_long (arg1);
1380 arg1 = value_from_pointer (target_type_ptr,
1381 value_as_long (arg2) + mem_offset);
1382 arg1 = value_ind (arg1);
1386 error (_("Non-pointer-to-member value used in pointer-to-member "
1389 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1391 /* Hair for method invocations. */
1395 /* First, evaluate the structure into arg2. */
1397 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1398 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1400 if (op == STRUCTOP_STRUCT)
1402 /* If v is a variable in a register, and the user types
1403 v.method (), this will produce an error, because v has
1406 A possible way around this would be to allocate a
1407 copy of the variable on the stack, copy in the
1408 contents, call the function, and copy out the
1409 contents. I.e. convert this from call by reference
1410 to call by copy-return (or whatever it's called).
1411 However, this does not work because it is not the
1412 same: the method being called could stash a copy of
1413 the address, and then future uses through that address
1414 (after the method returns) would be expected to
1415 use the variable itself, not some copy of it. */
1416 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1420 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1422 /* Check to see if the operator '->' has been
1423 overloaded. If the operator has been overloaded
1424 replace arg2 with the value returned by the custom
1425 operator and continue evaluation. */
1426 while (unop_user_defined_p (op, arg2))
1428 volatile struct gdb_exception except;
1429 struct value *value = NULL;
1430 TRY_CATCH (except, RETURN_MASK_ERROR)
1432 value = value_x_unop (arg2, op, noside);
1435 if (except.reason < 0)
1437 if (except.error == NOT_FOUND_ERROR)
1440 throw_exception (except);
1445 /* Now, say which argument to start evaluating from. */
1448 else if (op == OP_SCOPE
1449 && overload_resolution
1450 && (exp->language_defn->la_language == language_cplus))
1452 /* Unpack it locally so we can properly handle overload
1458 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
1459 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
1460 type = exp->elts[pc2 + 1].type;
1461 name = &exp->elts[pc2 + 3].string;
1464 function_name = NULL;
1465 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
1467 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
1469 get_selected_block (0),
1471 if (function == NULL)
1472 error (_("No symbol \"%s\" in namespace \"%s\"."),
1473 name, TYPE_TAG_NAME (type));
1476 /* arg2 is left as NULL on purpose. */
1480 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1481 || TYPE_CODE (type) == TYPE_CODE_UNION);
1482 function_name = name;
1484 /* We need a properly typed value for method lookup. For
1485 static methods arg2 is otherwise unused. */
1486 arg2 = value_zero (type, lval_memory);
1491 else if (op == OP_ADL_FUNC)
1493 /* Save the function position and move pos so that the arguments
1494 can be evaluated. */
1500 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1501 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1505 /* Non-method function call. */
1509 /* If this is a C++ function wait until overload resolution. */
1510 if (op == OP_VAR_VALUE
1511 && overload_resolution
1512 && (exp->language_defn->la_language == language_cplus))
1514 (*pos) += 4; /* Skip the evaluation of the symbol. */
1519 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1520 type = value_type (argvec[0]);
1521 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1522 type = TYPE_TARGET_TYPE (type);
1523 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1525 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1527 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1535 /* Evaluate arguments (if not already done, e.g., namespace::func()
1536 and overload-resolution is off). */
1537 for (; tem <= nargs; tem++)
1539 /* Ensure that array expressions are coerced into pointer
1541 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1544 /* Signal end of arglist. */
1547 if (noside == EVAL_SKIP)
1550 if (op == OP_ADL_FUNC)
1552 struct symbol *symp;
1555 int string_pc = save_pos1 + 3;
1557 /* Extract the function name. */
1558 name_len = longest_to_int (exp->elts[string_pc].longconst);
1559 func_name = (char *) alloca (name_len + 1);
1560 strcpy (func_name, &exp->elts[string_pc + 1].string);
1562 find_overload_match (&argvec[1], nargs, func_name,
1563 NON_METHOD, /* not method */
1564 NULL, NULL, /* pass NULL symbol since
1565 symbol is unknown */
1566 NULL, &symp, NULL, 0, noside);
1568 /* Now fix the expression being evaluated. */
1569 exp->elts[save_pos1 + 2].symbol = symp;
1570 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1573 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1574 || (op == OP_SCOPE && function_name != NULL))
1576 int static_memfuncp;
1579 /* Method invocation: stuff "this" as first parameter.
1580 If the method turns out to be static we undo this below. */
1585 /* Name of method from expression. */
1586 tstr = &exp->elts[pc2 + 2].string;
1589 tstr = function_name;
1591 if (overload_resolution && (exp->language_defn->la_language
1594 /* Language is C++, do some overload resolution before
1596 struct value *valp = NULL;
1598 (void) find_overload_match (&argvec[1], nargs, tstr,
1599 METHOD, /* method */
1600 &arg2, /* the object */
1602 &static_memfuncp, 0, noside);
1604 if (op == OP_SCOPE && !static_memfuncp)
1606 /* For the time being, we don't handle this. */
1607 error (_("Call to overloaded function %s requires "
1611 argvec[1] = arg2; /* the ``this'' pointer */
1612 argvec[0] = valp; /* Use the method found after overload
1616 /* Non-C++ case -- or no overload resolution. */
1618 struct value *temp = arg2;
1620 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1622 op == STRUCTOP_STRUCT
1623 ? "structure" : "structure pointer");
1624 /* value_struct_elt updates temp with the correct value
1625 of the ``this'' pointer if necessary, so modify argvec[1] to
1626 reflect any ``this'' changes. */
1628 = value_from_longest (lookup_pointer_type(value_type (temp)),
1629 value_address (temp)
1630 + value_embedded_offset (temp));
1631 argvec[1] = arg2; /* the ``this'' pointer */
1634 /* Take out `this' if needed. */
1635 if (static_memfuncp)
1637 argvec[1] = argvec[0];
1642 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1644 /* Pointer to member. argvec[1] is already set up. */
1647 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1649 /* Non-member function being called. */
1650 /* fn: This can only be done for C++ functions. A C-style function
1651 in a C++ program, for instance, does not have the fields that
1652 are expected here. */
1654 if (overload_resolution && (exp->language_defn->la_language
1657 /* Language is C++, do some overload resolution before
1659 struct symbol *symp;
1662 /* If a scope has been specified disable ADL. */
1666 if (op == OP_VAR_VALUE)
1667 function = exp->elts[save_pos1+2].symbol;
1669 (void) find_overload_match (&argvec[1], nargs,
1670 NULL, /* no need for name */
1671 NON_METHOD, /* not method */
1672 NULL, function, /* the function */
1673 NULL, &symp, NULL, no_adl, noside);
1675 if (op == OP_VAR_VALUE)
1677 /* Now fix the expression being evaluated. */
1678 exp->elts[save_pos1+2].symbol = symp;
1679 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1683 argvec[0] = value_of_variable (symp, get_selected_block (0));
1687 /* Not C++, or no overload resolution allowed. */
1688 /* Nothing to be done; argvec already correctly set up. */
1693 /* It is probably a C-style function. */
1694 /* Nothing to be done; argvec already correctly set up. */
1699 if (argvec[0] == NULL)
1700 error (_("Cannot evaluate function -- may be inlined"));
1701 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1703 /* If the return type doesn't look like a function type, call an
1704 error. This can happen if somebody tries to turn a variable into
1705 a function call. This is here because people often want to
1706 call, eg, strcmp, which gdb doesn't know is a function. If
1707 gdb isn't asked for it's opinion (ie. through "whatis"),
1708 it won't offer it. */
1710 struct type *ftype = value_type (argvec[0]);
1712 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
1714 /* We don't know anything about what the internal
1715 function might return, but we have to return
1717 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
1720 else if (TYPE_GNU_IFUNC (ftype))
1721 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype)));
1722 else if (TYPE_TARGET_TYPE (ftype))
1723 return allocate_value (TYPE_TARGET_TYPE (ftype));
1725 error (_("Expression of type other than "
1726 "\"Function returning ...\" used as function"));
1728 switch (TYPE_CODE (value_type (argvec[0])))
1730 case TYPE_CODE_INTERNAL_FUNCTION:
1731 return call_internal_function (exp->gdbarch, exp->language_defn,
1732 argvec[0], nargs, argvec + 1);
1733 case TYPE_CODE_XMETHOD:
1734 return call_xmethod (argvec[0], nargs, argvec + 1);
1736 return call_function_by_hand (argvec[0], nargs, argvec + 1);
1738 /* pai: FIXME save value from call_function_by_hand, then adjust
1739 pc by adjust_fn_pc if +ve. */
1741 case OP_F77_UNDETERMINED_ARGLIST:
1743 /* Remember that in F77, functions, substring ops and
1744 array subscript operations cannot be disambiguated
1745 at parse time. We have made all array subscript operations,
1746 substring operations as well as function calls come here
1747 and we now have to discover what the heck this thing actually was.
1748 If it is a function, we process just as if we got an OP_FUNCALL. */
1750 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1753 /* First determine the type code we are dealing with. */
1754 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1755 type = check_typedef (value_type (arg1));
1756 code = TYPE_CODE (type);
1758 if (code == TYPE_CODE_PTR)
1760 /* Fortran always passes variable to subroutines as pointer.
1761 So we need to look into its target type to see if it is
1762 array, string or function. If it is, we need to switch
1763 to the target value the original one points to. */
1764 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1766 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1767 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1768 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1770 arg1 = value_ind (arg1);
1771 type = check_typedef (value_type (arg1));
1772 code = TYPE_CODE (type);
1778 case TYPE_CODE_ARRAY:
1779 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1780 return value_f90_subarray (arg1, exp, pos, noside);
1782 goto multi_f77_subscript;
1784 case TYPE_CODE_STRING:
1785 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1786 return value_f90_subarray (arg1, exp, pos, noside);
1789 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1790 return value_subscript (arg1, value_as_long (arg2));
1794 case TYPE_CODE_FUNC:
1795 /* It's a function call. */
1796 /* Allocate arg vector, including space for the function to be
1797 called in argvec[0] and a terminating NULL. */
1798 argvec = (struct value **)
1799 alloca (sizeof (struct value *) * (nargs + 2));
1802 for (; tem <= nargs; tem++)
1803 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1804 argvec[tem] = 0; /* signal end of arglist */
1805 if (noside == EVAL_SKIP)
1810 error (_("Cannot perform substring on this type"));
1814 /* We have a complex number, There should be 2 floating
1815 point numbers that compose it. */
1817 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1818 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1820 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1822 case STRUCTOP_STRUCT:
1823 tem = longest_to_int (exp->elts[pc + 1].longconst);
1824 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1825 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1826 if (noside == EVAL_SKIP)
1828 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1830 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1831 arg3 = value_zero (value_type (arg3), not_lval);
1835 tem = longest_to_int (exp->elts[pc + 1].longconst);
1836 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1837 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1838 if (noside == EVAL_SKIP)
1841 /* Check to see if operator '->' has been overloaded. If so replace
1842 arg1 with the value returned by evaluating operator->(). */
1843 while (unop_user_defined_p (op, arg1))
1845 volatile struct gdb_exception except;
1846 struct value *value = NULL;
1847 TRY_CATCH (except, RETURN_MASK_ERROR)
1849 value = value_x_unop (arg1, op, noside);
1852 if (except.reason < 0)
1854 if (except.error == NOT_FOUND_ERROR)
1857 throw_exception (except);
1862 /* JYG: if print object is on we need to replace the base type
1863 with rtti type in order to continue on with successful
1864 lookup of member / method only available in the rtti type. */
1866 struct type *type = value_type (arg1);
1867 struct type *real_type;
1868 int full, top, using_enc;
1869 struct value_print_options opts;
1871 get_user_print_options (&opts);
1872 if (opts.objectprint && TYPE_TARGET_TYPE(type)
1873 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
1875 real_type = value_rtti_indirect_type (arg1, &full, &top,
1878 arg1 = value_cast (real_type, arg1);
1882 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1883 NULL, "structure pointer");
1884 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1885 arg3 = value_zero (value_type (arg3), not_lval);
1888 case STRUCTOP_MEMBER:
1890 if (op == STRUCTOP_MEMBER)
1891 arg1 = evaluate_subexp_for_address (exp, pos, noside);
1893 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1895 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1897 if (noside == EVAL_SKIP)
1900 type = check_typedef (value_type (arg2));
1901 switch (TYPE_CODE (type))
1903 case TYPE_CODE_METHODPTR:
1904 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1905 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1908 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
1909 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
1910 return value_ind (arg2);
1913 case TYPE_CODE_MEMBERPTR:
1914 /* Now, convert these values to an address. */
1915 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
1918 mem_offset = value_as_long (arg2);
1920 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1921 value_as_long (arg1) + mem_offset);
1922 return value_ind (arg3);
1925 error (_("non-pointer-to-member value used "
1926 "in pointer-to-member construct"));
1930 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1931 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
1932 for (ix = 0; ix < nargs; ++ix)
1933 arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
1935 expect_type = make_params (nargs, arg_types);
1936 *(pos) += 3 + nargs;
1937 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
1938 xfree (TYPE_FIELDS (expect_type));
1939 xfree (TYPE_MAIN_TYPE (expect_type));
1940 xfree (expect_type);
1944 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1945 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1946 if (noside == EVAL_SKIP)
1948 if (binop_user_defined_p (op, arg1, arg2))
1949 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1951 return value_concat (arg1, arg2);
1954 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1955 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1957 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1959 if (binop_user_defined_p (op, arg1, arg2))
1960 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1962 return value_assign (arg1, arg2);
1964 case BINOP_ASSIGN_MODIFY:
1966 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1967 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1968 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1970 op = exp->elts[pc + 1].opcode;
1971 if (binop_user_defined_p (op, arg1, arg2))
1972 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
1973 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
1975 && is_integral_type (value_type (arg2)))
1976 arg2 = value_ptradd (arg1, value_as_long (arg2));
1977 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
1979 && is_integral_type (value_type (arg2)))
1980 arg2 = value_ptradd (arg1, - value_as_long (arg2));
1983 struct value *tmp = arg1;
1985 /* For shift and integer exponentiation operations,
1986 only promote the first argument. */
1987 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
1988 && is_integral_type (value_type (arg2)))
1989 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
1991 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
1993 arg2 = value_binop (tmp, arg2, op);
1995 return value_assign (arg1, arg2);
1998 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1999 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2000 if (noside == EVAL_SKIP)
2002 if (binop_user_defined_p (op, arg1, arg2))
2003 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2004 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2005 && is_integral_type (value_type (arg2)))
2006 return value_ptradd (arg1, value_as_long (arg2));
2007 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2008 && is_integral_type (value_type (arg1)))
2009 return value_ptradd (arg2, value_as_long (arg1));
2012 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2013 return value_binop (arg1, arg2, BINOP_ADD);
2017 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2018 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2019 if (noside == EVAL_SKIP)
2021 if (binop_user_defined_p (op, arg1, arg2))
2022 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2023 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2024 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2026 /* FIXME -- should be ptrdiff_t */
2027 type = builtin_type (exp->gdbarch)->builtin_long;
2028 return value_from_longest (type, value_ptrdiff (arg1, arg2));
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));
2035 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2036 return value_binop (arg1, arg2, BINOP_SUB);
2047 case BINOP_BITWISE_AND:
2048 case BINOP_BITWISE_IOR:
2049 case BINOP_BITWISE_XOR:
2050 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2051 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2052 if (noside == EVAL_SKIP)
2054 if (binop_user_defined_p (op, arg1, arg2))
2055 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2058 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2059 fudge arg2 to avoid division-by-zero, the caller is
2060 (theoretically) only looking for the type of the result. */
2061 if (noside == EVAL_AVOID_SIDE_EFFECTS
2062 /* ??? Do we really want to test for BINOP_MOD here?
2063 The implementation of value_binop gives it a well-defined
2066 || op == BINOP_INTDIV
2069 && value_logical_not (arg2))
2071 struct value *v_one, *retval;
2073 v_one = value_one (value_type (arg2));
2074 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2075 retval = value_binop (arg1, v_one, op);
2080 /* For shift and integer exponentiation operations,
2081 only promote the first argument. */
2082 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2083 && is_integral_type (value_type (arg2)))
2084 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2086 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2088 return value_binop (arg1, arg2, op);
2092 case BINOP_SUBSCRIPT:
2093 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2094 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2095 if (noside == EVAL_SKIP)
2097 if (binop_user_defined_p (op, arg1, arg2))
2098 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2101 /* If the user attempts to subscript something that is not an
2102 array or pointer type (like a plain int variable for example),
2103 then report this as an error. */
2105 arg1 = coerce_ref (arg1);
2106 type = check_typedef (value_type (arg1));
2107 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2108 && TYPE_CODE (type) != TYPE_CODE_PTR)
2110 if (TYPE_NAME (type))
2111 error (_("cannot subscript something of type `%s'"),
2114 error (_("cannot subscript requested type"));
2117 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2118 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2120 return value_subscript (arg1, value_as_long (arg2));
2122 case MULTI_SUBSCRIPT:
2124 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2125 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2128 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2129 /* FIXME: EVAL_SKIP handling may not be correct. */
2130 if (noside == EVAL_SKIP)
2141 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2142 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2144 /* If the user attempts to subscript something that has no target
2145 type (like a plain int variable for example), then report this
2148 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2151 arg1 = value_zero (type, VALUE_LVAL (arg1));
2157 error (_("cannot subscript something of type `%s'"),
2158 TYPE_NAME (value_type (arg1)));
2162 if (binop_user_defined_p (op, arg1, arg2))
2164 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2168 arg1 = coerce_ref (arg1);
2169 type = check_typedef (value_type (arg1));
2171 switch (TYPE_CODE (type))
2174 case TYPE_CODE_ARRAY:
2175 case TYPE_CODE_STRING:
2176 arg1 = value_subscript (arg1, value_as_long (arg2));
2180 if (TYPE_NAME (type))
2181 error (_("cannot subscript something of type `%s'"),
2184 error (_("cannot subscript requested type"));
2190 multi_f77_subscript:
2192 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2193 int ndimensions = 1, i;
2194 struct value *array = arg1;
2196 if (nargs > MAX_FORTRAN_DIMS)
2197 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2199 ndimensions = calc_f77_array_dims (type);
2201 if (nargs != ndimensions)
2202 error (_("Wrong number of subscripts"));
2204 gdb_assert (nargs > 0);
2206 /* Now that we know we have a legal array subscript expression
2207 let us actually find out where this element exists in the array. */
2209 /* Take array indices left to right. */
2210 for (i = 0; i < nargs; i++)
2212 /* Evaluate each subscript; it must be a legal integer in F77. */
2213 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2215 /* Fill in the subscript array. */
2217 subscript_array[i] = value_as_long (arg2);
2220 /* Internal type of array is arranged right to left. */
2221 for (i = nargs; i > 0; i--)
2223 struct type *array_type = check_typedef (value_type (array));
2224 LONGEST index = subscript_array[i - 1];
2226 array = value_subscripted_rvalue (array, index,
2227 f77_get_lowerbound (array_type));
2233 case BINOP_LOGICAL_AND:
2234 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2235 if (noside == EVAL_SKIP)
2237 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2242 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2245 if (binop_user_defined_p (op, arg1, arg2))
2247 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2248 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2252 tem = value_logical_not (arg1);
2253 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2254 (tem ? EVAL_SKIP : noside));
2255 type = language_bool_type (exp->language_defn, exp->gdbarch);
2256 return value_from_longest (type,
2257 (LONGEST) (!tem && !value_logical_not (arg2)));
2260 case BINOP_LOGICAL_OR:
2261 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2262 if (noside == EVAL_SKIP)
2264 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2269 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2272 if (binop_user_defined_p (op, arg1, arg2))
2274 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2275 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2279 tem = value_logical_not (arg1);
2280 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2281 (!tem ? EVAL_SKIP : noside));
2282 type = language_bool_type (exp->language_defn, exp->gdbarch);
2283 return value_from_longest (type,
2284 (LONGEST) (!tem || !value_logical_not (arg2)));
2288 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2289 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2290 if (noside == EVAL_SKIP)
2292 if (binop_user_defined_p (op, arg1, arg2))
2294 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2298 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2299 tem = value_equal (arg1, arg2);
2300 type = language_bool_type (exp->language_defn, exp->gdbarch);
2301 return value_from_longest (type, (LONGEST) tem);
2304 case BINOP_NOTEQUAL:
2305 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2306 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2307 if (noside == EVAL_SKIP)
2309 if (binop_user_defined_p (op, arg1, arg2))
2311 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2315 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2316 tem = value_equal (arg1, arg2);
2317 type = language_bool_type (exp->language_defn, exp->gdbarch);
2318 return value_from_longest (type, (LONGEST) ! tem);
2322 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2323 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2324 if (noside == EVAL_SKIP)
2326 if (binop_user_defined_p (op, arg1, arg2))
2328 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2332 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2333 tem = value_less (arg1, arg2);
2334 type = language_bool_type (exp->language_defn, exp->gdbarch);
2335 return value_from_longest (type, (LONGEST) tem);
2339 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2340 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2341 if (noside == EVAL_SKIP)
2343 if (binop_user_defined_p (op, arg1, arg2))
2345 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2349 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2350 tem = value_less (arg2, arg1);
2351 type = language_bool_type (exp->language_defn, exp->gdbarch);
2352 return value_from_longest (type, (LONGEST) tem);
2356 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2357 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2358 if (noside == EVAL_SKIP)
2360 if (binop_user_defined_p (op, arg1, arg2))
2362 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2366 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2367 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2368 type = language_bool_type (exp->language_defn, exp->gdbarch);
2369 return value_from_longest (type, (LONGEST) tem);
2373 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2374 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2375 if (noside == EVAL_SKIP)
2377 if (binop_user_defined_p (op, arg1, arg2))
2379 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2383 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2384 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2385 type = language_bool_type (exp->language_defn, exp->gdbarch);
2386 return value_from_longest (type, (LONGEST) tem);
2390 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2391 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2392 if (noside == EVAL_SKIP)
2394 type = check_typedef (value_type (arg2));
2395 if (TYPE_CODE (type) != TYPE_CODE_INT)
2396 error (_("Non-integral right operand for \"@\" operator."));
2397 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2399 return allocate_repeat_value (value_type (arg1),
2400 longest_to_int (value_as_long (arg2)));
2403 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2406 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2407 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2410 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2411 if (noside == EVAL_SKIP)
2413 if (unop_user_defined_p (op, arg1))
2414 return value_x_unop (arg1, op, noside);
2417 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2418 return value_pos (arg1);
2422 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2423 if (noside == EVAL_SKIP)
2425 if (unop_user_defined_p (op, arg1))
2426 return value_x_unop (arg1, op, noside);
2429 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2430 return value_neg (arg1);
2433 case UNOP_COMPLEMENT:
2434 /* C++: check for and handle destructor names. */
2435 op = exp->elts[*pos].opcode;
2437 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2438 if (noside == EVAL_SKIP)
2440 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2441 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2444 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2445 return value_complement (arg1);
2448 case UNOP_LOGICAL_NOT:
2449 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2450 if (noside == EVAL_SKIP)
2452 if (unop_user_defined_p (op, arg1))
2453 return value_x_unop (arg1, op, noside);
2456 type = language_bool_type (exp->language_defn, exp->gdbarch);
2457 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2461 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2462 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2463 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2464 type = check_typedef (value_type (arg1));
2465 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2466 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2467 error (_("Attempt to dereference pointer "
2468 "to member without an object"));
2469 if (noside == EVAL_SKIP)
2471 if (unop_user_defined_p (op, arg1))
2472 return value_x_unop (arg1, op, noside);
2473 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2475 type = check_typedef (value_type (arg1));
2476 if (TYPE_CODE (type) == TYPE_CODE_PTR
2477 || TYPE_CODE (type) == TYPE_CODE_REF
2478 /* In C you can dereference an array to get the 1st elt. */
2479 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2481 return value_zero (TYPE_TARGET_TYPE (type),
2483 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2484 /* GDB allows dereferencing an int. */
2485 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2488 error (_("Attempt to take contents of a non-pointer value."));
2491 /* Allow * on an integer so we can cast it to whatever we want.
2492 This returns an int, which seems like the most C-like thing to
2493 do. "long long" variables are rare enough that
2494 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2495 if (TYPE_CODE (type) == TYPE_CODE_INT)
2496 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2497 (CORE_ADDR) value_as_address (arg1));
2498 return value_ind (arg1);
2501 /* C++: check for and handle pointer to members. */
2503 op = exp->elts[*pos].opcode;
2505 if (noside == EVAL_SKIP)
2507 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2512 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2519 if (noside == EVAL_SKIP)
2521 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2524 return evaluate_subexp_for_sizeof (exp, pos, noside);
2528 type = exp->elts[pc + 1].type;
2529 arg1 = evaluate_subexp (type, exp, pos, noside);
2530 if (noside == EVAL_SKIP)
2532 if (type != value_type (arg1))
2533 arg1 = value_cast (type, arg1);
2536 case UNOP_CAST_TYPE:
2537 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2538 type = value_type (arg1);
2539 arg1 = evaluate_subexp (type, exp, pos, noside);
2540 if (noside == EVAL_SKIP)
2542 if (type != value_type (arg1))
2543 arg1 = value_cast (type, arg1);
2546 case UNOP_DYNAMIC_CAST:
2547 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2548 type = value_type (arg1);
2549 arg1 = evaluate_subexp (type, exp, pos, noside);
2550 if (noside == EVAL_SKIP)
2552 return value_dynamic_cast (type, arg1);
2554 case UNOP_REINTERPRET_CAST:
2555 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2556 type = value_type (arg1);
2557 arg1 = evaluate_subexp (type, exp, pos, noside);
2558 if (noside == EVAL_SKIP)
2560 return value_reinterpret_cast (type, arg1);
2564 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2565 if (noside == EVAL_SKIP)
2567 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2568 return value_zero (exp->elts[pc + 1].type, lval_memory);
2570 return value_at_lazy (exp->elts[pc + 1].type,
2571 value_as_address (arg1));
2573 case UNOP_MEMVAL_TYPE:
2574 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2575 type = value_type (arg1);
2576 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2577 if (noside == EVAL_SKIP)
2579 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2580 return value_zero (type, lval_memory);
2582 return value_at_lazy (type, value_as_address (arg1));
2584 case UNOP_MEMVAL_TLS:
2586 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2587 if (noside == EVAL_SKIP)
2589 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2590 return value_zero (exp->elts[pc + 2].type, lval_memory);
2595 tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2596 value_as_address (arg1));
2597 return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
2600 case UNOP_PREINCREMENT:
2601 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2602 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2604 else if (unop_user_defined_p (op, arg1))
2606 return value_x_unop (arg1, op, noside);
2610 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2611 arg2 = value_ptradd (arg1, 1);
2614 struct value *tmp = arg1;
2616 arg2 = value_one (value_type (arg1));
2617 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2618 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2621 return value_assign (arg1, arg2);
2624 case UNOP_PREDECREMENT:
2625 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2626 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2628 else if (unop_user_defined_p (op, arg1))
2630 return value_x_unop (arg1, op, noside);
2634 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2635 arg2 = value_ptradd (arg1, -1);
2638 struct value *tmp = arg1;
2640 arg2 = value_one (value_type (arg1));
2641 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2642 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2645 return value_assign (arg1, arg2);
2648 case UNOP_POSTINCREMENT:
2649 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2650 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2652 else if (unop_user_defined_p (op, arg1))
2654 return value_x_unop (arg1, op, noside);
2658 arg3 = value_non_lval (arg1);
2660 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2661 arg2 = value_ptradd (arg1, 1);
2664 struct value *tmp = arg1;
2666 arg2 = value_one (value_type (arg1));
2667 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2668 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2671 value_assign (arg1, arg2);
2675 case UNOP_POSTDECREMENT:
2676 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2677 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2679 else if (unop_user_defined_p (op, arg1))
2681 return value_x_unop (arg1, op, noside);
2685 arg3 = value_non_lval (arg1);
2687 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2688 arg2 = value_ptradd (arg1, -1);
2691 struct value *tmp = arg1;
2693 arg2 = value_one (value_type (arg1));
2694 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2695 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2698 value_assign (arg1, arg2);
2704 return value_of_this (exp->language_defn);
2707 /* The value is not supposed to be used. This is here to make it
2708 easier to accommodate expressions that contain types. */
2710 if (noside == EVAL_SKIP)
2712 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2714 struct type *type = exp->elts[pc + 1].type;
2716 /* If this is a typedef, then find its immediate target. We
2717 use check_typedef to resolve stubs, but we ignore its
2718 result because we do not want to dig past all
2720 check_typedef (type);
2721 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2722 type = TYPE_TARGET_TYPE (type);
2723 return allocate_value (type);
2726 error (_("Attempt to use a type name as an expression"));
2730 if (noside == EVAL_SKIP)
2732 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2735 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2737 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2738 struct value *result;
2740 result = evaluate_subexp (NULL_TYPE, exp, pos,
2741 EVAL_AVOID_SIDE_EFFECTS);
2743 /* 'decltype' has special semantics for lvalues. */
2744 if (op == OP_DECLTYPE
2745 && (sub_op == BINOP_SUBSCRIPT
2746 || sub_op == STRUCTOP_MEMBER
2747 || sub_op == STRUCTOP_MPTR
2748 || sub_op == UNOP_IND
2749 || sub_op == STRUCTOP_STRUCT
2750 || sub_op == STRUCTOP_PTR
2751 || sub_op == OP_SCOPE))
2753 struct type *type = value_type (result);
2755 if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF)
2757 type = lookup_reference_type (type);
2758 result = allocate_value (type);
2765 error (_("Attempt to use a type as an expression"));
2769 struct value *result;
2770 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2772 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2773 result = evaluate_subexp (NULL_TYPE, exp, pos,
2774 EVAL_AVOID_SIDE_EFFECTS);
2776 result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2778 if (noside != EVAL_NORMAL)
2779 return allocate_value (cplus_typeid_type (exp->gdbarch));
2781 return cplus_typeid (result);
2785 /* Removing this case and compiling with gcc -Wall reveals that
2786 a lot of cases are hitting this case. Some of these should
2787 probably be removed from expression.h; others are legitimate
2788 expressions which are (apparently) not fully implemented.
2790 If there are any cases landing here which mean a user error,
2791 then they should be separate cases, with more descriptive
2794 error (_("GDB does not (yet) know how to "
2795 "evaluate that kind of expression"));
2799 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
2802 /* Evaluate a subexpression of EXP, at index *POS,
2803 and return the address of that subexpression.
2804 Advance *POS over the subexpression.
2805 If the subexpression isn't an lvalue, get an error.
2806 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2807 then only the type of the result need be correct. */
2809 static struct value *
2810 evaluate_subexp_for_address (struct expression *exp, int *pos,
2820 op = exp->elts[pc].opcode;
2826 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2828 /* We can't optimize out "&*" if there's a user-defined operator*. */
2829 if (unop_user_defined_p (op, x))
2831 x = value_x_unop (x, op, noside);
2832 goto default_case_after_eval;
2835 return coerce_array (x);
2839 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2840 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2842 case UNOP_MEMVAL_TYPE:
2847 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2848 type = value_type (x);
2849 return value_cast (lookup_pointer_type (type),
2850 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2854 var = exp->elts[pc + 2].symbol;
2856 /* C++: The "address" of a reference should yield the address
2857 * of the object pointed to. Let value_addr() deal with it. */
2858 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
2862 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2865 lookup_pointer_type (SYMBOL_TYPE (var));
2866 enum address_class sym_class = SYMBOL_CLASS (var);
2868 if (sym_class == LOC_CONST
2869 || sym_class == LOC_CONST_BYTES
2870 || sym_class == LOC_REGISTER)
2871 error (_("Attempt to take address of register or constant."));
2874 value_zero (type, not_lval);
2877 return address_of_variable (var, exp->elts[pc + 1].block);
2880 tem = longest_to_int (exp->elts[pc + 2].longconst);
2881 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2882 x = value_aggregate_elt (exp->elts[pc + 1].type,
2883 &exp->elts[pc + 3].string,
2886 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2891 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2892 default_case_after_eval:
2893 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2895 struct type *type = check_typedef (value_type (x));
2897 if (TYPE_CODE (type) == TYPE_CODE_REF)
2898 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2900 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2901 return value_zero (lookup_pointer_type (value_type (x)),
2904 error (_("Attempt to take address of "
2905 "value not located in memory."));
2907 return value_addr (x);
2911 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2912 When used in contexts where arrays will be coerced anyway, this is
2913 equivalent to `evaluate_subexp' but much faster because it avoids
2914 actually fetching array contents (perhaps obsolete now that we have
2917 Note that we currently only do the coercion for C expressions, where
2918 arrays are zero based and the coercion is correct. For other languages,
2919 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2920 to decide if coercion is appropriate. */
2923 evaluate_subexp_with_coercion (struct expression *exp,
2924 int *pos, enum noside noside)
2933 op = exp->elts[pc].opcode;
2938 var = exp->elts[pc + 2].symbol;
2939 type = check_typedef (SYMBOL_TYPE (var));
2940 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
2941 && !TYPE_VECTOR (type)
2942 && CAST_IS_CONVERSION (exp->language_defn))
2945 val = address_of_variable (var, exp->elts[pc + 1].block);
2946 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2952 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2956 /* Evaluate a subexpression of EXP, at index *POS,
2957 and return a value for the size of that subexpression.
2958 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2959 we allow side-effects on the operand if its type is a variable
2962 static struct value *
2963 evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
2966 /* FIXME: This should be size_t. */
2967 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
2974 op = exp->elts[pc].opcode;
2978 /* This case is handled specially
2979 so that we avoid creating a value for the result type.
2980 If the result type is very big, it's desirable not to
2981 create a value unnecessarily. */
2984 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2985 type = check_typedef (value_type (val));
2986 if (TYPE_CODE (type) != TYPE_CODE_PTR
2987 && TYPE_CODE (type) != TYPE_CODE_REF
2988 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
2989 error (_("Attempt to take contents of a non-pointer value."));
2990 type = TYPE_TARGET_TYPE (type);
2991 if (is_dynamic_type (type))
2992 type = value_type (value_ind (val));
2993 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
2997 type = exp->elts[pc + 1].type;
3000 case UNOP_MEMVAL_TYPE:
3002 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3003 type = value_type (val);
3007 type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
3008 if (is_dynamic_type (type))
3010 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3011 type = value_type (val);
3017 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3018 type of the subscript is a variable length array type. In this case we
3019 must re-evaluate the right hand side of the subcription to allow
3021 case BINOP_SUBSCRIPT:
3022 if (noside == EVAL_NORMAL)
3024 int pc = (*pos) + 1;
3026 val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
3027 type = check_typedef (value_type (val));
3028 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3030 type = check_typedef (TYPE_TARGET_TYPE (type));
3031 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3033 type = TYPE_INDEX_TYPE (type);
3034 /* Only re-evaluate the right hand side if the resulting type
3035 is a variable length type. */
3036 if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
3038 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3039 return value_from_longest
3040 (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
3049 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3050 type = value_type (val);
3054 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3055 "When applied to a reference or a reference type, the result is
3056 the size of the referenced type." */
3057 CHECK_TYPEDEF (type);
3058 if (exp->language_defn->la_language == language_cplus
3059 && TYPE_CODE (type) == TYPE_CODE_REF)
3060 type = check_typedef (TYPE_TARGET_TYPE (type));
3061 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3064 /* Parse a type expression in the string [P..P+LENGTH). */
3067 parse_and_eval_type (char *p, int length)
3069 char *tmp = (char *) alloca (length + 4);
3070 struct expression *expr;
3073 memcpy (tmp + 1, p, length);
3074 tmp[length + 1] = ')';
3075 tmp[length + 2] = '0';
3076 tmp[length + 3] = '\0';
3077 expr = parse_expression (tmp);
3078 if (expr->elts[0].opcode != UNOP_CAST)
3079 error (_("Internal error in eval_type."));
3080 return expr->elts[1].type;
3084 calc_f77_array_dims (struct type *array_type)
3087 struct type *tmp_type;
3089 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3090 error (_("Can't get dimensions for a non-array type"));
3092 tmp_type = array_type;
3094 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3096 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)