1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986-2013 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/>. */
21 #include "gdb_string.h"
25 #include "expression.h"
28 #include "language.h" /* For CAST_IS_CONVERSION. */
29 #include "f-lang.h" /* For array bound stuff. */
32 #include "objc-lang.h"
34 #include "parser-defs.h"
35 #include "cp-support.h"
37 #include "exceptions.h"
39 #include "user-regs.h"
41 #include "gdb_obstack.h"
43 #include "python/python.h"
45 #include "gdb_assert.h"
49 /* This is defined in valops.c */
50 extern int overload_resolution
;
52 /* Prototypes for local functions. */
54 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
56 static struct value
*evaluate_subexp_for_address (struct expression
*,
59 static struct value
*evaluate_struct_tuple (struct value
*,
60 struct expression
*, int *,
63 static LONGEST
init_array_element (struct value
*, struct value
*,
64 struct expression
*, int *, enum noside
,
68 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
69 int *pos
, enum noside noside
)
71 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
72 (expect_type
, exp
, pos
, noside
);
75 /* Parse the string EXP as a C expression, evaluate it,
76 and return the result as a number. */
79 parse_and_eval_address (char *exp
)
81 struct expression
*expr
= parse_expression (exp
);
83 struct cleanup
*old_chain
=
84 make_cleanup (free_current_contents
, &expr
);
86 addr
= value_as_address (evaluate_expression (expr
));
87 do_cleanups (old_chain
);
91 /* Like parse_and_eval_address, but treats the value of the expression
92 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
94 parse_and_eval_long (char *exp
)
96 struct expression
*expr
= parse_expression (exp
);
98 struct cleanup
*old_chain
=
99 make_cleanup (free_current_contents
, &expr
);
101 retval
= value_as_long (evaluate_expression (expr
));
102 do_cleanups (old_chain
);
107 parse_and_eval (char *exp
)
109 struct expression
*expr
= parse_expression (exp
);
111 struct cleanup
*old_chain
=
112 make_cleanup (free_current_contents
, &expr
);
114 val
= evaluate_expression (expr
);
115 do_cleanups (old_chain
);
119 /* Parse up to a comma (or to a closeparen)
120 in the string EXPP as an expression, evaluate it, and return the value.
121 EXPP is advanced to point to the comma. */
124 parse_to_comma_and_eval (char **expp
)
126 struct expression
*expr
= parse_exp_1 (expp
, 0, (struct block
*) 0, 1);
128 struct cleanup
*old_chain
=
129 make_cleanup (free_current_contents
, &expr
);
131 val
= evaluate_expression (expr
);
132 do_cleanups (old_chain
);
136 /* Evaluate an expression in internal prefix form
137 such as is constructed by parse.y.
139 See expression.h for info on the format of an expression. */
142 evaluate_expression (struct expression
*exp
)
146 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
149 /* Evaluate an expression, avoiding all memory references
150 and getting a value whose type alone is correct. */
153 evaluate_type (struct expression
*exp
)
157 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
160 /* Evaluate a subexpression, avoiding all memory references and
161 getting a value whose type alone is correct. */
164 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
166 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
169 /* Find the current value of a watchpoint on EXP. Return the value in
170 *VALP and *RESULTP and the chain of intermediate and final values
171 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
174 If a memory error occurs while evaluating the expression, *RESULTP will
175 be set to NULL. *RESULTP may be a lazy value, if the result could
176 not be read from memory. It is used to determine whether a value
177 is user-specified (we should watch the whole value) or intermediate
178 (we should watch only the bit used to locate the final value).
180 If the final value, or any intermediate value, could not be read
181 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
182 set to any referenced values. *VALP will never be a lazy value.
183 This is the value which we store in struct breakpoint.
185 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
186 value chain. The caller must free the values individually. If
187 VAL_CHAIN is NULL, all generated values will be left on the value
191 fetch_subexp_value (struct expression
*exp
, int *pc
, struct value
**valp
,
192 struct value
**resultp
, struct value
**val_chain
)
194 struct value
*mark
, *new_mark
, *result
;
195 volatile struct gdb_exception ex
;
203 /* Evaluate the expression. */
204 mark
= value_mark ();
207 TRY_CATCH (ex
, RETURN_MASK_ALL
)
209 result
= evaluate_subexp (NULL_TYPE
, exp
, pc
, EVAL_NORMAL
);
213 /* Ignore memory errors, we want watchpoints pointing at
214 inaccessible memory to still be created; otherwise, throw the
215 error to some higher catcher. */
221 throw_exception (ex
);
226 new_mark
= value_mark ();
227 if (mark
== new_mark
)
232 /* Make sure it's not lazy, so that after the target stops again we
233 have a non-lazy previous value to compare with. */
236 if (!value_lazy (result
))
240 volatile struct gdb_exception except
;
242 TRY_CATCH (except
, RETURN_MASK_ERROR
)
244 value_fetch_lazy (result
);
252 /* Return the chain of intermediate values. We use this to
253 decide which addresses to watch. */
254 *val_chain
= new_mark
;
255 value_release_to_mark (mark
);
259 /* Extract a field operation from an expression. If the subexpression
260 of EXP starting at *SUBEXP is not a structure dereference
261 operation, return NULL. Otherwise, return the name of the
262 dereferenced field, and advance *SUBEXP to point to the
263 subexpression of the left-hand-side of the dereference. This is
264 used when completing field names. */
267 extract_field_op (struct expression
*exp
, int *subexp
)
272 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
273 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
275 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
276 result
= &exp
->elts
[*subexp
+ 2].string
;
277 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
281 /* This function evaluates brace-initializers (in C/C++) for
284 static struct value
*
285 evaluate_struct_tuple (struct value
*struct_val
,
286 struct expression
*exp
,
287 int *pos
, enum noside noside
, int nargs
)
289 struct type
*struct_type
= check_typedef (value_type (struct_val
));
290 struct type
*field_type
;
295 struct value
*val
= NULL
;
300 /* Skip static fields. */
301 while (fieldno
< TYPE_NFIELDS (struct_type
)
302 && field_is_static (&TYPE_FIELD (struct_type
,
305 if (fieldno
>= TYPE_NFIELDS (struct_type
))
306 error (_("too many initializers"));
307 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
308 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
309 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
310 error (_("don't know which variant you want to set"));
312 /* Here, struct_type is the type of the inner struct,
313 while substruct_type is the type of the inner struct.
314 These are the same for normal structures, but a variant struct
315 contains anonymous union fields that contain substruct fields.
316 The value fieldno is the index of the top-level (normal or
317 anonymous union) field in struct_field, while the value
318 subfieldno is the index of the actual real (named inner) field
319 in substruct_type. */
321 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
323 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
325 /* Now actually set the field in struct_val. */
327 /* Assign val to field fieldno. */
328 if (value_type (val
) != field_type
)
329 val
= value_cast (field_type
, val
);
331 bitsize
= TYPE_FIELD_BITSIZE (struct_type
, fieldno
);
332 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
333 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
335 modify_field (struct_type
, addr
,
336 value_as_long (val
), bitpos
% 8, bitsize
);
338 memcpy (addr
, value_contents (val
),
339 TYPE_LENGTH (value_type (val
)));
345 /* Recursive helper function for setting elements of array tuples for
346 (the deleted) Chill. The target is ARRAY (which has bounds
347 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
348 and NOSIDE are as usual. Evaluates index expresions and sets the
349 specified element(s) of ARRAY to ELEMENT. Returns last index
353 init_array_element (struct value
*array
, struct value
*element
,
354 struct expression
*exp
, int *pos
,
355 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
358 int element_size
= TYPE_LENGTH (value_type (element
));
360 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
363 init_array_element (array
, element
, exp
, pos
, noside
,
364 low_bound
, high_bound
);
365 return init_array_element (array
, element
,
366 exp
, pos
, noside
, low_bound
, high_bound
);
368 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
373 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
374 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
375 if (low
< low_bound
|| high
> high_bound
)
376 error (_("tuple range index out of range"));
377 for (index
= low
; index
<= high
; index
++)
379 memcpy (value_contents_raw (array
)
380 + (index
- low_bound
) * element_size
,
381 value_contents (element
), element_size
);
386 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
387 if (index
< low_bound
|| index
> high_bound
)
388 error (_("tuple index out of range"));
389 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
390 value_contents (element
), element_size
);
395 static struct value
*
396 value_f90_subarray (struct value
*array
,
397 struct expression
*exp
, int *pos
, enum noside noside
)
400 LONGEST low_bound
, high_bound
;
401 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
402 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
406 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
407 low_bound
= TYPE_LOW_BOUND (range
);
409 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
411 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
412 high_bound
= TYPE_HIGH_BOUND (range
);
414 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
416 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
420 /* Promote value ARG1 as appropriate before performing a unary operation
422 If the result is not appropriate for any particular language then it
423 needs to patch this function. */
426 unop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
431 *arg1
= coerce_ref (*arg1
);
432 type1
= check_typedef (value_type (*arg1
));
434 if (is_integral_type (type1
))
436 switch (language
->la_language
)
439 /* Perform integral promotion for ANSI C/C++.
440 If not appropropriate for any particular language
441 it needs to modify this function. */
443 struct type
*builtin_int
= builtin_type (gdbarch
)->builtin_int
;
445 if (TYPE_LENGTH (type1
) < TYPE_LENGTH (builtin_int
))
446 *arg1
= value_cast (builtin_int
, *arg1
);
453 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
454 operation on those two operands.
455 If the result is not appropriate for any particular language then it
456 needs to patch this function. */
459 binop_promote (const struct language_defn
*language
, struct gdbarch
*gdbarch
,
460 struct value
**arg1
, struct value
**arg2
)
462 struct type
*promoted_type
= NULL
;
466 *arg1
= coerce_ref (*arg1
);
467 *arg2
= coerce_ref (*arg2
);
469 type1
= check_typedef (value_type (*arg1
));
470 type2
= check_typedef (value_type (*arg2
));
472 if ((TYPE_CODE (type1
) != TYPE_CODE_FLT
473 && TYPE_CODE (type1
) != TYPE_CODE_DECFLOAT
474 && !is_integral_type (type1
))
475 || (TYPE_CODE (type2
) != TYPE_CODE_FLT
476 && TYPE_CODE (type2
) != TYPE_CODE_DECFLOAT
477 && !is_integral_type (type2
)))
480 if (TYPE_CODE (type1
) == TYPE_CODE_DECFLOAT
481 || TYPE_CODE (type2
) == TYPE_CODE_DECFLOAT
)
483 /* No promotion required. */
485 else if (TYPE_CODE (type1
) == TYPE_CODE_FLT
486 || TYPE_CODE (type2
) == TYPE_CODE_FLT
)
488 switch (language
->la_language
)
494 case language_opencl
:
495 /* No promotion required. */
499 /* For other languages the result type is unchanged from gdb
500 version 6.7 for backward compatibility.
501 If either arg was long double, make sure that value is also long
502 double. Otherwise use double. */
503 if (TYPE_LENGTH (type1
) * 8 > gdbarch_double_bit (gdbarch
)
504 || TYPE_LENGTH (type2
) * 8 > gdbarch_double_bit (gdbarch
))
505 promoted_type
= builtin_type (gdbarch
)->builtin_long_double
;
507 promoted_type
= builtin_type (gdbarch
)->builtin_double
;
511 else if (TYPE_CODE (type1
) == TYPE_CODE_BOOL
512 && TYPE_CODE (type2
) == TYPE_CODE_BOOL
)
514 /* No promotion required. */
517 /* Integral operations here. */
518 /* FIXME: Also mixed integral/booleans, with result an integer. */
520 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
521 unsigned int promoted_len1
= TYPE_LENGTH (type1
);
522 unsigned int promoted_len2
= TYPE_LENGTH (type2
);
523 int is_unsigned1
= TYPE_UNSIGNED (type1
);
524 int is_unsigned2
= TYPE_UNSIGNED (type2
);
525 unsigned int result_len
;
526 int unsigned_operation
;
528 /* Determine type length and signedness after promotion for
530 if (promoted_len1
< TYPE_LENGTH (builtin
->builtin_int
))
533 promoted_len1
= TYPE_LENGTH (builtin
->builtin_int
);
535 if (promoted_len2
< TYPE_LENGTH (builtin
->builtin_int
))
538 promoted_len2
= TYPE_LENGTH (builtin
->builtin_int
);
541 if (promoted_len1
> promoted_len2
)
543 unsigned_operation
= is_unsigned1
;
544 result_len
= promoted_len1
;
546 else if (promoted_len2
> promoted_len1
)
548 unsigned_operation
= is_unsigned2
;
549 result_len
= promoted_len2
;
553 unsigned_operation
= is_unsigned1
|| is_unsigned2
;
554 result_len
= promoted_len1
;
557 switch (language
->la_language
)
563 if (result_len
<= TYPE_LENGTH (builtin
->builtin_int
))
565 promoted_type
= (unsigned_operation
566 ? builtin
->builtin_unsigned_int
567 : builtin
->builtin_int
);
569 else if (result_len
<= TYPE_LENGTH (builtin
->builtin_long
))
571 promoted_type
= (unsigned_operation
572 ? builtin
->builtin_unsigned_long
573 : builtin
->builtin_long
);
577 promoted_type
= (unsigned_operation
578 ? builtin
->builtin_unsigned_long_long
579 : builtin
->builtin_long_long
);
582 case language_opencl
:
583 if (result_len
<= TYPE_LENGTH (lookup_signed_typename
584 (language
, gdbarch
, "int")))
588 ? lookup_unsigned_typename (language
, gdbarch
, "int")
589 : lookup_signed_typename (language
, gdbarch
, "int"));
591 else if (result_len
<= TYPE_LENGTH (lookup_signed_typename
592 (language
, gdbarch
, "long")))
596 ? lookup_unsigned_typename (language
, gdbarch
, "long")
597 : lookup_signed_typename (language
, gdbarch
,"long"));
601 /* For other languages the result type is unchanged from gdb
602 version 6.7 for backward compatibility.
603 If either arg was long long, make sure that value is also long
604 long. Otherwise use long. */
605 if (unsigned_operation
)
607 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
608 promoted_type
= builtin
->builtin_unsigned_long_long
;
610 promoted_type
= builtin
->builtin_unsigned_long
;
614 if (result_len
> gdbarch_long_bit (gdbarch
) / HOST_CHAR_BIT
)
615 promoted_type
= builtin
->builtin_long_long
;
617 promoted_type
= builtin
->builtin_long
;
625 /* Promote both operands to common type. */
626 *arg1
= value_cast (promoted_type
, *arg1
);
627 *arg2
= value_cast (promoted_type
, *arg2
);
632 ptrmath_type_p (const struct language_defn
*lang
, struct type
*type
)
634 type
= check_typedef (type
);
635 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
636 type
= TYPE_TARGET_TYPE (type
);
638 switch (TYPE_CODE (type
))
644 case TYPE_CODE_ARRAY
:
645 return TYPE_VECTOR (type
) ? 0 : lang
->c_style_arrays
;
652 /* Constructs a fake method with the given parameter types.
653 This function is used by the parser to construct an "expected"
654 type for method overload resolution. */
657 make_params (int num_types
, struct type
**param_types
)
659 struct type
*type
= XZALLOC (struct type
);
660 TYPE_MAIN_TYPE (type
) = XZALLOC (struct main_type
);
661 TYPE_LENGTH (type
) = 1;
662 TYPE_CODE (type
) = TYPE_CODE_METHOD
;
663 TYPE_VPTR_FIELDNO (type
) = -1;
664 TYPE_CHAIN (type
) = type
;
667 if (param_types
[num_types
- 1] == NULL
)
670 TYPE_VARARGS (type
) = 1;
672 else if (TYPE_CODE (check_typedef (param_types
[num_types
- 1]))
676 /* Caller should have ensured this. */
677 gdb_assert (num_types
== 0);
678 TYPE_PROTOTYPED (type
) = 1;
682 TYPE_NFIELDS (type
) = num_types
;
683 TYPE_FIELDS (type
) = (struct field
*)
684 TYPE_ZALLOC (type
, sizeof (struct field
) * num_types
);
686 while (num_types
-- > 0)
687 TYPE_FIELD_TYPE (type
, num_types
) = param_types
[num_types
];
693 evaluate_subexp_standard (struct type
*expect_type
,
694 struct expression
*exp
, int *pos
,
699 int pc
, pc2
= 0, oldpos
;
700 struct value
*arg1
= NULL
;
701 struct value
*arg2
= NULL
;
705 struct value
**argvec
;
709 struct type
**arg_types
;
711 struct symbol
*function
= NULL
;
712 char *function_name
= NULL
;
715 op
= exp
->elts
[pc
].opcode
;
720 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
721 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
722 if (noside
== EVAL_SKIP
)
724 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
725 &exp
->elts
[pc
+ 3].string
,
726 expect_type
, 0, noside
);
728 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
733 return value_from_longest (exp
->elts
[pc
+ 1].type
,
734 exp
->elts
[pc
+ 2].longconst
);
738 return value_from_double (exp
->elts
[pc
+ 1].type
,
739 exp
->elts
[pc
+ 2].doubleconst
);
743 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
744 exp
->elts
[pc
+ 2].decfloatconst
);
749 if (noside
== EVAL_SKIP
)
752 /* JYG: We used to just return value_zero of the symbol type
753 if we're asked to avoid side effects. Otherwise we return
754 value_of_variable (...). However I'm not sure if
755 value_of_variable () has any side effect.
756 We need a full value object returned here for whatis_exp ()
757 to call evaluate_type () and then pass the full value to
758 value_rtti_target_type () if we are dealing with a pointer
759 or reference to a base class and print object is on. */
762 volatile struct gdb_exception except
;
763 struct value
*ret
= NULL
;
765 TRY_CATCH (except
, RETURN_MASK_ERROR
)
767 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
768 exp
->elts
[pc
+ 1].block
);
771 if (except
.reason
< 0)
773 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
774 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
),
777 throw_exception (except
);
783 case OP_VAR_ENTRY_VALUE
:
785 if (noside
== EVAL_SKIP
)
789 struct symbol
*sym
= exp
->elts
[pc
+ 1].symbol
;
790 struct frame_info
*frame
;
792 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
793 return value_zero (SYMBOL_TYPE (sym
), not_lval
);
795 if (SYMBOL_CLASS (sym
) != LOC_COMPUTED
796 || SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
== NULL
)
797 error (_("Symbol \"%s\" does not have any specific entry value"),
798 SYMBOL_PRINT_NAME (sym
));
800 frame
= get_selected_frame (NULL
);
801 return SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry (sym
, frame
);
807 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
811 const char *name
= &exp
->elts
[pc
+ 2].string
;
815 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
816 regno
= user_reg_map_name_to_regnum (exp
->gdbarch
,
817 name
, strlen (name
));
819 error (_("Register $%s not available."), name
);
821 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
822 a value with the appropriate register type. Unfortunately,
823 we don't have easy access to the type of user registers.
824 So for these registers, we fetch the register value regardless
825 of the evaluation mode. */
826 if (noside
== EVAL_AVOID_SIDE_EFFECTS
827 && regno
< gdbarch_num_regs (exp
->gdbarch
)
828 + gdbarch_num_pseudo_regs (exp
->gdbarch
))
829 val
= value_zero (register_type (exp
->gdbarch
, regno
), not_lval
);
831 val
= value_of_register (regno
, get_selected_frame (NULL
));
833 error (_("Value of register %s not available."), name
);
839 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
840 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
844 return value_of_internalvar (exp
->gdbarch
,
845 exp
->elts
[pc
+ 1].internalvar
);
848 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
849 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
850 if (noside
== EVAL_SKIP
)
852 type
= language_string_char_type (exp
->language_defn
, exp
->gdbarch
);
853 return value_string (&exp
->elts
[pc
+ 2].string
, tem
, type
);
855 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class
856 NSString constant. */
857 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
858 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
859 if (noside
== EVAL_SKIP
)
863 return value_nsstring (exp
->gdbarch
, &exp
->elts
[pc
+ 2].string
, tem
+ 1);
867 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
868 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
869 nargs
= tem3
- tem2
+ 1;
870 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
872 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
873 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
875 struct value
*rec
= allocate_value (expect_type
);
877 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
878 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
881 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
882 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
884 struct type
*range_type
= TYPE_INDEX_TYPE (type
);
885 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
886 struct value
*array
= allocate_value (expect_type
);
887 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
888 LONGEST low_bound
, high_bound
, index
;
890 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
893 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
896 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
897 for (tem
= nargs
; --nargs
>= 0;)
899 struct value
*element
;
902 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
905 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
907 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
908 if (value_type (element
) != element_type
)
909 element
= value_cast (element_type
, element
);
912 int continue_pc
= *pos
;
915 index
= init_array_element (array
, element
, exp
, pos
, noside
,
916 low_bound
, high_bound
);
921 if (index
> high_bound
)
922 /* To avoid memory corruption. */
923 error (_("Too many array elements"));
924 memcpy (value_contents_raw (array
)
925 + (index
- low_bound
) * element_size
,
926 value_contents (element
),
934 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
935 && TYPE_CODE (type
) == TYPE_CODE_SET
)
937 struct value
*set
= allocate_value (expect_type
);
938 gdb_byte
*valaddr
= value_contents_raw (set
);
939 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
940 struct type
*check_type
= element_type
;
941 LONGEST low_bound
, high_bound
;
943 /* Get targettype of elementtype. */
944 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
945 || TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
946 check_type
= TYPE_TARGET_TYPE (check_type
);
948 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
949 error (_("(power)set type with unknown size"));
950 memset (valaddr
, '\0', TYPE_LENGTH (type
));
951 for (tem
= 0; tem
< nargs
; tem
++)
953 LONGEST range_low
, range_high
;
954 struct type
*range_low_type
, *range_high_type
;
955 struct value
*elem_val
;
957 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
960 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
961 range_low_type
= value_type (elem_val
);
962 range_low
= value_as_long (elem_val
);
963 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
964 range_high_type
= value_type (elem_val
);
965 range_high
= value_as_long (elem_val
);
969 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
970 range_low_type
= range_high_type
= value_type (elem_val
);
971 range_low
= range_high
= value_as_long (elem_val
);
973 /* Check types of elements to avoid mixture of elements from
974 different types. Also check if type of element is "compatible"
975 with element type of powerset. */
976 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
977 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
978 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
979 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
980 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
))
981 || (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
982 && (range_low_type
!= range_high_type
)))
983 /* different element modes. */
984 error (_("POWERSET tuple elements of different mode"));
985 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
))
986 || (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
987 && range_low_type
!= check_type
))
988 error (_("incompatible POWERSET tuple elements"));
989 if (range_low
> range_high
)
991 warning (_("empty POWERSET tuple range"));
994 if (range_low
< low_bound
|| range_high
> high_bound
)
995 error (_("POWERSET tuple element out of range"));
996 range_low
-= low_bound
;
997 range_high
-= low_bound
;
998 for (; range_low
<= range_high
; range_low
++)
1000 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
1002 if (gdbarch_bits_big_endian (exp
->gdbarch
))
1003 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
1004 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
1011 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
1012 for (tem
= 0; tem
< nargs
; tem
++)
1014 /* Ensure that array expressions are coerced into pointer
1016 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1018 if (noside
== EVAL_SKIP
)
1020 return value_array (tem2
, tem3
, argvec
);
1024 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1026 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1028 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1030 if (noside
== EVAL_SKIP
)
1032 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
1036 /* Skip third and second args to evaluate the first one. */
1037 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1038 if (value_logical_not (arg1
))
1040 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1041 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1045 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1046 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1050 case OP_OBJC_SELECTOR
:
1051 { /* Objective C @selector operator. */
1052 char *sel
= &exp
->elts
[pc
+ 2].string
;
1053 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1054 struct type
*selector_type
;
1056 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
1057 if (noside
== EVAL_SKIP
)
1061 sel
[len
] = 0; /* Make sure it's terminated. */
1063 selector_type
= builtin_type (exp
->gdbarch
)->builtin_data_ptr
;
1064 return value_from_longest (selector_type
,
1065 lookup_child_selector (exp
->gdbarch
, sel
));
1068 case OP_OBJC_MSGCALL
:
1069 { /* Objective C message (method) call. */
1071 CORE_ADDR responds_selector
= 0;
1072 CORE_ADDR method_selector
= 0;
1074 CORE_ADDR selector
= 0;
1076 int struct_return
= 0;
1077 int sub_no_side
= 0;
1079 struct value
*msg_send
= NULL
;
1080 struct value
*msg_send_stret
= NULL
;
1081 int gnu_runtime
= 0;
1083 struct value
*target
= NULL
;
1084 struct value
*method
= NULL
;
1085 struct value
*called_method
= NULL
;
1087 struct type
*selector_type
= NULL
;
1088 struct type
*long_type
;
1090 struct value
*ret
= NULL
;
1093 selector
= exp
->elts
[pc
+ 1].longconst
;
1094 nargs
= exp
->elts
[pc
+ 2].longconst
;
1095 argvec
= (struct value
**) alloca (sizeof (struct value
*)
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))
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], 3, argvec
+ 1);
1184 /* Function objc_msg_lookup returns a pointer. */
1186 ret
= call_function_by_hand (argvec
[0], 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], 3, argvec
+ 1);
1207 ret
= call_function_by_hand (argvec
[0], 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 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
)
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], nargs
+ 2, argvec
+ 1);
1352 ret
= call_function_by_hand (argvec
[0], 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] 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 (noside
== EVAL_SKIP
)
1373 if (op
== STRUCTOP_MEMBER
)
1375 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1379 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1382 /* If the function is a virtual function, then the
1383 aggregate value (providing the structure) plays
1384 its part by providing the vtable. Otherwise,
1385 it is just along for the ride: call the function
1388 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1390 type
= check_typedef (value_type (arg1
));
1391 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_DOMAIN_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);
1434 if (noside
== EVAL_SKIP
)
1437 if (op
== STRUCTOP_STRUCT
)
1439 /* If v is a variable in a register, and the user types
1440 v.method (), this will produce an error, because v has
1443 A possible way around this would be to allocate a
1444 copy of the variable on the stack, copy in the
1445 contents, call the function, and copy out the
1446 contents. I.e. convert this from call by reference
1447 to call by copy-return (or whatever it's called).
1448 However, this does not work because it is not the
1449 same: the method being called could stash a copy of
1450 the address, and then future uses through that address
1451 (after the method returns) would be expected to
1452 use the variable itself, not some copy of it. */
1453 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1457 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1459 /* Check to see if the operator '->' has been
1460 overloaded. If the operator has been overloaded
1461 replace arg2 with the value returned by the custom
1462 operator and continue evaluation. */
1463 while (unop_user_defined_p (op
, arg2
))
1465 volatile struct gdb_exception except
;
1466 struct value
*value
= NULL
;
1467 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1469 value
= value_x_unop (arg2
, op
, noside
);
1472 if (except
.reason
< 0)
1474 if (except
.error
== NOT_FOUND_ERROR
)
1477 throw_exception (except
);
1482 /* Now, say which argument to start evaluating from. */
1485 else if (op
== OP_SCOPE
1486 && overload_resolution
1487 && (exp
->language_defn
->la_language
== language_cplus
))
1489 /* Unpack it locally so we can properly handle overload
1495 local_tem
= longest_to_int (exp
->elts
[pc2
+ 2].longconst
);
1496 (*pos
) += 4 + BYTES_TO_EXP_ELEM (local_tem
+ 1);
1497 type
= exp
->elts
[pc2
+ 1].type
;
1498 name
= &exp
->elts
[pc2
+ 3].string
;
1501 function_name
= NULL
;
1502 if (TYPE_CODE (type
) == TYPE_CODE_NAMESPACE
)
1504 function
= cp_lookup_symbol_namespace (TYPE_TAG_NAME (type
),
1506 get_selected_block (0),
1508 if (function
== NULL
)
1509 error (_("No symbol \"%s\" in namespace \"%s\"."),
1510 name
, TYPE_TAG_NAME (type
));
1516 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
1517 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
1518 function_name
= name
;
1520 arg2
= value_zero (type
, lval_memory
);
1525 else if (op
== OP_ADL_FUNC
)
1527 /* Save the function position and move pos so that the arguments
1528 can be evaluated. */
1534 func_name_len
= longest_to_int (exp
->elts
[save_pos1
+ 3].longconst
);
1535 (*pos
) += 6 + BYTES_TO_EXP_ELEM (func_name_len
+ 1);
1539 /* Non-method function call. */
1543 /* If this is a C++ function wait until overload resolution. */
1544 if (op
== OP_VAR_VALUE
1545 && overload_resolution
1546 && (exp
->language_defn
->la_language
== language_cplus
))
1548 (*pos
) += 4; /* Skip the evaluation of the symbol. */
1553 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1554 type
= value_type (argvec
[0]);
1555 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1556 type
= TYPE_TARGET_TYPE (type
);
1557 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1559 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1561 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
,
1569 /* Evaluate arguments. */
1570 for (; tem
<= nargs
; tem
++)
1572 /* Ensure that array expressions are coerced into pointer
1574 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1577 /* Signal end of arglist. */
1579 if (op
== OP_ADL_FUNC
)
1581 struct symbol
*symp
;
1584 int string_pc
= save_pos1
+ 3;
1586 /* Extract the function name. */
1587 name_len
= longest_to_int (exp
->elts
[string_pc
].longconst
);
1588 func_name
= (char *) alloca (name_len
+ 1);
1589 strcpy (func_name
, &exp
->elts
[string_pc
+ 1].string
);
1591 find_overload_match (&argvec
[1], nargs
, func_name
,
1592 NON_METHOD
, /* not method */
1593 0, /* strict match */
1594 NULL
, NULL
, /* pass NULL symbol since
1595 symbol is unknown */
1596 NULL
, &symp
, NULL
, 0);
1598 /* Now fix the expression being evaluated. */
1599 exp
->elts
[save_pos1
+ 2].symbol
= symp
;
1600 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1603 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
1604 || (op
== OP_SCOPE
&& function_name
!= NULL
))
1606 int static_memfuncp
;
1609 /* Method invocation : stuff "this" as first parameter. */
1614 /* Name of method from expression. */
1615 tstr
= &exp
->elts
[pc2
+ 2].string
;
1618 tstr
= function_name
;
1620 if (overload_resolution
&& (exp
->language_defn
->la_language
1623 /* Language is C++, do some overload resolution before
1625 struct value
*valp
= NULL
;
1627 (void) find_overload_match (&argvec
[1], nargs
, tstr
,
1628 METHOD
, /* method */
1629 0, /* strict match */
1630 &arg2
, /* the object */
1632 &static_memfuncp
, 0);
1634 if (op
== OP_SCOPE
&& !static_memfuncp
)
1636 /* For the time being, we don't handle this. */
1637 error (_("Call to overloaded function %s requires "
1641 argvec
[1] = arg2
; /* the ``this'' pointer */
1642 argvec
[0] = valp
; /* Use the method found after overload
1646 /* Non-C++ case -- or no overload resolution. */
1648 struct value
*temp
= arg2
;
1650 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1652 op
== STRUCTOP_STRUCT
1653 ? "structure" : "structure pointer");
1654 /* value_struct_elt updates temp with the correct value
1655 of the ``this'' pointer if necessary, so modify argvec[1] to
1656 reflect any ``this'' changes. */
1658 = value_from_longest (lookup_pointer_type(value_type (temp
)),
1659 value_address (temp
)
1660 + value_embedded_offset (temp
));
1661 argvec
[1] = arg2
; /* the ``this'' pointer */
1664 if (static_memfuncp
)
1666 argvec
[1] = argvec
[0];
1671 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1673 /* Pointer to member. argvec[1] is already set up. */
1676 else if (op
== OP_VAR_VALUE
|| (op
== OP_SCOPE
&& function
!= NULL
))
1678 /* Non-member function being called. */
1679 /* fn: This can only be done for C++ functions. A C-style function
1680 in a C++ program, for instance, does not have the fields that
1681 are expected here. */
1683 if (overload_resolution
&& (exp
->language_defn
->la_language
1686 /* Language is C++, do some overload resolution before
1688 struct symbol
*symp
;
1691 /* If a scope has been specified disable ADL. */
1695 if (op
== OP_VAR_VALUE
)
1696 function
= exp
->elts
[save_pos1
+2].symbol
;
1698 (void) find_overload_match (&argvec
[1], nargs
,
1699 NULL
, /* no need for name */
1700 NON_METHOD
, /* not method */
1701 0, /* strict match */
1702 NULL
, function
, /* the function */
1703 NULL
, &symp
, NULL
, no_adl
);
1705 if (op
== OP_VAR_VALUE
)
1707 /* Now fix the expression being evaluated. */
1708 exp
->elts
[save_pos1
+2].symbol
= symp
;
1709 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
,
1713 argvec
[0] = value_of_variable (symp
, get_selected_block (0));
1717 /* Not C++, or no overload resolution allowed. */
1718 /* Nothing to be done; argvec already correctly set up. */
1723 /* It is probably a C-style function. */
1724 /* Nothing to be done; argvec already correctly set up. */
1729 if (noside
== EVAL_SKIP
)
1731 if (argvec
[0] == NULL
)
1732 error (_("Cannot evaluate function -- may be inlined"));
1733 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1735 /* If the return type doesn't look like a function type, call an
1736 error. This can happen if somebody tries to turn a variable into
1737 a function call. This is here because people often want to
1738 call, eg, strcmp, which gdb doesn't know is a function. If
1739 gdb isn't asked for it's opinion (ie. through "whatis"),
1740 it won't offer it. */
1742 struct type
*ftype
= value_type (argvec
[0]);
1744 if (TYPE_CODE (ftype
) == TYPE_CODE_INTERNAL_FUNCTION
)
1746 /* We don't know anything about what the internal
1747 function might return, but we have to return
1749 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
1752 else if (TYPE_GNU_IFUNC (ftype
))
1753 return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype
)));
1754 else if (TYPE_TARGET_TYPE (ftype
))
1755 return allocate_value (TYPE_TARGET_TYPE (ftype
));
1757 error (_("Expression of type other than "
1758 "\"Function returning ...\" used as function"));
1760 if (TYPE_CODE (value_type (argvec
[0])) == TYPE_CODE_INTERNAL_FUNCTION
)
1761 return call_internal_function (exp
->gdbarch
, exp
->language_defn
,
1762 argvec
[0], nargs
, argvec
+ 1);
1764 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1765 /* pai: FIXME save value from call_function_by_hand, then adjust
1766 pc by adjust_fn_pc if +ve. */
1768 case OP_F77_UNDETERMINED_ARGLIST
:
1770 /* Remember that in F77, functions, substring ops and
1771 array subscript operations cannot be disambiguated
1772 at parse time. We have made all array subscript operations,
1773 substring operations as well as function calls come here
1774 and we now have to discover what the heck this thing actually was.
1775 If it is a function, we process just as if we got an OP_FUNCALL. */
1777 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1780 /* First determine the type code we are dealing with. */
1781 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1782 type
= check_typedef (value_type (arg1
));
1783 code
= TYPE_CODE (type
);
1785 if (code
== TYPE_CODE_PTR
)
1787 /* Fortran always passes variable to subroutines as pointer.
1788 So we need to look into its target type to see if it is
1789 array, string or function. If it is, we need to switch
1790 to the target value the original one points to. */
1791 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1793 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1794 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1795 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1797 arg1
= value_ind (arg1
);
1798 type
= check_typedef (value_type (arg1
));
1799 code
= TYPE_CODE (type
);
1805 case TYPE_CODE_ARRAY
:
1806 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1807 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1809 goto multi_f77_subscript
;
1811 case TYPE_CODE_STRING
:
1812 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1813 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1816 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1817 return value_subscript (arg1
, value_as_long (arg2
));
1821 case TYPE_CODE_FUNC
:
1822 /* It's a function call. */
1823 /* Allocate arg vector, including space for the function to be
1824 called in argvec[0] and a terminating NULL. */
1825 argvec
= (struct value
**)
1826 alloca (sizeof (struct value
*) * (nargs
+ 2));
1829 for (; tem
<= nargs
; tem
++)
1830 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1831 argvec
[tem
] = 0; /* signal end of arglist */
1835 error (_("Cannot perform substring on this type"));
1839 /* We have a complex number, There should be 2 floating
1840 point numbers that compose it. */
1842 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1843 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1845 return value_literal_complex (arg1
, arg2
, exp
->elts
[pc
+ 1].type
);
1847 case STRUCTOP_STRUCT
:
1848 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1849 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1850 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1851 if (noside
== EVAL_SKIP
)
1853 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1854 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1855 &exp
->elts
[pc
+ 2].string
,
1860 struct value
*temp
= arg1
;
1862 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1867 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1868 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1869 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1870 if (noside
== EVAL_SKIP
)
1873 /* Check to see if operator '->' has been overloaded. If so replace
1874 arg1 with the value returned by evaluating operator->(). */
1875 while (unop_user_defined_p (op
, arg1
))
1877 volatile struct gdb_exception except
;
1878 struct value
*value
= NULL
;
1879 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1881 value
= value_x_unop (arg1
, op
, noside
);
1884 if (except
.reason
< 0)
1886 if (except
.error
== NOT_FOUND_ERROR
)
1889 throw_exception (except
);
1894 /* JYG: if print object is on we need to replace the base type
1895 with rtti type in order to continue on with successful
1896 lookup of member / method only available in the rtti type. */
1898 struct type
*type
= value_type (arg1
);
1899 struct type
*real_type
;
1900 int full
, top
, using_enc
;
1901 struct value_print_options opts
;
1903 get_user_print_options (&opts
);
1904 if (opts
.objectprint
&& TYPE_TARGET_TYPE(type
)
1905 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1907 real_type
= value_rtti_indirect_type (arg1
, &full
, &top
,
1910 arg1
= value_cast (real_type
, arg1
);
1914 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1915 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1916 &exp
->elts
[pc
+ 2].string
,
1921 struct value
*temp
= arg1
;
1923 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1924 NULL
, "structure pointer");
1927 case STRUCTOP_MEMBER
:
1929 if (op
== STRUCTOP_MEMBER
)
1930 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1932 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1934 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1936 if (noside
== EVAL_SKIP
)
1939 type
= check_typedef (value_type (arg2
));
1940 switch (TYPE_CODE (type
))
1942 case TYPE_CODE_METHODPTR
:
1943 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1944 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1947 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1948 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1949 return value_ind (arg2
);
1952 case TYPE_CODE_MEMBERPTR
:
1953 /* Now, convert these values to an address. */
1954 arg1
= value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1957 mem_offset
= value_as_long (arg2
);
1959 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1960 value_as_long (arg1
) + mem_offset
);
1961 return value_ind (arg3
);
1964 error (_("non-pointer-to-member value used "
1965 "in pointer-to-member construct"));
1969 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1970 arg_types
= (struct type
**) alloca (nargs
* sizeof (struct type
*));
1971 for (ix
= 0; ix
< nargs
; ++ix
)
1972 arg_types
[ix
] = exp
->elts
[pc
+ 1 + ix
+ 1].type
;
1974 expect_type
= make_params (nargs
, arg_types
);
1975 *(pos
) += 3 + nargs
;
1976 arg1
= evaluate_subexp_standard (expect_type
, exp
, pos
, noside
);
1977 xfree (TYPE_FIELDS (expect_type
));
1978 xfree (TYPE_MAIN_TYPE (expect_type
));
1979 xfree (expect_type
);
1983 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1984 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1985 if (noside
== EVAL_SKIP
)
1987 if (binop_user_defined_p (op
, arg1
, arg2
))
1988 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1990 return value_concat (arg1
, arg2
);
1993 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1994 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1996 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1998 if (binop_user_defined_p (op
, arg1
, arg2
))
1999 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2001 return value_assign (arg1
, arg2
);
2003 case BINOP_ASSIGN_MODIFY
:
2005 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2006 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2007 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2009 op
= exp
->elts
[pc
+ 1].opcode
;
2010 if (binop_user_defined_p (op
, arg1
, arg2
))
2011 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
2012 else if (op
== BINOP_ADD
&& ptrmath_type_p (exp
->language_defn
,
2014 && is_integral_type (value_type (arg2
)))
2015 arg2
= value_ptradd (arg1
, value_as_long (arg2
));
2016 else if (op
== BINOP_SUB
&& ptrmath_type_p (exp
->language_defn
,
2018 && is_integral_type (value_type (arg2
)))
2019 arg2
= value_ptradd (arg1
, - value_as_long (arg2
));
2022 struct value
*tmp
= arg1
;
2024 /* For shift and integer exponentiation operations,
2025 only promote the first argument. */
2026 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2027 && is_integral_type (value_type (arg2
)))
2028 unop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
);
2030 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2032 arg2
= value_binop (tmp
, arg2
, op
);
2034 return value_assign (arg1
, arg2
);
2037 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2038 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2039 if (noside
== EVAL_SKIP
)
2041 if (binop_user_defined_p (op
, arg1
, arg2
))
2042 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2043 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2044 && is_integral_type (value_type (arg2
)))
2045 return value_ptradd (arg1
, value_as_long (arg2
));
2046 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg2
))
2047 && is_integral_type (value_type (arg1
)))
2048 return value_ptradd (arg2
, value_as_long (arg1
));
2051 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2052 return value_binop (arg1
, arg2
, BINOP_ADD
);
2056 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2057 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2058 if (noside
== EVAL_SKIP
)
2060 if (binop_user_defined_p (op
, arg1
, arg2
))
2061 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2062 else if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
))
2063 && ptrmath_type_p (exp
->language_defn
, value_type (arg2
)))
2065 /* FIXME -- should be ptrdiff_t */
2066 type
= builtin_type (exp
->gdbarch
)->builtin_long
;
2067 return value_from_longest (type
, value_ptrdiff (arg1
, arg2
));
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
));
2074 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2075 return value_binop (arg1
, arg2
, BINOP_SUB
);
2086 case BINOP_BITWISE_AND
:
2087 case BINOP_BITWISE_IOR
:
2088 case BINOP_BITWISE_XOR
:
2089 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2090 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2091 if (noside
== EVAL_SKIP
)
2093 if (binop_user_defined_p (op
, arg1
, arg2
))
2094 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2097 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2098 fudge arg2 to avoid division-by-zero, the caller is
2099 (theoretically) only looking for the type of the result. */
2100 if (noside
== EVAL_AVOID_SIDE_EFFECTS
2101 /* ??? Do we really want to test for BINOP_MOD here?
2102 The implementation of value_binop gives it a well-defined
2105 || op
== BINOP_INTDIV
2108 && value_logical_not (arg2
))
2110 struct value
*v_one
, *retval
;
2112 v_one
= value_one (value_type (arg2
));
2113 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &v_one
);
2114 retval
= value_binop (arg1
, v_one
, op
);
2119 /* For shift and integer exponentiation operations,
2120 only promote the first argument. */
2121 if ((op
== BINOP_LSH
|| op
== BINOP_RSH
|| op
== BINOP_EXP
)
2122 && is_integral_type (value_type (arg2
)))
2123 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2125 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2127 return value_binop (arg1
, arg2
, op
);
2132 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2133 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2134 if (noside
== EVAL_SKIP
)
2136 error (_("':' operator used in invalid context"));
2138 case BINOP_SUBSCRIPT
:
2139 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2140 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2141 if (noside
== EVAL_SKIP
)
2143 if (binop_user_defined_p (op
, arg1
, arg2
))
2144 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2147 /* If the user attempts to subscript something that is not an
2148 array or pointer type (like a plain int variable for example),
2149 then report this as an error. */
2151 arg1
= coerce_ref (arg1
);
2152 type
= check_typedef (value_type (arg1
));
2153 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2154 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
2156 if (TYPE_NAME (type
))
2157 error (_("cannot subscript something of type `%s'"),
2160 error (_("cannot subscript requested type"));
2163 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2164 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
2166 return value_subscript (arg1
, value_as_long (arg2
));
2170 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2171 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2172 if (noside
== EVAL_SKIP
)
2174 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2175 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
2177 case MULTI_SUBSCRIPT
:
2179 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
2180 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2183 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2184 /* FIXME: EVAL_SKIP handling may not be correct. */
2185 if (noside
== EVAL_SKIP
)
2196 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2197 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2199 /* If the user attempts to subscript something that has no target
2200 type (like a plain int variable for example), then report this
2203 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
2206 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
2212 error (_("cannot subscript something of type `%s'"),
2213 TYPE_NAME (value_type (arg1
)));
2217 if (binop_user_defined_p (op
, arg1
, arg2
))
2219 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2223 arg1
= coerce_ref (arg1
);
2224 type
= check_typedef (value_type (arg1
));
2226 switch (TYPE_CODE (type
))
2229 case TYPE_CODE_ARRAY
:
2230 case TYPE_CODE_STRING
:
2231 arg1
= value_subscript (arg1
, value_as_long (arg2
));
2235 if (TYPE_NAME (type
))
2236 error (_("cannot subscript something of type `%s'"),
2239 error (_("cannot subscript requested type"));
2245 multi_f77_subscript
:
2247 LONGEST subscript_array
[MAX_FORTRAN_DIMS
];
2248 int ndimensions
= 1, i
;
2249 struct value
*array
= arg1
;
2251 if (nargs
> MAX_FORTRAN_DIMS
)
2252 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
2254 ndimensions
= calc_f77_array_dims (type
);
2256 if (nargs
!= ndimensions
)
2257 error (_("Wrong number of subscripts"));
2259 gdb_assert (nargs
> 0);
2261 /* Now that we know we have a legal array subscript expression
2262 let us actually find out where this element exists in the array. */
2264 /* Take array indices left to right. */
2265 for (i
= 0; i
< nargs
; i
++)
2267 /* Evaluate each subscript; it must be a legal integer in F77. */
2268 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
2270 /* Fill in the subscript array. */
2272 subscript_array
[i
] = value_as_long (arg2
);
2275 /* Internal type of array is arranged right to left. */
2276 for (i
= nargs
; i
> 0; i
--)
2278 struct type
*array_type
= check_typedef (value_type (array
));
2279 LONGEST index
= subscript_array
[i
- 1];
2281 array
= value_subscripted_rvalue (array
, index
,
2282 f77_get_lowerbound (array_type
));
2288 case BINOP_LOGICAL_AND
:
2289 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2290 if (noside
== EVAL_SKIP
)
2292 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2297 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2300 if (binop_user_defined_p (op
, arg1
, arg2
))
2302 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2303 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2307 tem
= value_logical_not (arg1
);
2308 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2309 (tem
? EVAL_SKIP
: noside
));
2310 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2311 return value_from_longest (type
,
2312 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
2315 case BINOP_LOGICAL_OR
:
2316 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2317 if (noside
== EVAL_SKIP
)
2319 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2324 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2327 if (binop_user_defined_p (op
, arg1
, arg2
))
2329 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2330 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2334 tem
= value_logical_not (arg1
);
2335 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2336 (!tem
? EVAL_SKIP
: noside
));
2337 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2338 return value_from_longest (type
,
2339 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
2343 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2344 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2345 if (noside
== EVAL_SKIP
)
2347 if (binop_user_defined_p (op
, arg1
, arg2
))
2349 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2353 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2354 tem
= value_equal (arg1
, arg2
);
2355 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2356 return value_from_longest (type
, (LONGEST
) tem
);
2359 case BINOP_NOTEQUAL
:
2360 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2361 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2362 if (noside
== EVAL_SKIP
)
2364 if (binop_user_defined_p (op
, arg1
, arg2
))
2366 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2370 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2371 tem
= value_equal (arg1
, arg2
);
2372 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2373 return value_from_longest (type
, (LONGEST
) ! tem
);
2377 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2378 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2379 if (noside
== EVAL_SKIP
)
2381 if (binop_user_defined_p (op
, arg1
, arg2
))
2383 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2387 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2388 tem
= value_less (arg1
, arg2
);
2389 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2390 return value_from_longest (type
, (LONGEST
) tem
);
2394 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2395 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2396 if (noside
== EVAL_SKIP
)
2398 if (binop_user_defined_p (op
, arg1
, arg2
))
2400 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2404 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2405 tem
= value_less (arg2
, arg1
);
2406 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2407 return value_from_longest (type
, (LONGEST
) tem
);
2411 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2412 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2413 if (noside
== EVAL_SKIP
)
2415 if (binop_user_defined_p (op
, arg1
, arg2
))
2417 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2421 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2422 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
2423 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2424 return value_from_longest (type
, (LONGEST
) tem
);
2428 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2429 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
2430 if (noside
== EVAL_SKIP
)
2432 if (binop_user_defined_p (op
, arg1
, arg2
))
2434 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
2438 binop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
, &arg2
);
2439 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
2440 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2441 return value_from_longest (type
, (LONGEST
) tem
);
2445 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2446 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2447 if (noside
== EVAL_SKIP
)
2449 type
= check_typedef (value_type (arg2
));
2450 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
2451 error (_("Non-integral right operand for \"@\" operator."));
2452 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2454 return allocate_repeat_value (value_type (arg1
),
2455 longest_to_int (value_as_long (arg2
)));
2458 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
2461 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2462 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2465 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2466 if (noside
== EVAL_SKIP
)
2468 if (unop_user_defined_p (op
, arg1
))
2469 return value_x_unop (arg1
, op
, noside
);
2472 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2473 return value_pos (arg1
);
2477 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2478 if (noside
== EVAL_SKIP
)
2480 if (unop_user_defined_p (op
, arg1
))
2481 return value_x_unop (arg1
, op
, noside
);
2484 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2485 return value_neg (arg1
);
2488 case UNOP_COMPLEMENT
:
2489 /* C++: check for and handle destructor names. */
2490 op
= exp
->elts
[*pos
].opcode
;
2492 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2493 if (noside
== EVAL_SKIP
)
2495 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
2496 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
2499 unop_promote (exp
->language_defn
, exp
->gdbarch
, &arg1
);
2500 return value_complement (arg1
);
2503 case UNOP_LOGICAL_NOT
:
2504 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2505 if (noside
== EVAL_SKIP
)
2507 if (unop_user_defined_p (op
, arg1
))
2508 return value_x_unop (arg1
, op
, noside
);
2511 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
2512 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
2516 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
2517 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
2518 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2519 type
= check_typedef (value_type (arg1
));
2520 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
2521 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2522 error (_("Attempt to dereference pointer "
2523 "to member without an object"));
2524 if (noside
== EVAL_SKIP
)
2526 if (unop_user_defined_p (op
, arg1
))
2527 return value_x_unop (arg1
, op
, noside
);
2528 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2530 type
= check_typedef (value_type (arg1
));
2531 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2532 || TYPE_CODE (type
) == TYPE_CODE_REF
2533 /* In C you can dereference an array to get the 1st elt. */
2534 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2536 return value_zero (TYPE_TARGET_TYPE (type
),
2538 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2539 /* GDB allows dereferencing an int. */
2540 return value_zero (builtin_type (exp
->gdbarch
)->builtin_int
,
2543 error (_("Attempt to take contents of a non-pointer value."));
2546 /* Allow * on an integer so we can cast it to whatever we want.
2547 This returns an int, which seems like the most C-like thing to
2548 do. "long long" variables are rare enough that
2549 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2550 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2551 return value_at_lazy (builtin_type (exp
->gdbarch
)->builtin_int
,
2552 (CORE_ADDR
) value_as_address (arg1
));
2553 return value_ind (arg1
);
2556 /* C++: check for and handle pointer to members. */
2558 op
= exp
->elts
[*pos
].opcode
;
2560 if (noside
== EVAL_SKIP
)
2562 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2567 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
,
2574 if (noside
== EVAL_SKIP
)
2576 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2579 return evaluate_subexp_for_sizeof (exp
, pos
);
2583 type
= exp
->elts
[pc
+ 1].type
;
2584 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2585 if (noside
== EVAL_SKIP
)
2587 if (type
!= value_type (arg1
))
2588 arg1
= value_cast (type
, arg1
);
2591 case UNOP_CAST_TYPE
:
2592 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2593 type
= value_type (arg1
);
2594 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2595 if (noside
== EVAL_SKIP
)
2597 if (type
!= value_type (arg1
))
2598 arg1
= value_cast (type
, arg1
);
2601 case UNOP_DYNAMIC_CAST
:
2602 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2603 type
= value_type (arg1
);
2604 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2605 if (noside
== EVAL_SKIP
)
2607 return value_dynamic_cast (type
, arg1
);
2609 case UNOP_REINTERPRET_CAST
:
2610 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2611 type
= value_type (arg1
);
2612 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2613 if (noside
== EVAL_SKIP
)
2615 return value_reinterpret_cast (type
, arg1
);
2619 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2620 if (noside
== EVAL_SKIP
)
2622 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2623 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2625 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2626 value_as_address (arg1
));
2628 case UNOP_MEMVAL_TYPE
:
2629 arg1
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2630 type
= value_type (arg1
);
2631 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2632 if (noside
== EVAL_SKIP
)
2634 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2635 return value_zero (type
, lval_memory
);
2637 return value_at_lazy (type
, value_as_address (arg1
));
2639 case UNOP_MEMVAL_TLS
:
2641 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2642 if (noside
== EVAL_SKIP
)
2644 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2645 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2650 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2651 value_as_address (arg1
));
2652 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2655 case UNOP_PREINCREMENT
:
2656 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2657 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2659 else if (unop_user_defined_p (op
, arg1
))
2661 return value_x_unop (arg1
, op
, noside
);
2665 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2666 arg2
= value_ptradd (arg1
, 1);
2669 struct value
*tmp
= arg1
;
2671 arg2
= value_one (value_type (arg1
));
2672 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2673 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2676 return value_assign (arg1
, arg2
);
2679 case UNOP_PREDECREMENT
:
2680 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2681 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2683 else if (unop_user_defined_p (op
, arg1
))
2685 return value_x_unop (arg1
, op
, noside
);
2689 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2690 arg2
= value_ptradd (arg1
, -1);
2693 struct value
*tmp
= arg1
;
2695 arg2
= value_one (value_type (arg1
));
2696 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2697 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2700 return value_assign (arg1
, arg2
);
2703 case UNOP_POSTINCREMENT
:
2704 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2705 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2707 else if (unop_user_defined_p (op
, arg1
))
2709 return value_x_unop (arg1
, op
, noside
);
2713 arg3
= value_non_lval (arg1
);
2715 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2716 arg2
= value_ptradd (arg1
, 1);
2719 struct value
*tmp
= arg1
;
2721 arg2
= value_one (value_type (arg1
));
2722 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2723 arg2
= value_binop (tmp
, arg2
, BINOP_ADD
);
2726 value_assign (arg1
, arg2
);
2730 case UNOP_POSTDECREMENT
:
2731 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2732 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2734 else if (unop_user_defined_p (op
, arg1
))
2736 return value_x_unop (arg1
, op
, noside
);
2740 arg3
= value_non_lval (arg1
);
2742 if (ptrmath_type_p (exp
->language_defn
, value_type (arg1
)))
2743 arg2
= value_ptradd (arg1
, -1);
2746 struct value
*tmp
= arg1
;
2748 arg2
= value_one (value_type (arg1
));
2749 binop_promote (exp
->language_defn
, exp
->gdbarch
, &tmp
, &arg2
);
2750 arg2
= value_binop (tmp
, arg2
, BINOP_SUB
);
2753 value_assign (arg1
, arg2
);
2759 return value_of_this (exp
->language_defn
);
2762 /* The value is not supposed to be used. This is here to make it
2763 easier to accommodate expressions that contain types. */
2765 if (noside
== EVAL_SKIP
)
2767 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2769 struct type
*type
= exp
->elts
[pc
+ 1].type
;
2771 /* If this is a typedef, then find its immediate target. We
2772 use check_typedef to resolve stubs, but we ignore its
2773 result because we do not want to dig past all
2775 check_typedef (type
);
2776 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
2777 type
= TYPE_TARGET_TYPE (type
);
2778 return allocate_value (type
);
2781 error (_("Attempt to use a type name as an expression"));
2785 if (noside
== EVAL_SKIP
)
2787 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2790 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2792 enum exp_opcode sub_op
= exp
->elts
[*pos
].opcode
;
2793 struct value
*result
;
2795 result
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
2796 EVAL_AVOID_SIDE_EFFECTS
);
2798 /* 'decltype' has special semantics for lvalues. */
2799 if (op
== OP_DECLTYPE
2800 && (sub_op
== BINOP_SUBSCRIPT
2801 || sub_op
== STRUCTOP_MEMBER
2802 || sub_op
== STRUCTOP_MPTR
2803 || sub_op
== UNOP_IND
2804 || sub_op
== STRUCTOP_STRUCT
2805 || sub_op
== STRUCTOP_PTR
2806 || sub_op
== OP_SCOPE
))
2808 struct type
*type
= value_type (result
);
2810 if (TYPE_CODE (check_typedef (type
)) != TYPE_CODE_REF
)
2812 type
= lookup_reference_type (type
);
2813 result
= allocate_value (type
);
2820 error (_("Attempt to use a type as an expression"));
2823 /* Removing this case and compiling with gcc -Wall reveals that
2824 a lot of cases are hitting this case. Some of these should
2825 probably be removed from expression.h; others are legitimate
2826 expressions which are (apparently) not fully implemented.
2828 If there are any cases landing here which mean a user error,
2829 then they should be separate cases, with more descriptive
2832 error (_("GDB does not (yet) know how to "
2833 "evaluate that kind of expression"));
2837 return value_from_longest (builtin_type (exp
->gdbarch
)->builtin_int
, 1);
2840 /* Evaluate a subexpression of EXP, at index *POS,
2841 and return the address of that subexpression.
2842 Advance *POS over the subexpression.
2843 If the subexpression isn't an lvalue, get an error.
2844 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2845 then only the type of the result need be correct. */
2847 static struct value
*
2848 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2858 op
= exp
->elts
[pc
].opcode
;
2864 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2866 /* We can't optimize out "&*" if there's a user-defined operator*. */
2867 if (unop_user_defined_p (op
, x
))
2869 x
= value_x_unop (x
, op
, noside
);
2870 goto default_case_after_eval
;
2873 return coerce_array (x
);
2877 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2878 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2880 case UNOP_MEMVAL_TYPE
:
2885 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2886 type
= value_type (x
);
2887 return value_cast (lookup_pointer_type (type
),
2888 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2892 var
= exp
->elts
[pc
+ 2].symbol
;
2894 /* C++: The "address" of a reference should yield the address
2895 * of the object pointed to. Let value_addr() deal with it. */
2896 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2900 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2903 lookup_pointer_type (SYMBOL_TYPE (var
));
2904 enum address_class sym_class
= SYMBOL_CLASS (var
);
2906 if (sym_class
== LOC_CONST
2907 || sym_class
== LOC_CONST_BYTES
2908 || sym_class
== LOC_REGISTER
)
2909 error (_("Attempt to take address of register or constant."));
2912 value_zero (type
, not_lval
);
2915 return address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2918 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2919 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2920 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2921 &exp
->elts
[pc
+ 3].string
,
2924 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2929 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2930 default_case_after_eval
:
2931 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2933 struct type
*type
= check_typedef (value_type (x
));
2935 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2936 return value_zero (lookup_pointer_type (value_type (x
)),
2938 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2939 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2942 error (_("Attempt to take address of "
2943 "value not located in memory."));
2945 return value_addr (x
);
2949 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2950 When used in contexts where arrays will be coerced anyway, this is
2951 equivalent to `evaluate_subexp' but much faster because it avoids
2952 actually fetching array contents (perhaps obsolete now that we have
2955 Note that we currently only do the coercion for C expressions, where
2956 arrays are zero based and the coercion is correct. For other languages,
2957 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2958 to decide if coercion is appropriate. */
2961 evaluate_subexp_with_coercion (struct expression
*exp
,
2962 int *pos
, enum noside noside
)
2971 op
= exp
->elts
[pc
].opcode
;
2976 var
= exp
->elts
[pc
+ 2].symbol
;
2977 type
= check_typedef (SYMBOL_TYPE (var
));
2978 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
2979 && !TYPE_VECTOR (type
)
2980 && CAST_IS_CONVERSION (exp
->language_defn
))
2983 val
= address_of_variable (var
, exp
->elts
[pc
+ 1].block
);
2984 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2990 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2994 /* Evaluate a subexpression of EXP, at index *POS,
2995 and return a value for the size of that subexpression.
2996 Advance *POS over the subexpression. */
2998 static struct value
*
2999 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
= check_typedef (TYPE_TARGET_TYPE (type
));
3026 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3030 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
3031 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3033 case UNOP_MEMVAL_TYPE
:
3035 val
= evaluate_subexp (NULL
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3036 type
= check_typedef (value_type (val
));
3037 return value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3041 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
3043 value_from_longest (size_type
, (LONGEST
) TYPE_LENGTH (type
));
3046 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
3047 return value_from_longest (size_type
,
3048 (LONGEST
) TYPE_LENGTH (value_type (val
)));
3052 /* Parse a type expression in the string [P..P+LENGTH). */
3055 parse_and_eval_type (char *p
, int length
)
3057 char *tmp
= (char *) alloca (length
+ 4);
3058 struct expression
*expr
;
3061 memcpy (tmp
+ 1, p
, length
);
3062 tmp
[length
+ 1] = ')';
3063 tmp
[length
+ 2] = '0';
3064 tmp
[length
+ 3] = '\0';
3065 expr
= parse_expression (tmp
);
3066 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
3067 error (_("Internal error in eval_type."));
3068 return expr
->elts
[1].type
;
3072 calc_f77_array_dims (struct type
*array_type
)
3075 struct type
*tmp_type
;
3077 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
3078 error (_("Can't get dimensions for a non-array type"));
3080 tmp_type
= array_type
;
3082 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
3084 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)