1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
27 #include "expression.h"
30 #include "language.h" /* For CAST_IS_CONVERSION */
31 #include "f-lang.h" /* for array bound stuff */
34 #include "objc-lang.h"
36 #include "parser-defs.h"
37 #include "cp-support.h"
39 #include "exceptions.h"
42 #include "gdb_assert.h"
44 /* This is defined in valops.c */
45 extern int overload_resolution
;
47 /* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
48 on with successful lookup for member/method of the rtti type. */
49 extern int objectprint
;
51 /* Prototypes for local functions. */
53 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
55 static struct value
*evaluate_subexp_for_address (struct expression
*,
58 static struct value
*evaluate_subexp (struct type
*, struct expression
*,
61 static char *get_label (struct expression
*, int *);
63 static struct value
*evaluate_struct_tuple (struct value
*,
64 struct expression
*, int *,
67 static LONGEST
init_array_element (struct value
*, struct value
*,
68 struct expression
*, int *, enum noside
,
72 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
73 int *pos
, enum noside noside
)
75 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
76 (expect_type
, exp
, pos
, noside
);
79 /* Parse the string EXP as a C expression, evaluate it,
80 and return the result as a number. */
83 parse_and_eval_address (char *exp
)
85 struct expression
*expr
= parse_expression (exp
);
87 struct cleanup
*old_chain
=
88 make_cleanup (free_current_contents
, &expr
);
90 addr
= value_as_address (evaluate_expression (expr
));
91 do_cleanups (old_chain
);
95 /* Like parse_and_eval_address but takes a pointer to a char * variable
96 and advanced that variable across the characters parsed. */
99 parse_and_eval_address_1 (char **expptr
)
101 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*) 0, 0);
103 struct cleanup
*old_chain
=
104 make_cleanup (free_current_contents
, &expr
);
106 addr
= value_as_address (evaluate_expression (expr
));
107 do_cleanups (old_chain
);
111 /* Like parse_and_eval_address, but treats the value of the expression
112 as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
114 parse_and_eval_long (char *exp
)
116 struct expression
*expr
= parse_expression (exp
);
118 struct cleanup
*old_chain
=
119 make_cleanup (free_current_contents
, &expr
);
121 retval
= value_as_long (evaluate_expression (expr
));
122 do_cleanups (old_chain
);
127 parse_and_eval (char *exp
)
129 struct expression
*expr
= parse_expression (exp
);
131 struct cleanup
*old_chain
=
132 make_cleanup (free_current_contents
, &expr
);
134 val
= evaluate_expression (expr
);
135 do_cleanups (old_chain
);
139 /* Parse up to a comma (or to a closeparen)
140 in the string EXPP as an expression, evaluate it, and return the value.
141 EXPP is advanced to point to the comma. */
144 parse_to_comma_and_eval (char **expp
)
146 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
148 struct cleanup
*old_chain
=
149 make_cleanup (free_current_contents
, &expr
);
151 val
= evaluate_expression (expr
);
152 do_cleanups (old_chain
);
156 /* Evaluate an expression in internal prefix form
157 such as is constructed by parse.y.
159 See expression.h for info on the format of an expression. */
162 evaluate_expression (struct expression
*exp
)
165 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
168 /* Evaluate an expression, avoiding all memory references
169 and getting a value whose type alone is correct. */
172 evaluate_type (struct expression
*exp
)
175 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
178 /* If the next expression is an OP_LABELED, skips past it,
179 returning the label. Otherwise, does nothing and returns NULL. */
182 get_label (struct expression
*exp
, int *pos
)
184 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
187 char *name
= &exp
->elts
[pc
+ 2].string
;
188 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
189 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
196 /* This function evaluates tuples (in (the deleted) Chill) or
197 brace-initializers (in C/C++) for structure types. */
199 static struct value
*
200 evaluate_struct_tuple (struct value
*struct_val
,
201 struct expression
*exp
,
202 int *pos
, enum noside noside
, int nargs
)
204 struct type
*struct_type
= check_typedef (value_type (struct_val
));
205 struct type
*substruct_type
= struct_type
;
206 struct type
*field_type
;
213 struct value
*val
= NULL
;
218 /* Skip past the labels, and count them. */
219 while (get_label (exp
, pos
) != NULL
)
224 char *label
= get_label (exp
, &pc
);
227 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
230 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
231 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
234 subfieldno
= fieldno
;
235 substruct_type
= struct_type
;
239 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
242 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
243 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
244 if ((field_name
== 0 || *field_name
== '\0')
245 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
248 for (; variantno
< TYPE_NFIELDS (field_type
);
252 = TYPE_FIELD_TYPE (field_type
, variantno
);
253 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
256 subfieldno
< TYPE_NFIELDS (substruct_type
);
259 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
270 error (_("there is no field named %s"), label
);
276 /* Unlabelled tuple element - go to next field. */
280 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
283 substruct_type
= struct_type
;
289 /* Skip static fields. */
290 while (fieldno
< TYPE_NFIELDS (struct_type
)
291 && TYPE_FIELD_STATIC_KIND (struct_type
, fieldno
))
293 subfieldno
= fieldno
;
294 if (fieldno
>= TYPE_NFIELDS (struct_type
))
295 error (_("too many initializers"));
296 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
297 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
298 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
299 error (_("don't know which variant you want to set"));
303 /* Here, struct_type is the type of the inner struct,
304 while substruct_type is the type of the inner struct.
305 These are the same for normal structures, but a variant struct
306 contains anonymous union fields that contain substruct fields.
307 The value fieldno is the index of the top-level (normal or
308 anonymous union) field in struct_field, while the value
309 subfieldno is the index of the actual real (named inner) field
310 in substruct_type. */
312 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
314 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
316 /* Now actually set the field in struct_val. */
318 /* Assign val to field fieldno. */
319 if (value_type (val
) != field_type
)
320 val
= value_cast (field_type
, val
);
322 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
323 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
325 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
326 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
328 modify_field (addr
, value_as_long (val
),
329 bitpos
% 8, bitsize
);
331 memcpy (addr
, value_contents (val
),
332 TYPE_LENGTH (value_type (val
)));
334 while (--nlabels
> 0);
339 /* Recursive helper function for setting elements of array tuples for
340 (the deleted) Chill. The target is ARRAY (which has bounds
341 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
342 and NOSIDE are as usual. Evaluates index expresions and sets the
343 specified element(s) of ARRAY to ELEMENT. Returns last index
347 init_array_element (struct value
*array
, struct value
*element
,
348 struct expression
*exp
, int *pos
,
349 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
352 int element_size
= TYPE_LENGTH (value_type (element
));
353 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
356 init_array_element (array
, element
, exp
, pos
, noside
,
357 low_bound
, high_bound
);
358 return init_array_element (array
, element
,
359 exp
, pos
, noside
, low_bound
, high_bound
);
361 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
365 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
366 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
367 if (low
< low_bound
|| high
> high_bound
)
368 error (_("tuple range index out of range"));
369 for (index
= low
; index
<= high
; index
++)
371 memcpy (value_contents_raw (array
)
372 + (index
- low_bound
) * element_size
,
373 value_contents (element
), element_size
);
378 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
379 if (index
< low_bound
|| index
> high_bound
)
380 error (_("tuple index out of range"));
381 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
382 value_contents (element
), element_size
);
388 value_f90_subarray (struct value
*array
,
389 struct expression
*exp
, int *pos
, enum noside noside
)
392 LONGEST low_bound
, high_bound
;
393 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
394 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
398 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
399 low_bound
= TYPE_LOW_BOUND (range
);
401 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
403 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
404 high_bound
= TYPE_HIGH_BOUND (range
);
406 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
408 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
412 evaluate_subexp_standard (struct type
*expect_type
,
413 struct expression
*exp
, int *pos
,
418 int pc
, pc2
= 0, oldpos
;
419 struct value
*arg1
= NULL
;
420 struct value
*arg2
= NULL
;
424 struct value
**argvec
;
425 int upper
, lower
, retcode
;
429 struct type
**arg_types
;
433 op
= exp
->elts
[pc
].opcode
;
438 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
439 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
440 if (noside
== EVAL_SKIP
)
442 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
443 &exp
->elts
[pc
+ 3].string
,
446 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
451 return value_from_longest (exp
->elts
[pc
+ 1].type
,
452 exp
->elts
[pc
+ 2].longconst
);
456 return value_from_double (exp
->elts
[pc
+ 1].type
,
457 exp
->elts
[pc
+ 2].doubleconst
);
461 if (noside
== EVAL_SKIP
)
464 /* JYG: We used to just return value_zero of the symbol type
465 if we're asked to avoid side effects. Otherwise we return
466 value_of_variable (...). However I'm not sure if
467 value_of_variable () has any side effect.
468 We need a full value object returned here for whatis_exp ()
469 to call evaluate_type () and then pass the full value to
470 value_rtti_target_type () if we are dealing with a pointer
471 or reference to a base class and print object is on. */
474 volatile struct gdb_exception except
;
475 struct value
*ret
= NULL
;
477 TRY_CATCH (except
, RETURN_MASK_ERROR
)
479 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
480 exp
->elts
[pc
+ 1].block
);
483 if (except
.reason
< 0)
485 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
486 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
), not_lval
);
488 throw_exception (except
);
497 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
501 const char *name
= &exp
->elts
[pc
+ 2].string
;
505 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
506 regno
= frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
507 name
, strlen (name
));
509 error (_("Register $%s not available."), name
);
510 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
511 val
= value_zero (register_type (current_gdbarch
, regno
), not_lval
);
513 val
= value_of_register (regno
, get_selected_frame (NULL
));
515 error (_("Value of register %s not available."), name
);
521 return value_from_longest (LA_BOOL_TYPE
,
522 exp
->elts
[pc
+ 1].longconst
);
526 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
529 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
530 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
531 if (noside
== EVAL_SKIP
)
533 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
535 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
536 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
537 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
538 if (noside
== EVAL_SKIP
)
542 return (struct value
*) value_nsstring (&exp
->elts
[pc
+ 2].string
, tem
+ 1);
545 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
547 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
548 if (noside
== EVAL_SKIP
)
550 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
555 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
556 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
557 nargs
= tem3
- tem2
+ 1;
558 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
560 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
561 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
563 struct value
*rec
= allocate_value (expect_type
);
564 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
565 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
568 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
569 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
571 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
572 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
573 struct value
*array
= allocate_value (expect_type
);
574 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
575 LONGEST low_bound
, high_bound
, index
;
576 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
579 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
582 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
583 for (tem
= nargs
; --nargs
>= 0;)
585 struct value
*element
;
587 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
590 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
592 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
593 if (value_type (element
) != element_type
)
594 element
= value_cast (element_type
, element
);
597 int continue_pc
= *pos
;
599 index
= init_array_element (array
, element
, exp
, pos
, noside
,
600 low_bound
, high_bound
);
605 if (index
> high_bound
)
606 /* to avoid memory corruption */
607 error (_("Too many array elements"));
608 memcpy (value_contents_raw (array
)
609 + (index
- low_bound
) * element_size
,
610 value_contents (element
),
618 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
619 && TYPE_CODE (type
) == TYPE_CODE_SET
)
621 struct value
*set
= allocate_value (expect_type
);
622 gdb_byte
*valaddr
= value_contents_raw (set
);
623 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
624 struct type
*check_type
= element_type
;
625 LONGEST low_bound
, high_bound
;
627 /* get targettype of elementtype */
628 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
629 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
630 check_type
= TYPE_TARGET_TYPE (check_type
);
632 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
633 error (_("(power)set type with unknown size"));
634 memset (valaddr
, '\0', TYPE_LENGTH (type
));
635 for (tem
= 0; tem
< nargs
; tem
++)
637 LONGEST range_low
, range_high
;
638 struct type
*range_low_type
, *range_high_type
;
639 struct value
*elem_val
;
640 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
643 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
644 range_low_type
= value_type (elem_val
);
645 range_low
= value_as_long (elem_val
);
646 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
647 range_high_type
= value_type (elem_val
);
648 range_high
= value_as_long (elem_val
);
652 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
653 range_low_type
= range_high_type
= value_type (elem_val
);
654 range_low
= range_high
= value_as_long (elem_val
);
656 /* check types of elements to avoid mixture of elements from
657 different types. Also check if type of element is "compatible"
658 with element type of powerset */
659 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
660 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
661 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
662 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
663 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
664 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
665 (range_low_type
!= range_high_type
)))
666 /* different element modes */
667 error (_("POWERSET tuple elements of different mode"));
668 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
669 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
670 range_low_type
!= check_type
))
671 error (_("incompatible POWERSET tuple elements"));
672 if (range_low
> range_high
)
674 warning (_("empty POWERSET tuple range"));
677 if (range_low
< low_bound
|| range_high
> high_bound
)
678 error (_("POWERSET tuple element out of range"));
679 range_low
-= low_bound
;
680 range_high
-= low_bound
;
681 for (; range_low
<= range_high
; range_low
++)
683 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
685 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
686 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
693 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
694 for (tem
= 0; tem
< nargs
; tem
++)
696 /* Ensure that array expressions are coerced into pointer objects. */
697 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
699 if (noside
== EVAL_SKIP
)
701 return value_array (tem2
, tem3
, argvec
);
705 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
707 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
709 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
710 if (noside
== EVAL_SKIP
)
712 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
715 case TERNOP_SLICE_COUNT
:
717 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
719 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
721 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
722 return value_slice (array
, lowbound
, length
);
726 /* Skip third and second args to evaluate the first one. */
727 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
728 if (value_logical_not (arg1
))
730 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
731 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
735 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
736 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
740 case OP_OBJC_SELECTOR
:
741 { /* Objective C @selector operator. */
742 char *sel
= &exp
->elts
[pc
+ 2].string
;
743 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
745 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
746 if (noside
== EVAL_SKIP
)
750 sel
[len
] = 0; /* Make sure it's terminated. */
751 return value_from_longest (lookup_pointer_type (builtin_type_void
),
752 lookup_child_selector (sel
));
755 case OP_OBJC_MSGCALL
:
756 { /* Objective C message (method) call. */
758 static CORE_ADDR responds_selector
= 0;
759 static CORE_ADDR method_selector
= 0;
761 CORE_ADDR selector
= 0;
763 int struct_return
= 0;
766 static struct value
*msg_send
= NULL
;
767 static struct value
*msg_send_stret
= NULL
;
768 static int gnu_runtime
= 0;
770 struct value
*target
= NULL
;
771 struct value
*method
= NULL
;
772 struct value
*called_method
= NULL
;
774 struct type
*selector_type
= NULL
;
776 struct value
*ret
= NULL
;
779 selector
= exp
->elts
[pc
+ 1].longconst
;
780 nargs
= exp
->elts
[pc
+ 2].longconst
;
781 argvec
= (struct value
**) alloca (sizeof (struct value
*)
786 selector_type
= lookup_pointer_type (builtin_type_void
);
787 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
788 sub_no_side
= EVAL_NORMAL
;
790 sub_no_side
= noside
;
792 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
794 if (value_as_long (target
) == 0)
795 return value_from_longest (builtin_type_long
, 0);
797 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
800 /* Find the method dispatch (Apple runtime) or method lookup
801 (GNU runtime) function for Objective-C. These will be used
802 to lookup the symbol information for the method. If we
803 can't find any symbol information, then we'll use these to
804 call the method, otherwise we can call the method
805 directly. The msg_send_stret function is used in the special
806 case of a method that returns a structure (Apple runtime
811 type
= lookup_pointer_type (builtin_type_void
);
812 type
= lookup_function_type (type
);
813 type
= lookup_pointer_type (type
);
814 type
= lookup_function_type (type
);
815 type
= lookup_pointer_type (type
);
817 msg_send
= find_function_in_inferior ("objc_msg_lookup");
818 msg_send_stret
= find_function_in_inferior ("objc_msg_lookup");
820 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
821 msg_send_stret
= value_from_pointer (type
,
822 value_as_address (msg_send_stret
));
826 msg_send
= find_function_in_inferior ("objc_msgSend");
827 /* Special dispatcher for methods returning structs */
828 msg_send_stret
= find_function_in_inferior ("objc_msgSend_stret");
831 /* Verify the target object responds to this method. The
832 standard top-level 'Object' class uses a different name for
833 the verification method than the non-standard, but more
834 often used, 'NSObject' class. Make sure we check for both. */
836 responds_selector
= lookup_child_selector ("respondsToSelector:");
837 if (responds_selector
== 0)
838 responds_selector
= lookup_child_selector ("respondsTo:");
840 if (responds_selector
== 0)
841 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
843 method_selector
= lookup_child_selector ("methodForSelector:");
844 if (method_selector
== 0)
845 method_selector
= lookup_child_selector ("methodFor:");
847 if (method_selector
== 0)
848 error (_("no 'methodFor:' or 'methodForSelector:' method"));
850 /* Call the verification method, to make sure that the target
851 class implements the desired method. */
853 argvec
[0] = msg_send
;
855 argvec
[2] = value_from_longest (builtin_type_long
, responds_selector
);
856 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
859 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
862 /* Function objc_msg_lookup returns a pointer. */
864 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
866 if (value_as_long (ret
) == 0)
867 error (_("Target does not respond to this message selector."));
869 /* Call "methodForSelector:" method, to get the address of a
870 function method that implements this selector for this
871 class. If we can find a symbol at that address, then we
872 know the return type, parameter types etc. (that's a good
875 argvec
[0] = msg_send
;
877 argvec
[2] = value_from_longest (builtin_type_long
, method_selector
);
878 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
881 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
885 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
888 /* ret should now be the selector. */
890 addr
= value_as_long (ret
);
893 struct symbol
*sym
= NULL
;
894 /* Is it a high_level symbol? */
896 sym
= find_pc_function (addr
);
898 method
= value_of_variable (sym
, 0);
901 /* If we found a method with symbol information, check to see
902 if it returns a struct. Otherwise assume it doesn't. */
908 struct type
*value_type
;
910 funaddr
= find_function_addr (method
, &value_type
);
912 b
= block_for_pc (funaddr
);
914 CHECK_TYPEDEF (value_type
);
916 if ((value_type
== NULL
)
917 || (TYPE_CODE(value_type
) == TYPE_CODE_ERROR
))
919 if (expect_type
!= NULL
)
920 value_type
= expect_type
;
923 struct_return
= using_struct_return (value_type
);
925 else if (expect_type
!= NULL
)
927 struct_return
= using_struct_return (check_typedef (expect_type
));
930 /* Found a function symbol. Now we will substitute its
931 value in place of the message dispatcher (obj_msgSend),
932 so that we call the method directly instead of thru
933 the dispatcher. The main reason for doing this is that
934 we can now evaluate the return value and parameter values
935 according to their known data types, in case we need to
936 do things like promotion, dereferencing, special handling
937 of structs and doubles, etc.
939 We want to use the type signature of 'method', but still
940 jump to objc_msgSend() or objc_msgSend_stret() to better
941 mimic the behavior of the runtime. */
945 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
946 error (_("method address has symbol information with non-function type; skipping"));
948 VALUE_ADDRESS (method
) = value_as_address (msg_send_stret
);
950 VALUE_ADDRESS (method
) = value_as_address (msg_send
);
951 called_method
= method
;
956 called_method
= msg_send_stret
;
958 called_method
= msg_send
;
961 if (noside
== EVAL_SKIP
)
964 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
966 /* If the return type doesn't look like a function type,
967 call an error. This can happen if somebody tries to
968 turn a variable into a function call. This is here
969 because people often want to call, eg, strcmp, which
970 gdb doesn't know is a function. If gdb isn't asked for
971 it's opinion (ie. through "whatis"), it won't offer
974 struct type
*type
= value_type (called_method
);
975 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
976 type
= TYPE_TARGET_TYPE (type
);
977 type
= TYPE_TARGET_TYPE (type
);
981 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
982 return allocate_value (expect_type
);
984 return allocate_value (type
);
987 error (_("Expression of type other than \"method returning ...\" used as a method"));
990 /* Now depending on whether we found a symbol for the method,
991 we will either call the runtime dispatcher or the method
994 argvec
[0] = called_method
;
996 argvec
[2] = value_from_longest (builtin_type_long
, selector
);
997 /* User-supplied arguments. */
998 for (tem
= 0; tem
< nargs
; tem
++)
999 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1000 argvec
[tem
+ 3] = 0;
1002 if (gnu_runtime
&& (method
!= NULL
))
1004 /* Function objc_msg_lookup returns a pointer. */
1005 deprecated_set_value_type (argvec
[0],
1006 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1007 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1010 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1017 op
= exp
->elts
[*pos
].opcode
;
1018 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1019 /* Allocate arg vector, including space for the function to be
1020 called in argvec[0] and a terminating NULL */
1021 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1022 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1025 /* First, evaluate the structure into arg2 */
1028 if (noside
== EVAL_SKIP
)
1031 if (op
== STRUCTOP_MEMBER
)
1033 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1037 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1040 /* If the function is a virtual function, then the
1041 aggregate value (providing the structure) plays
1042 its part by providing the vtable. Otherwise,
1043 it is just along for the ride: call the function
1046 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1048 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1049 != TYPE_CODE_METHODPTR
)
1050 error (_("Non-pointer-to-member value used in pointer-to-member "
1053 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1055 struct type
*method_type
= check_typedef (value_type (arg1
));
1056 arg1
= value_zero (method_type
, not_lval
);
1059 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1061 /* Now, say which argument to start evaluating from */
1064 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1066 /* Hair for method invocations */
1070 /* First, evaluate the structure into arg2 */
1072 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1073 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1074 if (noside
== EVAL_SKIP
)
1077 if (op
== STRUCTOP_STRUCT
)
1079 /* If v is a variable in a register, and the user types
1080 v.method (), this will produce an error, because v has
1083 A possible way around this would be to allocate a
1084 copy of the variable on the stack, copy in the
1085 contents, call the function, and copy out the
1086 contents. I.e. convert this from call by reference
1087 to call by copy-return (or whatever it's called).
1088 However, this does not work because it is not the
1089 same: the method being called could stash a copy of
1090 the address, and then future uses through that address
1091 (after the method returns) would be expected to
1092 use the variable itself, not some copy of it. */
1093 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1097 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1099 /* Now, say which argument to start evaluating from */
1104 /* Non-method function call */
1106 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1108 type
= value_type (argvec
[0]);
1109 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1110 type
= TYPE_TARGET_TYPE (type
);
1111 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1113 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1115 /* pai: FIXME This seems to be coercing arguments before
1116 * overload resolution has been done! */
1117 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1123 /* Evaluate arguments */
1124 for (; tem
<= nargs
; tem
++)
1126 /* Ensure that array expressions are coerced into pointer objects. */
1127 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1130 /* signal end of arglist */
1133 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1135 int static_memfuncp
;
1138 /* Method invocation : stuff "this" as first parameter */
1140 /* Name of method from expression */
1141 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1143 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1145 /* Language is C++, do some overload resolution before evaluation */
1146 struct value
*valp
= NULL
;
1148 /* Prepare list of argument types for overload resolution */
1149 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1150 for (ix
= 1; ix
<= nargs
; ix
++)
1151 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1153 (void) find_overload_match (arg_types
, nargs
, tstr
,
1154 1 /* method */ , 0 /* strict match */ ,
1155 &arg2
/* the object */ , NULL
,
1156 &valp
, NULL
, &static_memfuncp
);
1159 argvec
[1] = arg2
; /* the ``this'' pointer */
1160 argvec
[0] = valp
; /* use the method found after overload resolution */
1163 /* Non-C++ case -- or no overload resolution */
1165 struct value
*temp
= arg2
;
1166 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1168 op
== STRUCTOP_STRUCT
1169 ? "structure" : "structure pointer");
1170 /* value_struct_elt updates temp with the correct value
1171 of the ``this'' pointer if necessary, so modify argvec[1] to
1172 reflect any ``this'' changes. */
1173 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1174 VALUE_ADDRESS (temp
) + value_offset (temp
)
1175 + value_embedded_offset (temp
));
1176 argvec
[1] = arg2
; /* the ``this'' pointer */
1179 if (static_memfuncp
)
1181 argvec
[1] = argvec
[0];
1186 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1191 else if (op
== OP_VAR_VALUE
)
1193 /* Non-member function being called */
1194 /* fn: This can only be done for C++ functions. A C-style function
1195 in a C++ program, for instance, does not have the fields that
1196 are expected here */
1198 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1200 /* Language is C++, do some overload resolution before evaluation */
1201 struct symbol
*symp
;
1203 /* Prepare list of argument types for overload resolution */
1204 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1205 for (ix
= 1; ix
<= nargs
; ix
++)
1206 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1208 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1209 0 /* not method */ , 0 /* strict match */ ,
1210 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1213 /* Now fix the expression being evaluated */
1214 exp
->elts
[save_pos1
+2].symbol
= symp
;
1215 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1219 /* Not C++, or no overload resolution allowed */
1220 /* nothing to be done; argvec already correctly set up */
1225 /* It is probably a C-style function */
1226 /* nothing to be done; argvec already correctly set up */
1231 if (noside
== EVAL_SKIP
)
1233 if (argvec
[0] == NULL
)
1234 error (_("Cannot evaluate function -- may be inlined"));
1235 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1237 /* If the return type doesn't look like a function type, call an
1238 error. This can happen if somebody tries to turn a variable into
1239 a function call. This is here because people often want to
1240 call, eg, strcmp, which gdb doesn't know is a function. If
1241 gdb isn't asked for it's opinion (ie. through "whatis"),
1242 it won't offer it. */
1244 struct type
*ftype
=
1245 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1248 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1250 error (_("Expression of type other than \"Function returning ...\" used as function"));
1252 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1253 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1255 case OP_F77_UNDETERMINED_ARGLIST
:
1257 /* Remember that in F77, functions, substring ops and
1258 array subscript operations cannot be disambiguated
1259 at parse time. We have made all array subscript operations,
1260 substring operations as well as function calls come here
1261 and we now have to discover what the heck this thing actually was.
1262 If it is a function, we process just as if we got an OP_FUNCALL. */
1264 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1267 /* First determine the type code we are dealing with. */
1268 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1269 type
= check_typedef (value_type (arg1
));
1270 code
= TYPE_CODE (type
);
1272 if (code
== TYPE_CODE_PTR
)
1274 /* Fortran always passes variable to subroutines as pointer.
1275 So we need to look into its target type to see if it is
1276 array, string or function. If it is, we need to switch
1277 to the target value the original one points to. */
1278 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1280 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1281 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1282 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1284 arg1
= value_ind (arg1
);
1285 type
= check_typedef (value_type (arg1
));
1286 code
= TYPE_CODE (type
);
1292 case TYPE_CODE_ARRAY
:
1293 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1294 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1296 goto multi_f77_subscript
;
1298 case TYPE_CODE_STRING
:
1299 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1300 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1303 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1304 return value_subscript (arg1
, arg2
);
1308 case TYPE_CODE_FUNC
:
1309 /* It's a function call. */
1310 /* Allocate arg vector, including space for the function to be
1311 called in argvec[0] and a terminating NULL */
1312 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1315 for (; tem
<= nargs
; tem
++)
1316 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1317 argvec
[tem
] = 0; /* signal end of arglist */
1321 error (_("Cannot perform substring on this type"));
1325 /* We have a complex number, There should be 2 floating
1326 point numbers that compose it */
1327 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1328 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1330 return value_literal_complex (arg1
, arg2
, builtin_type_f_complex_s16
);
1332 case STRUCTOP_STRUCT
:
1333 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1334 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1335 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1336 if (noside
== EVAL_SKIP
)
1338 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1339 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1340 &exp
->elts
[pc
+ 2].string
,
1345 struct value
*temp
= arg1
;
1346 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1351 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1352 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1353 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1354 if (noside
== EVAL_SKIP
)
1357 /* JYG: if print object is on we need to replace the base type
1358 with rtti type in order to continue on with successful
1359 lookup of member / method only available in the rtti type. */
1361 struct type
*type
= value_type (arg1
);
1362 struct type
*real_type
;
1363 int full
, top
, using_enc
;
1365 if (objectprint
&& TYPE_TARGET_TYPE(type
) &&
1366 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1368 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1371 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1372 real_type
= lookup_pointer_type (real_type
);
1374 real_type
= lookup_reference_type (real_type
);
1376 arg1
= value_cast (real_type
, arg1
);
1381 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1382 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1383 &exp
->elts
[pc
+ 2].string
,
1388 struct value
*temp
= arg1
;
1389 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1390 NULL
, "structure pointer");
1393 case STRUCTOP_MEMBER
:
1395 if (op
== STRUCTOP_MEMBER
)
1396 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1398 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1400 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1402 if (noside
== EVAL_SKIP
)
1405 type
= check_typedef (value_type (arg2
));
1406 switch (TYPE_CODE (type
))
1408 case TYPE_CODE_METHODPTR
:
1409 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1410 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1413 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1414 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1415 return value_ind (arg2
);
1418 case TYPE_CODE_MEMBERPTR
:
1419 /* Now, convert these values to an address. */
1420 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1423 mem_offset
= value_as_long (arg2
);
1425 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1426 value_as_long (arg1
) + mem_offset
);
1427 return value_ind (arg3
);
1430 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1434 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1435 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1436 if (noside
== EVAL_SKIP
)
1438 if (binop_user_defined_p (op
, arg1
, arg2
))
1439 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1441 return value_concat (arg1
, arg2
);
1444 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1445 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1447 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1449 if (binop_user_defined_p (op
, arg1
, arg2
))
1450 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1452 return value_assign (arg1
, arg2
);
1454 case BINOP_ASSIGN_MODIFY
:
1456 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1457 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1458 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1460 op
= exp
->elts
[pc
+ 1].opcode
;
1461 if (binop_user_defined_p (op
, arg1
, arg2
))
1462 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1463 else if (op
== BINOP_ADD
)
1464 arg2
= value_add (arg1
, arg2
);
1465 else if (op
== BINOP_SUB
)
1466 arg2
= value_sub (arg1
, arg2
);
1468 arg2
= value_binop (arg1
, arg2
, op
);
1469 return value_assign (arg1
, arg2
);
1472 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1473 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1474 if (noside
== EVAL_SKIP
)
1476 if (binop_user_defined_p (op
, arg1
, arg2
))
1477 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1479 return value_add (arg1
, arg2
);
1482 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1483 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1484 if (noside
== EVAL_SKIP
)
1486 if (binop_user_defined_p (op
, arg1
, arg2
))
1487 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1489 return value_sub (arg1
, arg2
);
1498 case BINOP_BITWISE_AND
:
1499 case BINOP_BITWISE_IOR
:
1500 case BINOP_BITWISE_XOR
:
1501 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1502 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1503 if (noside
== EVAL_SKIP
)
1505 if (binop_user_defined_p (op
, arg1
, arg2
))
1506 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1507 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
1508 && (op
== BINOP_DIV
|| op
== BINOP_REM
|| op
== BINOP_MOD
))
1509 return value_zero (value_type (arg1
), not_lval
);
1511 return value_binop (arg1
, arg2
, op
);
1514 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1515 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1516 if (noside
== EVAL_SKIP
)
1518 error (_("':' operator used in invalid context"));
1520 case BINOP_SUBSCRIPT
:
1521 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1522 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1523 if (noside
== EVAL_SKIP
)
1525 if (binop_user_defined_p (op
, arg1
, arg2
))
1526 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1529 /* If the user attempts to subscript something that is not an
1530 array or pointer type (like a plain int variable for example),
1531 then report this as an error. */
1533 arg1
= coerce_ref (arg1
);
1534 type
= check_typedef (value_type (arg1
));
1535 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1536 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1538 if (TYPE_NAME (type
))
1539 error (_("cannot subscript something of type `%s'"),
1542 error (_("cannot subscript requested type"));
1545 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1546 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1548 return value_subscript (arg1
, arg2
);
1552 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1553 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1554 if (noside
== EVAL_SKIP
)
1556 return value_in (arg1
, arg2
);
1558 case MULTI_SUBSCRIPT
:
1560 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1561 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1564 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1565 /* FIXME: EVAL_SKIP handling may not be correct. */
1566 if (noside
== EVAL_SKIP
)
1577 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1578 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1580 /* If the user attempts to subscript something that has no target
1581 type (like a plain int variable for example), then report this
1584 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1587 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1593 error (_("cannot subscript something of type `%s'"),
1594 TYPE_NAME (value_type (arg1
)));
1598 if (binop_user_defined_p (op
, arg1
, arg2
))
1600 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1604 arg1
= value_subscript (arg1
, arg2
);
1609 multi_f77_subscript
:
1611 int subscript_array
[MAX_FORTRAN_DIMS
];
1612 int array_size_array
[MAX_FORTRAN_DIMS
];
1613 int ndimensions
= 1, i
;
1614 struct type
*tmp_type
;
1615 int offset_item
; /* The array offset where the item lives */
1617 if (nargs
> MAX_FORTRAN_DIMS
)
1618 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1620 tmp_type
= check_typedef (value_type (arg1
));
1621 ndimensions
= calc_f77_array_dims (type
);
1623 if (nargs
!= ndimensions
)
1624 error (_("Wrong number of subscripts"));
1626 /* Now that we know we have a legal array subscript expression
1627 let us actually find out where this element exists in the array. */
1630 /* Take array indices left to right */
1631 for (i
= 0; i
< nargs
; i
++)
1633 /* Evaluate each subscript, It must be a legal integer in F77 */
1634 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1636 /* Fill in the subscript and array size arrays */
1638 subscript_array
[i
] = value_as_long (arg2
);
1641 /* Internal type of array is arranged right to left */
1642 for (i
= 0; i
< nargs
; i
++)
1644 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1645 if (retcode
== BOUND_FETCH_ERROR
)
1646 error (_("Cannot obtain dynamic upper bound"));
1648 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1649 if (retcode
== BOUND_FETCH_ERROR
)
1650 error (_("Cannot obtain dynamic lower bound"));
1652 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
1654 /* Zero-normalize subscripts so that offsetting will work. */
1656 subscript_array
[nargs
- i
- 1] -= lower
;
1658 /* If we are at the bottom of a multidimensional
1659 array type then keep a ptr to the last ARRAY
1660 type around for use when calling value_subscript()
1661 below. This is done because we pretend to value_subscript
1662 that we actually have a one-dimensional array
1663 of base element type that we apply a simple
1667 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1670 /* Now let us calculate the offset for this item */
1672 offset_item
= subscript_array
[ndimensions
- 1];
1674 for (i
= ndimensions
- 1; i
> 0; --i
)
1676 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
1678 /* Construct a value node with the value of the offset */
1680 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
);
1682 /* Let us now play a dirty trick: we will take arg1
1683 which is a value node pointing to the topmost level
1684 of the multidimensional array-set and pretend
1685 that it is actually a array of the final element
1686 type, this will ensure that value_subscript()
1687 returns the correct type value */
1689 deprecated_set_value_type (arg1
, tmp_type
);
1690 return value_ind (value_add (value_coerce_array (arg1
), arg2
));
1693 case BINOP_LOGICAL_AND
:
1694 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1695 if (noside
== EVAL_SKIP
)
1697 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1702 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1705 if (binop_user_defined_p (op
, arg1
, arg2
))
1707 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1708 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1712 tem
= value_logical_not (arg1
);
1713 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1714 (tem
? EVAL_SKIP
: noside
));
1715 return value_from_longest (LA_BOOL_TYPE
,
1716 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
1719 case BINOP_LOGICAL_OR
:
1720 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1721 if (noside
== EVAL_SKIP
)
1723 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1728 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1731 if (binop_user_defined_p (op
, arg1
, arg2
))
1733 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1734 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1738 tem
= value_logical_not (arg1
);
1739 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1740 (!tem
? EVAL_SKIP
: noside
));
1741 return value_from_longest (LA_BOOL_TYPE
,
1742 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
1746 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1747 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1748 if (noside
== EVAL_SKIP
)
1750 if (binop_user_defined_p (op
, arg1
, arg2
))
1752 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1756 tem
= value_equal (arg1
, arg2
);
1757 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1760 case BINOP_NOTEQUAL
:
1761 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1762 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1763 if (noside
== EVAL_SKIP
)
1765 if (binop_user_defined_p (op
, arg1
, arg2
))
1767 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1771 tem
= value_equal (arg1
, arg2
);
1772 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) ! tem
);
1776 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1777 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1778 if (noside
== EVAL_SKIP
)
1780 if (binop_user_defined_p (op
, arg1
, arg2
))
1782 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1786 tem
= value_less (arg1
, arg2
);
1787 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1791 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1792 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1793 if (noside
== EVAL_SKIP
)
1795 if (binop_user_defined_p (op
, arg1
, arg2
))
1797 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1801 tem
= value_less (arg2
, arg1
);
1802 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1806 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1807 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1808 if (noside
== EVAL_SKIP
)
1810 if (binop_user_defined_p (op
, arg1
, arg2
))
1812 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1816 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1817 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1821 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1822 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1823 if (noside
== EVAL_SKIP
)
1825 if (binop_user_defined_p (op
, arg1
, arg2
))
1827 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1831 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1832 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1836 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1837 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1838 if (noside
== EVAL_SKIP
)
1840 type
= check_typedef (value_type (arg2
));
1841 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
1842 error (_("Non-integral right operand for \"@\" operator."));
1843 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1845 return allocate_repeat_value (value_type (arg1
),
1846 longest_to_int (value_as_long (arg2
)));
1849 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1852 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1853 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1856 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1857 if (noside
== EVAL_SKIP
)
1859 if (unop_user_defined_p (op
, arg1
))
1860 return value_x_unop (arg1
, op
, noside
);
1862 return value_pos (arg1
);
1865 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1866 if (noside
== EVAL_SKIP
)
1868 if (unop_user_defined_p (op
, arg1
))
1869 return value_x_unop (arg1
, op
, noside
);
1871 return value_neg (arg1
);
1873 case UNOP_COMPLEMENT
:
1874 /* C++: check for and handle destructor names. */
1875 op
= exp
->elts
[*pos
].opcode
;
1877 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1878 if (noside
== EVAL_SKIP
)
1880 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1881 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1883 return value_complement (arg1
);
1885 case UNOP_LOGICAL_NOT
:
1886 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1887 if (noside
== EVAL_SKIP
)
1889 if (unop_user_defined_p (op
, arg1
))
1890 return value_x_unop (arg1
, op
, noside
);
1892 return value_from_longest (LA_BOOL_TYPE
,
1893 (LONGEST
) value_logical_not (arg1
));
1896 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
1897 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
1898 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1899 type
= check_typedef (value_type (arg1
));
1900 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
1901 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1902 error (_("Attempt to dereference pointer to member without an object"));
1903 if (noside
== EVAL_SKIP
)
1905 if (unop_user_defined_p (op
, arg1
))
1906 return value_x_unop (arg1
, op
, noside
);
1907 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1909 type
= check_typedef (value_type (arg1
));
1910 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1911 || TYPE_CODE (type
) == TYPE_CODE_REF
1912 /* In C you can dereference an array to get the 1st elt. */
1913 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1915 return value_zero (TYPE_TARGET_TYPE (type
),
1917 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1918 /* GDB allows dereferencing an int. */
1919 return value_zero (builtin_type_int
, lval_memory
);
1921 error (_("Attempt to take contents of a non-pointer value."));
1923 return value_ind (arg1
);
1926 /* C++: check for and handle pointer to members. */
1928 op
= exp
->elts
[*pos
].opcode
;
1930 if (noside
== EVAL_SKIP
)
1932 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1937 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
1942 if (noside
== EVAL_SKIP
)
1944 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1947 return evaluate_subexp_for_sizeof (exp
, pos
);
1951 type
= exp
->elts
[pc
+ 1].type
;
1952 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
1953 if (noside
== EVAL_SKIP
)
1955 if (type
!= value_type (arg1
))
1956 arg1
= value_cast (type
, arg1
);
1961 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1962 if (noside
== EVAL_SKIP
)
1964 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1965 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
1967 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
1968 value_as_address (arg1
));
1970 case UNOP_MEMVAL_TLS
:
1972 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1973 if (noside
== EVAL_SKIP
)
1975 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1976 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
1980 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
1981 value_as_address (arg1
));
1982 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
1985 case UNOP_PREINCREMENT
:
1986 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1987 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1989 else if (unop_user_defined_p (op
, arg1
))
1991 return value_x_unop (arg1
, op
, noside
);
1995 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
1997 return value_assign (arg1
, arg2
);
2000 case UNOP_PREDECREMENT
:
2001 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2002 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2004 else if (unop_user_defined_p (op
, arg1
))
2006 return value_x_unop (arg1
, op
, noside
);
2010 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2012 return value_assign (arg1
, arg2
);
2015 case UNOP_POSTINCREMENT
:
2016 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2017 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2019 else if (unop_user_defined_p (op
, arg1
))
2021 return value_x_unop (arg1
, op
, noside
);
2025 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
2027 value_assign (arg1
, arg2
);
2031 case UNOP_POSTDECREMENT
:
2032 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2033 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2035 else if (unop_user_defined_p (op
, arg1
))
2037 return value_x_unop (arg1
, op
, noside
);
2041 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2043 value_assign (arg1
, arg2
);
2049 return value_of_this (1);
2053 return value_of_local ("self", 1);
2056 /* The value is not supposed to be used. This is here to make it
2057 easier to accommodate expressions that contain types. */
2059 if (noside
== EVAL_SKIP
)
2061 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2062 return allocate_value (exp
->elts
[pc
+ 1].type
);
2064 error (_("Attempt to use a type name as an expression"));
2067 /* Removing this case and compiling with gcc -Wall reveals that
2068 a lot of cases are hitting this case. Some of these should
2069 probably be removed from expression.h; others are legitimate
2070 expressions which are (apparently) not fully implemented.
2072 If there are any cases landing here which mean a user error,
2073 then they should be separate cases, with more descriptive
2077 GDB does not (yet) know how to evaluate that kind of expression"));
2081 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
2084 /* Evaluate a subexpression of EXP, at index *POS,
2085 and return the address of that subexpression.
2086 Advance *POS over the subexpression.
2087 If the subexpression isn't an lvalue, get an error.
2088 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2089 then only the type of the result need be correct. */
2091 static struct value
*
2092 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2102 op
= exp
->elts
[pc
].opcode
;
2108 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2110 /* We can't optimize out "&*" if there's a user-defined operator*. */
2111 if (unop_user_defined_p (op
, x
))
2113 x
= value_x_unop (x
, op
, noside
);
2114 goto default_case_after_eval
;
2121 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2122 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2125 var
= exp
->elts
[pc
+ 2].symbol
;
2127 /* C++: The "address" of a reference should yield the address
2128 * of the object pointed to. Let value_addr() deal with it. */
2129 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2133 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2136 lookup_pointer_type (SYMBOL_TYPE (var
));
2137 enum address_class sym_class
= SYMBOL_CLASS (var
);
2139 if (sym_class
== LOC_CONST
2140 || sym_class
== LOC_CONST_BYTES
2141 || sym_class
== LOC_REGISTER
2142 || sym_class
== LOC_REGPARM
)
2143 error (_("Attempt to take address of register or constant."));
2146 value_zero (type
, not_lval
);
2152 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2155 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2156 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2157 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2158 &exp
->elts
[pc
+ 3].string
,
2161 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2166 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2167 default_case_after_eval
:
2168 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2170 struct type
*type
= check_typedef (value_type (x
));
2172 if (VALUE_LVAL (x
) == lval_memory
)
2173 return value_zero (lookup_pointer_type (value_type (x
)),
2175 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2176 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2179 error (_("Attempt to take address of non-lval"));
2181 return value_addr (x
);
2185 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2186 When used in contexts where arrays will be coerced anyway, this is
2187 equivalent to `evaluate_subexp' but much faster because it avoids
2188 actually fetching array contents (perhaps obsolete now that we have
2191 Note that we currently only do the coercion for C expressions, where
2192 arrays are zero based and the coercion is correct. For other languages,
2193 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2194 to decide if coercion is appropriate.
2199 evaluate_subexp_with_coercion (struct expression
*exp
,
2200 int *pos
, enum noside noside
)
2208 op
= exp
->elts
[pc
].opcode
;
2213 var
= exp
->elts
[pc
+ 2].symbol
;
2214 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
2215 && CAST_IS_CONVERSION
)
2220 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2221 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
2227 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2231 /* Evaluate a subexpression of EXP, at index *POS,
2232 and return a value for the size of that subexpression.
2233 Advance *POS over the subexpression. */
2235 static struct value
*
2236 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2244 op
= exp
->elts
[pc
].opcode
;
2248 /* This case is handled specially
2249 so that we avoid creating a value for the result type.
2250 If the result type is very big, it's desirable not to
2251 create a value unnecessarily. */
2254 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2255 type
= check_typedef (value_type (val
));
2256 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2257 && TYPE_CODE (type
) != TYPE_CODE_REF
2258 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2259 error (_("Attempt to take contents of a non-pointer value."));
2260 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2261 return value_from_longest (builtin_type_int
, (LONGEST
)
2262 TYPE_LENGTH (type
));
2266 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2267 return value_from_longest (builtin_type_int
,
2268 (LONGEST
) TYPE_LENGTH (type
));
2272 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2274 value_from_longest (builtin_type_int
, (LONGEST
) TYPE_LENGTH (type
));
2277 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2278 return value_from_longest (builtin_type_int
,
2279 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2283 /* Parse a type expression in the string [P..P+LENGTH). */
2286 parse_and_eval_type (char *p
, int length
)
2288 char *tmp
= (char *) alloca (length
+ 4);
2289 struct expression
*expr
;
2291 memcpy (tmp
+ 1, p
, length
);
2292 tmp
[length
+ 1] = ')';
2293 tmp
[length
+ 2] = '0';
2294 tmp
[length
+ 3] = '\0';
2295 expr
= parse_expression (tmp
);
2296 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2297 error (_("Internal error in eval_type."));
2298 return expr
->elts
[1].type
;
2302 calc_f77_array_dims (struct type
*array_type
)
2305 struct type
*tmp_type
;
2307 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2308 error (_("Can't get dimensions for a non-array type"));
2310 tmp_type
= array_type
;
2312 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2314 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)