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"
44 /* This is defined in valops.c */
45 extern int overload_resolution;
47 /* Prototypes for local functions. */
49 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *,
52 static struct value *evaluate_subexp_for_address (struct expression *,
55 static struct value *evaluate_struct_tuple (struct value *,
56 struct expression *, int *,
59 static LONGEST init_array_element (struct value *, struct value *,
60 struct expression *, int *, enum noside,
64 evaluate_subexp (struct type *expect_type, struct expression *exp,
65 int *pos, enum noside noside)
67 struct cleanup *cleanups;
69 int cleanup_temps = 0;
71 if (*pos == 0 && target_has_execution
72 && exp->language_defn->la_language == language_cplus
73 && !thread_stack_temporaries_enabled_p (inferior_ptid))
75 cleanups = enable_thread_stack_temporaries (inferior_ptid);
79 retval = (*exp->language_defn->la_exp_desc->evaluate_exp)
80 (expect_type, exp, pos, noside);
84 if (value_in_thread_stack_temporaries (retval, inferior_ptid))
85 retval = value_non_lval (retval);
86 do_cleanups (cleanups);
92 /* Parse the string EXP as a C expression, evaluate it,
93 and return the result as a number. */
96 parse_and_eval_address (const char *exp)
98 expression_up expr = parse_expression (exp);
100 return value_as_address (evaluate_expression (expr.get ()));
103 /* Like parse_and_eval_address, but treats the value of the expression
104 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
106 parse_and_eval_long (const char *exp)
108 expression_up expr = parse_expression (exp);
110 return value_as_long (evaluate_expression (expr.get ()));
114 parse_and_eval (const char *exp)
116 expression_up expr = parse_expression (exp);
118 return evaluate_expression (expr.get ());
121 /* Parse up to a comma (or to a closeparen)
122 in the string EXPP as an expression, evaluate it, and return the value.
123 EXPP is advanced to point to the comma. */
126 parse_to_comma_and_eval (const char **expp)
128 expression_up expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
130 return evaluate_expression (expr.get ());
133 /* Evaluate an expression in internal prefix form
134 such as is constructed by parse.y.
136 See expression.h for info on the format of an expression. */
139 evaluate_expression (struct expression *exp)
143 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
146 /* Evaluate an expression, avoiding all memory references
147 and getting a value whose type alone is correct. */
150 evaluate_type (struct expression *exp)
154 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
157 /* Evaluate a subexpression, avoiding all memory references and
158 getting a value whose type alone is correct. */
161 evaluate_subexpression_type (struct expression *exp, int subexp)
163 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
166 /* Find the current value of a watchpoint on EXP. Return the value in
167 *VALP and *RESULTP and the chain of intermediate and final values
168 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
171 If PRESERVE_ERRORS is true, then exceptions are passed through.
172 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
173 occurs while evaluating the expression, *RESULTP will be set to
174 NULL. *RESULTP may be a lazy value, if the result could not be
175 read from memory. It is used to determine whether a value is
176 user-specified (we should watch the whole value) or intermediate
177 (we should watch only the bit used to locate the final value).
179 If the final value, or any intermediate value, could not be read
180 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
181 set to any referenced values. *VALP will never be a lazy value.
182 This is the value which we store in struct breakpoint.
184 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
185 value chain. The caller must free the values individually. If
186 VAL_CHAIN is NULL, all generated values will be left on the value
190 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
191 struct value **resultp, struct value **val_chain,
194 struct value *mark, *new_mark, *result;
202 /* Evaluate the expression. */
203 mark = value_mark ();
208 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
210 CATCH (ex, RETURN_MASK_ALL)
212 /* Ignore memory errors if we want watchpoints pointing at
213 inaccessible memory to still be created; otherwise, throw the
214 error to some higher catcher. */
218 if (!preserve_errors)
221 throw_exception (ex);
227 new_mark = value_mark ();
228 if (mark == new_mark)
233 /* Make sure it's not lazy, so that after the target stops again we
234 have a non-lazy previous value to compare with. */
237 if (!value_lazy (result))
244 value_fetch_lazy (result);
247 CATCH (except, RETURN_MASK_ERROR)
256 /* Return the chain of intermediate values. We use this to
257 decide which addresses to watch. */
258 *val_chain = new_mark;
259 value_release_to_mark (mark);
263 /* Extract a field operation from an expression. If the subexpression
264 of EXP starting at *SUBEXP is not a structure dereference
265 operation, return NULL. Otherwise, return the name of the
266 dereferenced field, and advance *SUBEXP to point to the
267 subexpression of the left-hand-side of the dereference. This is
268 used when completing field names. */
271 extract_field_op (struct expression *exp, int *subexp)
276 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
277 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
279 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
280 result = &exp->elts[*subexp + 2].string;
281 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
285 /* This function evaluates brace-initializers (in C/C++) for
288 static struct value *
289 evaluate_struct_tuple (struct value *struct_val,
290 struct expression *exp,
291 int *pos, enum noside noside, int nargs)
293 struct type *struct_type = check_typedef (value_type (struct_val));
294 struct type *field_type;
299 struct value *val = NULL;
304 /* Skip static fields. */
305 while (fieldno < TYPE_NFIELDS (struct_type)
306 && field_is_static (&TYPE_FIELD (struct_type,
309 if (fieldno >= TYPE_NFIELDS (struct_type))
310 error (_("too many initializers"));
311 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
312 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
313 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
314 error (_("don't know which variant you want to set"));
316 /* Here, struct_type is the type of the inner struct,
317 while substruct_type is the type of the inner struct.
318 These are the same for normal structures, but a variant struct
319 contains anonymous union fields that contain substruct fields.
320 The value fieldno is the index of the top-level (normal or
321 anonymous union) field in struct_field, while the value
322 subfieldno is the index of the actual real (named inner) field
323 in substruct_type. */
325 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
327 val = evaluate_subexp (field_type, exp, pos, noside);
329 /* Now actually set the field in struct_val. */
331 /* Assign val to field fieldno. */
332 if (value_type (val) != field_type)
333 val = value_cast (field_type, val);
335 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
336 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
337 addr = value_contents_writeable (struct_val) + bitpos / 8;
339 modify_field (struct_type, addr,
340 value_as_long (val), bitpos % 8, bitsize);
342 memcpy (addr, value_contents (val),
343 TYPE_LENGTH (value_type (val)));
349 /* Recursive helper function for setting elements of array tuples.
350 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
351 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
352 Evaluates index expresions and sets the specified element(s) of
353 ARRAY to ELEMENT. Returns last index value. */
356 init_array_element (struct value *array, struct value *element,
357 struct expression *exp, int *pos,
358 enum noside noside, LONGEST low_bound, LONGEST high_bound)
361 int element_size = TYPE_LENGTH (value_type (element));
363 if (exp->elts[*pos].opcode == BINOP_COMMA)
366 init_array_element (array, element, exp, pos, noside,
367 low_bound, high_bound);
368 return init_array_element (array, element,
369 exp, pos, noside, low_bound, high_bound);
373 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
374 if (index < low_bound || index > high_bound)
375 error (_("tuple index out of range"));
376 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
377 value_contents (element), element_size);
382 static struct value *
383 value_f90_subarray (struct value *array,
384 struct expression *exp, int *pos, enum noside noside)
387 LONGEST low_bound, high_bound;
388 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
389 enum range_type range_type
390 = (enum range_type) longest_to_int (exp->elts[pc].longconst);
394 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
395 low_bound = TYPE_LOW_BOUND (range);
397 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
399 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
400 high_bound = TYPE_HIGH_BOUND (range);
402 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
404 return value_slice (array, low_bound, high_bound - low_bound + 1);
408 /* Promote value ARG1 as appropriate before performing a unary operation
410 If the result is not appropriate for any particular language then it
411 needs to patch this function. */
414 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
419 *arg1 = coerce_ref (*arg1);
420 type1 = check_typedef (value_type (*arg1));
422 if (is_integral_type (type1))
424 switch (language->la_language)
427 /* Perform integral promotion for ANSI C/C++.
428 If not appropropriate for any particular language
429 it needs to modify this function. */
431 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
433 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
434 *arg1 = value_cast (builtin_int, *arg1);
441 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
442 operation on those two operands.
443 If the result is not appropriate for any particular language then it
444 needs to patch this function. */
447 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
448 struct value **arg1, struct value **arg2)
450 struct type *promoted_type = NULL;
454 *arg1 = coerce_ref (*arg1);
455 *arg2 = coerce_ref (*arg2);
457 type1 = check_typedef (value_type (*arg1));
458 type2 = check_typedef (value_type (*arg2));
460 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
461 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
462 && !is_integral_type (type1))
463 || (TYPE_CODE (type2) != TYPE_CODE_FLT
464 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
465 && !is_integral_type (type2)))
468 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
469 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
471 /* No promotion required. */
473 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
474 || TYPE_CODE (type2) == TYPE_CODE_FLT)
476 switch (language->la_language)
482 case language_opencl:
483 /* No promotion required. */
487 /* For other languages the result type is unchanged from gdb
488 version 6.7 for backward compatibility.
489 If either arg was long double, make sure that value is also long
490 double. Otherwise use double. */
491 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
492 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
493 promoted_type = builtin_type (gdbarch)->builtin_long_double;
495 promoted_type = builtin_type (gdbarch)->builtin_double;
499 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
500 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
502 /* No promotion required. */
505 /* Integral operations here. */
506 /* FIXME: Also mixed integral/booleans, with result an integer. */
508 const struct builtin_type *builtin = builtin_type (gdbarch);
509 unsigned int promoted_len1 = TYPE_LENGTH (type1);
510 unsigned int promoted_len2 = TYPE_LENGTH (type2);
511 int is_unsigned1 = TYPE_UNSIGNED (type1);
512 int is_unsigned2 = TYPE_UNSIGNED (type2);
513 unsigned int result_len;
514 int unsigned_operation;
516 /* Determine type length and signedness after promotion for
518 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
521 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
523 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
526 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
529 if (promoted_len1 > promoted_len2)
531 unsigned_operation = is_unsigned1;
532 result_len = promoted_len1;
534 else if (promoted_len2 > promoted_len1)
536 unsigned_operation = is_unsigned2;
537 result_len = promoted_len2;
541 unsigned_operation = is_unsigned1 || is_unsigned2;
542 result_len = promoted_len1;
545 switch (language->la_language)
551 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
553 promoted_type = (unsigned_operation
554 ? builtin->builtin_unsigned_int
555 : builtin->builtin_int);
557 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
559 promoted_type = (unsigned_operation
560 ? builtin->builtin_unsigned_long
561 : builtin->builtin_long);
565 promoted_type = (unsigned_operation
566 ? builtin->builtin_unsigned_long_long
567 : builtin->builtin_long_long);
570 case language_opencl:
571 if (result_len <= TYPE_LENGTH (lookup_signed_typename
572 (language, gdbarch, "int")))
576 ? lookup_unsigned_typename (language, gdbarch, "int")
577 : lookup_signed_typename (language, gdbarch, "int"));
579 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
580 (language, gdbarch, "long")))
584 ? lookup_unsigned_typename (language, gdbarch, "long")
585 : lookup_signed_typename (language, gdbarch,"long"));
589 /* For other languages the result type is unchanged from gdb
590 version 6.7 for backward compatibility.
591 If either arg was long long, make sure that value is also long
592 long. Otherwise use long. */
593 if (unsigned_operation)
595 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
596 promoted_type = builtin->builtin_unsigned_long_long;
598 promoted_type = builtin->builtin_unsigned_long;
602 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
603 promoted_type = builtin->builtin_long_long;
605 promoted_type = builtin->builtin_long;
613 /* Promote both operands to common type. */
614 *arg1 = value_cast (promoted_type, *arg1);
615 *arg2 = value_cast (promoted_type, *arg2);
620 ptrmath_type_p (const struct language_defn *lang, struct type *type)
622 type = check_typedef (type);
623 if (TYPE_IS_REFERENCE (type))
624 type = TYPE_TARGET_TYPE (type);
626 switch (TYPE_CODE (type))
632 case TYPE_CODE_ARRAY:
633 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
640 /* Constructs a fake method with the given parameter types.
641 This function is used by the parser to construct an "expected"
642 type for method overload resolution. */
645 make_params (int num_types, struct type **param_types)
647 struct type *type = XCNEW (struct type);
648 TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
649 TYPE_LENGTH (type) = 1;
650 TYPE_CODE (type) = TYPE_CODE_METHOD;
651 TYPE_CHAIN (type) = type;
654 if (param_types[num_types - 1] == NULL)
657 TYPE_VARARGS (type) = 1;
659 else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
663 /* Caller should have ensured this. */
664 gdb_assert (num_types == 0);
665 TYPE_PROTOTYPED (type) = 1;
669 TYPE_NFIELDS (type) = num_types;
670 TYPE_FIELDS (type) = (struct field *)
671 TYPE_ZALLOC (type, sizeof (struct field) * num_types);
673 while (num_types-- > 0)
674 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
679 /* Helper for evaluating an OP_VAR_MSYM_VALUE. */
682 evaluate_var_msym_value (enum noside noside,
683 struct objfile *objfile, minimal_symbol *msymbol)
685 if (noside == EVAL_AVOID_SIDE_EFFECTS)
687 type *the_type = find_minsym_type_and_address (msymbol, objfile, NULL);
688 return value_zero (the_type, not_lval);
693 type *the_type = find_minsym_type_and_address (msymbol, objfile, &address);
694 return value_at_lazy (the_type, address);
698 /* Helper for returning a value when handling EVAL_SKIP. */
701 eval_skip_value (expression *exp)
703 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
707 evaluate_subexp_standard (struct type *expect_type,
708 struct expression *exp, int *pos,
713 int pc, pc2 = 0, oldpos;
714 struct value *arg1 = NULL;
715 struct value *arg2 = NULL;
719 struct value **argvec;
723 struct type **arg_types;
725 struct symbol *function = NULL;
726 char *function_name = NULL;
727 const char *var_func_name = NULL;
730 op = exp->elts[pc].opcode;
735 tem = longest_to_int (exp->elts[pc + 2].longconst);
736 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
737 if (noside == EVAL_SKIP)
738 return eval_skip_value (exp);
739 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
740 &exp->elts[pc + 3].string,
741 expect_type, 0, noside);
743 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
748 return value_from_longest (exp->elts[pc + 1].type,
749 exp->elts[pc + 2].longconst);
753 return value_from_double (exp->elts[pc + 1].type,
754 exp->elts[pc + 2].doubleconst);
758 return value_from_decfloat (exp->elts[pc + 1].type,
759 exp->elts[pc + 2].decfloatconst);
764 if (noside == EVAL_SKIP)
765 return eval_skip_value (exp);
767 /* JYG: We used to just return value_zero of the symbol type
768 if we're asked to avoid side effects. Otherwise we return
769 value_of_variable (...). However I'm not sure if
770 value_of_variable () has any side effect.
771 We need a full value object returned here for whatis_exp ()
772 to call evaluate_type () and then pass the full value to
773 value_rtti_target_type () if we are dealing with a pointer
774 or reference to a base class and print object is on. */
777 struct value *ret = NULL;
781 ret = value_of_variable (exp->elts[pc + 2].symbol,
782 exp->elts[pc + 1].block);
785 CATCH (except, RETURN_MASK_ERROR)
787 if (noside == EVAL_AVOID_SIDE_EFFECTS)
788 ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
791 throw_exception (except);
797 case OP_VAR_MSYM_VALUE:
799 return evaluate_var_msym_value (noside,
800 exp->elts[pc + 1].objfile,
801 exp->elts[pc + 2].msymbol);
803 case OP_VAR_ENTRY_VALUE:
805 if (noside == EVAL_SKIP)
806 return eval_skip_value (exp);
809 struct symbol *sym = exp->elts[pc + 1].symbol;
810 struct frame_info *frame;
812 if (noside == EVAL_AVOID_SIDE_EFFECTS)
813 return value_zero (SYMBOL_TYPE (sym), not_lval);
815 if (SYMBOL_COMPUTED_OPS (sym) == NULL
816 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
817 error (_("Symbol \"%s\" does not have any specific entry value"),
818 SYMBOL_PRINT_NAME (sym));
820 frame = get_selected_frame (NULL);
821 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
827 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
831 const char *name = &exp->elts[pc + 2].string;
835 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
836 regno = user_reg_map_name_to_regnum (exp->gdbarch,
837 name, strlen (name));
839 error (_("Register $%s not available."), name);
841 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
842 a value with the appropriate register type. Unfortunately,
843 we don't have easy access to the type of user registers.
844 So for these registers, we fetch the register value regardless
845 of the evaluation mode. */
846 if (noside == EVAL_AVOID_SIDE_EFFECTS
847 && regno < gdbarch_num_regs (exp->gdbarch)
848 + gdbarch_num_pseudo_regs (exp->gdbarch))
849 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
851 val = value_of_register (regno, get_selected_frame (NULL));
853 error (_("Value of register %s not available."), name);
859 type = language_bool_type (exp->language_defn, exp->gdbarch);
860 return value_from_longest (type, exp->elts[pc + 1].longconst);
864 return value_of_internalvar (exp->gdbarch,
865 exp->elts[pc + 1].internalvar);
868 tem = longest_to_int (exp->elts[pc + 1].longconst);
869 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
870 if (noside == EVAL_SKIP)
871 return eval_skip_value (exp);
872 type = language_string_char_type (exp->language_defn, exp->gdbarch);
873 return value_string (&exp->elts[pc + 2].string, tem, type);
875 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
876 NSString constant. */
877 tem = longest_to_int (exp->elts[pc + 1].longconst);
878 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
879 if (noside == EVAL_SKIP)
880 return eval_skip_value (exp);
881 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
885 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
886 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
887 nargs = tem3 - tem2 + 1;
888 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
890 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
891 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
893 struct value *rec = allocate_value (expect_type);
895 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
896 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
899 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
900 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
902 struct type *range_type = TYPE_INDEX_TYPE (type);
903 struct type *element_type = TYPE_TARGET_TYPE (type);
904 struct value *array = allocate_value (expect_type);
905 int element_size = TYPE_LENGTH (check_typedef (element_type));
906 LONGEST low_bound, high_bound, index;
908 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
911 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
914 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
915 for (tem = nargs; --nargs >= 0;)
917 struct value *element;
920 element = evaluate_subexp (element_type, exp, pos, noside);
921 if (value_type (element) != element_type)
922 element = value_cast (element_type, element);
925 int continue_pc = *pos;
928 index = init_array_element (array, element, exp, pos, noside,
929 low_bound, high_bound);
934 if (index > high_bound)
935 /* To avoid memory corruption. */
936 error (_("Too many array elements"));
937 memcpy (value_contents_raw (array)
938 + (index - low_bound) * element_size,
939 value_contents (element),
947 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
948 && TYPE_CODE (type) == TYPE_CODE_SET)
950 struct value *set = allocate_value (expect_type);
951 gdb_byte *valaddr = value_contents_raw (set);
952 struct type *element_type = TYPE_INDEX_TYPE (type);
953 struct type *check_type = element_type;
954 LONGEST low_bound, high_bound;
956 /* Get targettype of elementtype. */
957 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
958 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
959 check_type = TYPE_TARGET_TYPE (check_type);
961 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
962 error (_("(power)set type with unknown size"));
963 memset (valaddr, '\0', TYPE_LENGTH (type));
964 for (tem = 0; tem < nargs; tem++)
966 LONGEST range_low, range_high;
967 struct type *range_low_type, *range_high_type;
968 struct value *elem_val;
970 elem_val = evaluate_subexp (element_type, exp, pos, noside);
971 range_low_type = range_high_type = value_type (elem_val);
972 range_low = range_high = value_as_long (elem_val);
974 /* Check types of elements to avoid mixture of elements from
975 different types. Also check if type of element is "compatible"
976 with element type of powerset. */
977 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
978 range_low_type = TYPE_TARGET_TYPE (range_low_type);
979 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
980 range_high_type = TYPE_TARGET_TYPE (range_high_type);
981 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
982 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
983 && (range_low_type != range_high_type)))
984 /* different element modes. */
985 error (_("POWERSET tuple elements of different mode"));
986 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
987 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
988 && range_low_type != check_type))
989 error (_("incompatible POWERSET tuple elements"));
990 if (range_low > range_high)
992 warning (_("empty POWERSET tuple range"));
995 if (range_low < low_bound || range_high > high_bound)
996 error (_("POWERSET tuple element out of range"));
997 range_low -= low_bound;
998 range_high -= low_bound;
999 for (; range_low <= range_high; range_low++)
1001 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
1003 if (gdbarch_bits_big_endian (exp->gdbarch))
1004 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
1005 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1012 argvec = XALLOCAVEC (struct value *, nargs);
1013 for (tem = 0; tem < nargs; tem++)
1015 /* Ensure that array expressions are coerced into pointer
1017 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1019 if (noside == EVAL_SKIP)
1020 return eval_skip_value (exp);
1021 return value_array (tem2, tem3, argvec);
1025 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1027 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1029 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1031 if (noside == EVAL_SKIP)
1032 return eval_skip_value (exp);
1033 return value_slice (array, lowbound, upper - lowbound + 1);
1037 /* Skip third and second args to evaluate the first one. */
1038 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1039 if (value_logical_not (arg1))
1041 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1042 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1046 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1047 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1051 case OP_OBJC_SELECTOR:
1052 { /* Objective C @selector operator. */
1053 char *sel = &exp->elts[pc + 2].string;
1054 int len = longest_to_int (exp->elts[pc + 1].longconst);
1055 struct type *selector_type;
1057 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1058 if (noside == EVAL_SKIP)
1059 return eval_skip_value (exp);
1062 sel[len] = 0; /* Make sure it's terminated. */
1064 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1065 return value_from_longest (selector_type,
1066 lookup_child_selector (exp->gdbarch, sel));
1069 case OP_OBJC_MSGCALL:
1070 { /* Objective C message (method) call. */
1072 CORE_ADDR responds_selector = 0;
1073 CORE_ADDR method_selector = 0;
1075 CORE_ADDR selector = 0;
1077 int struct_return = 0;
1078 enum noside sub_no_side = EVAL_NORMAL;
1080 struct value *msg_send = NULL;
1081 struct value *msg_send_stret = NULL;
1082 int gnu_runtime = 0;
1084 struct value *target = NULL;
1085 struct value *method = NULL;
1086 struct value *called_method = NULL;
1088 struct type *selector_type = NULL;
1089 struct type *long_type;
1091 struct value *ret = NULL;
1094 selector = exp->elts[pc + 1].longconst;
1095 nargs = exp->elts[pc + 2].longconst;
1096 argvec = XALLOCAVEC (struct value *, nargs + 5);
1100 long_type = builtin_type (exp->gdbarch)->builtin_long;
1101 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1103 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1104 sub_no_side = EVAL_NORMAL;
1106 sub_no_side = noside;
1108 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1110 if (value_as_long (target) == 0)
1111 return value_from_longest (long_type, 0);
1113 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
1116 /* Find the method dispatch (Apple runtime) or method lookup
1117 (GNU runtime) function for Objective-C. These will be used
1118 to lookup the symbol information for the method. If we
1119 can't find any symbol information, then we'll use these to
1120 call the method, otherwise we can call the method
1121 directly. The msg_send_stret function is used in the special
1122 case of a method that returns a structure (Apple runtime
1126 struct type *type = selector_type;
1128 type = lookup_function_type (type);
1129 type = lookup_pointer_type (type);
1130 type = lookup_function_type (type);
1131 type = lookup_pointer_type (type);
1133 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1135 = find_function_in_inferior ("objc_msg_lookup", NULL);
1137 msg_send = value_from_pointer (type, value_as_address (msg_send));
1138 msg_send_stret = value_from_pointer (type,
1139 value_as_address (msg_send_stret));
1143 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1144 /* Special dispatcher for methods returning structs. */
1146 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1149 /* Verify the target object responds to this method. The
1150 standard top-level 'Object' class uses a different name for
1151 the verification method than the non-standard, but more
1152 often used, 'NSObject' class. Make sure we check for both. */
1155 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1156 if (responds_selector == 0)
1158 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1160 if (responds_selector == 0)
1161 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1164 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1165 if (method_selector == 0)
1167 = lookup_child_selector (exp->gdbarch, "methodFor:");
1169 if (method_selector == 0)
1170 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1172 /* Call the verification method, to make sure that the target
1173 class implements the desired method. */
1175 argvec[0] = msg_send;
1177 argvec[2] = value_from_longest (long_type, responds_selector);
1178 argvec[3] = value_from_longest (long_type, selector);
1181 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1184 /* Function objc_msg_lookup returns a pointer. */
1186 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1188 if (value_as_long (ret) == 0)
1189 error (_("Target does not respond to this message selector."));
1191 /* Call "methodForSelector:" method, to get the address of a
1192 function method that implements this selector for this
1193 class. If we can find a symbol at that address, then we
1194 know the return type, parameter types etc. (that's a good
1197 argvec[0] = msg_send;
1199 argvec[2] = value_from_longest (long_type, method_selector);
1200 argvec[3] = value_from_longest (long_type, selector);
1203 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1207 ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
1210 /* ret should now be the selector. */
1212 addr = value_as_long (ret);
1215 struct symbol *sym = NULL;
1217 /* The address might point to a function descriptor;
1218 resolve it to the actual code address instead. */
1219 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1222 /* Is it a high_level symbol? */
1223 sym = find_pc_function (addr);
1225 method = value_of_variable (sym, 0);
1228 /* If we found a method with symbol information, check to see
1229 if it returns a struct. Otherwise assume it doesn't. */
1234 struct type *val_type;
1236 funaddr = find_function_addr (method, &val_type);
1238 block_for_pc (funaddr);
1240 val_type = check_typedef (val_type);
1242 if ((val_type == NULL)
1243 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1245 if (expect_type != NULL)
1246 val_type = expect_type;
1249 struct_return = using_struct_return (exp->gdbarch, method,
1252 else if (expect_type != NULL)
1254 struct_return = using_struct_return (exp->gdbarch, NULL,
1255 check_typedef (expect_type));
1258 /* Found a function symbol. Now we will substitute its
1259 value in place of the message dispatcher (obj_msgSend),
1260 so that we call the method directly instead of thru
1261 the dispatcher. The main reason for doing this is that
1262 we can now evaluate the return value and parameter values
1263 according to their known data types, in case we need to
1264 do things like promotion, dereferencing, special handling
1265 of structs and doubles, etc.
1267 We want to use the type signature of 'method', but still
1268 jump to objc_msgSend() or objc_msgSend_stret() to better
1269 mimic the behavior of the runtime. */
1273 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1274 error (_("method address has symbol information "
1275 "with non-function type; skipping"));
1277 /* Create a function pointer of the appropriate type, and
1278 replace its value with the value of msg_send or
1279 msg_send_stret. We must use a pointer here, as
1280 msg_send and msg_send_stret are of pointer type, and
1281 the representation may be different on systems that use
1282 function descriptors. */
1285 = value_from_pointer (lookup_pointer_type (value_type (method)),
1286 value_as_address (msg_send_stret));
1289 = value_from_pointer (lookup_pointer_type (value_type (method)),
1290 value_as_address (msg_send));
1295 called_method = msg_send_stret;
1297 called_method = msg_send;
1300 if (noside == EVAL_SKIP)
1301 return eval_skip_value (exp);
1303 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1305 /* If the return type doesn't look like a function type,
1306 call an error. This can happen if somebody tries to
1307 turn a variable into a function call. This is here
1308 because people often want to call, eg, strcmp, which
1309 gdb doesn't know is a function. If gdb isn't asked for
1310 it's opinion (ie. through "whatis"), it won't offer
1313 struct type *type = value_type (called_method);
1315 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1316 type = TYPE_TARGET_TYPE (type);
1317 type = TYPE_TARGET_TYPE (type);
1321 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1322 return allocate_value (expect_type);
1324 return allocate_value (type);
1327 error (_("Expression of type other than "
1328 "\"method returning ...\" used as a method"));
1331 /* Now depending on whether we found a symbol for the method,
1332 we will either call the runtime dispatcher or the method
1335 argvec[0] = called_method;
1337 argvec[2] = value_from_longest (long_type, selector);
1338 /* User-supplied arguments. */
1339 for (tem = 0; tem < nargs; tem++)
1340 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1341 argvec[tem + 3] = 0;
1343 if (gnu_runtime && (method != NULL))
1345 /* Function objc_msg_lookup returns a pointer. */
1346 deprecated_set_value_type (argvec[0],
1347 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1349 = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
1352 ret = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
1359 op = exp->elts[*pos].opcode;
1360 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1361 /* Allocate arg vector, including space for the function to be
1362 called in argvec[0], a potential `this', and a terminating NULL. */
1363 argvec = (struct value **)
1364 alloca (sizeof (struct value *) * (nargs + 3));
1365 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1367 /* First, evaluate the structure into arg2. */
1370 if (op == STRUCTOP_MEMBER)
1372 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1376 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1379 /* If the function is a virtual function, then the
1380 aggregate value (providing the structure) plays
1381 its part by providing the vtable. Otherwise,
1382 it is just along for the ride: call the function
1385 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1387 type = check_typedef (value_type (arg1));
1388 if (noside == EVAL_SKIP)
1389 tem = 1; /* Set it to the right arg index so that all arguments
1390 can also be skipped. */
1391 else if (TYPE_CODE (type) == TYPE_CODE_METHODPTR)
1393 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1394 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval);
1396 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1398 /* Now, say which argument to start evaluating from. */
1403 else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
1405 struct type *type_ptr
1406 = lookup_pointer_type (TYPE_SELF_TYPE (type));
1407 struct type *target_type_ptr
1408 = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1410 /* Now, convert these values to an address. */
1411 arg2 = value_cast (type_ptr, arg2);
1413 mem_offset = value_as_long (arg1);
1415 arg1 = value_from_pointer (target_type_ptr,
1416 value_as_long (arg2) + mem_offset);
1417 arg1 = value_ind (arg1);
1421 error (_("Non-pointer-to-member value used in pointer-to-member "
1424 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1426 /* Hair for method invocations. */
1430 /* First, evaluate the structure into arg2. */
1432 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1433 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1435 if (op == STRUCTOP_STRUCT)
1437 /* If v is a variable in a register, and the user types
1438 v.method (), this will produce an error, because v has
1441 A possible way around this would be to allocate a
1442 copy of the variable on the stack, copy in the
1443 contents, call the function, and copy out the
1444 contents. I.e. convert this from call by reference
1445 to call by copy-return (or whatever it's called).
1446 However, this does not work because it is not the
1447 same: the method being called could stash a copy of
1448 the address, and then future uses through that address
1449 (after the method returns) would be expected to
1450 use the variable itself, not some copy of it. */
1451 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1455 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1457 /* Check to see if the operator '->' has been
1458 overloaded. If the operator has been overloaded
1459 replace arg2 with the value returned by the custom
1460 operator and continue evaluation. */
1461 while (unop_user_defined_p (op, arg2))
1463 struct value *value = NULL;
1466 value = value_x_unop (arg2, op, noside);
1469 CATCH (except, RETURN_MASK_ERROR)
1471 if (except.error == NOT_FOUND_ERROR)
1474 throw_exception (except);
1481 /* Now, say which argument to start evaluating from. */
1484 else if (op == OP_SCOPE
1485 && overload_resolution
1486 && (exp->language_defn->la_language == language_cplus))
1488 /* Unpack it locally so we can properly handle overload
1494 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
1495 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
1496 type = exp->elts[pc2 + 1].type;
1497 name = &exp->elts[pc2 + 3].string;
1500 function_name = NULL;
1501 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
1503 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
1505 get_selected_block (0),
1507 if (function == NULL)
1508 error (_("No symbol \"%s\" in namespace \"%s\"."),
1509 name, TYPE_TAG_NAME (type));
1512 /* arg2 is left as NULL on purpose. */
1516 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1517 || TYPE_CODE (type) == TYPE_CODE_UNION);
1518 function_name = name;
1520 /* We need a properly typed value for method lookup. For
1521 static methods arg2 is otherwise unused. */
1522 arg2 = value_zero (type, lval_memory);
1527 else if (op == OP_ADL_FUNC)
1529 /* Save the function position and move pos so that the arguments
1530 can be evaluated. */
1536 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1537 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1541 /* Non-method function call. */
1545 /* If this is a C++ function wait until overload resolution. */
1546 if (op == OP_VAR_VALUE
1547 && overload_resolution
1548 && (exp->language_defn->la_language == language_cplus))
1550 (*pos) += 4; /* Skip the evaluation of the symbol. */
1555 if (op == OP_VAR_MSYM_VALUE)
1557 symbol *sym = exp->elts[*pos + 2].symbol;
1558 var_func_name = SYMBOL_PRINT_NAME (sym);
1560 else if (op == OP_VAR_VALUE)
1562 minimal_symbol *msym = exp->elts[*pos + 2].msymbol;
1563 var_func_name = MSYMBOL_PRINT_NAME (msym);
1566 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1567 type = value_type (argvec[0]);
1568 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1569 type = TYPE_TARGET_TYPE (type);
1570 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1572 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1574 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1582 /* Evaluate arguments (if not already done, e.g., namespace::func()
1583 and overload-resolution is off). */
1584 for (; tem <= nargs; tem++)
1586 /* Ensure that array expressions are coerced into pointer
1588 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1591 /* Signal end of arglist. */
1594 if (noside == EVAL_SKIP)
1595 return eval_skip_value (exp);
1597 if (op == OP_ADL_FUNC)
1599 struct symbol *symp;
1602 int string_pc = save_pos1 + 3;
1604 /* Extract the function name. */
1605 name_len = longest_to_int (exp->elts[string_pc].longconst);
1606 func_name = (char *) alloca (name_len + 1);
1607 strcpy (func_name, &exp->elts[string_pc + 1].string);
1609 find_overload_match (&argvec[1], nargs, func_name,
1610 NON_METHOD, /* not method */
1611 NULL, NULL, /* pass NULL symbol since
1612 symbol is unknown */
1613 NULL, &symp, NULL, 0, noside);
1615 /* Now fix the expression being evaluated. */
1616 exp->elts[save_pos1 + 2].symbol = symp;
1617 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1620 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1621 || (op == OP_SCOPE && function_name != NULL))
1623 int static_memfuncp;
1626 /* Method invocation: stuff "this" as first parameter.
1627 If the method turns out to be static we undo this below. */
1632 /* Name of method from expression. */
1633 tstr = &exp->elts[pc2 + 2].string;
1636 tstr = function_name;
1638 if (overload_resolution && (exp->language_defn->la_language
1641 /* Language is C++, do some overload resolution before
1643 struct value *valp = NULL;
1645 (void) find_overload_match (&argvec[1], nargs, tstr,
1646 METHOD, /* method */
1647 &arg2, /* the object */
1649 &static_memfuncp, 0, noside);
1651 if (op == OP_SCOPE && !static_memfuncp)
1653 /* For the time being, we don't handle this. */
1654 error (_("Call to overloaded function %s requires "
1658 argvec[1] = arg2; /* the ``this'' pointer */
1659 argvec[0] = valp; /* Use the method found after overload
1663 /* Non-C++ case -- or no overload resolution. */
1665 struct value *temp = arg2;
1667 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1669 op == STRUCTOP_STRUCT
1670 ? "structure" : "structure pointer");
1671 /* value_struct_elt updates temp with the correct value
1672 of the ``this'' pointer if necessary, so modify argvec[1] to
1673 reflect any ``this'' changes. */
1675 = value_from_longest (lookup_pointer_type(value_type (temp)),
1676 value_address (temp)
1677 + value_embedded_offset (temp));
1678 argvec[1] = arg2; /* the ``this'' pointer */
1681 /* Take out `this' if needed. */
1682 if (static_memfuncp)
1684 argvec[1] = argvec[0];
1689 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1691 /* Pointer to member. argvec[1] is already set up. */
1694 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1696 /* Non-member function being called. */
1697 /* fn: This can only be done for C++ functions. A C-style function
1698 in a C++ program, for instance, does not have the fields that
1699 are expected here. */
1701 if (overload_resolution && (exp->language_defn->la_language
1704 /* Language is C++, do some overload resolution before
1706 struct symbol *symp;
1709 /* If a scope has been specified disable ADL. */
1713 if (op == OP_VAR_VALUE)
1714 function = exp->elts[save_pos1+2].symbol;
1716 (void) find_overload_match (&argvec[1], nargs,
1717 NULL, /* no need for name */
1718 NON_METHOD, /* not method */
1719 NULL, function, /* the function */
1720 NULL, &symp, NULL, no_adl, noside);
1722 if (op == OP_VAR_VALUE)
1724 /* Now fix the expression being evaluated. */
1725 exp->elts[save_pos1+2].symbol = symp;
1726 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1730 argvec[0] = value_of_variable (symp, get_selected_block (0));
1734 /* Not C++, or no overload resolution allowed. */
1735 /* Nothing to be done; argvec already correctly set up. */
1740 /* It is probably a C-style function. */
1741 /* Nothing to be done; argvec already correctly set up. */
1746 if (argvec[0] == NULL)
1747 error (_("Cannot evaluate function -- may be inlined"));
1748 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1750 /* If the return type doesn't look like a function type,
1751 call an error. This can happen if somebody tries to turn
1752 a variable into a function call. */
1754 struct type *ftype = value_type (argvec[0]);
1756 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
1758 /* We don't know anything about what the internal
1759 function might return, but we have to return
1761 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
1764 else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
1766 struct type *return_type
1767 = result_type_of_xmethod (argvec[0], nargs, argvec + 1);
1769 if (return_type == NULL)
1770 error (_("Xmethod is missing return type."));
1771 return value_zero (return_type, not_lval);
1773 else if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
1774 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
1776 struct type *return_type = TYPE_TARGET_TYPE (ftype);
1778 if (return_type == NULL)
1779 return_type = expect_type;
1781 if (return_type == NULL)
1782 error_call_unknown_return_type (var_func_name);
1784 return allocate_value (return_type);
1787 error (_("Expression of type other than "
1788 "\"Function returning ...\" used as function"));
1790 switch (TYPE_CODE (value_type (argvec[0])))
1792 case TYPE_CODE_INTERNAL_FUNCTION:
1793 return call_internal_function (exp->gdbarch, exp->language_defn,
1794 argvec[0], nargs, argvec + 1);
1795 case TYPE_CODE_XMETHOD:
1796 return call_xmethod (argvec[0], nargs, argvec + 1);
1798 return call_function_by_hand (argvec[0],
1799 expect_type, nargs, argvec + 1);
1801 /* pai: FIXME save value from call_function_by_hand, then adjust
1802 pc by adjust_fn_pc if +ve. */
1804 case OP_F77_UNDETERMINED_ARGLIST:
1806 /* Remember that in F77, functions, substring ops and
1807 array subscript operations cannot be disambiguated
1808 at parse time. We have made all array subscript operations,
1809 substring operations as well as function calls come here
1810 and we now have to discover what the heck this thing actually was.
1811 If it is a function, we process just as if we got an OP_FUNCALL. */
1813 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1816 /* First determine the type code we are dealing with. */
1817 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1818 type = check_typedef (value_type (arg1));
1819 code = TYPE_CODE (type);
1821 if (code == TYPE_CODE_PTR)
1823 /* Fortran always passes variable to subroutines as pointer.
1824 So we need to look into its target type to see if it is
1825 array, string or function. If it is, we need to switch
1826 to the target value the original one points to. */
1827 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1829 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1830 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1831 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1833 arg1 = value_ind (arg1);
1834 type = check_typedef (value_type (arg1));
1835 code = TYPE_CODE (type);
1841 case TYPE_CODE_ARRAY:
1842 if (exp->elts[*pos].opcode == OP_RANGE)
1843 return value_f90_subarray (arg1, exp, pos, noside);
1845 goto multi_f77_subscript;
1847 case TYPE_CODE_STRING:
1848 if (exp->elts[*pos].opcode == OP_RANGE)
1849 return value_f90_subarray (arg1, exp, pos, noside);
1852 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1853 return value_subscript (arg1, value_as_long (arg2));
1857 case TYPE_CODE_FUNC:
1858 /* It's a function call. */
1859 /* Allocate arg vector, including space for the function to be
1860 called in argvec[0] and a terminating NULL. */
1861 argvec = (struct value **)
1862 alloca (sizeof (struct value *) * (nargs + 2));
1865 for (; tem <= nargs; tem++)
1866 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1867 argvec[tem] = 0; /* signal end of arglist */
1868 if (noside == EVAL_SKIP)
1869 return eval_skip_value (exp);
1873 error (_("Cannot perform substring on this type"));
1877 /* We have a complex number, There should be 2 floating
1878 point numbers that compose it. */
1880 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1881 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1883 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1885 case STRUCTOP_STRUCT:
1886 tem = longest_to_int (exp->elts[pc + 1].longconst);
1887 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1888 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1889 if (noside == EVAL_SKIP)
1890 return eval_skip_value (exp);
1891 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1893 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1894 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
1898 tem = longest_to_int (exp->elts[pc + 1].longconst);
1899 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1900 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1901 if (noside == EVAL_SKIP)
1902 return eval_skip_value (exp);
1904 /* Check to see if operator '->' has been overloaded. If so replace
1905 arg1 with the value returned by evaluating operator->(). */
1906 while (unop_user_defined_p (op, arg1))
1908 struct value *value = NULL;
1911 value = value_x_unop (arg1, op, noside);
1914 CATCH (except, RETURN_MASK_ERROR)
1916 if (except.error == NOT_FOUND_ERROR)
1919 throw_exception (except);
1926 /* JYG: if print object is on we need to replace the base type
1927 with rtti type in order to continue on with successful
1928 lookup of member / method only available in the rtti type. */
1930 struct type *type = value_type (arg1);
1931 struct type *real_type;
1932 int full, using_enc;
1934 struct value_print_options opts;
1936 get_user_print_options (&opts);
1937 if (opts.objectprint && TYPE_TARGET_TYPE(type)
1938 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
1940 real_type = value_rtti_indirect_type (arg1, &full, &top,
1943 arg1 = value_cast (real_type, arg1);
1947 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1948 NULL, "structure pointer");
1949 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1950 arg3 = value_zero (value_type (arg3), VALUE_LVAL (arg3));
1953 case STRUCTOP_MEMBER:
1955 if (op == STRUCTOP_MEMBER)
1956 arg1 = evaluate_subexp_for_address (exp, pos, noside);
1958 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1960 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1962 if (noside == EVAL_SKIP)
1963 return eval_skip_value (exp);
1965 type = check_typedef (value_type (arg2));
1966 switch (TYPE_CODE (type))
1968 case TYPE_CODE_METHODPTR:
1969 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1970 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1973 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
1974 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
1975 return value_ind (arg2);
1978 case TYPE_CODE_MEMBERPTR:
1979 /* Now, convert these values to an address. */
1980 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
1983 mem_offset = value_as_long (arg2);
1985 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1986 value_as_long (arg1) + mem_offset);
1987 return value_ind (arg3);
1990 error (_("non-pointer-to-member value used "
1991 "in pointer-to-member construct"));
1995 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1996 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
1997 for (ix = 0; ix < nargs; ++ix)
1998 arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
2000 expect_type = make_params (nargs, arg_types);
2001 *(pos) += 3 + nargs;
2002 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
2003 xfree (TYPE_FIELDS (expect_type));
2004 xfree (TYPE_MAIN_TYPE (expect_type));
2005 xfree (expect_type);
2009 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2010 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2011 if (noside == EVAL_SKIP)
2012 return eval_skip_value (exp);
2013 if (binop_user_defined_p (op, arg1, arg2))
2014 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2016 return value_concat (arg1, arg2);
2019 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2020 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2022 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2024 if (binop_user_defined_p (op, arg1, arg2))
2025 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2027 return value_assign (arg1, arg2);
2029 case BINOP_ASSIGN_MODIFY:
2031 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2032 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2033 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2035 op = exp->elts[pc + 1].opcode;
2036 if (binop_user_defined_p (op, arg1, arg2))
2037 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
2038 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2040 && is_integral_type (value_type (arg2)))
2041 arg2 = value_ptradd (arg1, value_as_long (arg2));
2042 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2044 && is_integral_type (value_type (arg2)))
2045 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2048 struct value *tmp = arg1;
2050 /* For shift and integer exponentiation operations,
2051 only promote the first argument. */
2052 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2053 && is_integral_type (value_type (arg2)))
2054 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2056 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2058 arg2 = value_binop (tmp, arg2, op);
2060 return value_assign (arg1, arg2);
2063 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2064 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2065 if (noside == EVAL_SKIP)
2066 return eval_skip_value (exp);
2067 if (binop_user_defined_p (op, arg1, arg2))
2068 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2069 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2070 && is_integral_type (value_type (arg2)))
2071 return value_ptradd (arg1, value_as_long (arg2));
2072 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2073 && is_integral_type (value_type (arg1)))
2074 return value_ptradd (arg2, value_as_long (arg1));
2077 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2078 return value_binop (arg1, arg2, BINOP_ADD);
2082 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2083 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2084 if (noside == EVAL_SKIP)
2085 return eval_skip_value (exp);
2086 if (binop_user_defined_p (op, arg1, arg2))
2087 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2088 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2089 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2091 /* FIXME -- should be ptrdiff_t */
2092 type = builtin_type (exp->gdbarch)->builtin_long;
2093 return value_from_longest (type, value_ptrdiff (arg1, arg2));
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));
2100 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2101 return value_binop (arg1, arg2, BINOP_SUB);
2112 case BINOP_BITWISE_AND:
2113 case BINOP_BITWISE_IOR:
2114 case BINOP_BITWISE_XOR:
2115 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2116 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2117 if (noside == EVAL_SKIP)
2118 return eval_skip_value (exp);
2119 if (binop_user_defined_p (op, arg1, arg2))
2120 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2123 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2124 fudge arg2 to avoid division-by-zero, the caller is
2125 (theoretically) only looking for the type of the result. */
2126 if (noside == EVAL_AVOID_SIDE_EFFECTS
2127 /* ??? Do we really want to test for BINOP_MOD here?
2128 The implementation of value_binop gives it a well-defined
2131 || op == BINOP_INTDIV
2134 && value_logical_not (arg2))
2136 struct value *v_one, *retval;
2138 v_one = value_one (value_type (arg2));
2139 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2140 retval = value_binop (arg1, v_one, op);
2145 /* For shift and integer exponentiation operations,
2146 only promote the first argument. */
2147 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2148 && is_integral_type (value_type (arg2)))
2149 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2151 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2153 return value_binop (arg1, arg2, op);
2157 case BINOP_SUBSCRIPT:
2158 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2159 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2160 if (noside == EVAL_SKIP)
2161 return eval_skip_value (exp);
2162 if (binop_user_defined_p (op, arg1, arg2))
2163 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2166 /* If the user attempts to subscript something that is not an
2167 array or pointer type (like a plain int variable for example),
2168 then report this as an error. */
2170 arg1 = coerce_ref (arg1);
2171 type = check_typedef (value_type (arg1));
2172 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2173 && TYPE_CODE (type) != TYPE_CODE_PTR)
2175 if (TYPE_NAME (type))
2176 error (_("cannot subscript something of type `%s'"),
2179 error (_("cannot subscript requested type"));
2182 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2183 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2185 return value_subscript (arg1, value_as_long (arg2));
2187 case MULTI_SUBSCRIPT:
2189 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2190 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2193 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2194 /* FIXME: EVAL_SKIP handling may not be correct. */
2195 if (noside == EVAL_SKIP)
2199 return eval_skip_value (exp);
2201 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2202 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2204 /* If the user attempts to subscript something that has no target
2205 type (like a plain int variable for example), then report this
2208 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2211 arg1 = value_zero (type, VALUE_LVAL (arg1));
2217 error (_("cannot subscript something of type `%s'"),
2218 TYPE_NAME (value_type (arg1)));
2222 if (binop_user_defined_p (op, arg1, arg2))
2224 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2228 arg1 = coerce_ref (arg1);
2229 type = check_typedef (value_type (arg1));
2231 switch (TYPE_CODE (type))
2234 case TYPE_CODE_ARRAY:
2235 case TYPE_CODE_STRING:
2236 arg1 = value_subscript (arg1, value_as_long (arg2));
2240 if (TYPE_NAME (type))
2241 error (_("cannot subscript something of type `%s'"),
2244 error (_("cannot subscript requested type"));
2250 multi_f77_subscript:
2252 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2253 int ndimensions = 1, i;
2254 struct value *array = arg1;
2256 if (nargs > MAX_FORTRAN_DIMS)
2257 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2259 ndimensions = calc_f77_array_dims (type);
2261 if (nargs != ndimensions)
2262 error (_("Wrong number of subscripts"));
2264 gdb_assert (nargs > 0);
2266 /* Now that we know we have a legal array subscript expression
2267 let us actually find out where this element exists in the array. */
2269 /* Take array indices left to right. */
2270 for (i = 0; i < nargs; i++)
2272 /* Evaluate each subscript; it must be a legal integer in F77. */
2273 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2275 /* Fill in the subscript array. */
2277 subscript_array[i] = value_as_long (arg2);
2280 /* Internal type of array is arranged right to left. */
2281 for (i = nargs; i > 0; i--)
2283 struct type *array_type = check_typedef (value_type (array));
2284 LONGEST index = subscript_array[i - 1];
2286 array = value_subscripted_rvalue (array, index,
2287 f77_get_lowerbound (array_type));
2293 case BINOP_LOGICAL_AND:
2294 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2295 if (noside == EVAL_SKIP)
2297 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2298 return eval_skip_value (exp);
2302 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2305 if (binop_user_defined_p (op, arg1, arg2))
2307 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2308 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2312 tem = value_logical_not (arg1);
2313 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2314 (tem ? EVAL_SKIP : noside));
2315 type = language_bool_type (exp->language_defn, exp->gdbarch);
2316 return value_from_longest (type,
2317 (LONGEST) (!tem && !value_logical_not (arg2)));
2320 case BINOP_LOGICAL_OR:
2321 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2322 if (noside == EVAL_SKIP)
2324 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2325 return eval_skip_value (exp);
2329 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2332 if (binop_user_defined_p (op, arg1, arg2))
2334 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2335 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2339 tem = value_logical_not (arg1);
2340 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2341 (!tem ? EVAL_SKIP : noside));
2342 type = language_bool_type (exp->language_defn, exp->gdbarch);
2343 return value_from_longest (type,
2344 (LONGEST) (!tem || !value_logical_not (arg2)));
2348 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2349 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2350 if (noside == EVAL_SKIP)
2351 return eval_skip_value (exp);
2352 if (binop_user_defined_p (op, arg1, arg2))
2354 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2358 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2359 tem = value_equal (arg1, arg2);
2360 type = language_bool_type (exp->language_defn, exp->gdbarch);
2361 return value_from_longest (type, (LONGEST) tem);
2364 case BINOP_NOTEQUAL:
2365 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2366 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2367 if (noside == EVAL_SKIP)
2368 return eval_skip_value (exp);
2369 if (binop_user_defined_p (op, arg1, arg2))
2371 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2375 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2376 tem = value_equal (arg1, arg2);
2377 type = language_bool_type (exp->language_defn, exp->gdbarch);
2378 return value_from_longest (type, (LONGEST) ! tem);
2382 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2383 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2384 if (noside == EVAL_SKIP)
2385 return eval_skip_value (exp);
2386 if (binop_user_defined_p (op, arg1, arg2))
2388 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2392 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2393 tem = value_less (arg1, arg2);
2394 type = language_bool_type (exp->language_defn, exp->gdbarch);
2395 return value_from_longest (type, (LONGEST) tem);
2399 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2400 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2401 if (noside == EVAL_SKIP)
2402 return eval_skip_value (exp);
2403 if (binop_user_defined_p (op, arg1, arg2))
2405 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2409 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2410 tem = value_less (arg2, arg1);
2411 type = language_bool_type (exp->language_defn, exp->gdbarch);
2412 return value_from_longest (type, (LONGEST) tem);
2416 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2417 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2418 if (noside == EVAL_SKIP)
2419 return eval_skip_value (exp);
2420 if (binop_user_defined_p (op, arg1, arg2))
2422 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2426 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2427 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2428 type = language_bool_type (exp->language_defn, exp->gdbarch);
2429 return value_from_longest (type, (LONGEST) tem);
2433 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2434 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2435 if (noside == EVAL_SKIP)
2436 return eval_skip_value (exp);
2437 if (binop_user_defined_p (op, arg1, arg2))
2439 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2443 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2444 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2445 type = language_bool_type (exp->language_defn, exp->gdbarch);
2446 return value_from_longest (type, (LONGEST) tem);
2450 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2451 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2452 if (noside == EVAL_SKIP)
2453 return eval_skip_value (exp);
2454 type = check_typedef (value_type (arg2));
2455 if (TYPE_CODE (type) != TYPE_CODE_INT
2456 && TYPE_CODE (type) != TYPE_CODE_ENUM)
2457 error (_("Non-integral right operand for \"@\" operator."));
2458 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2460 return allocate_repeat_value (value_type (arg1),
2461 longest_to_int (value_as_long (arg2)));
2464 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2467 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2468 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2471 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2472 if (noside == EVAL_SKIP)
2473 return eval_skip_value (exp);
2474 if (unop_user_defined_p (op, arg1))
2475 return value_x_unop (arg1, op, noside);
2478 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2479 return value_pos (arg1);
2483 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2484 if (noside == EVAL_SKIP)
2485 return eval_skip_value (exp);
2486 if (unop_user_defined_p (op, arg1))
2487 return value_x_unop (arg1, op, noside);
2490 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2491 return value_neg (arg1);
2494 case UNOP_COMPLEMENT:
2495 /* C++: check for and handle destructor names. */
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 (UNOP_COMPLEMENT, arg1))
2501 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2504 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2505 return value_complement (arg1);
2508 case UNOP_LOGICAL_NOT:
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 type = language_bool_type (exp->language_defn, exp->gdbarch);
2517 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2521 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2522 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2523 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2524 type = check_typedef (value_type (arg1));
2525 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2526 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2527 error (_("Attempt to dereference pointer "
2528 "to member without an object"));
2529 if (noside == EVAL_SKIP)
2530 return eval_skip_value (exp);
2531 if (unop_user_defined_p (op, arg1))
2532 return value_x_unop (arg1, op, noside);
2533 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2535 type = check_typedef (value_type (arg1));
2536 if (TYPE_CODE (type) == TYPE_CODE_PTR
2537 || TYPE_IS_REFERENCE (type)
2538 /* In C you can dereference an array to get the 1st elt. */
2539 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2541 return value_zero (TYPE_TARGET_TYPE (type),
2543 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2544 /* GDB allows dereferencing an int. */
2545 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2548 error (_("Attempt to take contents of a non-pointer value."));
2551 /* Allow * on an integer so we can cast it to whatever we want.
2552 This returns an int, which seems like the most C-like thing to
2553 do. "long long" variables are rare enough that
2554 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2555 if (TYPE_CODE (type) == TYPE_CODE_INT)
2556 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2557 (CORE_ADDR) value_as_address (arg1));
2558 return value_ind (arg1);
2561 /* C++: check for and handle pointer to members. */
2563 if (noside == EVAL_SKIP)
2565 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2566 return eval_skip_value (exp);
2570 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2577 if (noside == EVAL_SKIP)
2579 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2580 return eval_skip_value (exp);
2582 return evaluate_subexp_for_sizeof (exp, pos, noside);
2586 type = exp->elts[pc + 1].type;
2587 arg1 = evaluate_subexp (type, exp, pos, noside);
2588 if (noside == EVAL_SKIP)
2589 return eval_skip_value (exp);
2590 if (type != value_type (arg1))
2591 arg1 = value_cast (type, arg1);
2594 case UNOP_CAST_TYPE:
2595 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2596 type = value_type (arg1);
2597 arg1 = evaluate_subexp (type, exp, pos, noside);
2598 if (noside == EVAL_SKIP)
2599 return eval_skip_value (exp);
2600 if (type != value_type (arg1))
2601 arg1 = value_cast (type, arg1);
2604 case UNOP_DYNAMIC_CAST:
2605 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2606 type = value_type (arg1);
2607 arg1 = evaluate_subexp (type, exp, pos, noside);
2608 if (noside == EVAL_SKIP)
2609 return eval_skip_value (exp);
2610 return value_dynamic_cast (type, arg1);
2612 case UNOP_REINTERPRET_CAST:
2613 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2614 type = value_type (arg1);
2615 arg1 = evaluate_subexp (type, exp, pos, noside);
2616 if (noside == EVAL_SKIP)
2617 return eval_skip_value (exp);
2618 return value_reinterpret_cast (type, arg1);
2622 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2623 if (noside == EVAL_SKIP)
2624 return eval_skip_value (exp);
2625 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2626 return value_zero (exp->elts[pc + 1].type, lval_memory);
2628 return value_at_lazy (exp->elts[pc + 1].type,
2629 value_as_address (arg1));
2631 case UNOP_MEMVAL_TYPE:
2632 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2633 type = value_type (arg1);
2634 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2635 if (noside == EVAL_SKIP)
2636 return eval_skip_value (exp);
2637 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2638 return value_zero (type, lval_memory);
2640 return value_at_lazy (type, value_as_address (arg1));
2642 case UNOP_MEMVAL_TLS:
2644 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2645 if (noside == EVAL_SKIP)
2646 return eval_skip_value (exp);
2647 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2648 return value_zero (exp->elts[pc + 2].type, lval_memory);
2653 tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2654 value_as_address (arg1));
2655 return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
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);
2926 tem = longest_to_int (exp->elts[pc + 2].longconst);
2927 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2928 x = value_aggregate_elt (exp->elts[pc + 1].type,
2929 &exp->elts[pc + 3].string,
2932 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2937 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2938 default_case_after_eval:
2939 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2941 struct type *type = check_typedef (value_type (x));
2943 if (TYPE_IS_REFERENCE (type))
2944 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2946 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2947 return value_zero (lookup_pointer_type (value_type (x)),
2950 error (_("Attempt to take address of "
2951 "value not located in memory."));
2953 return value_addr (x);
2957 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2958 When used in contexts where arrays will be coerced anyway, this is
2959 equivalent to `evaluate_subexp' but much faster because it avoids
2960 actually fetching array contents (perhaps obsolete now that we have
2963 Note that we currently only do the coercion for C expressions, where
2964 arrays are zero based and the coercion is correct. For other languages,
2965 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2966 to decide if coercion is appropriate. */
2969 evaluate_subexp_with_coercion (struct expression *exp,
2970 int *pos, enum noside noside)
2979 op = exp->elts[pc].opcode;
2984 var = exp->elts[pc + 2].symbol;
2985 type = check_typedef (SYMBOL_TYPE (var));
2986 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
2987 && !TYPE_VECTOR (type)
2988 && CAST_IS_CONVERSION (exp->language_defn))
2991 val = address_of_variable (var, exp->elts[pc + 1].block);
2992 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2998 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
3002 /* Evaluate a subexpression of EXP, at index *POS,
3003 and return a value for the size of that subexpression.
3004 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
3005 we allow side-effects on the operand if its type is a variable
3008 static struct value *
3009 evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
3012 /* FIXME: This should be size_t. */
3013 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3020 op = exp->elts[pc].opcode;
3024 /* This case is handled specially
3025 so that we avoid creating a value for the result type.
3026 If the result type is very big, it's desirable not to
3027 create a value unnecessarily. */
3030 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3031 type = check_typedef (value_type (val));
3032 if (TYPE_CODE (type) != TYPE_CODE_PTR
3033 && !TYPE_IS_REFERENCE (type)
3034 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3035 error (_("Attempt to take contents of a non-pointer value."));
3036 type = TYPE_TARGET_TYPE (type);
3037 if (is_dynamic_type (type))
3038 type = value_type (value_ind (val));
3039 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3043 type = exp->elts[pc + 1].type;
3046 case UNOP_MEMVAL_TYPE:
3048 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3049 type = value_type (val);
3053 type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
3054 if (is_dynamic_type (type))
3056 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3057 type = value_type (val);
3063 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3064 type of the subscript is a variable length array type. In this case we
3065 must re-evaluate the right hand side of the subcription to allow
3067 case BINOP_SUBSCRIPT:
3068 if (noside == EVAL_NORMAL)
3070 int pc = (*pos) + 1;
3072 val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
3073 type = check_typedef (value_type (val));
3074 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3076 type = check_typedef (TYPE_TARGET_TYPE (type));
3077 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3079 type = TYPE_INDEX_TYPE (type);
3080 /* Only re-evaluate the right hand side if the resulting type
3081 is a variable length type. */
3082 if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
3084 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3085 return value_from_longest
3086 (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
3095 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3096 type = value_type (val);
3100 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3101 "When applied to a reference or a reference type, the result is
3102 the size of the referenced type." */
3103 type = check_typedef (type);
3104 if (exp->language_defn->la_language == language_cplus
3105 && (TYPE_IS_REFERENCE (type)))
3106 type = check_typedef (TYPE_TARGET_TYPE (type));
3107 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3110 /* Parse a type expression in the string [P..P+LENGTH). */
3113 parse_and_eval_type (char *p, int length)
3115 char *tmp = (char *) alloca (length + 4);
3118 memcpy (tmp + 1, p, length);
3119 tmp[length + 1] = ')';
3120 tmp[length + 2] = '0';
3121 tmp[length + 3] = '\0';
3122 expression_up expr = parse_expression (tmp);
3123 if (expr->elts[0].opcode != UNOP_CAST)
3124 error (_("Internal error in eval_type."));
3125 return expr->elts[1].type;
3129 calc_f77_array_dims (struct type *array_type)
3132 struct type *tmp_type;
3134 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3135 error (_("Can't get dimensions for a non-array type"));
3137 tmp_type = array_type;
3139 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3141 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)