1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
27 #include "gdbthread.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
29 #include "f-lang.h" /* For array bound stuff. */
32 #include "objc-lang.h"
34 #include "parser-defs.h"
35 #include "cp-support.h"
38 #include "user-regs.h"
40 #include "gdb_obstack.h"
42 #include "typeprint.h"
45 /* This is defined in valops.c */
46 extern int overload_resolution;
48 /* Prototypes for local functions. */
50 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *,
53 static struct value *evaluate_subexp_for_address (struct expression *,
56 static value *evaluate_subexp_for_cast (expression *exp, int *pos,
60 static struct value *evaluate_struct_tuple (struct value *,
61 struct expression *, int *,
64 static LONGEST init_array_element (struct value *, struct value *,
65 struct expression *, int *, enum noside,
69 evaluate_subexp (struct type *expect_type, struct expression *exp,
70 int *pos, enum noside noside)
72 struct cleanup *cleanups;
74 int cleanup_temps = 0;
76 if (*pos == 0 && target_has_execution
77 && exp->language_defn->la_language == language_cplus
78 && !thread_stack_temporaries_enabled_p (inferior_ptid))
80 cleanups = enable_thread_stack_temporaries (inferior_ptid);
84 retval = (*exp->language_defn->la_exp_desc->evaluate_exp)
85 (expect_type, exp, pos, noside);
89 if (value_in_thread_stack_temporaries (retval, inferior_ptid))
90 retval = value_non_lval (retval);
91 do_cleanups (cleanups);
97 /* Parse the string EXP as a C expression, evaluate it,
98 and return the result as a number. */
101 parse_and_eval_address (const char *exp)
103 expression_up expr = parse_expression (exp);
105 return value_as_address (evaluate_expression (expr.get ()));
108 /* Like parse_and_eval_address, but treats the value of the expression
109 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
111 parse_and_eval_long (const char *exp)
113 expression_up expr = parse_expression (exp);
115 return value_as_long (evaluate_expression (expr.get ()));
119 parse_and_eval (const char *exp)
121 expression_up expr = parse_expression (exp);
123 return evaluate_expression (expr.get ());
126 /* Parse up to a comma (or to a closeparen)
127 in the string EXPP as an expression, evaluate it, and return the value.
128 EXPP is advanced to point to the comma. */
131 parse_to_comma_and_eval (const char **expp)
133 expression_up expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
135 return evaluate_expression (expr.get ());
138 /* Evaluate an expression in internal prefix form
139 such as is constructed by parse.y.
141 See expression.h for info on the format of an expression. */
144 evaluate_expression (struct expression *exp)
148 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
151 /* Evaluate an expression, avoiding all memory references
152 and getting a value whose type alone is correct. */
155 evaluate_type (struct expression *exp)
159 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
162 /* Evaluate a subexpression, avoiding all memory references and
163 getting a value whose type alone is correct. */
166 evaluate_subexpression_type (struct expression *exp, int subexp)
168 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
171 /* Find the current value of a watchpoint on EXP. Return the value in
172 *VALP and *RESULTP and the chain of intermediate and final values
173 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
176 If PRESERVE_ERRORS is true, then exceptions are passed through.
177 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
178 occurs while evaluating the expression, *RESULTP will be set to
179 NULL. *RESULTP may be a lazy value, if the result could not be
180 read from memory. It is used to determine whether a value is
181 user-specified (we should watch the whole value) or intermediate
182 (we should watch only the bit used to locate the final value).
184 If the final value, or any intermediate value, could not be read
185 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
186 set to any referenced values. *VALP will never be a lazy value.
187 This is the value which we store in struct breakpoint.
189 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
190 value chain. The caller must free the values individually. If
191 VAL_CHAIN is NULL, all generated values will be left on the value
195 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
196 struct value **resultp, struct value **val_chain,
199 struct value *mark, *new_mark, *result;
207 /* Evaluate the expression. */
208 mark = value_mark ();
213 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
215 CATCH (ex, RETURN_MASK_ALL)
217 /* Ignore memory errors if we want watchpoints pointing at
218 inaccessible memory to still be created; otherwise, throw the
219 error to some higher catcher. */
223 if (!preserve_errors)
226 throw_exception (ex);
232 new_mark = value_mark ();
233 if (mark == new_mark)
238 /* Make sure it's not lazy, so that after the target stops again we
239 have a non-lazy previous value to compare with. */
242 if (!value_lazy (result))
249 value_fetch_lazy (result);
252 CATCH (except, RETURN_MASK_ERROR)
261 /* Return the chain of intermediate values. We use this to
262 decide which addresses to watch. */
263 *val_chain = new_mark;
264 value_release_to_mark (mark);
268 /* Extract a field operation from an expression. If the subexpression
269 of EXP starting at *SUBEXP is not a structure dereference
270 operation, return NULL. Otherwise, return the name of the
271 dereferenced field, and advance *SUBEXP to point to the
272 subexpression of the left-hand-side of the dereference. This is
273 used when completing field names. */
276 extract_field_op (struct expression *exp, int *subexp)
281 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
282 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
284 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
285 result = &exp->elts[*subexp + 2].string;
286 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
290 /* This function evaluates brace-initializers (in C/C++) for
293 static struct value *
294 evaluate_struct_tuple (struct value *struct_val,
295 struct expression *exp,
296 int *pos, enum noside noside, int nargs)
298 struct type *struct_type = check_typedef (value_type (struct_val));
299 struct type *field_type;
304 struct value *val = NULL;
309 /* Skip static fields. */
310 while (fieldno < TYPE_NFIELDS (struct_type)
311 && field_is_static (&TYPE_FIELD (struct_type,
314 if (fieldno >= TYPE_NFIELDS (struct_type))
315 error (_("too many initializers"));
316 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
317 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
318 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
319 error (_("don't know which variant you want to set"));
321 /* Here, struct_type is the type of the inner struct,
322 while substruct_type is the type of the inner struct.
323 These are the same for normal structures, but a variant struct
324 contains anonymous union fields that contain substruct fields.
325 The value fieldno is the index of the top-level (normal or
326 anonymous union) field in struct_field, while the value
327 subfieldno is the index of the actual real (named inner) field
328 in substruct_type. */
330 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
332 val = evaluate_subexp (field_type, exp, pos, noside);
334 /* Now actually set the field in struct_val. */
336 /* Assign val to field fieldno. */
337 if (value_type (val) != field_type)
338 val = value_cast (field_type, val);
340 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
341 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
342 addr = value_contents_writeable (struct_val) + bitpos / 8;
344 modify_field (struct_type, addr,
345 value_as_long (val), bitpos % 8, bitsize);
347 memcpy (addr, value_contents (val),
348 TYPE_LENGTH (value_type (val)));
354 /* Recursive helper function for setting elements of array tuples.
355 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
356 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
357 Evaluates index expresions and sets the specified element(s) of
358 ARRAY to ELEMENT. Returns last index value. */
361 init_array_element (struct value *array, struct value *element,
362 struct expression *exp, int *pos,
363 enum noside noside, LONGEST low_bound, LONGEST high_bound)
366 int element_size = TYPE_LENGTH (value_type (element));
368 if (exp->elts[*pos].opcode == BINOP_COMMA)
371 init_array_element (array, element, exp, pos, noside,
372 low_bound, high_bound);
373 return init_array_element (array, element,
374 exp, pos, noside, low_bound, high_bound);
378 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
379 if (index < low_bound || index > high_bound)
380 error (_("tuple index out of range"));
381 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
382 value_contents (element), element_size);
387 static struct value *
388 value_f90_subarray (struct value *array,
389 struct expression *exp, int *pos, enum noside noside)
392 LONGEST low_bound, high_bound;
393 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
394 enum range_type range_type
395 = (enum range_type) longest_to_int (exp->elts[pc].longconst);
399 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
400 low_bound = TYPE_LOW_BOUND (range);
402 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
404 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
405 high_bound = TYPE_HIGH_BOUND (range);
407 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
409 return value_slice (array, low_bound, high_bound - low_bound + 1);
413 /* Promote value ARG1 as appropriate before performing a unary operation
415 If the result is not appropriate for any particular language then it
416 needs to patch this function. */
419 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
424 *arg1 = coerce_ref (*arg1);
425 type1 = check_typedef (value_type (*arg1));
427 if (is_integral_type (type1))
429 switch (language->la_language)
432 /* Perform integral promotion for ANSI C/C++.
433 If not appropropriate for any particular language
434 it needs to modify this function. */
436 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
438 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
439 *arg1 = value_cast (builtin_int, *arg1);
446 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
447 operation on those two operands.
448 If the result is not appropriate for any particular language then it
449 needs to patch this function. */
452 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
453 struct value **arg1, struct value **arg2)
455 struct type *promoted_type = NULL;
459 *arg1 = coerce_ref (*arg1);
460 *arg2 = coerce_ref (*arg2);
462 type1 = check_typedef (value_type (*arg1));
463 type2 = check_typedef (value_type (*arg2));
465 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
466 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
467 && !is_integral_type (type1))
468 || (TYPE_CODE (type2) != TYPE_CODE_FLT
469 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
470 && !is_integral_type (type2)))
473 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
474 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
476 /* No promotion required. */
478 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
479 || TYPE_CODE (type2) == TYPE_CODE_FLT)
481 switch (language->la_language)
487 case language_opencl:
488 /* No promotion required. */
492 /* For other languages the result type is unchanged from gdb
493 version 6.7 for backward compatibility.
494 If either arg was long double, make sure that value is also long
495 double. Otherwise use double. */
496 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
497 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
498 promoted_type = builtin_type (gdbarch)->builtin_long_double;
500 promoted_type = builtin_type (gdbarch)->builtin_double;
504 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
505 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
507 /* No promotion required. */
510 /* Integral operations here. */
511 /* FIXME: Also mixed integral/booleans, with result an integer. */
513 const struct builtin_type *builtin = builtin_type (gdbarch);
514 unsigned int promoted_len1 = TYPE_LENGTH (type1);
515 unsigned int promoted_len2 = TYPE_LENGTH (type2);
516 int is_unsigned1 = TYPE_UNSIGNED (type1);
517 int is_unsigned2 = TYPE_UNSIGNED (type2);
518 unsigned int result_len;
519 int unsigned_operation;
521 /* Determine type length and signedness after promotion for
523 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
526 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
528 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
531 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
534 if (promoted_len1 > promoted_len2)
536 unsigned_operation = is_unsigned1;
537 result_len = promoted_len1;
539 else if (promoted_len2 > promoted_len1)
541 unsigned_operation = is_unsigned2;
542 result_len = promoted_len2;
546 unsigned_operation = is_unsigned1 || is_unsigned2;
547 result_len = promoted_len1;
550 switch (language->la_language)
556 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
558 promoted_type = (unsigned_operation
559 ? builtin->builtin_unsigned_int
560 : builtin->builtin_int);
562 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
564 promoted_type = (unsigned_operation
565 ? builtin->builtin_unsigned_long
566 : builtin->builtin_long);
570 promoted_type = (unsigned_operation
571 ? builtin->builtin_unsigned_long_long
572 : builtin->builtin_long_long);
575 case language_opencl:
576 if (result_len <= TYPE_LENGTH (lookup_signed_typename
577 (language, gdbarch, "int")))
581 ? lookup_unsigned_typename (language, gdbarch, "int")
582 : lookup_signed_typename (language, gdbarch, "int"));
584 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
585 (language, gdbarch, "long")))
589 ? lookup_unsigned_typename (language, gdbarch, "long")
590 : lookup_signed_typename (language, gdbarch,"long"));
594 /* For other languages the result type is unchanged from gdb
595 version 6.7 for backward compatibility.
596 If either arg was long long, make sure that value is also long
597 long. Otherwise use long. */
598 if (unsigned_operation)
600 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
601 promoted_type = builtin->builtin_unsigned_long_long;
603 promoted_type = builtin->builtin_unsigned_long;
607 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
608 promoted_type = builtin->builtin_long_long;
610 promoted_type = builtin->builtin_long;
618 /* Promote both operands to common type. */
619 *arg1 = value_cast (promoted_type, *arg1);
620 *arg2 = value_cast (promoted_type, *arg2);
625 ptrmath_type_p (const struct language_defn *lang, struct type *type)
627 type = check_typedef (type);
628 if (TYPE_IS_REFERENCE (type))
629 type = TYPE_TARGET_TYPE (type);
631 switch (TYPE_CODE (type))
637 case TYPE_CODE_ARRAY:
638 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
645 /* Constructs a fake method with the given parameter types.
646 This function is used by the parser to construct an "expected"
647 type for method overload resolution. */
650 make_params (int num_types, struct type **param_types)
652 struct type *type = XCNEW (struct type);
653 TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
654 TYPE_LENGTH (type) = 1;
655 TYPE_CODE (type) = TYPE_CODE_METHOD;
656 TYPE_CHAIN (type) = type;
659 if (param_types[num_types - 1] == NULL)
662 TYPE_VARARGS (type) = 1;
664 else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
668 /* Caller should have ensured this. */
669 gdb_assert (num_types == 0);
670 TYPE_PROTOTYPED (type) = 1;
674 TYPE_NFIELDS (type) = num_types;
675 TYPE_FIELDS (type) = (struct field *)
676 TYPE_ZALLOC (type, sizeof (struct field) * num_types);
678 while (num_types-- > 0)
679 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
684 /* Helper for evaluating an OP_VAR_VALUE. */
687 evaluate_var_value (enum noside noside, const block *blk, symbol *var)
689 /* JYG: We used to just return value_zero of the symbol type if
690 we're asked to avoid side effects. Otherwise we return
691 value_of_variable (...). However I'm not sure if
692 value_of_variable () has any side effect. We need a full value
693 object returned here for whatis_exp () to call evaluate_type ()
694 and then pass the full value to value_rtti_target_type () if we
695 are dealing with a pointer or reference to a base class and print
698 struct value *ret = NULL;
702 ret = value_of_variable (var, blk);
705 CATCH (except, RETURN_MASK_ERROR)
707 if (noside != EVAL_AVOID_SIDE_EFFECTS)
708 throw_exception (except);
710 ret = value_zero (SYMBOL_TYPE (var), not_lval);
717 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
720 evaluate_var_msym_value (enum noside noside,
721 struct objfile *objfile, minimal_symbol *msymbol)
723 if (noside == EVAL_AVOID_SIDE_EFFECTS)
725 type *the_type = find_minsym_type_and_address (msymbol, objfile, NULL);
726 return value_zero (the_type, not_lval);
731 type *the_type = find_minsym_type_and_address (msymbol, objfile, &address);
732 return value_at_lazy (the_type, address);
736 /* Helper for returning a value when handling EVAL_SKIP. */
739 eval_skip_value (expression *exp)
741 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
745 evaluate_subexp_standard (struct type *expect_type,
746 struct expression *exp, int *pos,
751 int pc, pc2 = 0, oldpos;
752 struct value *arg1 = NULL;
753 struct value *arg2 = NULL;
757 struct value **argvec;
761 struct type **arg_types;
763 struct symbol *function = NULL;
764 char *function_name = NULL;
765 const char *var_func_name = NULL;
768 op = exp->elts[pc].opcode;
773 tem = longest_to_int (exp->elts[pc + 2].longconst);
774 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
775 if (noside == EVAL_SKIP)
776 return eval_skip_value (exp);
777 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
778 &exp->elts[pc + 3].string,
779 expect_type, 0, noside);
781 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
786 return value_from_longest (exp->elts[pc + 1].type,
787 exp->elts[pc + 2].longconst);
791 return value_from_double (exp->elts[pc + 1].type,
792 exp->elts[pc + 2].doubleconst);
796 return value_from_decfloat (exp->elts[pc + 1].type,
797 exp->elts[pc + 2].decfloatconst);
802 if (noside == EVAL_SKIP)
803 return eval_skip_value (exp);
806 symbol *var = exp->elts[pc + 2].symbol;
807 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR)
808 error_unknown_type (SYMBOL_PRINT_NAME (var));
810 return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
813 case OP_VAR_MSYM_VALUE:
817 minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
818 value *val = evaluate_var_msym_value (noside,
819 exp->elts[pc + 1].objfile,
822 type = value_type (val);
823 if (TYPE_CODE (type) == TYPE_CODE_ERROR
824 && (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0))
825 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
829 case OP_VAR_ENTRY_VALUE:
831 if (noside == EVAL_SKIP)
832 return eval_skip_value (exp);
835 struct symbol *sym = exp->elts[pc + 1].symbol;
836 struct frame_info *frame;
838 if (noside == EVAL_AVOID_SIDE_EFFECTS)
839 return value_zero (SYMBOL_TYPE (sym), not_lval);
841 if (SYMBOL_COMPUTED_OPS (sym) == NULL
842 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
843 error (_("Symbol \"%s\" does not have any specific entry value"),
844 SYMBOL_PRINT_NAME (sym));
846 frame = get_selected_frame (NULL);
847 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
853 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
857 const char *name = &exp->elts[pc + 2].string;
861 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
862 regno = user_reg_map_name_to_regnum (exp->gdbarch,
863 name, strlen (name));
865 error (_("Register $%s not available."), name);
867 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
868 a value with the appropriate register type. Unfortunately,
869 we don't have easy access to the type of user registers.
870 So for these registers, we fetch the register value regardless
871 of the evaluation mode. */
872 if (noside == EVAL_AVOID_SIDE_EFFECTS
873 && regno < gdbarch_num_regs (exp->gdbarch)
874 + gdbarch_num_pseudo_regs (exp->gdbarch))
875 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
877 val = value_of_register (regno, get_selected_frame (NULL));
879 error (_("Value of register %s not available."), name);
885 type = language_bool_type (exp->language_defn, exp->gdbarch);
886 return value_from_longest (type, exp->elts[pc + 1].longconst);
890 return value_of_internalvar (exp->gdbarch,
891 exp->elts[pc + 1].internalvar);
894 tem = longest_to_int (exp->elts[pc + 1].longconst);
895 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
896 if (noside == EVAL_SKIP)
897 return eval_skip_value (exp);
898 type = language_string_char_type (exp->language_defn, exp->gdbarch);
899 return value_string (&exp->elts[pc + 2].string, tem, type);
901 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
902 NSString constant. */
903 tem = longest_to_int (exp->elts[pc + 1].longconst);
904 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
905 if (noside == EVAL_SKIP)
906 return eval_skip_value (exp);
907 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
911 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
912 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
913 nargs = tem3 - tem2 + 1;
914 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
916 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
917 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
919 struct value *rec = allocate_value (expect_type);
921 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
922 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
925 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
926 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
928 struct type *range_type = TYPE_INDEX_TYPE (type);
929 struct type *element_type = TYPE_TARGET_TYPE (type);
930 struct value *array = allocate_value (expect_type);
931 int element_size = TYPE_LENGTH (check_typedef (element_type));
932 LONGEST low_bound, high_bound, index;
934 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
937 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
940 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
941 for (tem = nargs; --nargs >= 0;)
943 struct value *element;
946 element = evaluate_subexp (element_type, exp, pos, noside);
947 if (value_type (element) != element_type)
948 element = value_cast (element_type, element);
951 int continue_pc = *pos;
954 index = init_array_element (array, element, exp, pos, noside,
955 low_bound, high_bound);
960 if (index > high_bound)
961 /* To avoid memory corruption. */
962 error (_("Too many array elements"));
963 memcpy (value_contents_raw (array)
964 + (index - low_bound) * element_size,
965 value_contents (element),
973 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
974 && TYPE_CODE (type) == TYPE_CODE_SET)
976 struct value *set = allocate_value (expect_type);
977 gdb_byte *valaddr = value_contents_raw (set);
978 struct type *element_type = TYPE_INDEX_TYPE (type);
979 struct type *check_type = element_type;
980 LONGEST low_bound, high_bound;
982 /* Get targettype of elementtype. */
983 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
984 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
985 check_type = TYPE_TARGET_TYPE (check_type);
987 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
988 error (_("(power)set type with unknown size"));
989 memset (valaddr, '\0', TYPE_LENGTH (type));
990 for (tem = 0; tem < nargs; tem++)
992 LONGEST range_low, range_high;
993 struct type *range_low_type, *range_high_type;
994 struct value *elem_val;
996 elem_val = evaluate_subexp (element_type, exp, pos, noside);
997 range_low_type = range_high_type = value_type (elem_val);
998 range_low = range_high = value_as_long (elem_val);
1000 /* Check types of elements to avoid mixture of elements from
1001 different types. Also check if type of element is "compatible"
1002 with element type of powerset. */
1003 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
1004 range_low_type = TYPE_TARGET_TYPE (range_low_type);
1005 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
1006 range_high_type = TYPE_TARGET_TYPE (range_high_type);
1007 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
1008 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
1009 && (range_low_type != range_high_type)))
1010 /* different element modes. */
1011 error (_("POWERSET tuple elements of different mode"));
1012 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
1013 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
1014 && range_low_type != check_type))
1015 error (_("incompatible POWERSET tuple elements"));
1016 if (range_low > range_high)
1018 warning (_("empty POWERSET tuple range"));
1021 if (range_low < low_bound || range_high > high_bound)
1022 error (_("POWERSET tuple element out of range"));
1023 range_low -= low_bound;
1024 range_high -= low_bound;
1025 for (; range_low <= range_high; range_low++)
1027 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
1029 if (gdbarch_bits_big_endian (exp->gdbarch))
1030 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
1031 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1038 argvec = XALLOCAVEC (struct value *, nargs);
1039 for (tem = 0; tem < nargs; tem++)
1041 /* Ensure that array expressions are coerced into pointer
1043 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1045 if (noside == EVAL_SKIP)
1046 return eval_skip_value (exp);
1047 return value_array (tem2, tem3, argvec);
1051 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1053 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1055 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1057 if (noside == EVAL_SKIP)
1058 return eval_skip_value (exp);
1059 return value_slice (array, lowbound, upper - lowbound + 1);
1063 /* Skip third and second args to evaluate the first one. */
1064 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1065 if (value_logical_not (arg1))
1067 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1068 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1072 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1073 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1077 case OP_OBJC_SELECTOR:
1078 { /* Objective C @selector operator. */
1079 char *sel = &exp->elts[pc + 2].string;
1080 int len = longest_to_int (exp->elts[pc + 1].longconst);
1081 struct type *selector_type;
1083 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1084 if (noside == EVAL_SKIP)
1085 return eval_skip_value (exp);
1088 sel[len] = 0; /* Make sure it's terminated. */
1090 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1091 return value_from_longest (selector_type,
1092 lookup_child_selector (exp->gdbarch, sel));
1095 case OP_OBJC_MSGCALL:
1096 { /* Objective C message (method) call. */
1098 CORE_ADDR responds_selector = 0;
1099 CORE_ADDR method_selector = 0;
1101 CORE_ADDR selector = 0;
1103 int struct_return = 0;
1104 enum noside sub_no_side = EVAL_NORMAL;
1106 struct value *msg_send = NULL;
1107 struct value *msg_send_stret = NULL;
1108 int gnu_runtime = 0;
1110 struct value *target = NULL;
1111 struct value *method = NULL;
1112 struct value *called_method = NULL;
1114 struct type *selector_type = NULL;
1115 struct type *long_type;
1117 struct value *ret = NULL;
1120 selector = exp->elts[pc + 1].longconst;
1121 nargs = exp->elts[pc + 2].longconst;
1122 argvec = XALLOCAVEC (struct value *, nargs + 5);
1126 long_type = builtin_type (exp->gdbarch)->builtin_long;
1127 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1129 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1130 sub_no_side = EVAL_NORMAL;
1132 sub_no_side = noside;
1134 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1136 if (value_as_long (target) == 0)
1137 return value_from_longest (long_type, 0);
1139 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
1142 /* Find the method dispatch (Apple runtime) or method lookup
1143 (GNU runtime) function for Objective-C. These will be used
1144 to lookup the symbol information for the method. If we
1145 can't find any symbol information, then we'll use these to
1146 call the method, otherwise we can call the method
1147 directly. The msg_send_stret function is used in the special
1148 case of a method that returns a structure (Apple runtime
1152 struct type *type = selector_type;
1154 type = lookup_function_type (type);
1155 type = lookup_pointer_type (type);
1156 type = lookup_function_type (type);
1157 type = lookup_pointer_type (type);
1159 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1161 = find_function_in_inferior ("objc_msg_lookup", NULL);
1163 msg_send = value_from_pointer (type, value_as_address (msg_send));
1164 msg_send_stret = value_from_pointer (type,
1165 value_as_address (msg_send_stret));
1169 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1170 /* Special dispatcher for methods returning structs. */
1172 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1175 /* Verify the target object responds to this method. The
1176 standard top-level 'Object' class uses a different name for
1177 the verification method than the non-standard, but more
1178 often used, 'NSObject' class. Make sure we check for both. */
1181 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1182 if (responds_selector == 0)
1184 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1186 if (responds_selector == 0)
1187 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1190 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1191 if (method_selector == 0)
1193 = lookup_child_selector (exp->gdbarch, "methodFor:");
1195 if (method_selector == 0)
1196 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1198 /* Call the verification method, to make sure that the target
1199 class implements the desired method. */
1201 argvec[0] = msg_send;
1203 argvec[2] = value_from_longest (long_type, responds_selector);
1204 argvec[3] = value_from_longest (long_type, selector);
1207 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1210 /* Function objc_msg_lookup returns a pointer. */
1212 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1214 if (value_as_long (ret) == 0)
1215 error (_("Target does not respond to this message selector."));
1217 /* Call "methodForSelector:" method, to get the address of a
1218 function method that implements this selector for this
1219 class. If we can find a symbol at that address, then we
1220 know the return type, parameter types etc. (that's a good
1223 argvec[0] = msg_send;
1225 argvec[2] = value_from_longest (long_type, method_selector);
1226 argvec[3] = value_from_longest (long_type, selector);
1229 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1233 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1236 /* ret should now be the selector. */
1238 addr = value_as_long (ret);
1241 struct symbol *sym = NULL;
1243 /* The address might point to a function descriptor;
1244 resolve it to the actual code address instead. */
1245 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1248 /* Is it a high_level symbol? */
1249 sym = find_pc_function (addr);
1251 method = value_of_variable (sym, 0);
1254 /* If we found a method with symbol information, check to see
1255 if it returns a struct. Otherwise assume it doesn't. */
1260 struct type *val_type;
1262 funaddr = find_function_addr (method, &val_type);
1264 block_for_pc (funaddr);
1266 val_type = check_typedef (val_type);
1268 if ((val_type == NULL)
1269 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1271 if (expect_type != NULL)
1272 val_type = expect_type;
1275 struct_return = using_struct_return (exp->gdbarch, method,
1278 else if (expect_type != NULL)
1280 struct_return = using_struct_return (exp->gdbarch, NULL,
1281 check_typedef (expect_type));
1284 /* Found a function symbol. Now we will substitute its
1285 value in place of the message dispatcher (obj_msgSend),
1286 so that we call the method directly instead of thru
1287 the dispatcher. The main reason for doing this is that
1288 we can now evaluate the return value and parameter values
1289 according to their known data types, in case we need to
1290 do things like promotion, dereferencing, special handling
1291 of structs and doubles, etc.
1293 We want to use the type signature of 'method', but still
1294 jump to objc_msgSend() or objc_msgSend_stret() to better
1295 mimic the behavior of the runtime. */
1299 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1300 error (_("method address has symbol information "
1301 "with non-function type; skipping"));
1303 /* Create a function pointer of the appropriate type, and
1304 replace its value with the value of msg_send or
1305 msg_send_stret. We must use a pointer here, as
1306 msg_send and msg_send_stret are of pointer type, and
1307 the representation may be different on systems that use
1308 function descriptors. */
1311 = value_from_pointer (lookup_pointer_type (value_type (method)),
1312 value_as_address (msg_send_stret));
1315 = value_from_pointer (lookup_pointer_type (value_type (method)),
1316 value_as_address (msg_send));
1321 called_method = msg_send_stret;
1323 called_method = msg_send;
1326 if (noside == EVAL_SKIP)
1327 return eval_skip_value (exp);
1329 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1331 /* If the return type doesn't look like a function type,
1332 call an error. This can happen if somebody tries to
1333 turn a variable into a function call. This is here
1334 because people often want to call, eg, strcmp, which
1335 gdb doesn't know is a function. If gdb isn't asked for
1336 it's opinion (ie. through "whatis"), it won't offer
1339 struct type *type = value_type (called_method);
1341 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1342 type = TYPE_TARGET_TYPE (type);
1343 type = TYPE_TARGET_TYPE (type);
1347 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1348 return allocate_value (expect_type);
1350 return allocate_value (type);
1353 error (_("Expression of type other than "
1354 "\"method returning ...\" used as a method"));
1357 /* Now depending on whether we found a symbol for the method,
1358 we will either call the runtime dispatcher or the method
1361 argvec[0] = called_method;
1363 argvec[2] = value_from_longest (long_type, selector);
1364 /* User-supplied arguments. */
1365 for (tem = 0; tem < nargs; tem++)
1366 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1367 argvec[tem + 3] = 0;
1369 if (gnu_runtime && (method != NULL))
1371 /* Function objc_msg_lookup returns a pointer. */
1372 deprecated_set_value_type (argvec[0],
1373 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1375 = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
1378 ret = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
1385 op = exp->elts[*pos].opcode;
1386 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1387 /* Allocate arg vector, including space for the function to be
1388 called in argvec[0], a potential `this', and a terminating NULL. */
1389 argvec = (struct value **)
1390 alloca (sizeof (struct value *) * (nargs + 3));
1391 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1393 /* First, evaluate the structure into arg2. */
1396 if (op == STRUCTOP_MEMBER)
1398 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1402 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1405 /* If the function is a virtual function, then the
1406 aggregate value (providing the structure) plays
1407 its part by providing the vtable. Otherwise,
1408 it is just along for the ride: call the function
1411 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1413 type = check_typedef (value_type (arg1));
1414 if (noside == EVAL_SKIP)
1415 tem = 1; /* Set it to the right arg index so that all arguments
1416 can also be skipped. */
1417 else if (TYPE_CODE (type) == TYPE_CODE_METHODPTR)
1419 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1420 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval);
1422 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1424 /* Now, say which argument to start evaluating from. */
1429 else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
1431 struct type *type_ptr
1432 = lookup_pointer_type (TYPE_SELF_TYPE (type));
1433 struct type *target_type_ptr
1434 = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1436 /* Now, convert these values to an address. */
1437 arg2 = value_cast (type_ptr, arg2);
1439 mem_offset = value_as_long (arg1);
1441 arg1 = value_from_pointer (target_type_ptr,
1442 value_as_long (arg2) + mem_offset);
1443 arg1 = value_ind (arg1);
1447 error (_("Non-pointer-to-member value used in pointer-to-member "
1450 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1452 /* Hair for method invocations. */
1456 /* First, evaluate the structure into arg2. */
1458 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1459 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1461 if (op == STRUCTOP_STRUCT)
1463 /* If v is a variable in a register, and the user types
1464 v.method (), this will produce an error, because v has
1467 A possible way around this would be to allocate a
1468 copy of the variable on the stack, copy in the
1469 contents, call the function, and copy out the
1470 contents. I.e. convert this from call by reference
1471 to call by copy-return (or whatever it's called).
1472 However, this does not work because it is not the
1473 same: the method being called could stash a copy of
1474 the address, and then future uses through that address
1475 (after the method returns) would be expected to
1476 use the variable itself, not some copy of it. */
1477 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1481 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1483 /* Check to see if the operator '->' has been
1484 overloaded. If the operator has been overloaded
1485 replace arg2 with the value returned by the custom
1486 operator and continue evaluation. */
1487 while (unop_user_defined_p (op, arg2))
1489 struct value *value = NULL;
1492 value = value_x_unop (arg2, op, noside);
1495 CATCH (except, RETURN_MASK_ERROR)
1497 if (except.error == NOT_FOUND_ERROR)
1500 throw_exception (except);
1507 /* Now, say which argument to start evaluating from. */
1510 else if (op == OP_SCOPE
1511 && overload_resolution
1512 && (exp->language_defn->la_language == language_cplus))
1514 /* Unpack it locally so we can properly handle overload
1520 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
1521 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
1522 type = exp->elts[pc2 + 1].type;
1523 name = &exp->elts[pc2 + 3].string;
1526 function_name = NULL;
1527 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
1529 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
1531 get_selected_block (0),
1533 if (function == NULL)
1534 error (_("No symbol \"%s\" in namespace \"%s\"."),
1535 name, TYPE_TAG_NAME (type));
1538 /* arg2 is left as NULL on purpose. */
1542 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1543 || TYPE_CODE (type) == TYPE_CODE_UNION);
1544 function_name = name;
1546 /* We need a properly typed value for method lookup. For
1547 static methods arg2 is otherwise unused. */
1548 arg2 = value_zero (type, lval_memory);
1553 else if (op == OP_ADL_FUNC)
1555 /* Save the function position and move pos so that the arguments
1556 can be evaluated. */
1562 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1563 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1567 /* Non-method function call. */
1571 /* If this is a C++ function wait until overload resolution. */
1572 if (op == OP_VAR_VALUE
1573 && overload_resolution
1574 && (exp->language_defn->la_language == language_cplus))
1576 (*pos) += 4; /* Skip the evaluation of the symbol. */
1581 if (op == OP_VAR_MSYM_VALUE)
1583 symbol *sym = exp->elts[*pos + 2].symbol;
1584 var_func_name = SYMBOL_PRINT_NAME (sym);
1586 else if (op == OP_VAR_VALUE)
1588 minimal_symbol *msym = exp->elts[*pos + 2].msymbol;
1589 var_func_name = MSYMBOL_PRINT_NAME (msym);
1592 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1593 type = value_type (argvec[0]);
1594 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1595 type = TYPE_TARGET_TYPE (type);
1596 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1598 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1600 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1608 /* Evaluate arguments (if not already done, e.g., namespace::func()
1609 and overload-resolution is off). */
1610 for (; tem <= nargs; tem++)
1612 /* Ensure that array expressions are coerced into pointer
1614 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1617 /* Signal end of arglist. */
1620 if (noside == EVAL_SKIP)
1621 return eval_skip_value (exp);
1623 if (op == OP_ADL_FUNC)
1625 struct symbol *symp;
1628 int string_pc = save_pos1 + 3;
1630 /* Extract the function name. */
1631 name_len = longest_to_int (exp->elts[string_pc].longconst);
1632 func_name = (char *) alloca (name_len + 1);
1633 strcpy (func_name, &exp->elts[string_pc + 1].string);
1635 find_overload_match (&argvec[1], nargs, func_name,
1636 NON_METHOD, /* not method */
1637 NULL, NULL, /* pass NULL symbol since
1638 symbol is unknown */
1639 NULL, &symp, NULL, 0, noside);
1641 /* Now fix the expression being evaluated. */
1642 exp->elts[save_pos1 + 2].symbol = symp;
1643 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1646 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1647 || (op == OP_SCOPE && function_name != NULL))
1649 int static_memfuncp;
1652 /* Method invocation: stuff "this" as first parameter.
1653 If the method turns out to be static we undo this below. */
1658 /* Name of method from expression. */
1659 tstr = &exp->elts[pc2 + 2].string;
1662 tstr = function_name;
1664 if (overload_resolution && (exp->language_defn->la_language
1667 /* Language is C++, do some overload resolution before
1669 struct value *valp = NULL;
1671 (void) find_overload_match (&argvec[1], nargs, tstr,
1672 METHOD, /* method */
1673 &arg2, /* the object */
1675 &static_memfuncp, 0, noside);
1677 if (op == OP_SCOPE && !static_memfuncp)
1679 /* For the time being, we don't handle this. */
1680 error (_("Call to overloaded function %s requires "
1684 argvec[1] = arg2; /* the ``this'' pointer */
1685 argvec[0] = valp; /* Use the method found after overload
1689 /* Non-C++ case -- or no overload resolution. */
1691 struct value *temp = arg2;
1693 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1695 op == STRUCTOP_STRUCT
1696 ? "structure" : "structure pointer");
1697 /* value_struct_elt updates temp with the correct value
1698 of the ``this'' pointer if necessary, so modify argvec[1] to
1699 reflect any ``this'' changes. */
1701 = value_from_longest (lookup_pointer_type(value_type (temp)),
1702 value_address (temp)
1703 + value_embedded_offset (temp));
1704 argvec[1] = arg2; /* the ``this'' pointer */
1707 /* Take out `this' if needed. */
1708 if (static_memfuncp)
1710 argvec[1] = argvec[0];
1715 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1717 /* Pointer to member. argvec[1] is already set up. */
1720 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1722 /* Non-member function being called. */
1723 /* fn: This can only be done for C++ functions. A C-style function
1724 in a C++ program, for instance, does not have the fields that
1725 are expected here. */
1727 if (overload_resolution && (exp->language_defn->la_language
1730 /* Language is C++, do some overload resolution before
1732 struct symbol *symp;
1735 /* If a scope has been specified disable ADL. */
1739 if (op == OP_VAR_VALUE)
1740 function = exp->elts[save_pos1+2].symbol;
1742 (void) find_overload_match (&argvec[1], nargs,
1743 NULL, /* no need for name */
1744 NON_METHOD, /* not method */
1745 NULL, function, /* the function */
1746 NULL, &symp, NULL, no_adl, noside);
1748 if (op == OP_VAR_VALUE)
1750 /* Now fix the expression being evaluated. */
1751 exp->elts[save_pos1+2].symbol = symp;
1752 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1756 argvec[0] = value_of_variable (symp, get_selected_block (0));
1760 /* Not C++, or no overload resolution allowed. */
1761 /* Nothing to be done; argvec already correctly set up. */
1766 /* It is probably a C-style function. */
1767 /* Nothing to be done; argvec already correctly set up. */
1772 if (argvec[0] == NULL)
1773 error (_("Cannot evaluate function -- may be inlined"));
1774 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1776 /* If the return type doesn't look like a function type,
1777 call an error. This can happen if somebody tries to turn
1778 a variable into a function call. */
1780 struct type *ftype = value_type (argvec[0]);
1782 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
1784 /* We don't know anything about what the internal
1785 function might return, but we have to return
1787 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
1790 else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
1792 struct type *return_type
1793 = result_type_of_xmethod (argvec[0], nargs, argvec + 1);
1795 if (return_type == NULL)
1796 error (_("Xmethod is missing return type."));
1797 return value_zero (return_type, not_lval);
1799 else if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
1800 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
1802 struct type *return_type = TYPE_TARGET_TYPE (ftype);
1804 if (return_type == NULL)
1805 return_type = expect_type;
1807 if (return_type == NULL)
1808 error_call_unknown_return_type (var_func_name);
1810 return allocate_value (return_type);
1813 error (_("Expression of type other than "
1814 "\"Function returning ...\" used as function"));
1816 switch (TYPE_CODE (value_type (argvec[0])))
1818 case TYPE_CODE_INTERNAL_FUNCTION:
1819 return call_internal_function (exp->gdbarch, exp->language_defn,
1820 argvec[0], nargs, argvec + 1);
1821 case TYPE_CODE_XMETHOD:
1822 return call_xmethod (argvec[0], nargs, argvec + 1);
1824 return call_function_by_hand (argvec[0],
1825 expect_type, nargs, argvec + 1);
1827 /* pai: FIXME save value from call_function_by_hand, then adjust
1828 pc by adjust_fn_pc if +ve. */
1830 case OP_F77_UNDETERMINED_ARGLIST:
1832 /* Remember that in F77, functions, substring ops and
1833 array subscript operations cannot be disambiguated
1834 at parse time. We have made all array subscript operations,
1835 substring operations as well as function calls come here
1836 and we now have to discover what the heck this thing actually was.
1837 If it is a function, we process just as if we got an OP_FUNCALL. */
1839 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1842 /* First determine the type code we are dealing with. */
1843 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1844 type = check_typedef (value_type (arg1));
1845 code = TYPE_CODE (type);
1847 if (code == TYPE_CODE_PTR)
1849 /* Fortran always passes variable to subroutines as pointer.
1850 So we need to look into its target type to see if it is
1851 array, string or function. If it is, we need to switch
1852 to the target value the original one points to. */
1853 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1855 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1856 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1857 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1859 arg1 = value_ind (arg1);
1860 type = check_typedef (value_type (arg1));
1861 code = TYPE_CODE (type);
1867 case TYPE_CODE_ARRAY:
1868 if (exp->elts[*pos].opcode == OP_RANGE)
1869 return value_f90_subarray (arg1, exp, pos, noside);
1871 goto multi_f77_subscript;
1873 case TYPE_CODE_STRING:
1874 if (exp->elts[*pos].opcode == OP_RANGE)
1875 return value_f90_subarray (arg1, exp, pos, noside);
1878 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1879 return value_subscript (arg1, value_as_long (arg2));
1883 case TYPE_CODE_FUNC:
1884 /* It's a function call. */
1885 /* Allocate arg vector, including space for the function to be
1886 called in argvec[0] and a terminating NULL. */
1887 argvec = (struct value **)
1888 alloca (sizeof (struct value *) * (nargs + 2));
1891 for (; tem <= nargs; tem++)
1892 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1893 argvec[tem] = 0; /* signal end of arglist */
1894 if (noside == EVAL_SKIP)
1895 return eval_skip_value (exp);
1899 error (_("Cannot perform substring on this type"));
1903 /* We have a complex number, There should be 2 floating
1904 point numbers that compose it. */
1906 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1907 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1909 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1911 case STRUCTOP_STRUCT:
1912 tem = longest_to_int (exp->elts[pc + 1].longconst);
1913 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1914 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1915 if (noside == EVAL_SKIP)
1916 return eval_skip_value (exp);
1917 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1919 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1920 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
1924 tem = longest_to_int (exp->elts[pc + 1].longconst);
1925 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1926 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1927 if (noside == EVAL_SKIP)
1928 return eval_skip_value (exp);
1930 /* Check to see if operator '->' has been overloaded. If so replace
1931 arg1 with the value returned by evaluating operator->(). */
1932 while (unop_user_defined_p (op, arg1))
1934 struct value *value = NULL;
1937 value = value_x_unop (arg1, op, noside);
1940 CATCH (except, RETURN_MASK_ERROR)
1942 if (except.error == NOT_FOUND_ERROR)
1945 throw_exception (except);
1952 /* JYG: if print object is on we need to replace the base type
1953 with rtti type in order to continue on with successful
1954 lookup of member / method only available in the rtti type. */
1956 struct type *type = value_type (arg1);
1957 struct type *real_type;
1958 int full, using_enc;
1960 struct value_print_options opts;
1962 get_user_print_options (&opts);
1963 if (opts.objectprint && TYPE_TARGET_TYPE(type)
1964 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
1966 real_type = value_rtti_indirect_type (arg1, &full, &top,
1969 arg1 = value_cast (real_type, arg1);
1973 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1974 NULL, "structure pointer");
1975 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1976 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
1979 case STRUCTOP_MEMBER:
1981 if (op == STRUCTOP_MEMBER)
1982 arg1 = evaluate_subexp_for_address (exp, pos, noside);
1984 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1986 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1988 if (noside == EVAL_SKIP)
1989 return eval_skip_value (exp);
1991 type = check_typedef (value_type (arg2));
1992 switch (TYPE_CODE (type))
1994 case TYPE_CODE_METHODPTR:
1995 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1996 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1999 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
2000 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
2001 return value_ind (arg2);
2004 case TYPE_CODE_MEMBERPTR:
2005 /* Now, convert these values to an address. */
2006 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
2009 mem_offset = value_as_long (arg2);
2011 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2012 value_as_long (arg1) + mem_offset);
2013 return value_ind (arg3);
2016 error (_("non-pointer-to-member value used "
2017 "in pointer-to-member construct"));
2021 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2022 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
2023 for (ix = 0; ix < nargs; ++ix)
2024 arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
2026 expect_type = make_params (nargs, arg_types);
2027 *(pos) += 3 + nargs;
2028 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
2029 xfree (TYPE_FIELDS (expect_type));
2030 xfree (TYPE_MAIN_TYPE (expect_type));
2031 xfree (expect_type);
2035 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2036 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2037 if (noside == EVAL_SKIP)
2038 return eval_skip_value (exp);
2039 if (binop_user_defined_p (op, arg1, arg2))
2040 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2042 return value_concat (arg1, arg2);
2045 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2046 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2048 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2050 if (binop_user_defined_p (op, arg1, arg2))
2051 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2053 return value_assign (arg1, arg2);
2055 case BINOP_ASSIGN_MODIFY:
2057 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2058 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2059 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2061 op = exp->elts[pc + 1].opcode;
2062 if (binop_user_defined_p (op, arg1, arg2))
2063 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
2064 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2066 && is_integral_type (value_type (arg2)))
2067 arg2 = value_ptradd (arg1, value_as_long (arg2));
2068 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2070 && is_integral_type (value_type (arg2)))
2071 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2074 struct value *tmp = arg1;
2076 /* For shift and integer exponentiation operations,
2077 only promote the first argument. */
2078 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2079 && is_integral_type (value_type (arg2)))
2080 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2082 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2084 arg2 = value_binop (tmp, arg2, op);
2086 return value_assign (arg1, arg2);
2089 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2090 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2091 if (noside == EVAL_SKIP)
2092 return eval_skip_value (exp);
2093 if (binop_user_defined_p (op, arg1, arg2))
2094 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2095 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2096 && is_integral_type (value_type (arg2)))
2097 return value_ptradd (arg1, value_as_long (arg2));
2098 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2099 && is_integral_type (value_type (arg1)))
2100 return value_ptradd (arg2, value_as_long (arg1));
2103 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2104 return value_binop (arg1, arg2, BINOP_ADD);
2108 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2109 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2110 if (noside == EVAL_SKIP)
2111 return eval_skip_value (exp);
2112 if (binop_user_defined_p (op, arg1, arg2))
2113 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2114 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2115 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2117 /* FIXME -- should be ptrdiff_t */
2118 type = builtin_type (exp->gdbarch)->builtin_long;
2119 return value_from_longest (type, value_ptrdiff (arg1, arg2));
2121 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2122 && is_integral_type (value_type (arg2)))
2123 return value_ptradd (arg1, - value_as_long (arg2));
2126 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2127 return value_binop (arg1, arg2, BINOP_SUB);
2138 case BINOP_BITWISE_AND:
2139 case BINOP_BITWISE_IOR:
2140 case BINOP_BITWISE_XOR:
2141 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2142 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2143 if (noside == EVAL_SKIP)
2144 return eval_skip_value (exp);
2145 if (binop_user_defined_p (op, arg1, arg2))
2146 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2149 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2150 fudge arg2 to avoid division-by-zero, the caller is
2151 (theoretically) only looking for the type of the result. */
2152 if (noside == EVAL_AVOID_SIDE_EFFECTS
2153 /* ??? Do we really want to test for BINOP_MOD here?
2154 The implementation of value_binop gives it a well-defined
2157 || op == BINOP_INTDIV
2160 && value_logical_not (arg2))
2162 struct value *v_one, *retval;
2164 v_one = value_one (value_type (arg2));
2165 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2166 retval = value_binop (arg1, v_one, op);
2171 /* For shift and integer exponentiation operations,
2172 only promote the first argument. */
2173 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2174 && is_integral_type (value_type (arg2)))
2175 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2177 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2179 return value_binop (arg1, arg2, op);
2183 case BINOP_SUBSCRIPT:
2184 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2185 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2186 if (noside == EVAL_SKIP)
2187 return eval_skip_value (exp);
2188 if (binop_user_defined_p (op, arg1, arg2))
2189 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2192 /* If the user attempts to subscript something that is not an
2193 array or pointer type (like a plain int variable for example),
2194 then report this as an error. */
2196 arg1 = coerce_ref (arg1);
2197 type = check_typedef (value_type (arg1));
2198 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2199 && TYPE_CODE (type) != TYPE_CODE_PTR)
2201 if (TYPE_NAME (type))
2202 error (_("cannot subscript something of type `%s'"),
2205 error (_("cannot subscript requested type"));
2208 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2209 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2211 return value_subscript (arg1, value_as_long (arg2));
2213 case MULTI_SUBSCRIPT:
2215 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2216 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2219 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2220 /* FIXME: EVAL_SKIP handling may not be correct. */
2221 if (noside == EVAL_SKIP)
2225 return eval_skip_value (exp);
2227 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2228 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2230 /* If the user attempts to subscript something that has no target
2231 type (like a plain int variable for example), then report this
2234 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2237 arg1 = value_zero (type, VALUE_LVAL (arg1));
2243 error (_("cannot subscript something of type `%s'"),
2244 TYPE_NAME (value_type (arg1)));
2248 if (binop_user_defined_p (op, arg1, arg2))
2250 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2254 arg1 = coerce_ref (arg1);
2255 type = check_typedef (value_type (arg1));
2257 switch (TYPE_CODE (type))
2260 case TYPE_CODE_ARRAY:
2261 case TYPE_CODE_STRING:
2262 arg1 = value_subscript (arg1, value_as_long (arg2));
2266 if (TYPE_NAME (type))
2267 error (_("cannot subscript something of type `%s'"),
2270 error (_("cannot subscript requested type"));
2276 multi_f77_subscript:
2278 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2279 int ndimensions = 1, i;
2280 struct value *array = arg1;
2282 if (nargs > MAX_FORTRAN_DIMS)
2283 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2285 ndimensions = calc_f77_array_dims (type);
2287 if (nargs != ndimensions)
2288 error (_("Wrong number of subscripts"));
2290 gdb_assert (nargs > 0);
2292 /* Now that we know we have a legal array subscript expression
2293 let us actually find out where this element exists in the array. */
2295 /* Take array indices left to right. */
2296 for (i = 0; i < nargs; i++)
2298 /* Evaluate each subscript; it must be a legal integer in F77. */
2299 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2301 /* Fill in the subscript array. */
2303 subscript_array[i] = value_as_long (arg2);
2306 /* Internal type of array is arranged right to left. */
2307 for (i = nargs; i > 0; i--)
2309 struct type *array_type = check_typedef (value_type (array));
2310 LONGEST index = subscript_array[i - 1];
2312 array = value_subscripted_rvalue (array, index,
2313 f77_get_lowerbound (array_type));
2319 case BINOP_LOGICAL_AND:
2320 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2321 if (noside == EVAL_SKIP)
2323 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2324 return eval_skip_value (exp);
2328 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2331 if (binop_user_defined_p (op, arg1, arg2))
2333 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2334 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2338 tem = value_logical_not (arg1);
2339 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2340 (tem ? EVAL_SKIP : noside));
2341 type = language_bool_type (exp->language_defn, exp->gdbarch);
2342 return value_from_longest (type,
2343 (LONGEST) (!tem && !value_logical_not (arg2)));
2346 case BINOP_LOGICAL_OR:
2347 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2348 if (noside == EVAL_SKIP)
2350 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2351 return eval_skip_value (exp);
2355 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2358 if (binop_user_defined_p (op, arg1, arg2))
2360 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2361 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2365 tem = value_logical_not (arg1);
2366 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2367 (!tem ? EVAL_SKIP : noside));
2368 type = language_bool_type (exp->language_defn, exp->gdbarch);
2369 return value_from_longest (type,
2370 (LONGEST) (!tem || !value_logical_not (arg2)));
2374 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2375 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2376 if (noside == EVAL_SKIP)
2377 return eval_skip_value (exp);
2378 if (binop_user_defined_p (op, arg1, arg2))
2380 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2384 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2385 tem = value_equal (arg1, arg2);
2386 type = language_bool_type (exp->language_defn, exp->gdbarch);
2387 return value_from_longest (type, (LONGEST) tem);
2390 case BINOP_NOTEQUAL:
2391 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2392 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2393 if (noside == EVAL_SKIP)
2394 return eval_skip_value (exp);
2395 if (binop_user_defined_p (op, arg1, arg2))
2397 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2401 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2402 tem = value_equal (arg1, arg2);
2403 type = language_bool_type (exp->language_defn, exp->gdbarch);
2404 return value_from_longest (type, (LONGEST) ! tem);
2408 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2409 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2410 if (noside == EVAL_SKIP)
2411 return eval_skip_value (exp);
2412 if (binop_user_defined_p (op, arg1, arg2))
2414 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2418 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2419 tem = value_less (arg1, arg2);
2420 type = language_bool_type (exp->language_defn, exp->gdbarch);
2421 return value_from_longest (type, (LONGEST) tem);
2425 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2426 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2427 if (noside == EVAL_SKIP)
2428 return eval_skip_value (exp);
2429 if (binop_user_defined_p (op, arg1, arg2))
2431 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2435 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2436 tem = value_less (arg2, arg1);
2437 type = language_bool_type (exp->language_defn, exp->gdbarch);
2438 return value_from_longest (type, (LONGEST) tem);
2442 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2443 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2444 if (noside == EVAL_SKIP)
2445 return eval_skip_value (exp);
2446 if (binop_user_defined_p (op, arg1, arg2))
2448 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2452 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2453 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2454 type = language_bool_type (exp->language_defn, exp->gdbarch);
2455 return value_from_longest (type, (LONGEST) tem);
2459 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2460 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2461 if (noside == EVAL_SKIP)
2462 return eval_skip_value (exp);
2463 if (binop_user_defined_p (op, arg1, arg2))
2465 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2469 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2470 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2471 type = language_bool_type (exp->language_defn, exp->gdbarch);
2472 return value_from_longest (type, (LONGEST) tem);
2476 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2477 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2478 if (noside == EVAL_SKIP)
2479 return eval_skip_value (exp);
2480 type = check_typedef (value_type (arg2));
2481 if (TYPE_CODE (type) != TYPE_CODE_INT
2482 && TYPE_CODE (type) != TYPE_CODE_ENUM)
2483 error (_("Non-integral right operand for \"@\" operator."));
2484 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2486 return allocate_repeat_value (value_type (arg1),
2487 longest_to_int (value_as_long (arg2)));
2490 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2493 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2494 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2497 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2498 if (noside == EVAL_SKIP)
2499 return eval_skip_value (exp);
2500 if (unop_user_defined_p (op, arg1))
2501 return value_x_unop (arg1, op, noside);
2504 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2505 return value_pos (arg1);
2509 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2510 if (noside == EVAL_SKIP)
2511 return eval_skip_value (exp);
2512 if (unop_user_defined_p (op, arg1))
2513 return value_x_unop (arg1, op, noside);
2516 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2517 return value_neg (arg1);
2520 case UNOP_COMPLEMENT:
2521 /* C++: check for and handle destructor names. */
2523 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2524 if (noside == EVAL_SKIP)
2525 return eval_skip_value (exp);
2526 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2527 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2530 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2531 return value_complement (arg1);
2534 case UNOP_LOGICAL_NOT:
2535 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2536 if (noside == EVAL_SKIP)
2537 return eval_skip_value (exp);
2538 if (unop_user_defined_p (op, arg1))
2539 return value_x_unop (arg1, op, noside);
2542 type = language_bool_type (exp->language_defn, exp->gdbarch);
2543 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2547 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2548 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2549 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2550 type = check_typedef (value_type (arg1));
2551 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2552 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2553 error (_("Attempt to dereference pointer "
2554 "to member without an object"));
2555 if (noside == EVAL_SKIP)
2556 return eval_skip_value (exp);
2557 if (unop_user_defined_p (op, arg1))
2558 return value_x_unop (arg1, op, noside);
2559 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2561 type = check_typedef (value_type (arg1));
2562 if (TYPE_CODE (type) == TYPE_CODE_PTR
2563 || TYPE_IS_REFERENCE (type)
2564 /* In C you can dereference an array to get the 1st elt. */
2565 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2567 return value_zero (TYPE_TARGET_TYPE (type),
2569 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2570 /* GDB allows dereferencing an int. */
2571 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2574 error (_("Attempt to take contents of a non-pointer value."));
2577 /* Allow * on an integer so we can cast it to whatever we want.
2578 This returns an int, which seems like the most C-like thing to
2579 do. "long long" variables are rare enough that
2580 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2581 if (TYPE_CODE (type) == TYPE_CODE_INT)
2582 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2583 (CORE_ADDR) value_as_address (arg1));
2584 return value_ind (arg1);
2587 /* C++: check for and handle pointer to members. */
2589 if (noside == EVAL_SKIP)
2591 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2592 return eval_skip_value (exp);
2596 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2603 if (noside == EVAL_SKIP)
2605 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2606 return eval_skip_value (exp);
2608 return evaluate_subexp_for_sizeof (exp, pos, noside);
2612 type = exp->elts[pc + 1].type;
2613 return evaluate_subexp_for_cast (exp, pos, noside, type);
2615 case UNOP_CAST_TYPE:
2616 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2617 type = value_type (arg1);
2618 return evaluate_subexp_for_cast (exp, pos, noside, type);
2620 case UNOP_DYNAMIC_CAST:
2621 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2622 type = value_type (arg1);
2623 arg1 = evaluate_subexp (type, exp, pos, noside);
2624 if (noside == EVAL_SKIP)
2625 return eval_skip_value (exp);
2626 return value_dynamic_cast (type, arg1);
2628 case UNOP_REINTERPRET_CAST:
2629 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2630 type = value_type (arg1);
2631 arg1 = evaluate_subexp (type, exp, pos, noside);
2632 if (noside == EVAL_SKIP)
2633 return eval_skip_value (exp);
2634 return value_reinterpret_cast (type, arg1);
2638 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2639 if (noside == EVAL_SKIP)
2640 return eval_skip_value (exp);
2641 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2642 return value_zero (exp->elts[pc + 1].type, lval_memory);
2644 return value_at_lazy (exp->elts[pc + 1].type,
2645 value_as_address (arg1));
2647 case UNOP_MEMVAL_TYPE:
2648 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2649 type = value_type (arg1);
2650 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2651 if (noside == EVAL_SKIP)
2652 return eval_skip_value (exp);
2653 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2654 return value_zero (type, lval_memory);
2656 return value_at_lazy (type, value_as_address (arg1));
2658 case UNOP_PREINCREMENT:
2659 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2660 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2662 else if (unop_user_defined_p (op, arg1))
2664 return value_x_unop (arg1, op, noside);
2668 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2669 arg2 = value_ptradd (arg1, 1);
2672 struct value *tmp = arg1;
2674 arg2 = value_one (value_type (arg1));
2675 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2676 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2679 return value_assign (arg1, arg2);
2682 case UNOP_PREDECREMENT:
2683 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2684 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2686 else if (unop_user_defined_p (op, arg1))
2688 return value_x_unop (arg1, op, noside);
2692 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2693 arg2 = value_ptradd (arg1, -1);
2696 struct value *tmp = arg1;
2698 arg2 = value_one (value_type (arg1));
2699 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2700 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2703 return value_assign (arg1, arg2);
2706 case UNOP_POSTINCREMENT:
2707 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2708 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2710 else if (unop_user_defined_p (op, arg1))
2712 return value_x_unop (arg1, op, noside);
2716 arg3 = value_non_lval (arg1);
2718 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2719 arg2 = value_ptradd (arg1, 1);
2722 struct value *tmp = arg1;
2724 arg2 = value_one (value_type (arg1));
2725 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2726 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2729 value_assign (arg1, arg2);
2733 case UNOP_POSTDECREMENT:
2734 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2735 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2737 else if (unop_user_defined_p (op, arg1))
2739 return value_x_unop (arg1, op, noside);
2743 arg3 = value_non_lval (arg1);
2745 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2746 arg2 = value_ptradd (arg1, -1);
2749 struct value *tmp = arg1;
2751 arg2 = value_one (value_type (arg1));
2752 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2753 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2756 value_assign (arg1, arg2);
2762 return value_of_this (exp->language_defn);
2765 /* The value is not supposed to be used. This is here to make it
2766 easier to accommodate expressions that contain types. */
2768 if (noside == EVAL_SKIP)
2769 return eval_skip_value (exp);
2770 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2771 return allocate_value (exp->elts[pc + 1].type);
2773 error (_("Attempt to use a type name as an expression"));
2777 if (noside == EVAL_SKIP)
2779 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2780 return eval_skip_value (exp);
2782 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2784 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2785 struct value *result;
2787 result = evaluate_subexp (NULL_TYPE, exp, pos,
2788 EVAL_AVOID_SIDE_EFFECTS);
2790 /* 'decltype' has special semantics for lvalues. */
2791 if (op == OP_DECLTYPE
2792 && (sub_op == BINOP_SUBSCRIPT
2793 || sub_op == STRUCTOP_MEMBER
2794 || sub_op == STRUCTOP_MPTR
2795 || sub_op == UNOP_IND
2796 || sub_op == STRUCTOP_STRUCT
2797 || sub_op == STRUCTOP_PTR
2798 || sub_op == OP_SCOPE))
2800 struct type *type = value_type (result);
2802 if (!TYPE_IS_REFERENCE (type))
2804 type = lookup_lvalue_reference_type (type);
2805 result = allocate_value (type);
2812 error (_("Attempt to use a type as an expression"));
2816 struct value *result;
2817 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2819 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2820 result = evaluate_subexp (NULL_TYPE, exp, pos,
2821 EVAL_AVOID_SIDE_EFFECTS);
2823 result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2825 if (noside != EVAL_NORMAL)
2826 return allocate_value (cplus_typeid_type (exp->gdbarch));
2828 return cplus_typeid (result);
2832 /* Removing this case and compiling with gcc -Wall reveals that
2833 a lot of cases are hitting this case. Some of these should
2834 probably be removed from expression.h; others are legitimate
2835 expressions which are (apparently) not fully implemented.
2837 If there are any cases landing here which mean a user error,
2838 then they should be separate cases, with more descriptive
2841 error (_("GDB does not (yet) know how to "
2842 "evaluate that kind of expression"));
2845 gdb_assert_not_reached ("missed return?");
2848 /* Evaluate a subexpression of EXP, at index *POS,
2849 and return the address of that subexpression.
2850 Advance *POS over the subexpression.
2851 If the subexpression isn't an lvalue, get an error.
2852 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2853 then only the type of the result need be correct. */
2855 static struct value *
2856 evaluate_subexp_for_address (struct expression *exp, int *pos,
2866 op = exp->elts[pc].opcode;
2872 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2874 /* We can't optimize out "&*" if there's a user-defined operator*. */
2875 if (unop_user_defined_p (op, x))
2877 x = value_x_unop (x, op, noside);
2878 goto default_case_after_eval;
2881 return coerce_array (x);
2885 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2886 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2888 case UNOP_MEMVAL_TYPE:
2893 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2894 type = value_type (x);
2895 return value_cast (lookup_pointer_type (type),
2896 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2900 var = exp->elts[pc + 2].symbol;
2902 /* C++: The "address" of a reference should yield the address
2903 * of the object pointed to. Let value_addr() deal with it. */
2904 if (TYPE_IS_REFERENCE (SYMBOL_TYPE (var)))
2908 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2911 lookup_pointer_type (SYMBOL_TYPE (var));
2912 enum address_class sym_class = SYMBOL_CLASS (var);
2914 if (sym_class == LOC_CONST
2915 || sym_class == LOC_CONST_BYTES
2916 || sym_class == LOC_REGISTER)
2917 error (_("Attempt to take address of register or constant."));
2920 value_zero (type, not_lval);
2923 return address_of_variable (var, exp->elts[pc + 1].block);
2925 case OP_VAR_MSYM_VALUE:
2929 value *val = evaluate_var_msym_value (noside,
2930 exp->elts[pc + 1].objfile,
2931 exp->elts[pc + 2].msymbol);
2932 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2934 struct type *type = lookup_pointer_type (value_type (val));
2935 return value_zero (type, not_lval);
2938 return value_addr (val);
2942 tem = longest_to_int (exp->elts[pc + 2].longconst);
2943 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2944 x = value_aggregate_elt (exp->elts[pc + 1].type,
2945 &exp->elts[pc + 3].string,
2948 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2953 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2954 default_case_after_eval:
2955 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2957 struct type *type = check_typedef (value_type (x));
2959 if (TYPE_IS_REFERENCE (type))
2960 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2962 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2963 return value_zero (lookup_pointer_type (value_type (x)),
2966 error (_("Attempt to take address of "
2967 "value not located in memory."));
2969 return value_addr (x);
2973 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2974 When used in contexts where arrays will be coerced anyway, this is
2975 equivalent to `evaluate_subexp' but much faster because it avoids
2976 actually fetching array contents (perhaps obsolete now that we have
2979 Note that we currently only do the coercion for C expressions, where
2980 arrays are zero based and the coercion is correct. For other languages,
2981 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2982 to decide if coercion is appropriate. */
2985 evaluate_subexp_with_coercion (struct expression *exp,
2986 int *pos, enum noside noside)
2995 op = exp->elts[pc].opcode;
3000 var = exp->elts[pc + 2].symbol;
3001 type = check_typedef (SYMBOL_TYPE (var));
3002 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
3003 && !TYPE_VECTOR (type)
3004 && CAST_IS_CONVERSION (exp->language_defn))
3007 val = address_of_variable (var, exp->elts[pc + 1].block);
3008 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
3014 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
3018 /* Evaluate a subexpression of EXP, at index *POS,
3019 and return a value for the size of that subexpression.
3020 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3021 we allow side-effects on the operand if its type is a variable
3024 static struct value *
3025 evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
3028 /* FIXME: This should be size_t. */
3029 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3036 op = exp->elts[pc].opcode;
3040 /* This case is handled specially
3041 so that we avoid creating a value for the result type.
3042 If the result type is very big, it's desirable not to
3043 create a value unnecessarily. */
3046 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3047 type = check_typedef (value_type (val));
3048 if (TYPE_CODE (type) != TYPE_CODE_PTR
3049 && !TYPE_IS_REFERENCE (type)
3050 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3051 error (_("Attempt to take contents of a non-pointer value."));
3052 type = TYPE_TARGET_TYPE (type);
3053 if (is_dynamic_type (type))
3054 type = value_type (value_ind (val));
3055 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3059 type = exp->elts[pc + 1].type;
3062 case UNOP_MEMVAL_TYPE:
3064 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3065 type = value_type (val);
3069 type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
3070 if (is_dynamic_type (type))
3072 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3073 type = value_type (val);
3079 case OP_VAR_MSYM_VALUE:
3083 minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
3084 value *val = evaluate_var_msym_value (noside,
3085 exp->elts[pc + 1].objfile,
3088 type = value_type (val);
3089 if (TYPE_CODE (type) == TYPE_CODE_ERROR)
3090 error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
3092 return value_from_longest (size_type, TYPE_LENGTH (type));
3096 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3097 type of the subscript is a variable length array type. In this case we
3098 must re-evaluate the right hand side of the subcription to allow
3100 case BINOP_SUBSCRIPT:
3101 if (noside == EVAL_NORMAL)
3103 int pc = (*pos) + 1;
3105 val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
3106 type = check_typedef (value_type (val));
3107 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3109 type = check_typedef (TYPE_TARGET_TYPE (type));
3110 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3112 type = TYPE_INDEX_TYPE (type);
3113 /* Only re-evaluate the right hand side if the resulting type
3114 is a variable length type. */
3115 if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
3117 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3118 return value_from_longest
3119 (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
3128 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3129 type = value_type (val);
3133 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3134 "When applied to a reference or a reference type, the result is
3135 the size of the referenced type." */
3136 type = check_typedef (type);
3137 if (exp->language_defn->la_language == language_cplus
3138 && (TYPE_IS_REFERENCE (type)))
3139 type = check_typedef (TYPE_TARGET_TYPE (type));
3140 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3143 /* Evaluate a subexpression of EXP, at index *POS, and return a value
3144 for that subexpression cast to TO_TYPE. Advance *POS over the
3148 evaluate_subexp_for_cast (expression *exp, int *pos,
3150 struct type *to_type)
3154 /* Don't let symbols be evaluated with evaluate_subexp because that
3155 throws an "unknown type" error for no-debug data symbols.
3156 Instead, we want the cast to reinterpret the symbol. */
3157 if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE
3158 || exp->elts[pc].opcode == OP_VAR_VALUE)
3163 if (exp->elts[pc].opcode == OP_VAR_MSYM_VALUE)
3165 if (noside == EVAL_AVOID_SIDE_EFFECTS)
3166 return value_zero (to_type, not_lval);
3168 val = evaluate_var_msym_value (noside,
3169 exp->elts[pc + 1].objfile,
3170 exp->elts[pc + 2].msymbol);
3173 val = evaluate_var_value (noside,
3174 exp->elts[pc + 1].block,
3175 exp->elts[pc + 2].symbol);
3177 if (noside == EVAL_SKIP)
3178 return eval_skip_value (exp);
3180 val = value_cast (to_type, val);
3182 /* Don't allow e.g. '&(int)var_with_no_debug_info'. */
3183 if (VALUE_LVAL (val) == lval_memory)
3185 if (value_lazy (val))
3186 value_fetch_lazy (val);
3187 VALUE_LVAL (val) = not_lval;
3192 value *val = evaluate_subexp (to_type, exp, pos, noside);
3193 if (noside == EVAL_SKIP)
3194 return eval_skip_value (exp);
3195 return value_cast (to_type, val);
3198 /* Parse a type expression in the string [P..P+LENGTH). */
3201 parse_and_eval_type (char *p, int length)
3203 char *tmp = (char *) alloca (length + 4);
3206 memcpy (tmp + 1, p, length);
3207 tmp[length + 1] = ')';
3208 tmp[length + 2] = '0';
3209 tmp[length + 3] = '\0';
3210 expression_up expr = parse_expression (tmp);
3211 if (expr->elts[0].opcode != UNOP_CAST)
3212 error (_("Internal error in eval_type."));
3213 return expr->elts[1].type;
3217 calc_f77_array_dims (struct type *array_type)
3220 struct type *tmp_type;
3222 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3223 error (_("Can't get dimensions for a non-array type"));
3225 tmp_type = array_type;
3227 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3229 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)