1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2015 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 struct expression *expr = parse_expression (exp);
100 struct cleanup *old_chain =
101 make_cleanup (free_current_contents, &expr);
103 addr = value_as_address (evaluate_expression (expr));
104 do_cleanups (old_chain);
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 struct expression *expr = parse_expression (exp);
115 struct cleanup *old_chain =
116 make_cleanup (free_current_contents, &expr);
118 retval = value_as_long (evaluate_expression (expr));
119 do_cleanups (old_chain);
124 parse_and_eval (const char *exp)
126 struct expression *expr = parse_expression (exp);
128 struct cleanup *old_chain =
129 make_cleanup (free_current_contents, &expr);
131 val = evaluate_expression (expr);
132 do_cleanups (old_chain);
136 /* Parse up to a comma (or to a closeparen)
137 in the string EXPP as an expression, evaluate it, and return the value.
138 EXPP is advanced to point to the comma. */
141 parse_to_comma_and_eval (const char **expp)
143 struct expression *expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
145 struct cleanup *old_chain =
146 make_cleanup (free_current_contents, &expr);
148 val = evaluate_expression (expr);
149 do_cleanups (old_chain);
153 /* Evaluate an expression in internal prefix form
154 such as is constructed by parse.y.
156 See expression.h for info on the format of an expression. */
159 evaluate_expression (struct expression *exp)
163 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
166 /* Evaluate an expression, avoiding all memory references
167 and getting a value whose type alone is correct. */
170 evaluate_type (struct expression *exp)
174 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
177 /* Evaluate a subexpression, avoiding all memory references and
178 getting a value whose type alone is correct. */
181 evaluate_subexpression_type (struct expression *exp, int subexp)
183 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
186 /* Find the current value of a watchpoint on EXP. Return the value in
187 *VALP and *RESULTP and the chain of intermediate and final values
188 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
191 If PRESERVE_ERRORS is true, then exceptions are passed through.
192 Otherwise, if PRESERVE_ERRORS is false, then if a memory error
193 occurs while evaluating the expression, *RESULTP will be set to
194 NULL. *RESULTP may be a lazy value, if the result could not be
195 read from memory. It is used to determine whether a value is
196 user-specified (we should watch the whole value) or intermediate
197 (we should watch only the bit used to locate the final value).
199 If the final value, or any intermediate value, could not be read
200 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
201 set to any referenced values. *VALP will never be a lazy value.
202 This is the value which we store in struct breakpoint.
204 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
205 value chain. The caller must free the values individually. If
206 VAL_CHAIN is NULL, all generated values will be left on the value
210 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
211 struct value **resultp, struct value **val_chain,
214 struct value *mark, *new_mark, *result;
222 /* Evaluate the expression. */
223 mark = value_mark ();
228 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
230 CATCH (ex, RETURN_MASK_ALL)
232 /* Ignore memory errors if we want watchpoints pointing at
233 inaccessible memory to still be created; otherwise, throw the
234 error to some higher catcher. */
238 if (!preserve_errors)
241 throw_exception (ex);
247 new_mark = value_mark ();
248 if (mark == new_mark)
253 /* Make sure it's not lazy, so that after the target stops again we
254 have a non-lazy previous value to compare with. */
257 if (!value_lazy (result))
264 value_fetch_lazy (result);
267 CATCH (except, RETURN_MASK_ERROR)
276 /* Return the chain of intermediate values. We use this to
277 decide which addresses to watch. */
278 *val_chain = new_mark;
279 value_release_to_mark (mark);
283 /* Extract a field operation from an expression. If the subexpression
284 of EXP starting at *SUBEXP is not a structure dereference
285 operation, return NULL. Otherwise, return the name of the
286 dereferenced field, and advance *SUBEXP to point to the
287 subexpression of the left-hand-side of the dereference. This is
288 used when completing field names. */
291 extract_field_op (struct expression *exp, int *subexp)
296 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
297 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
299 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
300 result = &exp->elts[*subexp + 2].string;
301 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
305 /* This function evaluates brace-initializers (in C/C++) for
308 static struct value *
309 evaluate_struct_tuple (struct value *struct_val,
310 struct expression *exp,
311 int *pos, enum noside noside, int nargs)
313 struct type *struct_type = check_typedef (value_type (struct_val));
314 struct type *field_type;
319 struct value *val = NULL;
324 /* Skip static fields. */
325 while (fieldno < TYPE_NFIELDS (struct_type)
326 && field_is_static (&TYPE_FIELD (struct_type,
329 if (fieldno >= TYPE_NFIELDS (struct_type))
330 error (_("too many initializers"));
331 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
332 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
333 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
334 error (_("don't know which variant you want to set"));
336 /* Here, struct_type is the type of the inner struct,
337 while substruct_type is the type of the inner struct.
338 These are the same for normal structures, but a variant struct
339 contains anonymous union fields that contain substruct fields.
340 The value fieldno is the index of the top-level (normal or
341 anonymous union) field in struct_field, while the value
342 subfieldno is the index of the actual real (named inner) field
343 in substruct_type. */
345 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
347 val = evaluate_subexp (field_type, exp, pos, noside);
349 /* Now actually set the field in struct_val. */
351 /* Assign val to field fieldno. */
352 if (value_type (val) != field_type)
353 val = value_cast (field_type, val);
355 bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
356 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
357 addr = value_contents_writeable (struct_val) + bitpos / 8;
359 modify_field (struct_type, addr,
360 value_as_long (val), bitpos % 8, bitsize);
362 memcpy (addr, value_contents (val),
363 TYPE_LENGTH (value_type (val)));
369 /* Recursive helper function for setting elements of array tuples.
370 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
371 element value is ELEMENT; EXP, POS and NOSIDE are as usual.
372 Evaluates index expresions and sets the specified element(s) of
373 ARRAY to ELEMENT. Returns last index value. */
376 init_array_element (struct value *array, struct value *element,
377 struct expression *exp, int *pos,
378 enum noside noside, LONGEST low_bound, LONGEST high_bound)
381 int element_size = TYPE_LENGTH (value_type (element));
383 if (exp->elts[*pos].opcode == BINOP_COMMA)
386 init_array_element (array, element, exp, pos, noside,
387 low_bound, high_bound);
388 return init_array_element (array, element,
389 exp, pos, noside, low_bound, high_bound);
393 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
394 if (index < low_bound || index > high_bound)
395 error (_("tuple index out of range"));
396 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
397 value_contents (element), element_size);
402 static struct value *
403 value_f90_subarray (struct value *array,
404 struct expression *exp, int *pos, enum noside noside)
407 LONGEST low_bound, high_bound;
408 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
409 enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);
413 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
414 low_bound = TYPE_LOW_BOUND (range);
416 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
418 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
419 high_bound = TYPE_HIGH_BOUND (range);
421 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
423 return value_slice (array, low_bound, high_bound - low_bound + 1);
427 /* Promote value ARG1 as appropriate before performing a unary operation
429 If the result is not appropriate for any particular language then it
430 needs to patch this function. */
433 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
438 *arg1 = coerce_ref (*arg1);
439 type1 = check_typedef (value_type (*arg1));
441 if (is_integral_type (type1))
443 switch (language->la_language)
446 /* Perform integral promotion for ANSI C/C++.
447 If not appropropriate for any particular language
448 it needs to modify this function. */
450 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
452 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
453 *arg1 = value_cast (builtin_int, *arg1);
460 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
461 operation on those two operands.
462 If the result is not appropriate for any particular language then it
463 needs to patch this function. */
466 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
467 struct value **arg1, struct value **arg2)
469 struct type *promoted_type = NULL;
473 *arg1 = coerce_ref (*arg1);
474 *arg2 = coerce_ref (*arg2);
476 type1 = check_typedef (value_type (*arg1));
477 type2 = check_typedef (value_type (*arg2));
479 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
480 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
481 && !is_integral_type (type1))
482 || (TYPE_CODE (type2) != TYPE_CODE_FLT
483 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
484 && !is_integral_type (type2)))
487 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
488 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
490 /* No promotion required. */
492 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
493 || TYPE_CODE (type2) == TYPE_CODE_FLT)
495 switch (language->la_language)
501 case language_opencl:
502 /* No promotion required. */
506 /* For other languages the result type is unchanged from gdb
507 version 6.7 for backward compatibility.
508 If either arg was long double, make sure that value is also long
509 double. Otherwise use double. */
510 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
511 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
512 promoted_type = builtin_type (gdbarch)->builtin_long_double;
514 promoted_type = builtin_type (gdbarch)->builtin_double;
518 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
519 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
521 /* No promotion required. */
524 /* Integral operations here. */
525 /* FIXME: Also mixed integral/booleans, with result an integer. */
527 const struct builtin_type *builtin = builtin_type (gdbarch);
528 unsigned int promoted_len1 = TYPE_LENGTH (type1);
529 unsigned int promoted_len2 = TYPE_LENGTH (type2);
530 int is_unsigned1 = TYPE_UNSIGNED (type1);
531 int is_unsigned2 = TYPE_UNSIGNED (type2);
532 unsigned int result_len;
533 int unsigned_operation;
535 /* Determine type length and signedness after promotion for
537 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
540 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
542 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
545 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
548 if (promoted_len1 > promoted_len2)
550 unsigned_operation = is_unsigned1;
551 result_len = promoted_len1;
553 else if (promoted_len2 > promoted_len1)
555 unsigned_operation = is_unsigned2;
556 result_len = promoted_len2;
560 unsigned_operation = is_unsigned1 || is_unsigned2;
561 result_len = promoted_len1;
564 switch (language->la_language)
570 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
572 promoted_type = (unsigned_operation
573 ? builtin->builtin_unsigned_int
574 : builtin->builtin_int);
576 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
578 promoted_type = (unsigned_operation
579 ? builtin->builtin_unsigned_long
580 : builtin->builtin_long);
584 promoted_type = (unsigned_operation
585 ? builtin->builtin_unsigned_long_long
586 : builtin->builtin_long_long);
589 case language_opencl:
590 if (result_len <= TYPE_LENGTH (lookup_signed_typename
591 (language, gdbarch, "int")))
595 ? lookup_unsigned_typename (language, gdbarch, "int")
596 : lookup_signed_typename (language, gdbarch, "int"));
598 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
599 (language, gdbarch, "long")))
603 ? lookup_unsigned_typename (language, gdbarch, "long")
604 : lookup_signed_typename (language, gdbarch,"long"));
608 /* For other languages the result type is unchanged from gdb
609 version 6.7 for backward compatibility.
610 If either arg was long long, make sure that value is also long
611 long. Otherwise use long. */
612 if (unsigned_operation)
614 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
615 promoted_type = builtin->builtin_unsigned_long_long;
617 promoted_type = builtin->builtin_unsigned_long;
621 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
622 promoted_type = builtin->builtin_long_long;
624 promoted_type = builtin->builtin_long;
632 /* Promote both operands to common type. */
633 *arg1 = value_cast (promoted_type, *arg1);
634 *arg2 = value_cast (promoted_type, *arg2);
639 ptrmath_type_p (const struct language_defn *lang, struct type *type)
641 type = check_typedef (type);
642 if (TYPE_CODE (type) == TYPE_CODE_REF)
643 type = TYPE_TARGET_TYPE (type);
645 switch (TYPE_CODE (type))
651 case TYPE_CODE_ARRAY:
652 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
659 /* Constructs a fake method with the given parameter types.
660 This function is used by the parser to construct an "expected"
661 type for method overload resolution. */
664 make_params (int num_types, struct type **param_types)
666 struct type *type = XCNEW (struct type);
667 TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
668 TYPE_LENGTH (type) = 1;
669 TYPE_CODE (type) = TYPE_CODE_METHOD;
670 TYPE_CHAIN (type) = type;
673 if (param_types[num_types - 1] == NULL)
676 TYPE_VARARGS (type) = 1;
678 else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
682 /* Caller should have ensured this. */
683 gdb_assert (num_types == 0);
684 TYPE_PROTOTYPED (type) = 1;
688 TYPE_NFIELDS (type) = num_types;
689 TYPE_FIELDS (type) = (struct field *)
690 TYPE_ZALLOC (type, sizeof (struct field) * num_types);
692 while (num_types-- > 0)
693 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
699 evaluate_subexp_standard (struct type *expect_type,
700 struct expression *exp, int *pos,
705 int pc, pc2 = 0, oldpos;
706 struct value *arg1 = NULL;
707 struct value *arg2 = NULL;
711 struct value **argvec;
715 struct type **arg_types;
717 struct symbol *function = NULL;
718 char *function_name = NULL;
721 op = exp->elts[pc].opcode;
726 tem = longest_to_int (exp->elts[pc + 2].longconst);
727 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
728 if (noside == EVAL_SKIP)
730 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
731 &exp->elts[pc + 3].string,
732 expect_type, 0, noside);
734 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
739 return value_from_longest (exp->elts[pc + 1].type,
740 exp->elts[pc + 2].longconst);
744 return value_from_double (exp->elts[pc + 1].type,
745 exp->elts[pc + 2].doubleconst);
749 return value_from_decfloat (exp->elts[pc + 1].type,
750 exp->elts[pc + 2].decfloatconst);
755 if (noside == EVAL_SKIP)
758 /* JYG: We used to just return value_zero of the symbol type
759 if we're asked to avoid side effects. Otherwise we return
760 value_of_variable (...). However I'm not sure if
761 value_of_variable () has any side effect.
762 We need a full value object returned here for whatis_exp ()
763 to call evaluate_type () and then pass the full value to
764 value_rtti_target_type () if we are dealing with a pointer
765 or reference to a base class and print object is on. */
768 struct value *ret = NULL;
772 ret = value_of_variable (exp->elts[pc + 2].symbol,
773 exp->elts[pc + 1].block);
776 CATCH (except, RETURN_MASK_ERROR)
778 if (noside == EVAL_AVOID_SIDE_EFFECTS)
779 ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
782 throw_exception (except);
789 case OP_VAR_ENTRY_VALUE:
791 if (noside == EVAL_SKIP)
795 struct symbol *sym = exp->elts[pc + 1].symbol;
796 struct frame_info *frame;
798 if (noside == EVAL_AVOID_SIDE_EFFECTS)
799 return value_zero (SYMBOL_TYPE (sym), not_lval);
801 if (SYMBOL_COMPUTED_OPS (sym) == NULL
802 || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
803 error (_("Symbol \"%s\" does not have any specific entry value"),
804 SYMBOL_PRINT_NAME (sym));
806 frame = get_selected_frame (NULL);
807 return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
813 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
817 const char *name = &exp->elts[pc + 2].string;
821 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
822 regno = user_reg_map_name_to_regnum (exp->gdbarch,
823 name, strlen (name));
825 error (_("Register $%s not available."), name);
827 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
828 a value with the appropriate register type. Unfortunately,
829 we don't have easy access to the type of user registers.
830 So for these registers, we fetch the register value regardless
831 of the evaluation mode. */
832 if (noside == EVAL_AVOID_SIDE_EFFECTS
833 && regno < gdbarch_num_regs (exp->gdbarch)
834 + gdbarch_num_pseudo_regs (exp->gdbarch))
835 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
837 val = value_of_register (regno, get_selected_frame (NULL));
839 error (_("Value of register %s not available."), name);
845 type = language_bool_type (exp->language_defn, exp->gdbarch);
846 return value_from_longest (type, exp->elts[pc + 1].longconst);
850 return value_of_internalvar (exp->gdbarch,
851 exp->elts[pc + 1].internalvar);
854 tem = longest_to_int (exp->elts[pc + 1].longconst);
855 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
856 if (noside == EVAL_SKIP)
858 type = language_string_char_type (exp->language_defn, exp->gdbarch);
859 return value_string (&exp->elts[pc + 2].string, tem, type);
861 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
862 NSString constant. */
863 tem = longest_to_int (exp->elts[pc + 1].longconst);
864 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
865 if (noside == EVAL_SKIP)
869 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
873 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
874 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
875 nargs = tem3 - tem2 + 1;
876 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
878 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
879 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
881 struct value *rec = allocate_value (expect_type);
883 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
884 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
887 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
888 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
890 struct type *range_type = TYPE_INDEX_TYPE (type);
891 struct type *element_type = TYPE_TARGET_TYPE (type);
892 struct value *array = allocate_value (expect_type);
893 int element_size = TYPE_LENGTH (check_typedef (element_type));
894 LONGEST low_bound, high_bound, index;
896 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
899 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
902 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
903 for (tem = nargs; --nargs >= 0;)
905 struct value *element;
908 element = evaluate_subexp (element_type, exp, pos, noside);
909 if (value_type (element) != element_type)
910 element = value_cast (element_type, element);
913 int continue_pc = *pos;
916 index = init_array_element (array, element, exp, pos, noside,
917 low_bound, high_bound);
922 if (index > high_bound)
923 /* To avoid memory corruption. */
924 error (_("Too many array elements"));
925 memcpy (value_contents_raw (array)
926 + (index - low_bound) * element_size,
927 value_contents (element),
935 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
936 && TYPE_CODE (type) == TYPE_CODE_SET)
938 struct value *set = allocate_value (expect_type);
939 gdb_byte *valaddr = value_contents_raw (set);
940 struct type *element_type = TYPE_INDEX_TYPE (type);
941 struct type *check_type = element_type;
942 LONGEST low_bound, high_bound;
944 /* Get targettype of elementtype. */
945 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
946 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
947 check_type = TYPE_TARGET_TYPE (check_type);
949 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
950 error (_("(power)set type with unknown size"));
951 memset (valaddr, '\0', TYPE_LENGTH (type));
952 for (tem = 0; tem < nargs; tem++)
954 LONGEST range_low, range_high;
955 struct type *range_low_type, *range_high_type;
956 struct value *elem_val;
958 elem_val = evaluate_subexp (element_type, exp, pos, noside);
959 range_low_type = range_high_type = value_type (elem_val);
960 range_low = range_high = value_as_long (elem_val);
962 /* Check types of elements to avoid mixture of elements from
963 different types. Also check if type of element is "compatible"
964 with element type of powerset. */
965 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
966 range_low_type = TYPE_TARGET_TYPE (range_low_type);
967 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
968 range_high_type = TYPE_TARGET_TYPE (range_high_type);
969 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
970 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
971 && (range_low_type != range_high_type)))
972 /* different element modes. */
973 error (_("POWERSET tuple elements of different mode"));
974 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
975 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
976 && range_low_type != check_type))
977 error (_("incompatible POWERSET tuple elements"));
978 if (range_low > range_high)
980 warning (_("empty POWERSET tuple range"));
983 if (range_low < low_bound || range_high > high_bound)
984 error (_("POWERSET tuple element out of range"));
985 range_low -= low_bound;
986 range_high -= low_bound;
987 for (; range_low <= range_high; range_low++)
989 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
991 if (gdbarch_bits_big_endian (exp->gdbarch))
992 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
993 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1000 argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
1001 for (tem = 0; tem < nargs; tem++)
1003 /* Ensure that array expressions are coerced into pointer
1005 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1007 if (noside == EVAL_SKIP)
1009 return value_array (tem2, tem3, argvec);
1013 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1015 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1017 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1019 if (noside == EVAL_SKIP)
1021 return value_slice (array, lowbound, upper - lowbound + 1);
1025 /* Skip third and second args to evaluate the first one. */
1026 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1027 if (value_logical_not (arg1))
1029 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1030 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1034 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1035 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1039 case OP_OBJC_SELECTOR:
1040 { /* Objective C @selector operator. */
1041 char *sel = &exp->elts[pc + 2].string;
1042 int len = longest_to_int (exp->elts[pc + 1].longconst);
1043 struct type *selector_type;
1045 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1046 if (noside == EVAL_SKIP)
1050 sel[len] = 0; /* Make sure it's terminated. */
1052 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1053 return value_from_longest (selector_type,
1054 lookup_child_selector (exp->gdbarch, sel));
1057 case OP_OBJC_MSGCALL:
1058 { /* Objective C message (method) call. */
1060 CORE_ADDR responds_selector = 0;
1061 CORE_ADDR method_selector = 0;
1063 CORE_ADDR selector = 0;
1065 int struct_return = 0;
1066 enum noside sub_no_side = EVAL_NORMAL;
1068 struct value *msg_send = NULL;
1069 struct value *msg_send_stret = NULL;
1070 int gnu_runtime = 0;
1072 struct value *target = NULL;
1073 struct value *method = NULL;
1074 struct value *called_method = NULL;
1076 struct type *selector_type = NULL;
1077 struct type *long_type;
1079 struct value *ret = NULL;
1082 selector = exp->elts[pc + 1].longconst;
1083 nargs = exp->elts[pc + 2].longconst;
1084 argvec = (struct value **) alloca (sizeof (struct value *)
1089 long_type = builtin_type (exp->gdbarch)->builtin_long;
1090 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1092 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1093 sub_no_side = EVAL_NORMAL;
1095 sub_no_side = noside;
1097 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1099 if (value_as_long (target) == 0)
1100 return value_from_longest (long_type, 0);
1102 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
1105 /* Find the method dispatch (Apple runtime) or method lookup
1106 (GNU runtime) function for Objective-C. These will be used
1107 to lookup the symbol information for the method. If we
1108 can't find any symbol information, then we'll use these to
1109 call the method, otherwise we can call the method
1110 directly. The msg_send_stret function is used in the special
1111 case of a method that returns a structure (Apple runtime
1115 struct type *type = selector_type;
1117 type = lookup_function_type (type);
1118 type = lookup_pointer_type (type);
1119 type = lookup_function_type (type);
1120 type = lookup_pointer_type (type);
1122 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1124 = find_function_in_inferior ("objc_msg_lookup", NULL);
1126 msg_send = value_from_pointer (type, value_as_address (msg_send));
1127 msg_send_stret = value_from_pointer (type,
1128 value_as_address (msg_send_stret));
1132 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1133 /* Special dispatcher for methods returning structs. */
1135 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1138 /* Verify the target object responds to this method. The
1139 standard top-level 'Object' class uses a different name for
1140 the verification method than the non-standard, but more
1141 often used, 'NSObject' class. Make sure we check for both. */
1144 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1145 if (responds_selector == 0)
1147 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1149 if (responds_selector == 0)
1150 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1153 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1154 if (method_selector == 0)
1156 = lookup_child_selector (exp->gdbarch, "methodFor:");
1158 if (method_selector == 0)
1159 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1161 /* Call the verification method, to make sure that the target
1162 class implements the desired method. */
1164 argvec[0] = msg_send;
1166 argvec[2] = value_from_longest (long_type, responds_selector);
1167 argvec[3] = value_from_longest (long_type, selector);
1170 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1173 /* Function objc_msg_lookup returns a pointer. */
1175 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1177 if (value_as_long (ret) == 0)
1178 error (_("Target does not respond to this message selector."));
1180 /* Call "methodForSelector:" method, to get the address of a
1181 function method that implements this selector for this
1182 class. If we can find a symbol at that address, then we
1183 know the return type, parameter types etc. (that's a good
1186 argvec[0] = msg_send;
1188 argvec[2] = value_from_longest (long_type, method_selector);
1189 argvec[3] = value_from_longest (long_type, selector);
1192 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1196 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1199 /* ret should now be the selector. */
1201 addr = value_as_long (ret);
1204 struct symbol *sym = NULL;
1206 /* The address might point to a function descriptor;
1207 resolve it to the actual code address instead. */
1208 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1211 /* Is it a high_level symbol? */
1212 sym = find_pc_function (addr);
1214 method = value_of_variable (sym, 0);
1217 /* If we found a method with symbol information, check to see
1218 if it returns a struct. Otherwise assume it doesn't. */
1223 struct type *val_type;
1225 funaddr = find_function_addr (method, &val_type);
1227 block_for_pc (funaddr);
1229 val_type = check_typedef (val_type);
1231 if ((val_type == NULL)
1232 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1234 if (expect_type != NULL)
1235 val_type = expect_type;
1238 struct_return = using_struct_return (exp->gdbarch, method,
1241 else if (expect_type != NULL)
1243 struct_return = using_struct_return (exp->gdbarch, NULL,
1244 check_typedef (expect_type));
1247 /* Found a function symbol. Now we will substitute its
1248 value in place of the message dispatcher (obj_msgSend),
1249 so that we call the method directly instead of thru
1250 the dispatcher. The main reason for doing this is that
1251 we can now evaluate the return value and parameter values
1252 according to their known data types, in case we need to
1253 do things like promotion, dereferencing, special handling
1254 of structs and doubles, etc.
1256 We want to use the type signature of 'method', but still
1257 jump to objc_msgSend() or objc_msgSend_stret() to better
1258 mimic the behavior of the runtime. */
1262 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1263 error (_("method address has symbol information "
1264 "with non-function type; skipping"));
1266 /* Create a function pointer of the appropriate type, and
1267 replace its value with the value of msg_send or
1268 msg_send_stret. We must use a pointer here, as
1269 msg_send and msg_send_stret are of pointer type, and
1270 the representation may be different on systems that use
1271 function descriptors. */
1274 = value_from_pointer (lookup_pointer_type (value_type (method)),
1275 value_as_address (msg_send_stret));
1278 = value_from_pointer (lookup_pointer_type (value_type (method)),
1279 value_as_address (msg_send));
1284 called_method = msg_send_stret;
1286 called_method = msg_send;
1289 if (noside == EVAL_SKIP)
1292 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1294 /* If the return type doesn't look like a function type,
1295 call an error. This can happen if somebody tries to
1296 turn a variable into a function call. This is here
1297 because people often want to call, eg, strcmp, which
1298 gdb doesn't know is a function. If gdb isn't asked for
1299 it's opinion (ie. through "whatis"), it won't offer
1302 struct type *type = value_type (called_method);
1304 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1305 type = TYPE_TARGET_TYPE (type);
1306 type = TYPE_TARGET_TYPE (type);
1310 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1311 return allocate_value (expect_type);
1313 return allocate_value (type);
1316 error (_("Expression of type other than "
1317 "\"method returning ...\" used as a method"));
1320 /* Now depending on whether we found a symbol for the method,
1321 we will either call the runtime dispatcher or the method
1324 argvec[0] = called_method;
1326 argvec[2] = value_from_longest (long_type, selector);
1327 /* User-supplied arguments. */
1328 for (tem = 0; tem < nargs; tem++)
1329 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1330 argvec[tem + 3] = 0;
1332 if (gnu_runtime && (method != NULL))
1334 /* Function objc_msg_lookup returns a pointer. */
1335 deprecated_set_value_type (argvec[0],
1336 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1338 = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1341 ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1348 op = exp->elts[*pos].opcode;
1349 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1350 /* Allocate arg vector, including space for the function to be
1351 called in argvec[0], a potential `this', and a terminating NULL. */
1352 argvec = (struct value **)
1353 alloca (sizeof (struct value *) * (nargs + 3));
1354 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1356 /* First, evaluate the structure into arg2. */
1359 if (op == STRUCTOP_MEMBER)
1361 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1365 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1368 /* If the function is a virtual function, then the
1369 aggregate value (providing the structure) plays
1370 its part by providing the vtable. Otherwise,
1371 it is just along for the ride: call the function
1374 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1376 type = check_typedef (value_type (arg1));
1377 if (noside == EVAL_SKIP)
1378 tem = 1; /* Set it to the right arg index so that all arguments
1379 can also be skipped. */
1380 else if (TYPE_CODE (type) == TYPE_CODE_METHODPTR)
1382 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1383 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval);
1385 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1387 /* Now, say which argument to start evaluating from. */
1392 else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
1394 struct type *type_ptr
1395 = lookup_pointer_type (TYPE_SELF_TYPE (type));
1396 struct type *target_type_ptr
1397 = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1399 /* Now, convert these values to an address. */
1400 arg2 = value_cast (type_ptr, arg2);
1402 mem_offset = value_as_long (arg1);
1404 arg1 = value_from_pointer (target_type_ptr,
1405 value_as_long (arg2) + mem_offset);
1406 arg1 = value_ind (arg1);
1410 error (_("Non-pointer-to-member value used in pointer-to-member "
1413 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1415 /* Hair for method invocations. */
1419 /* First, evaluate the structure into arg2. */
1421 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1422 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1424 if (op == STRUCTOP_STRUCT)
1426 /* If v is a variable in a register, and the user types
1427 v.method (), this will produce an error, because v has
1430 A possible way around this would be to allocate a
1431 copy of the variable on the stack, copy in the
1432 contents, call the function, and copy out the
1433 contents. I.e. convert this from call by reference
1434 to call by copy-return (or whatever it's called).
1435 However, this does not work because it is not the
1436 same: the method being called could stash a copy of
1437 the address, and then future uses through that address
1438 (after the method returns) would be expected to
1439 use the variable itself, not some copy of it. */
1440 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1444 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1446 /* Check to see if the operator '->' has been
1447 overloaded. If the operator has been overloaded
1448 replace arg2 with the value returned by the custom
1449 operator and continue evaluation. */
1450 while (unop_user_defined_p (op, arg2))
1452 struct value *value = NULL;
1455 value = value_x_unop (arg2, op, noside);
1458 CATCH (except, RETURN_MASK_ERROR)
1460 if (except.error == NOT_FOUND_ERROR)
1463 throw_exception (except);
1470 /* Now, say which argument to start evaluating from. */
1473 else if (op == OP_SCOPE
1474 && overload_resolution
1475 && (exp->language_defn->la_language == language_cplus))
1477 /* Unpack it locally so we can properly handle overload
1483 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
1484 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
1485 type = exp->elts[pc2 + 1].type;
1486 name = &exp->elts[pc2 + 3].string;
1489 function_name = NULL;
1490 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
1492 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
1494 get_selected_block (0),
1496 if (function == NULL)
1497 error (_("No symbol \"%s\" in namespace \"%s\"."),
1498 name, TYPE_TAG_NAME (type));
1501 /* arg2 is left as NULL on purpose. */
1505 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1506 || TYPE_CODE (type) == TYPE_CODE_UNION);
1507 function_name = name;
1509 /* We need a properly typed value for method lookup. For
1510 static methods arg2 is otherwise unused. */
1511 arg2 = value_zero (type, lval_memory);
1516 else if (op == OP_ADL_FUNC)
1518 /* Save the function position and move pos so that the arguments
1519 can be evaluated. */
1525 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1526 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1530 /* Non-method function call. */
1534 /* If this is a C++ function wait until overload resolution. */
1535 if (op == OP_VAR_VALUE
1536 && overload_resolution
1537 && (exp->language_defn->la_language == language_cplus))
1539 (*pos) += 4; /* Skip the evaluation of the symbol. */
1544 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1545 type = value_type (argvec[0]);
1546 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1547 type = TYPE_TARGET_TYPE (type);
1548 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1550 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1552 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1560 /* Evaluate arguments (if not already done, e.g., namespace::func()
1561 and overload-resolution is off). */
1562 for (; tem <= nargs; tem++)
1564 /* Ensure that array expressions are coerced into pointer
1566 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1569 /* Signal end of arglist. */
1572 if (noside == EVAL_SKIP)
1575 if (op == OP_ADL_FUNC)
1577 struct symbol *symp;
1580 int string_pc = save_pos1 + 3;
1582 /* Extract the function name. */
1583 name_len = longest_to_int (exp->elts[string_pc].longconst);
1584 func_name = (char *) alloca (name_len + 1);
1585 strcpy (func_name, &exp->elts[string_pc + 1].string);
1587 find_overload_match (&argvec[1], nargs, func_name,
1588 NON_METHOD, /* not method */
1589 NULL, NULL, /* pass NULL symbol since
1590 symbol is unknown */
1591 NULL, &symp, NULL, 0, noside);
1593 /* Now fix the expression being evaluated. */
1594 exp->elts[save_pos1 + 2].symbol = symp;
1595 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1598 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1599 || (op == OP_SCOPE && function_name != NULL))
1601 int static_memfuncp;
1604 /* Method invocation: stuff "this" as first parameter.
1605 If the method turns out to be static we undo this below. */
1610 /* Name of method from expression. */
1611 tstr = &exp->elts[pc2 + 2].string;
1614 tstr = function_name;
1616 if (overload_resolution && (exp->language_defn->la_language
1619 /* Language is C++, do some overload resolution before
1621 struct value *valp = NULL;
1623 (void) find_overload_match (&argvec[1], nargs, tstr,
1624 METHOD, /* method */
1625 &arg2, /* the object */
1627 &static_memfuncp, 0, noside);
1629 if (op == OP_SCOPE && !static_memfuncp)
1631 /* For the time being, we don't handle this. */
1632 error (_("Call to overloaded function %s requires "
1636 argvec[1] = arg2; /* the ``this'' pointer */
1637 argvec[0] = valp; /* Use the method found after overload
1641 /* Non-C++ case -- or no overload resolution. */
1643 struct value *temp = arg2;
1645 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1647 op == STRUCTOP_STRUCT
1648 ? "structure" : "structure pointer");
1649 /* value_struct_elt updates temp with the correct value
1650 of the ``this'' pointer if necessary, so modify argvec[1] to
1651 reflect any ``this'' changes. */
1653 = value_from_longest (lookup_pointer_type(value_type (temp)),
1654 value_address (temp)
1655 + value_embedded_offset (temp));
1656 argvec[1] = arg2; /* the ``this'' pointer */
1659 /* Take out `this' if needed. */
1660 if (static_memfuncp)
1662 argvec[1] = argvec[0];
1667 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1669 /* Pointer to member. argvec[1] is already set up. */
1672 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1674 /* Non-member function being called. */
1675 /* fn: This can only be done for C++ functions. A C-style function
1676 in a C++ program, for instance, does not have the fields that
1677 are expected here. */
1679 if (overload_resolution && (exp->language_defn->la_language
1682 /* Language is C++, do some overload resolution before
1684 struct symbol *symp;
1687 /* If a scope has been specified disable ADL. */
1691 if (op == OP_VAR_VALUE)
1692 function = exp->elts[save_pos1+2].symbol;
1694 (void) find_overload_match (&argvec[1], nargs,
1695 NULL, /* no need for name */
1696 NON_METHOD, /* not method */
1697 NULL, function, /* the function */
1698 NULL, &symp, NULL, no_adl, noside);
1700 if (op == OP_VAR_VALUE)
1702 /* Now fix the expression being evaluated. */
1703 exp->elts[save_pos1+2].symbol = symp;
1704 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1708 argvec[0] = value_of_variable (symp, get_selected_block (0));
1712 /* Not C++, or no overload resolution allowed. */
1713 /* Nothing to be done; argvec already correctly set up. */
1718 /* It is probably a C-style function. */
1719 /* Nothing to be done; argvec already correctly set up. */
1724 if (argvec[0] == NULL)
1725 error (_("Cannot evaluate function -- may be inlined"));
1726 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1728 /* If the return type doesn't look like a function type, call an
1729 error. This can happen if somebody tries to turn a variable into
1730 a function call. This is here because people often want to
1731 call, eg, strcmp, which gdb doesn't know is a function. If
1732 gdb isn't asked for it's opinion (ie. through "whatis"),
1733 it won't offer it. */
1735 struct type *ftype = value_type (argvec[0]);
1737 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
1739 /* We don't know anything about what the internal
1740 function might return, but we have to return
1742 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
1745 else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
1747 struct type *return_type
1748 = result_type_of_xmethod (argvec[0], nargs, argvec + 1);
1750 if (return_type == NULL)
1751 error (_("Xmethod is missing return type."));
1752 return value_zero (return_type, not_lval);
1754 else if (TYPE_GNU_IFUNC (ftype))
1755 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype)));
1756 else if (TYPE_TARGET_TYPE (ftype))
1757 return allocate_value (TYPE_TARGET_TYPE (ftype));
1759 error (_("Expression of type other than "
1760 "\"Function returning ...\" used as function"));
1762 switch (TYPE_CODE (value_type (argvec[0])))
1764 case TYPE_CODE_INTERNAL_FUNCTION:
1765 return call_internal_function (exp->gdbarch, exp->language_defn,
1766 argvec[0], nargs, argvec + 1);
1767 case TYPE_CODE_XMETHOD:
1768 return call_xmethod (argvec[0], nargs, argvec + 1);
1770 return call_function_by_hand (argvec[0], nargs, argvec + 1);
1772 /* pai: FIXME save value from call_function_by_hand, then adjust
1773 pc by adjust_fn_pc if +ve. */
1775 case OP_F77_UNDETERMINED_ARGLIST:
1777 /* Remember that in F77, functions, substring ops and
1778 array subscript operations cannot be disambiguated
1779 at parse time. We have made all array subscript operations,
1780 substring operations as well as function calls come here
1781 and we now have to discover what the heck this thing actually was.
1782 If it is a function, we process just as if we got an OP_FUNCALL. */
1784 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1787 /* First determine the type code we are dealing with. */
1788 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1789 type = check_typedef (value_type (arg1));
1790 code = TYPE_CODE (type);
1792 if (code == TYPE_CODE_PTR)
1794 /* Fortran always passes variable to subroutines as pointer.
1795 So we need to look into its target type to see if it is
1796 array, string or function. If it is, we need to switch
1797 to the target value the original one points to. */
1798 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1800 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1801 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1802 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1804 arg1 = value_ind (arg1);
1805 type = check_typedef (value_type (arg1));
1806 code = TYPE_CODE (type);
1812 case TYPE_CODE_ARRAY:
1813 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1814 return value_f90_subarray (arg1, exp, pos, noside);
1816 goto multi_f77_subscript;
1818 case TYPE_CODE_STRING:
1819 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1820 return value_f90_subarray (arg1, exp, pos, noside);
1823 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1824 return value_subscript (arg1, value_as_long (arg2));
1828 case TYPE_CODE_FUNC:
1829 /* It's a function call. */
1830 /* Allocate arg vector, including space for the function to be
1831 called in argvec[0] and a terminating NULL. */
1832 argvec = (struct value **)
1833 alloca (sizeof (struct value *) * (nargs + 2));
1836 for (; tem <= nargs; tem++)
1837 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1838 argvec[tem] = 0; /* signal end of arglist */
1839 if (noside == EVAL_SKIP)
1844 error (_("Cannot perform substring on this type"));
1848 /* We have a complex number, There should be 2 floating
1849 point numbers that compose it. */
1851 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1852 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1854 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1856 case STRUCTOP_STRUCT:
1857 tem = longest_to_int (exp->elts[pc + 1].longconst);
1858 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1859 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1860 if (noside == EVAL_SKIP)
1862 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1864 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1865 arg3 = value_zero (value_type (arg3), not_lval);
1869 tem = longest_to_int (exp->elts[pc + 1].longconst);
1870 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1871 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1872 if (noside == EVAL_SKIP)
1875 /* Check to see if operator '->' has been overloaded. If so replace
1876 arg1 with the value returned by evaluating operator->(). */
1877 while (unop_user_defined_p (op, arg1))
1879 struct value *value = NULL;
1882 value = value_x_unop (arg1, op, noside);
1885 CATCH (except, RETURN_MASK_ERROR)
1887 if (except.error == NOT_FOUND_ERROR)
1890 throw_exception (except);
1897 /* JYG: if print object is on we need to replace the base type
1898 with rtti type in order to continue on with successful
1899 lookup of member / method only available in the rtti type. */
1901 struct type *type = value_type (arg1);
1902 struct type *real_type;
1903 int full, top, using_enc;
1904 struct value_print_options opts;
1906 get_user_print_options (&opts);
1907 if (opts.objectprint && TYPE_TARGET_TYPE(type)
1908 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
1910 real_type = value_rtti_indirect_type (arg1, &full, &top,
1913 arg1 = value_cast (real_type, arg1);
1917 arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1918 NULL, "structure pointer");
1919 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1920 arg3 = value_zero (value_type (arg3), not_lval);
1923 case STRUCTOP_MEMBER:
1925 if (op == STRUCTOP_MEMBER)
1926 arg1 = evaluate_subexp_for_address (exp, pos, noside);
1928 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1930 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1932 if (noside == EVAL_SKIP)
1935 type = check_typedef (value_type (arg2));
1936 switch (TYPE_CODE (type))
1938 case TYPE_CODE_METHODPTR:
1939 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1940 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1943 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
1944 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
1945 return value_ind (arg2);
1948 case TYPE_CODE_MEMBERPTR:
1949 /* Now, convert these values to an address. */
1950 arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
1953 mem_offset = value_as_long (arg2);
1955 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1956 value_as_long (arg1) + mem_offset);
1957 return value_ind (arg3);
1960 error (_("non-pointer-to-member value used "
1961 "in pointer-to-member construct"));
1965 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1966 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
1967 for (ix = 0; ix < nargs; ++ix)
1968 arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
1970 expect_type = make_params (nargs, arg_types);
1971 *(pos) += 3 + nargs;
1972 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
1973 xfree (TYPE_FIELDS (expect_type));
1974 xfree (TYPE_MAIN_TYPE (expect_type));
1975 xfree (expect_type);
1979 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1980 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1981 if (noside == EVAL_SKIP)
1983 if (binop_user_defined_p (op, arg1, arg2))
1984 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1986 return value_concat (arg1, arg2);
1989 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1990 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1992 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1994 if (binop_user_defined_p (op, arg1, arg2))
1995 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1997 return value_assign (arg1, arg2);
1999 case BINOP_ASSIGN_MODIFY:
2001 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2002 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2003 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2005 op = exp->elts[pc + 1].opcode;
2006 if (binop_user_defined_p (op, arg1, arg2))
2007 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
2008 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2010 && is_integral_type (value_type (arg2)))
2011 arg2 = value_ptradd (arg1, value_as_long (arg2));
2012 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2014 && is_integral_type (value_type (arg2)))
2015 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2018 struct value *tmp = arg1;
2020 /* For shift and integer exponentiation operations,
2021 only promote the first argument. */
2022 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2023 && is_integral_type (value_type (arg2)))
2024 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2026 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2028 arg2 = value_binop (tmp, arg2, op);
2030 return value_assign (arg1, arg2);
2033 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2034 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2035 if (noside == EVAL_SKIP)
2037 if (binop_user_defined_p (op, arg1, arg2))
2038 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2039 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2040 && is_integral_type (value_type (arg2)))
2041 return value_ptradd (arg1, value_as_long (arg2));
2042 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2043 && is_integral_type (value_type (arg1)))
2044 return value_ptradd (arg2, value_as_long (arg1));
2047 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2048 return value_binop (arg1, arg2, BINOP_ADD);
2052 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2053 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2054 if (noside == EVAL_SKIP)
2056 if (binop_user_defined_p (op, arg1, arg2))
2057 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2058 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2059 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2061 /* FIXME -- should be ptrdiff_t */
2062 type = builtin_type (exp->gdbarch)->builtin_long;
2063 return value_from_longest (type, value_ptrdiff (arg1, arg2));
2065 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2066 && is_integral_type (value_type (arg2)))
2067 return value_ptradd (arg1, - value_as_long (arg2));
2070 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2071 return value_binop (arg1, arg2, BINOP_SUB);
2082 case BINOP_BITWISE_AND:
2083 case BINOP_BITWISE_IOR:
2084 case BINOP_BITWISE_XOR:
2085 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2086 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2087 if (noside == EVAL_SKIP)
2089 if (binop_user_defined_p (op, arg1, arg2))
2090 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2093 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2094 fudge arg2 to avoid division-by-zero, the caller is
2095 (theoretically) only looking for the type of the result. */
2096 if (noside == EVAL_AVOID_SIDE_EFFECTS
2097 /* ??? Do we really want to test for BINOP_MOD here?
2098 The implementation of value_binop gives it a well-defined
2101 || op == BINOP_INTDIV
2104 && value_logical_not (arg2))
2106 struct value *v_one, *retval;
2108 v_one = value_one (value_type (arg2));
2109 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2110 retval = value_binop (arg1, v_one, op);
2115 /* For shift and integer exponentiation operations,
2116 only promote the first argument. */
2117 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2118 && is_integral_type (value_type (arg2)))
2119 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2121 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2123 return value_binop (arg1, arg2, op);
2127 case BINOP_SUBSCRIPT:
2128 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2129 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2130 if (noside == EVAL_SKIP)
2132 if (binop_user_defined_p (op, arg1, arg2))
2133 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2136 /* If the user attempts to subscript something that is not an
2137 array or pointer type (like a plain int variable for example),
2138 then report this as an error. */
2140 arg1 = coerce_ref (arg1);
2141 type = check_typedef (value_type (arg1));
2142 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2143 && TYPE_CODE (type) != TYPE_CODE_PTR)
2145 if (TYPE_NAME (type))
2146 error (_("cannot subscript something of type `%s'"),
2149 error (_("cannot subscript requested type"));
2152 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2153 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2155 return value_subscript (arg1, value_as_long (arg2));
2157 case MULTI_SUBSCRIPT:
2159 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2160 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2163 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2164 /* FIXME: EVAL_SKIP handling may not be correct. */
2165 if (noside == EVAL_SKIP)
2176 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2177 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2179 /* If the user attempts to subscript something that has no target
2180 type (like a plain int variable for example), then report this
2183 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2186 arg1 = value_zero (type, VALUE_LVAL (arg1));
2192 error (_("cannot subscript something of type `%s'"),
2193 TYPE_NAME (value_type (arg1)));
2197 if (binop_user_defined_p (op, arg1, arg2))
2199 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2203 arg1 = coerce_ref (arg1);
2204 type = check_typedef (value_type (arg1));
2206 switch (TYPE_CODE (type))
2209 case TYPE_CODE_ARRAY:
2210 case TYPE_CODE_STRING:
2211 arg1 = value_subscript (arg1, value_as_long (arg2));
2215 if (TYPE_NAME (type))
2216 error (_("cannot subscript something of type `%s'"),
2219 error (_("cannot subscript requested type"));
2225 multi_f77_subscript:
2227 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2228 int ndimensions = 1, i;
2229 struct value *array = arg1;
2231 if (nargs > MAX_FORTRAN_DIMS)
2232 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2234 ndimensions = calc_f77_array_dims (type);
2236 if (nargs != ndimensions)
2237 error (_("Wrong number of subscripts"));
2239 gdb_assert (nargs > 0);
2241 /* Now that we know we have a legal array subscript expression
2242 let us actually find out where this element exists in the array. */
2244 /* Take array indices left to right. */
2245 for (i = 0; i < nargs; i++)
2247 /* Evaluate each subscript; it must be a legal integer in F77. */
2248 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2250 /* Fill in the subscript array. */
2252 subscript_array[i] = value_as_long (arg2);
2255 /* Internal type of array is arranged right to left. */
2256 for (i = nargs; i > 0; i--)
2258 struct type *array_type = check_typedef (value_type (array));
2259 LONGEST index = subscript_array[i - 1];
2261 array = value_subscripted_rvalue (array, index,
2262 f77_get_lowerbound (array_type));
2268 case BINOP_LOGICAL_AND:
2269 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2270 if (noside == EVAL_SKIP)
2272 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2277 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2280 if (binop_user_defined_p (op, arg1, arg2))
2282 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2283 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2287 tem = value_logical_not (arg1);
2288 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2289 (tem ? EVAL_SKIP : noside));
2290 type = language_bool_type (exp->language_defn, exp->gdbarch);
2291 return value_from_longest (type,
2292 (LONGEST) (!tem && !value_logical_not (arg2)));
2295 case BINOP_LOGICAL_OR:
2296 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2297 if (noside == EVAL_SKIP)
2299 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2304 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2307 if (binop_user_defined_p (op, arg1, arg2))
2309 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2310 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2314 tem = value_logical_not (arg1);
2315 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2316 (!tem ? EVAL_SKIP : noside));
2317 type = language_bool_type (exp->language_defn, exp->gdbarch);
2318 return value_from_longest (type,
2319 (LONGEST) (!tem || !value_logical_not (arg2)));
2323 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2324 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2325 if (noside == EVAL_SKIP)
2327 if (binop_user_defined_p (op, arg1, arg2))
2329 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2333 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2334 tem = value_equal (arg1, arg2);
2335 type = language_bool_type (exp->language_defn, exp->gdbarch);
2336 return value_from_longest (type, (LONGEST) tem);
2339 case BINOP_NOTEQUAL:
2340 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2341 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2342 if (noside == EVAL_SKIP)
2344 if (binop_user_defined_p (op, arg1, arg2))
2346 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2350 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2351 tem = value_equal (arg1, arg2);
2352 type = language_bool_type (exp->language_defn, exp->gdbarch);
2353 return value_from_longest (type, (LONGEST) ! tem);
2357 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2358 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2359 if (noside == EVAL_SKIP)
2361 if (binop_user_defined_p (op, arg1, arg2))
2363 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2367 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2368 tem = value_less (arg1, arg2);
2369 type = language_bool_type (exp->language_defn, exp->gdbarch);
2370 return value_from_longest (type, (LONGEST) tem);
2374 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2375 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2376 if (noside == EVAL_SKIP)
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_less (arg2, arg1);
2386 type = language_bool_type (exp->language_defn, exp->gdbarch);
2387 return value_from_longest (type, (LONGEST) tem);
2391 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2392 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2393 if (noside == EVAL_SKIP)
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_less (arg2, arg1) || 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)
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) || value_equal (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 (NULL_TYPE, exp, pos, noside);
2427 if (noside == EVAL_SKIP)
2429 type = check_typedef (value_type (arg2));
2430 if (TYPE_CODE (type) != TYPE_CODE_INT)
2431 error (_("Non-integral right operand for \"@\" operator."));
2432 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2434 return allocate_repeat_value (value_type (arg1),
2435 longest_to_int (value_as_long (arg2)));
2438 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2441 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2442 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2445 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2446 if (noside == EVAL_SKIP)
2448 if (unop_user_defined_p (op, arg1))
2449 return value_x_unop (arg1, op, noside);
2452 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2453 return value_pos (arg1);
2457 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2458 if (noside == EVAL_SKIP)
2460 if (unop_user_defined_p (op, arg1))
2461 return value_x_unop (arg1, op, noside);
2464 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2465 return value_neg (arg1);
2468 case UNOP_COMPLEMENT:
2469 /* C++: check for and handle destructor names. */
2470 op = exp->elts[*pos].opcode;
2472 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2473 if (noside == EVAL_SKIP)
2475 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2476 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2479 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2480 return value_complement (arg1);
2483 case UNOP_LOGICAL_NOT:
2484 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2485 if (noside == EVAL_SKIP)
2487 if (unop_user_defined_p (op, arg1))
2488 return value_x_unop (arg1, op, noside);
2491 type = language_bool_type (exp->language_defn, exp->gdbarch);
2492 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2496 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2497 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2498 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2499 type = check_typedef (value_type (arg1));
2500 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2501 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2502 error (_("Attempt to dereference pointer "
2503 "to member without an object"));
2504 if (noside == EVAL_SKIP)
2506 if (unop_user_defined_p (op, arg1))
2507 return value_x_unop (arg1, op, noside);
2508 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2510 type = check_typedef (value_type (arg1));
2511 if (TYPE_CODE (type) == TYPE_CODE_PTR
2512 || TYPE_CODE (type) == TYPE_CODE_REF
2513 /* In C you can dereference an array to get the 1st elt. */
2514 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2516 return value_zero (TYPE_TARGET_TYPE (type),
2518 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2519 /* GDB allows dereferencing an int. */
2520 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2523 error (_("Attempt to take contents of a non-pointer value."));
2526 /* Allow * on an integer so we can cast it to whatever we want.
2527 This returns an int, which seems like the most C-like thing to
2528 do. "long long" variables are rare enough that
2529 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2530 if (TYPE_CODE (type) == TYPE_CODE_INT)
2531 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2532 (CORE_ADDR) value_as_address (arg1));
2533 return value_ind (arg1);
2536 /* C++: check for and handle pointer to members. */
2538 op = exp->elts[*pos].opcode;
2540 if (noside == EVAL_SKIP)
2542 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2547 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2554 if (noside == EVAL_SKIP)
2556 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2559 return evaluate_subexp_for_sizeof (exp, pos, noside);
2563 type = exp->elts[pc + 1].type;
2564 arg1 = evaluate_subexp (type, exp, pos, noside);
2565 if (noside == EVAL_SKIP)
2567 if (type != value_type (arg1))
2568 arg1 = value_cast (type, arg1);
2571 case UNOP_CAST_TYPE:
2572 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2573 type = value_type (arg1);
2574 arg1 = evaluate_subexp (type, exp, pos, noside);
2575 if (noside == EVAL_SKIP)
2577 if (type != value_type (arg1))
2578 arg1 = value_cast (type, arg1);
2581 case UNOP_DYNAMIC_CAST:
2582 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2583 type = value_type (arg1);
2584 arg1 = evaluate_subexp (type, exp, pos, noside);
2585 if (noside == EVAL_SKIP)
2587 return value_dynamic_cast (type, arg1);
2589 case UNOP_REINTERPRET_CAST:
2590 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2591 type = value_type (arg1);
2592 arg1 = evaluate_subexp (type, exp, pos, noside);
2593 if (noside == EVAL_SKIP)
2595 return value_reinterpret_cast (type, arg1);
2599 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2600 if (noside == EVAL_SKIP)
2602 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2603 return value_zero (exp->elts[pc + 1].type, lval_memory);
2605 return value_at_lazy (exp->elts[pc + 1].type,
2606 value_as_address (arg1));
2608 case UNOP_MEMVAL_TYPE:
2609 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2610 type = value_type (arg1);
2611 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2612 if (noside == EVAL_SKIP)
2614 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2615 return value_zero (type, lval_memory);
2617 return value_at_lazy (type, value_as_address (arg1));
2619 case UNOP_MEMVAL_TLS:
2621 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2622 if (noside == EVAL_SKIP)
2624 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2625 return value_zero (exp->elts[pc + 2].type, lval_memory);
2630 tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2631 value_as_address (arg1));
2632 return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
2635 case UNOP_PREINCREMENT:
2636 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2637 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2639 else if (unop_user_defined_p (op, arg1))
2641 return value_x_unop (arg1, op, noside);
2645 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2646 arg2 = value_ptradd (arg1, 1);
2649 struct value *tmp = arg1;
2651 arg2 = value_one (value_type (arg1));
2652 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2653 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2656 return value_assign (arg1, arg2);
2659 case UNOP_PREDECREMENT:
2660 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2661 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2663 else if (unop_user_defined_p (op, arg1))
2665 return value_x_unop (arg1, op, noside);
2669 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2670 arg2 = value_ptradd (arg1, -1);
2673 struct value *tmp = arg1;
2675 arg2 = value_one (value_type (arg1));
2676 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2677 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2680 return value_assign (arg1, arg2);
2683 case UNOP_POSTINCREMENT:
2684 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2685 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2687 else if (unop_user_defined_p (op, arg1))
2689 return value_x_unop (arg1, op, noside);
2693 arg3 = value_non_lval (arg1);
2695 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2696 arg2 = value_ptradd (arg1, 1);
2699 struct value *tmp = arg1;
2701 arg2 = value_one (value_type (arg1));
2702 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2703 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2706 value_assign (arg1, arg2);
2710 case UNOP_POSTDECREMENT:
2711 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2712 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2714 else if (unop_user_defined_p (op, arg1))
2716 return value_x_unop (arg1, op, noside);
2720 arg3 = value_non_lval (arg1);
2722 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2723 arg2 = value_ptradd (arg1, -1);
2726 struct value *tmp = arg1;
2728 arg2 = value_one (value_type (arg1));
2729 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2730 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2733 value_assign (arg1, arg2);
2739 return value_of_this (exp->language_defn);
2742 /* The value is not supposed to be used. This is here to make it
2743 easier to accommodate expressions that contain types. */
2745 if (noside == EVAL_SKIP)
2747 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2749 struct type *type = exp->elts[pc + 1].type;
2751 /* If this is a typedef, then find its immediate target. We
2752 use check_typedef to resolve stubs, but we ignore its
2753 result because we do not want to dig past all
2755 check_typedef (type);
2756 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2757 type = TYPE_TARGET_TYPE (type);
2758 return allocate_value (type);
2761 error (_("Attempt to use a type name as an expression"));
2765 if (noside == EVAL_SKIP)
2767 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2770 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2772 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2773 struct value *result;
2775 result = evaluate_subexp (NULL_TYPE, exp, pos,
2776 EVAL_AVOID_SIDE_EFFECTS);
2778 /* 'decltype' has special semantics for lvalues. */
2779 if (op == OP_DECLTYPE
2780 && (sub_op == BINOP_SUBSCRIPT
2781 || sub_op == STRUCTOP_MEMBER
2782 || sub_op == STRUCTOP_MPTR
2783 || sub_op == UNOP_IND
2784 || sub_op == STRUCTOP_STRUCT
2785 || sub_op == STRUCTOP_PTR
2786 || sub_op == OP_SCOPE))
2788 struct type *type = value_type (result);
2790 if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF)
2792 type = lookup_reference_type (type);
2793 result = allocate_value (type);
2800 error (_("Attempt to use a type as an expression"));
2804 struct value *result;
2805 enum exp_opcode sub_op = exp->elts[*pos].opcode;
2807 if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2808 result = evaluate_subexp (NULL_TYPE, exp, pos,
2809 EVAL_AVOID_SIDE_EFFECTS);
2811 result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2813 if (noside != EVAL_NORMAL)
2814 return allocate_value (cplus_typeid_type (exp->gdbarch));
2816 return cplus_typeid (result);
2820 /* Removing this case and compiling with gcc -Wall reveals that
2821 a lot of cases are hitting this case. Some of these should
2822 probably be removed from expression.h; others are legitimate
2823 expressions which are (apparently) not fully implemented.
2825 If there are any cases landing here which mean a user error,
2826 then they should be separate cases, with more descriptive
2829 error (_("GDB does not (yet) know how to "
2830 "evaluate that kind of expression"));
2834 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
2837 /* Evaluate a subexpression of EXP, at index *POS,
2838 and return the address of that subexpression.
2839 Advance *POS over the subexpression.
2840 If the subexpression isn't an lvalue, get an error.
2841 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2842 then only the type of the result need be correct. */
2844 static struct value *
2845 evaluate_subexp_for_address (struct expression *exp, int *pos,
2855 op = exp->elts[pc].opcode;
2861 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2863 /* We can't optimize out "&*" if there's a user-defined operator*. */
2864 if (unop_user_defined_p (op, x))
2866 x = value_x_unop (x, op, noside);
2867 goto default_case_after_eval;
2870 return coerce_array (x);
2874 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2875 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2877 case UNOP_MEMVAL_TYPE:
2882 x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2883 type = value_type (x);
2884 return value_cast (lookup_pointer_type (type),
2885 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2889 var = exp->elts[pc + 2].symbol;
2891 /* C++: The "address" of a reference should yield the address
2892 * of the object pointed to. Let value_addr() deal with it. */
2893 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
2897 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2900 lookup_pointer_type (SYMBOL_TYPE (var));
2901 enum address_class sym_class = SYMBOL_CLASS (var);
2903 if (sym_class == LOC_CONST
2904 || sym_class == LOC_CONST_BYTES
2905 || sym_class == LOC_REGISTER)
2906 error (_("Attempt to take address of register or constant."));
2909 value_zero (type, not_lval);
2912 return address_of_variable (var, exp->elts[pc + 1].block);
2915 tem = longest_to_int (exp->elts[pc + 2].longconst);
2916 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2917 x = value_aggregate_elt (exp->elts[pc + 1].type,
2918 &exp->elts[pc + 3].string,
2921 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2926 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2927 default_case_after_eval:
2928 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2930 struct type *type = check_typedef (value_type (x));
2932 if (TYPE_CODE (type) == TYPE_CODE_REF)
2933 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2935 else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2936 return value_zero (lookup_pointer_type (value_type (x)),
2939 error (_("Attempt to take address of "
2940 "value not located in memory."));
2942 return value_addr (x);
2946 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2947 When used in contexts where arrays will be coerced anyway, this is
2948 equivalent to `evaluate_subexp' but much faster because it avoids
2949 actually fetching array contents (perhaps obsolete now that we have
2952 Note that we currently only do the coercion for C expressions, where
2953 arrays are zero based and the coercion is correct. For other languages,
2954 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2955 to decide if coercion is appropriate. */
2958 evaluate_subexp_with_coercion (struct expression *exp,
2959 int *pos, enum noside noside)
2968 op = exp->elts[pc].opcode;
2973 var = exp->elts[pc + 2].symbol;
2974 type = check_typedef (SYMBOL_TYPE (var));
2975 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
2976 && !TYPE_VECTOR (type)
2977 && CAST_IS_CONVERSION (exp->language_defn))
2980 val = address_of_variable (var, exp->elts[pc + 1].block);
2981 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2987 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2991 /* Evaluate a subexpression of EXP, at index *POS,
2992 and return a value for the size of that subexpression.
2993 Advance *POS over the subexpression. If NOSIDE is EVAL_NORMAL
2994 we allow side-effects on the operand if its type is a variable
2997 static struct value *
2998 evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
3001 /* FIXME: This should be size_t. */
3002 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3009 op = exp->elts[pc].opcode;
3013 /* This case is handled specially
3014 so that we avoid creating a value for the result type.
3015 If the result type is very big, it's desirable not to
3016 create a value unnecessarily. */
3019 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3020 type = check_typedef (value_type (val));
3021 if (TYPE_CODE (type) != TYPE_CODE_PTR
3022 && TYPE_CODE (type) != TYPE_CODE_REF
3023 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3024 error (_("Attempt to take contents of a non-pointer value."));
3025 type = TYPE_TARGET_TYPE (type);
3026 if (is_dynamic_type (type))
3027 type = value_type (value_ind (val));
3028 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3032 type = exp->elts[pc + 1].type;
3035 case UNOP_MEMVAL_TYPE:
3037 val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3038 type = value_type (val);
3042 type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
3043 if (is_dynamic_type (type))
3045 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3046 type = value_type (val);
3052 /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3053 type of the subscript is a variable length array type. In this case we
3054 must re-evaluate the right hand side of the subcription to allow
3056 case BINOP_SUBSCRIPT:
3057 if (noside == EVAL_NORMAL)
3059 int pc = (*pos) + 1;
3061 val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
3062 type = check_typedef (value_type (val));
3063 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3065 type = check_typedef (TYPE_TARGET_TYPE (type));
3066 if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3068 type = TYPE_INDEX_TYPE (type);
3069 /* Only re-evaluate the right hand side if the resulting type
3070 is a variable length type. */
3071 if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
3073 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3074 return value_from_longest
3075 (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
3084 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3085 type = value_type (val);
3089 /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3090 "When applied to a reference or a reference type, the result is
3091 the size of the referenced type." */
3092 type = check_typedef (type);
3093 if (exp->language_defn->la_language == language_cplus
3094 && TYPE_CODE (type) == TYPE_CODE_REF)
3095 type = check_typedef (TYPE_TARGET_TYPE (type));
3096 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3099 /* Parse a type expression in the string [P..P+LENGTH). */
3102 parse_and_eval_type (char *p, int length)
3104 char *tmp = (char *) alloca (length + 4);
3105 struct expression *expr;
3108 memcpy (tmp + 1, p, length);
3109 tmp[length + 1] = ')';
3110 tmp[length + 2] = '0';
3111 tmp[length + 3] = '\0';
3112 expr = parse_expression (tmp);
3113 if (expr->elts[0].opcode != UNOP_CAST)
3114 error (_("Internal error in eval_type."));
3115 return expr->elts[1].type;
3119 calc_f77_array_dims (struct type *array_type)
3122 struct type *tmp_type;
3124 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3125 error (_("Can't get dimensions for a non-array type"));
3127 tmp_type = array_type;
3129 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3131 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)