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;
764 int struct_return
= 0;
767 static struct value
*msg_send
= NULL
;
768 static struct value
*msg_send_stret
= NULL
;
769 static int gnu_runtime
= 0;
771 struct value
*target
= NULL
;
772 struct value
*method
= NULL
;
773 struct value
*called_method
= NULL
;
775 struct type
*selector_type
= NULL
;
777 struct value
*ret
= NULL
;
780 selector
= exp
->elts
[pc
+ 1].longconst
;
781 nargs
= exp
->elts
[pc
+ 2].longconst
;
782 argvec
= (struct value
**) alloca (sizeof (struct value
*)
787 selector_type
= lookup_pointer_type (builtin_type_void
);
788 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
789 sub_no_side
= EVAL_NORMAL
;
791 sub_no_side
= noside
;
793 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
795 if (value_as_long (target
) == 0)
796 return value_from_longest (builtin_type_long
, 0);
798 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
801 /* Find the method dispatch (Apple runtime) or method lookup
802 (GNU runtime) function for Objective-C. These will be used
803 to lookup the symbol information for the method. If we
804 can't find any symbol information, then we'll use these to
805 call the method, otherwise we can call the method
806 directly. The msg_send_stret function is used in the special
807 case of a method that returns a structure (Apple runtime
812 type
= lookup_pointer_type (builtin_type_void
);
813 type
= lookup_function_type (type
);
814 type
= lookup_pointer_type (type
);
815 type
= lookup_function_type (type
);
816 type
= lookup_pointer_type (type
);
818 msg_send
= find_function_in_inferior ("objc_msg_lookup");
819 msg_send_stret
= find_function_in_inferior ("objc_msg_lookup");
821 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
822 msg_send_stret
= value_from_pointer (type
,
823 value_as_address (msg_send_stret
));
827 msg_send
= find_function_in_inferior ("objc_msgSend");
828 /* Special dispatcher for methods returning structs */
829 msg_send_stret
= find_function_in_inferior ("objc_msgSend_stret");
832 /* Verify the target object responds to this method. The
833 standard top-level 'Object' class uses a different name for
834 the verification method than the non-standard, but more
835 often used, 'NSObject' class. Make sure we check for both. */
837 responds_selector
= lookup_child_selector ("respondsToSelector:");
838 if (responds_selector
== 0)
839 responds_selector
= lookup_child_selector ("respondsTo:");
841 if (responds_selector
== 0)
842 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
844 method_selector
= lookup_child_selector ("methodForSelector:");
845 if (method_selector
== 0)
846 method_selector
= lookup_child_selector ("methodFor:");
848 if (method_selector
== 0)
849 error (_("no 'methodFor:' or 'methodForSelector:' method"));
851 /* Call the verification method, to make sure that the target
852 class implements the desired method. */
854 argvec
[0] = msg_send
;
856 argvec
[2] = value_from_longest (builtin_type_long
, responds_selector
);
857 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
860 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
863 /* Function objc_msg_lookup returns a pointer. */
865 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
867 if (value_as_long (ret
) == 0)
868 error (_("Target does not respond to this message selector."));
870 /* Call "methodForSelector:" method, to get the address of a
871 function method that implements this selector for this
872 class. If we can find a symbol at that address, then we
873 know the return type, parameter types etc. (that's a good
876 argvec
[0] = msg_send
;
878 argvec
[2] = value_from_longest (builtin_type_long
, method_selector
);
879 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
882 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
886 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
889 /* ret should now be the selector. */
891 addr
= value_as_long (ret
);
894 struct symbol
*sym
= NULL
;
895 /* Is it a high_level symbol? */
897 sym
= find_pc_function (addr
);
899 method
= value_of_variable (sym
, 0);
902 /* If we found a method with symbol information, check to see
903 if it returns a struct. Otherwise assume it doesn't. */
909 struct type
*value_type
;
911 funaddr
= find_function_addr (method
, &value_type
);
913 b
= block_for_pc (funaddr
);
915 /* If compiled without -g, assume GCC 2. */
916 using_gcc
= (b
== NULL
? 2 : BLOCK_GCC_COMPILED (b
));
918 CHECK_TYPEDEF (value_type
);
920 if ((value_type
== NULL
)
921 || (TYPE_CODE(value_type
) == TYPE_CODE_ERROR
))
923 if (expect_type
!= NULL
)
924 value_type
= expect_type
;
927 struct_return
= using_struct_return (value_type
, using_gcc
);
929 else if (expect_type
!= NULL
)
931 struct_return
= using_struct_return (check_typedef (expect_type
), using_gcc
);
934 /* Found a function symbol. Now we will substitute its
935 value in place of the message dispatcher (obj_msgSend),
936 so that we call the method directly instead of thru
937 the dispatcher. The main reason for doing this is that
938 we can now evaluate the return value and parameter values
939 according to their known data types, in case we need to
940 do things like promotion, dereferencing, special handling
941 of structs and doubles, etc.
943 We want to use the type signature of 'method', but still
944 jump to objc_msgSend() or objc_msgSend_stret() to better
945 mimic the behavior of the runtime. */
949 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
950 error (_("method address has symbol information with non-function type; skipping"));
952 VALUE_ADDRESS (method
) = value_as_address (msg_send_stret
);
954 VALUE_ADDRESS (method
) = value_as_address (msg_send
);
955 called_method
= method
;
960 called_method
= msg_send_stret
;
962 called_method
= msg_send
;
965 if (noside
== EVAL_SKIP
)
968 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
970 /* If the return type doesn't look like a function type,
971 call an error. This can happen if somebody tries to
972 turn a variable into a function call. This is here
973 because people often want to call, eg, strcmp, which
974 gdb doesn't know is a function. If gdb isn't asked for
975 it's opinion (ie. through "whatis"), it won't offer
978 struct type
*type
= value_type (called_method
);
979 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
980 type
= TYPE_TARGET_TYPE (type
);
981 type
= TYPE_TARGET_TYPE (type
);
985 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
986 return allocate_value (expect_type
);
988 return allocate_value (type
);
991 error (_("Expression of type other than \"method returning ...\" used as a method"));
994 /* Now depending on whether we found a symbol for the method,
995 we will either call the runtime dispatcher or the method
998 argvec
[0] = called_method
;
1000 argvec
[2] = value_from_longest (builtin_type_long
, selector
);
1001 /* User-supplied arguments. */
1002 for (tem
= 0; tem
< nargs
; tem
++)
1003 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1004 argvec
[tem
+ 3] = 0;
1006 if (gnu_runtime
&& (method
!= NULL
))
1008 /* Function objc_msg_lookup returns a pointer. */
1009 deprecated_set_value_type (argvec
[0],
1010 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1011 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1014 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1021 op
= exp
->elts
[*pos
].opcode
;
1022 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1023 /* Allocate arg vector, including space for the function to be
1024 called in argvec[0] and a terminating NULL */
1025 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1026 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1029 /* First, evaluate the structure into arg2 */
1032 if (noside
== EVAL_SKIP
)
1035 if (op
== STRUCTOP_MEMBER
)
1037 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1041 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1044 /* If the function is a virtual function, then the
1045 aggregate value (providing the structure) plays
1046 its part by providing the vtable. Otherwise,
1047 it is just along for the ride: call the function
1050 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1052 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1053 != TYPE_CODE_METHODPTR
)
1054 error (_("Non-pointer-to-member value used in pointer-to-member "
1057 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1059 struct type
*method_type
= check_typedef (value_type (arg1
));
1060 arg1
= value_zero (method_type
, not_lval
);
1063 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1065 /* Now, say which argument to start evaluating from */
1068 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1070 /* Hair for method invocations */
1074 /* First, evaluate the structure into arg2 */
1076 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1077 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1078 if (noside
== EVAL_SKIP
)
1081 if (op
== STRUCTOP_STRUCT
)
1083 /* If v is a variable in a register, and the user types
1084 v.method (), this will produce an error, because v has
1087 A possible way around this would be to allocate a
1088 copy of the variable on the stack, copy in the
1089 contents, call the function, and copy out the
1090 contents. I.e. convert this from call by reference
1091 to call by copy-return (or whatever it's called).
1092 However, this does not work because it is not the
1093 same: the method being called could stash a copy of
1094 the address, and then future uses through that address
1095 (after the method returns) would be expected to
1096 use the variable itself, not some copy of it. */
1097 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1101 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1103 /* Now, say which argument to start evaluating from */
1108 /* Non-method function call */
1110 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1112 type
= value_type (argvec
[0]);
1113 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1114 type
= TYPE_TARGET_TYPE (type
);
1115 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1117 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1119 /* pai: FIXME This seems to be coercing arguments before
1120 * overload resolution has been done! */
1121 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1127 /* Evaluate arguments */
1128 for (; tem
<= nargs
; tem
++)
1130 /* Ensure that array expressions are coerced into pointer objects. */
1131 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1134 /* signal end of arglist */
1137 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1139 int static_memfuncp
;
1142 /* Method invocation : stuff "this" as first parameter */
1144 /* Name of method from expression */
1145 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1147 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1149 /* Language is C++, do some overload resolution before evaluation */
1150 struct value
*valp
= NULL
;
1152 /* Prepare list of argument types for overload resolution */
1153 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1154 for (ix
= 1; ix
<= nargs
; ix
++)
1155 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1157 (void) find_overload_match (arg_types
, nargs
, tstr
,
1158 1 /* method */ , 0 /* strict match */ ,
1159 &arg2
/* the object */ , NULL
,
1160 &valp
, NULL
, &static_memfuncp
);
1163 argvec
[1] = arg2
; /* the ``this'' pointer */
1164 argvec
[0] = valp
; /* use the method found after overload resolution */
1167 /* Non-C++ case -- or no overload resolution */
1169 struct value
*temp
= arg2
;
1170 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1172 op
== STRUCTOP_STRUCT
1173 ? "structure" : "structure pointer");
1174 /* value_struct_elt updates temp with the correct value
1175 of the ``this'' pointer if necessary, so modify argvec[1] to
1176 reflect any ``this'' changes. */
1177 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1178 VALUE_ADDRESS (temp
) + value_offset (temp
)
1179 + value_embedded_offset (temp
));
1180 argvec
[1] = arg2
; /* the ``this'' pointer */
1183 if (static_memfuncp
)
1185 argvec
[1] = argvec
[0];
1190 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1195 else if (op
== OP_VAR_VALUE
)
1197 /* Non-member function being called */
1198 /* fn: This can only be done for C++ functions. A C-style function
1199 in a C++ program, for instance, does not have the fields that
1200 are expected here */
1202 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1204 /* Language is C++, do some overload resolution before evaluation */
1205 struct symbol
*symp
;
1207 /* Prepare list of argument types for overload resolution */
1208 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1209 for (ix
= 1; ix
<= nargs
; ix
++)
1210 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1212 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1213 0 /* not method */ , 0 /* strict match */ ,
1214 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1217 /* Now fix the expression being evaluated */
1218 exp
->elts
[save_pos1
+2].symbol
= symp
;
1219 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1223 /* Not C++, or no overload resolution allowed */
1224 /* nothing to be done; argvec already correctly set up */
1229 /* It is probably a C-style function */
1230 /* nothing to be done; argvec already correctly set up */
1235 if (noside
== EVAL_SKIP
)
1237 if (argvec
[0] == NULL
)
1238 error (_("Cannot evaluate function -- may be inlined"));
1239 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1241 /* If the return type doesn't look like a function type, call an
1242 error. This can happen if somebody tries to turn a variable into
1243 a function call. This is here because people often want to
1244 call, eg, strcmp, which gdb doesn't know is a function. If
1245 gdb isn't asked for it's opinion (ie. through "whatis"),
1246 it won't offer it. */
1248 struct type
*ftype
=
1249 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1252 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1254 error (_("Expression of type other than \"Function returning ...\" used as function"));
1256 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1257 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1259 case OP_F77_UNDETERMINED_ARGLIST
:
1261 /* Remember that in F77, functions, substring ops and
1262 array subscript operations cannot be disambiguated
1263 at parse time. We have made all array subscript operations,
1264 substring operations as well as function calls come here
1265 and we now have to discover what the heck this thing actually was.
1266 If it is a function, we process just as if we got an OP_FUNCALL. */
1268 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1271 /* First determine the type code we are dealing with. */
1272 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1273 type
= check_typedef (value_type (arg1
));
1274 code
= TYPE_CODE (type
);
1276 if (code
== TYPE_CODE_PTR
)
1278 /* Fortran always passes variable to subroutines as pointer.
1279 So we need to look into its target type to see if it is
1280 array, string or function. If it is, we need to switch
1281 to the target value the original one points to. */
1282 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1284 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1285 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1286 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1288 arg1
= value_ind (arg1
);
1289 type
= check_typedef (value_type (arg1
));
1290 code
= TYPE_CODE (type
);
1296 case TYPE_CODE_ARRAY
:
1297 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1298 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1300 goto multi_f77_subscript
;
1302 case TYPE_CODE_STRING
:
1303 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1304 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1307 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1308 return value_subscript (arg1
, arg2
);
1312 case TYPE_CODE_FUNC
:
1313 /* It's a function call. */
1314 /* Allocate arg vector, including space for the function to be
1315 called in argvec[0] and a terminating NULL */
1316 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1319 for (; tem
<= nargs
; tem
++)
1320 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1321 argvec
[tem
] = 0; /* signal end of arglist */
1325 error (_("Cannot perform substring on this type"));
1329 /* We have a complex number, There should be 2 floating
1330 point numbers that compose it */
1331 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1332 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1334 return value_literal_complex (arg1
, arg2
, builtin_type_f_complex_s16
);
1336 case STRUCTOP_STRUCT
:
1337 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1338 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1339 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1340 if (noside
== EVAL_SKIP
)
1342 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1343 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1344 &exp
->elts
[pc
+ 2].string
,
1349 struct value
*temp
= arg1
;
1350 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1355 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1356 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1357 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1358 if (noside
== EVAL_SKIP
)
1361 /* JYG: if print object is on we need to replace the base type
1362 with rtti type in order to continue on with successful
1363 lookup of member / method only available in the rtti type. */
1365 struct type
*type
= value_type (arg1
);
1366 struct type
*real_type
;
1367 int full
, top
, using_enc
;
1369 if (objectprint
&& TYPE_TARGET_TYPE(type
) &&
1370 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1372 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1375 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1376 real_type
= lookup_pointer_type (real_type
);
1378 real_type
= lookup_reference_type (real_type
);
1380 arg1
= value_cast (real_type
, arg1
);
1385 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1386 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1387 &exp
->elts
[pc
+ 2].string
,
1392 struct value
*temp
= arg1
;
1393 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1394 NULL
, "structure pointer");
1397 case STRUCTOP_MEMBER
:
1399 if (op
== STRUCTOP_MEMBER
)
1400 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1402 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1404 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1406 if (noside
== EVAL_SKIP
)
1409 type
= check_typedef (value_type (arg2
));
1410 switch (TYPE_CODE (type
))
1412 case TYPE_CODE_METHODPTR
:
1413 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1414 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1417 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1418 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1419 return value_ind (arg2
);
1422 case TYPE_CODE_MEMBERPTR
:
1423 /* Now, convert these values to an address. */
1424 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1427 mem_offset
= value_as_long (arg2
);
1429 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1430 value_as_long (arg1
) + mem_offset
);
1431 return value_ind (arg3
);
1434 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1438 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1439 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1440 if (noside
== EVAL_SKIP
)
1442 if (binop_user_defined_p (op
, arg1
, arg2
))
1443 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1445 return value_concat (arg1
, arg2
);
1448 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1449 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1451 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1453 if (binop_user_defined_p (op
, arg1
, arg2
))
1454 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1456 return value_assign (arg1
, arg2
);
1458 case BINOP_ASSIGN_MODIFY
:
1460 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1461 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1462 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1464 op
= exp
->elts
[pc
+ 1].opcode
;
1465 if (binop_user_defined_p (op
, arg1
, arg2
))
1466 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1467 else if (op
== BINOP_ADD
)
1468 arg2
= value_add (arg1
, arg2
);
1469 else if (op
== BINOP_SUB
)
1470 arg2
= value_sub (arg1
, arg2
);
1472 arg2
= value_binop (arg1
, arg2
, op
);
1473 return value_assign (arg1
, arg2
);
1476 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1477 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1478 if (noside
== EVAL_SKIP
)
1480 if (binop_user_defined_p (op
, arg1
, arg2
))
1481 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1483 return value_add (arg1
, arg2
);
1486 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1487 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1488 if (noside
== EVAL_SKIP
)
1490 if (binop_user_defined_p (op
, arg1
, arg2
))
1491 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1493 return value_sub (arg1
, arg2
);
1502 case BINOP_BITWISE_AND
:
1503 case BINOP_BITWISE_IOR
:
1504 case BINOP_BITWISE_XOR
:
1505 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1506 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1507 if (noside
== EVAL_SKIP
)
1509 if (binop_user_defined_p (op
, arg1
, arg2
))
1510 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1511 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
1512 && (op
== BINOP_DIV
|| op
== BINOP_REM
|| op
== BINOP_MOD
))
1513 return value_zero (value_type (arg1
), not_lval
);
1515 return value_binop (arg1
, arg2
, op
);
1518 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1519 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1520 if (noside
== EVAL_SKIP
)
1522 error (_("':' operator used in invalid context"));
1524 case BINOP_SUBSCRIPT
:
1525 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1526 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1527 if (noside
== EVAL_SKIP
)
1529 if (binop_user_defined_p (op
, arg1
, arg2
))
1530 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1533 /* If the user attempts to subscript something that is not an
1534 array or pointer type (like a plain int variable for example),
1535 then report this as an error. */
1537 arg1
= coerce_ref (arg1
);
1538 type
= check_typedef (value_type (arg1
));
1539 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1540 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1542 if (TYPE_NAME (type
))
1543 error (_("cannot subscript something of type `%s'"),
1546 error (_("cannot subscript requested type"));
1549 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1550 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1552 return value_subscript (arg1
, arg2
);
1556 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1557 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1558 if (noside
== EVAL_SKIP
)
1560 return value_in (arg1
, arg2
);
1562 case MULTI_SUBSCRIPT
:
1564 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1565 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1568 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1569 /* FIXME: EVAL_SKIP handling may not be correct. */
1570 if (noside
== EVAL_SKIP
)
1581 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1582 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1584 /* If the user attempts to subscript something that has no target
1585 type (like a plain int variable for example), then report this
1588 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1591 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1597 error (_("cannot subscript something of type `%s'"),
1598 TYPE_NAME (value_type (arg1
)));
1602 if (binop_user_defined_p (op
, arg1
, arg2
))
1604 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1608 arg1
= value_subscript (arg1
, arg2
);
1613 multi_f77_subscript
:
1615 int subscript_array
[MAX_FORTRAN_DIMS
];
1616 int array_size_array
[MAX_FORTRAN_DIMS
];
1617 int ndimensions
= 1, i
;
1618 struct type
*tmp_type
;
1619 int offset_item
; /* The array offset where the item lives */
1621 if (nargs
> MAX_FORTRAN_DIMS
)
1622 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1624 tmp_type
= check_typedef (value_type (arg1
));
1625 ndimensions
= calc_f77_array_dims (type
);
1627 if (nargs
!= ndimensions
)
1628 error (_("Wrong number of subscripts"));
1630 /* Now that we know we have a legal array subscript expression
1631 let us actually find out where this element exists in the array. */
1634 /* Take array indices left to right */
1635 for (i
= 0; i
< nargs
; i
++)
1637 /* Evaluate each subscript, It must be a legal integer in F77 */
1638 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1640 /* Fill in the subscript and array size arrays */
1642 subscript_array
[i
] = value_as_long (arg2
);
1645 /* Internal type of array is arranged right to left */
1646 for (i
= 0; i
< nargs
; i
++)
1648 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1649 if (retcode
== BOUND_FETCH_ERROR
)
1650 error (_("Cannot obtain dynamic upper bound"));
1652 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1653 if (retcode
== BOUND_FETCH_ERROR
)
1654 error (_("Cannot obtain dynamic lower bound"));
1656 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
1658 /* Zero-normalize subscripts so that offsetting will work. */
1660 subscript_array
[nargs
- i
- 1] -= lower
;
1662 /* If we are at the bottom of a multidimensional
1663 array type then keep a ptr to the last ARRAY
1664 type around for use when calling value_subscript()
1665 below. This is done because we pretend to value_subscript
1666 that we actually have a one-dimensional array
1667 of base element type that we apply a simple
1671 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1674 /* Now let us calculate the offset for this item */
1676 offset_item
= subscript_array
[ndimensions
- 1];
1678 for (i
= ndimensions
- 1; i
> 0; --i
)
1680 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
1682 /* Construct a value node with the value of the offset */
1684 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
);
1686 /* Let us now play a dirty trick: we will take arg1
1687 which is a value node pointing to the topmost level
1688 of the multidimensional array-set and pretend
1689 that it is actually a array of the final element
1690 type, this will ensure that value_subscript()
1691 returns the correct type value */
1693 deprecated_set_value_type (arg1
, tmp_type
);
1694 return value_ind (value_add (value_coerce_array (arg1
), arg2
));
1697 case BINOP_LOGICAL_AND
:
1698 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1699 if (noside
== EVAL_SKIP
)
1701 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1706 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1709 if (binop_user_defined_p (op
, arg1
, arg2
))
1711 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1712 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1716 tem
= value_logical_not (arg1
);
1717 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1718 (tem
? EVAL_SKIP
: noside
));
1719 return value_from_longest (LA_BOOL_TYPE
,
1720 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
1723 case BINOP_LOGICAL_OR
:
1724 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1725 if (noside
== EVAL_SKIP
)
1727 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1732 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1735 if (binop_user_defined_p (op
, arg1
, arg2
))
1737 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1738 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1742 tem
= value_logical_not (arg1
);
1743 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1744 (!tem
? EVAL_SKIP
: noside
));
1745 return value_from_longest (LA_BOOL_TYPE
,
1746 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
1750 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1751 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1752 if (noside
== EVAL_SKIP
)
1754 if (binop_user_defined_p (op
, arg1
, arg2
))
1756 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1760 tem
= value_equal (arg1
, arg2
);
1761 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1764 case BINOP_NOTEQUAL
:
1765 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1766 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1767 if (noside
== EVAL_SKIP
)
1769 if (binop_user_defined_p (op
, arg1
, arg2
))
1771 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1775 tem
= value_equal (arg1
, arg2
);
1776 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) ! tem
);
1780 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1781 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1782 if (noside
== EVAL_SKIP
)
1784 if (binop_user_defined_p (op
, arg1
, arg2
))
1786 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1790 tem
= value_less (arg1
, arg2
);
1791 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1795 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1796 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1797 if (noside
== EVAL_SKIP
)
1799 if (binop_user_defined_p (op
, arg1
, arg2
))
1801 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1805 tem
= value_less (arg2
, arg1
);
1806 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1810 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1811 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1812 if (noside
== EVAL_SKIP
)
1814 if (binop_user_defined_p (op
, arg1
, arg2
))
1816 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1820 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1821 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1825 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1826 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1827 if (noside
== EVAL_SKIP
)
1829 if (binop_user_defined_p (op
, arg1
, arg2
))
1831 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1835 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1836 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1840 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1841 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1842 if (noside
== EVAL_SKIP
)
1844 type
= check_typedef (value_type (arg2
));
1845 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
1846 error (_("Non-integral right operand for \"@\" operator."));
1847 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1849 return allocate_repeat_value (value_type (arg1
),
1850 longest_to_int (value_as_long (arg2
)));
1853 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1856 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1857 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1860 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1861 if (noside
== EVAL_SKIP
)
1863 if (unop_user_defined_p (op
, arg1
))
1864 return value_x_unop (arg1
, op
, noside
);
1866 return value_pos (arg1
);
1869 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1870 if (noside
== EVAL_SKIP
)
1872 if (unop_user_defined_p (op
, arg1
))
1873 return value_x_unop (arg1
, op
, noside
);
1875 return value_neg (arg1
);
1877 case UNOP_COMPLEMENT
:
1878 /* C++: check for and handle destructor names. */
1879 op
= exp
->elts
[*pos
].opcode
;
1881 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1882 if (noside
== EVAL_SKIP
)
1884 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1885 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1887 return value_complement (arg1
);
1889 case UNOP_LOGICAL_NOT
:
1890 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1891 if (noside
== EVAL_SKIP
)
1893 if (unop_user_defined_p (op
, arg1
))
1894 return value_x_unop (arg1
, op
, noside
);
1896 return value_from_longest (LA_BOOL_TYPE
,
1897 (LONGEST
) value_logical_not (arg1
));
1900 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
1901 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
1902 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1903 type
= check_typedef (value_type (arg1
));
1904 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
1905 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1906 error (_("Attempt to dereference pointer to member without an object"));
1907 if (noside
== EVAL_SKIP
)
1909 if (unop_user_defined_p (op
, arg1
))
1910 return value_x_unop (arg1
, op
, noside
);
1911 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1913 type
= check_typedef (value_type (arg1
));
1914 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1915 || TYPE_CODE (type
) == TYPE_CODE_REF
1916 /* In C you can dereference an array to get the 1st elt. */
1917 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1919 return value_zero (TYPE_TARGET_TYPE (type
),
1921 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1922 /* GDB allows dereferencing an int. */
1923 return value_zero (builtin_type_int
, lval_memory
);
1925 error (_("Attempt to take contents of a non-pointer value."));
1927 return value_ind (arg1
);
1930 /* C++: check for and handle pointer to members. */
1932 op
= exp
->elts
[*pos
].opcode
;
1934 if (noside
== EVAL_SKIP
)
1936 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1941 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
1946 if (noside
== EVAL_SKIP
)
1948 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1951 return evaluate_subexp_for_sizeof (exp
, pos
);
1955 type
= exp
->elts
[pc
+ 1].type
;
1956 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
1957 if (noside
== EVAL_SKIP
)
1959 if (type
!= value_type (arg1
))
1960 arg1
= value_cast (type
, arg1
);
1965 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1966 if (noside
== EVAL_SKIP
)
1968 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1969 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
1971 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
1972 value_as_address (arg1
));
1974 case UNOP_MEMVAL_TLS
:
1976 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1977 if (noside
== EVAL_SKIP
)
1979 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1980 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
1984 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
1985 value_as_address (arg1
));
1986 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
1989 case UNOP_PREINCREMENT
:
1990 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1991 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1993 else if (unop_user_defined_p (op
, arg1
))
1995 return value_x_unop (arg1
, op
, noside
);
1999 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
2001 return value_assign (arg1
, arg2
);
2004 case UNOP_PREDECREMENT
:
2005 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2006 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2008 else if (unop_user_defined_p (op
, arg1
))
2010 return value_x_unop (arg1
, op
, noside
);
2014 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2016 return value_assign (arg1
, arg2
);
2019 case UNOP_POSTINCREMENT
:
2020 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2021 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2023 else if (unop_user_defined_p (op
, arg1
))
2025 return value_x_unop (arg1
, op
, noside
);
2029 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
2031 value_assign (arg1
, arg2
);
2035 case UNOP_POSTDECREMENT
:
2036 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2037 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2039 else if (unop_user_defined_p (op
, arg1
))
2041 return value_x_unop (arg1
, op
, noside
);
2045 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2047 value_assign (arg1
, arg2
);
2053 return value_of_this (1);
2057 return value_of_local ("self", 1);
2060 /* The value is not supposed to be used. This is here to make it
2061 easier to accommodate expressions that contain types. */
2063 if (noside
== EVAL_SKIP
)
2065 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2066 return allocate_value (exp
->elts
[pc
+ 1].type
);
2068 error (_("Attempt to use a type name as an expression"));
2071 /* Removing this case and compiling with gcc -Wall reveals that
2072 a lot of cases are hitting this case. Some of these should
2073 probably be removed from expression.h; others are legitimate
2074 expressions which are (apparently) not fully implemented.
2076 If there are any cases landing here which mean a user error,
2077 then they should be separate cases, with more descriptive
2081 GDB does not (yet) know how to evaluate that kind of expression"));
2085 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
2088 /* Evaluate a subexpression of EXP, at index *POS,
2089 and return the address of that subexpression.
2090 Advance *POS over the subexpression.
2091 If the subexpression isn't an lvalue, get an error.
2092 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2093 then only the type of the result need be correct. */
2095 static struct value
*
2096 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2106 op
= exp
->elts
[pc
].opcode
;
2112 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2114 /* We can't optimize out "&*" if there's a user-defined operator*. */
2115 if (unop_user_defined_p (op
, x
))
2117 x
= value_x_unop (x
, op
, noside
);
2118 goto default_case_after_eval
;
2125 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2126 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2129 var
= exp
->elts
[pc
+ 2].symbol
;
2131 /* C++: The "address" of a reference should yield the address
2132 * of the object pointed to. Let value_addr() deal with it. */
2133 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2137 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2140 lookup_pointer_type (SYMBOL_TYPE (var
));
2141 enum address_class sym_class
= SYMBOL_CLASS (var
);
2143 if (sym_class
== LOC_CONST
2144 || sym_class
== LOC_CONST_BYTES
2145 || sym_class
== LOC_REGISTER
2146 || sym_class
== LOC_REGPARM
)
2147 error (_("Attempt to take address of register or constant."));
2150 value_zero (type
, not_lval
);
2156 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2159 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2160 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2161 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2162 &exp
->elts
[pc
+ 3].string
,
2165 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2170 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2171 default_case_after_eval
:
2172 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2174 struct type
*type
= check_typedef (value_type (x
));
2176 if (VALUE_LVAL (x
) == lval_memory
)
2177 return value_zero (lookup_pointer_type (value_type (x
)),
2179 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2180 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2183 error (_("Attempt to take address of non-lval"));
2185 return value_addr (x
);
2189 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2190 When used in contexts where arrays will be coerced anyway, this is
2191 equivalent to `evaluate_subexp' but much faster because it avoids
2192 actually fetching array contents (perhaps obsolete now that we have
2195 Note that we currently only do the coercion for C expressions, where
2196 arrays are zero based and the coercion is correct. For other languages,
2197 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2198 to decide if coercion is appropriate.
2203 evaluate_subexp_with_coercion (struct expression
*exp
,
2204 int *pos
, enum noside noside
)
2212 op
= exp
->elts
[pc
].opcode
;
2217 var
= exp
->elts
[pc
+ 2].symbol
;
2218 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
2219 && CAST_IS_CONVERSION
)
2224 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2225 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
2231 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2235 /* Evaluate a subexpression of EXP, at index *POS,
2236 and return a value for the size of that subexpression.
2237 Advance *POS over the subexpression. */
2239 static struct value
*
2240 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2248 op
= exp
->elts
[pc
].opcode
;
2252 /* This case is handled specially
2253 so that we avoid creating a value for the result type.
2254 If the result type is very big, it's desirable not to
2255 create a value unnecessarily. */
2258 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2259 type
= check_typedef (value_type (val
));
2260 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2261 && TYPE_CODE (type
) != TYPE_CODE_REF
2262 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2263 error (_("Attempt to take contents of a non-pointer value."));
2264 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2265 return value_from_longest (builtin_type_int
, (LONGEST
)
2266 TYPE_LENGTH (type
));
2270 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2271 return value_from_longest (builtin_type_int
,
2272 (LONGEST
) TYPE_LENGTH (type
));
2276 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2278 value_from_longest (builtin_type_int
, (LONGEST
) TYPE_LENGTH (type
));
2281 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2282 return value_from_longest (builtin_type_int
,
2283 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2287 /* Parse a type expression in the string [P..P+LENGTH). */
2290 parse_and_eval_type (char *p
, int length
)
2292 char *tmp
= (char *) alloca (length
+ 4);
2293 struct expression
*expr
;
2295 memcpy (tmp
+ 1, p
, length
);
2296 tmp
[length
+ 1] = ')';
2297 tmp
[length
+ 2] = '0';
2298 tmp
[length
+ 3] = '\0';
2299 expr
= parse_expression (tmp
);
2300 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2301 error (_("Internal error in eval_type."));
2302 return expr
->elts
[1].type
;
2306 calc_f77_array_dims (struct type
*array_type
)
2309 struct type
*tmp_type
;
2311 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2312 error (_("Can't get dimensions for a non-array type"));
2314 tmp_type
= array_type
;
2316 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2318 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)