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 2 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, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
25 #include "gdb_string.h"
29 #include "expression.h"
32 #include "language.h" /* For CAST_IS_CONVERSION */
33 #include "f-lang.h" /* for array bound stuff */
36 #include "objc-lang.h"
38 #include "parser-defs.h"
39 #include "cp-support.h"
41 #include "exceptions.h"
44 #include "gdb_assert.h"
46 /* This is defined in valops.c */
47 extern int overload_resolution
;
49 /* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
50 on with successful lookup for member/method of the rtti type. */
51 extern int objectprint
;
53 /* Prototypes for local functions. */
55 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
57 static struct value
*evaluate_subexp_for_address (struct expression
*,
60 static struct value
*evaluate_subexp (struct type
*, struct expression
*,
63 static char *get_label (struct expression
*, int *);
65 static struct value
*evaluate_struct_tuple (struct value
*,
66 struct expression
*, int *,
69 static LONGEST
init_array_element (struct value
*, struct value
*,
70 struct expression
*, int *, enum noside
,
74 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
75 int *pos
, enum noside noside
)
77 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
78 (expect_type
, exp
, pos
, noside
);
81 /* Parse the string EXP as a C expression, evaluate it,
82 and return the result as a number. */
85 parse_and_eval_address (char *exp
)
87 struct expression
*expr
= parse_expression (exp
);
89 struct cleanup
*old_chain
=
90 make_cleanup (free_current_contents
, &expr
);
92 addr
= value_as_address (evaluate_expression (expr
));
93 do_cleanups (old_chain
);
97 /* Like parse_and_eval_address but takes a pointer to a char * variable
98 and advanced that variable across the characters parsed. */
101 parse_and_eval_address_1 (char **expptr
)
103 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*) 0, 0);
105 struct cleanup
*old_chain
=
106 make_cleanup (free_current_contents
, &expr
);
108 addr
= value_as_address (evaluate_expression (expr
));
109 do_cleanups (old_chain
);
113 /* Like parse_and_eval_address, but treats the value of the expression
114 as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
116 parse_and_eval_long (char *exp
)
118 struct expression
*expr
= parse_expression (exp
);
120 struct cleanup
*old_chain
=
121 make_cleanup (free_current_contents
, &expr
);
123 retval
= value_as_long (evaluate_expression (expr
));
124 do_cleanups (old_chain
);
129 parse_and_eval (char *exp
)
131 struct expression
*expr
= parse_expression (exp
);
133 struct cleanup
*old_chain
=
134 make_cleanup (free_current_contents
, &expr
);
136 val
= evaluate_expression (expr
);
137 do_cleanups (old_chain
);
141 /* Parse up to a comma (or to a closeparen)
142 in the string EXPP as an expression, evaluate it, and return the value.
143 EXPP is advanced to point to the comma. */
146 parse_to_comma_and_eval (char **expp
)
148 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
150 struct cleanup
*old_chain
=
151 make_cleanup (free_current_contents
, &expr
);
153 val
= evaluate_expression (expr
);
154 do_cleanups (old_chain
);
158 /* Evaluate an expression in internal prefix form
159 such as is constructed by parse.y.
161 See expression.h for info on the format of an expression. */
164 evaluate_expression (struct expression
*exp
)
167 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
170 /* Evaluate an expression, avoiding all memory references
171 and getting a value whose type alone is correct. */
174 evaluate_type (struct expression
*exp
)
177 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
180 /* If the next expression is an OP_LABELED, skips past it,
181 returning the label. Otherwise, does nothing and returns NULL. */
184 get_label (struct expression
*exp
, int *pos
)
186 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
189 char *name
= &exp
->elts
[pc
+ 2].string
;
190 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
191 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
198 /* This function evaluates tuples (in (the deleted) Chill) or
199 brace-initializers (in C/C++) for structure types. */
201 static struct value
*
202 evaluate_struct_tuple (struct value
*struct_val
,
203 struct expression
*exp
,
204 int *pos
, enum noside noside
, int nargs
)
206 struct type
*struct_type
= check_typedef (value_type (struct_val
));
207 struct type
*substruct_type
= struct_type
;
208 struct type
*field_type
;
215 struct value
*val
= NULL
;
220 /* Skip past the labels, and count them. */
221 while (get_label (exp
, pos
) != NULL
)
226 char *label
= get_label (exp
, &pc
);
229 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
232 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
233 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
236 subfieldno
= fieldno
;
237 substruct_type
= struct_type
;
241 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
244 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
245 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
246 if ((field_name
== 0 || *field_name
== '\0')
247 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
250 for (; variantno
< TYPE_NFIELDS (field_type
);
254 = TYPE_FIELD_TYPE (field_type
, variantno
);
255 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
258 subfieldno
< TYPE_NFIELDS (substruct_type
);
261 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
272 error (_("there is no field named %s"), label
);
278 /* Unlabelled tuple element - go to next field. */
282 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
285 substruct_type
= struct_type
;
291 /* Skip static fields. */
292 while (fieldno
< TYPE_NFIELDS (struct_type
)
293 && TYPE_FIELD_STATIC_KIND (struct_type
, fieldno
))
295 subfieldno
= fieldno
;
296 if (fieldno
>= TYPE_NFIELDS (struct_type
))
297 error (_("too many initializers"));
298 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
299 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
300 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
301 error (_("don't know which variant you want to set"));
305 /* Here, struct_type is the type of the inner struct,
306 while substruct_type is the type of the inner struct.
307 These are the same for normal structures, but a variant struct
308 contains anonymous union fields that contain substruct fields.
309 The value fieldno is the index of the top-level (normal or
310 anonymous union) field in struct_field, while the value
311 subfieldno is the index of the actual real (named inner) field
312 in substruct_type. */
314 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
316 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
318 /* Now actually set the field in struct_val. */
320 /* Assign val to field fieldno. */
321 if (value_type (val
) != field_type
)
322 val
= value_cast (field_type
, val
);
324 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
325 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
327 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
328 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
330 modify_field (addr
, value_as_long (val
),
331 bitpos
% 8, bitsize
);
333 memcpy (addr
, value_contents (val
),
334 TYPE_LENGTH (value_type (val
)));
336 while (--nlabels
> 0);
341 /* Recursive helper function for setting elements of array tuples for
342 (the deleted) Chill. The target is ARRAY (which has bounds
343 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
344 and NOSIDE are as usual. Evaluates index expresions and sets the
345 specified element(s) of ARRAY to ELEMENT. Returns last index
349 init_array_element (struct value
*array
, struct value
*element
,
350 struct expression
*exp
, int *pos
,
351 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
354 int element_size
= TYPE_LENGTH (value_type (element
));
355 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
358 init_array_element (array
, element
, exp
, pos
, noside
,
359 low_bound
, high_bound
);
360 return init_array_element (array
, element
,
361 exp
, pos
, noside
, low_bound
, high_bound
);
363 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
367 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
368 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
369 if (low
< low_bound
|| high
> high_bound
)
370 error (_("tuple range index out of range"));
371 for (index
= low
; index
<= high
; index
++)
373 memcpy (value_contents_raw (array
)
374 + (index
- low_bound
) * element_size
,
375 value_contents (element
), element_size
);
380 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
381 if (index
< low_bound
|| index
> high_bound
)
382 error (_("tuple index out of range"));
383 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
384 value_contents (element
), element_size
);
390 value_f90_subarray (struct value
*array
,
391 struct expression
*exp
, int *pos
, enum noside noside
)
394 LONGEST low_bound
, high_bound
;
395 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
396 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
400 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
401 low_bound
= TYPE_LOW_BOUND (range
);
403 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
405 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
406 high_bound
= TYPE_HIGH_BOUND (range
);
408 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
410 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
414 evaluate_subexp_standard (struct type
*expect_type
,
415 struct expression
*exp
, int *pos
,
420 int pc
, pc2
= 0, oldpos
;
421 struct value
*arg1
= NULL
;
422 struct value
*arg2
= NULL
;
426 struct value
**argvec
;
427 int upper
, lower
, retcode
;
431 struct type
**arg_types
;
435 op
= exp
->elts
[pc
].opcode
;
440 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
441 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
442 if (noside
== EVAL_SKIP
)
444 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
445 &exp
->elts
[pc
+ 3].string
,
448 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
453 return value_from_longest (exp
->elts
[pc
+ 1].type
,
454 exp
->elts
[pc
+ 2].longconst
);
458 return value_from_double (exp
->elts
[pc
+ 1].type
,
459 exp
->elts
[pc
+ 2].doubleconst
);
463 if (noside
== EVAL_SKIP
)
466 /* JYG: We used to just return value_zero of the symbol type
467 if we're asked to avoid side effects. Otherwise we return
468 value_of_variable (...). However I'm not sure if
469 value_of_variable () has any side effect.
470 We need a full value object returned here for whatis_exp ()
471 to call evaluate_type () and then pass the full value to
472 value_rtti_target_type () if we are dealing with a pointer
473 or reference to a base class and print object is on. */
476 volatile struct gdb_exception except
;
477 struct value
*ret
= NULL
;
479 TRY_CATCH (except
, RETURN_MASK_ERROR
)
481 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
482 exp
->elts
[pc
+ 1].block
);
485 if (except
.reason
< 0)
487 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
488 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
), not_lval
);
490 throw_exception (except
);
499 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
503 const char *name
= &exp
->elts
[pc
+ 2].string
;
507 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
508 regno
= frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
509 name
, strlen (name
));
511 error (_("Register $%s not available."), name
);
512 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
513 val
= value_zero (register_type (current_gdbarch
, regno
), not_lval
);
515 val
= value_of_register (regno
, get_selected_frame (NULL
));
517 error (_("Value of register %s not available."), name
);
523 return value_from_longest (LA_BOOL_TYPE
,
524 exp
->elts
[pc
+ 1].longconst
);
528 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
531 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
532 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
533 if (noside
== EVAL_SKIP
)
535 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
537 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
538 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
539 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
540 if (noside
== EVAL_SKIP
)
544 return (struct value
*) value_nsstring (&exp
->elts
[pc
+ 2].string
, tem
+ 1);
547 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
549 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
550 if (noside
== EVAL_SKIP
)
552 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
557 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
558 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
559 nargs
= tem3
- tem2
+ 1;
560 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
562 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
563 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
565 struct value
*rec
= allocate_value (expect_type
);
566 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
567 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
570 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
571 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
573 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
574 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
575 struct value
*array
= allocate_value (expect_type
);
576 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
577 LONGEST low_bound
, high_bound
, index
;
578 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
581 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
584 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
585 for (tem
= nargs
; --nargs
>= 0;)
587 struct value
*element
;
589 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
592 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
594 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
595 if (value_type (element
) != element_type
)
596 element
= value_cast (element_type
, element
);
599 int continue_pc
= *pos
;
601 index
= init_array_element (array
, element
, exp
, pos
, noside
,
602 low_bound
, high_bound
);
607 if (index
> high_bound
)
608 /* to avoid memory corruption */
609 error (_("Too many array elements"));
610 memcpy (value_contents_raw (array
)
611 + (index
- low_bound
) * element_size
,
612 value_contents (element
),
620 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
621 && TYPE_CODE (type
) == TYPE_CODE_SET
)
623 struct value
*set
= allocate_value (expect_type
);
624 gdb_byte
*valaddr
= value_contents_raw (set
);
625 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
626 struct type
*check_type
= element_type
;
627 LONGEST low_bound
, high_bound
;
629 /* get targettype of elementtype */
630 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
631 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
632 check_type
= TYPE_TARGET_TYPE (check_type
);
634 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
635 error (_("(power)set type with unknown size"));
636 memset (valaddr
, '\0', TYPE_LENGTH (type
));
637 for (tem
= 0; tem
< nargs
; tem
++)
639 LONGEST range_low
, range_high
;
640 struct type
*range_low_type
, *range_high_type
;
641 struct value
*elem_val
;
642 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
645 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
646 range_low_type
= value_type (elem_val
);
647 range_low
= value_as_long (elem_val
);
648 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
649 range_high_type
= value_type (elem_val
);
650 range_high
= value_as_long (elem_val
);
654 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
655 range_low_type
= range_high_type
= value_type (elem_val
);
656 range_low
= range_high
= value_as_long (elem_val
);
658 /* check types of elements to avoid mixture of elements from
659 different types. Also check if type of element is "compatible"
660 with element type of powerset */
661 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
662 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
663 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
664 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
665 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
666 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
667 (range_low_type
!= range_high_type
)))
668 /* different element modes */
669 error (_("POWERSET tuple elements of different mode"));
670 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
671 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
672 range_low_type
!= check_type
))
673 error (_("incompatible POWERSET tuple elements"));
674 if (range_low
> range_high
)
676 warning (_("empty POWERSET tuple range"));
679 if (range_low
< low_bound
|| range_high
> high_bound
)
680 error (_("POWERSET tuple element out of range"));
681 range_low
-= low_bound
;
682 range_high
-= low_bound
;
683 for (; range_low
<= range_high
; range_low
++)
685 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
687 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
688 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
695 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
696 for (tem
= 0; tem
< nargs
; tem
++)
698 /* Ensure that array expressions are coerced into pointer objects. */
699 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
701 if (noside
== EVAL_SKIP
)
703 return value_array (tem2
, tem3
, argvec
);
707 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
709 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
711 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
712 if (noside
== EVAL_SKIP
)
714 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
717 case TERNOP_SLICE_COUNT
:
719 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
721 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
723 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
724 return value_slice (array
, lowbound
, length
);
728 /* Skip third and second args to evaluate the first one. */
729 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
730 if (value_logical_not (arg1
))
732 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
733 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
737 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
738 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
742 case OP_OBJC_SELECTOR
:
743 { /* Objective C @selector operator. */
744 char *sel
= &exp
->elts
[pc
+ 2].string
;
745 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
747 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
748 if (noside
== EVAL_SKIP
)
752 sel
[len
] = 0; /* Make sure it's terminated. */
753 return value_from_longest (lookup_pointer_type (builtin_type_void
),
754 lookup_child_selector (sel
));
757 case OP_OBJC_MSGCALL
:
758 { /* Objective C message (method) call. */
760 static CORE_ADDR responds_selector
= 0;
761 static CORE_ADDR method_selector
= 0;
763 CORE_ADDR selector
= 0;
766 int struct_return
= 0;
769 static struct value
*msg_send
= NULL
;
770 static struct value
*msg_send_stret
= NULL
;
771 static int gnu_runtime
= 0;
773 struct value
*target
= NULL
;
774 struct value
*method
= NULL
;
775 struct value
*called_method
= NULL
;
777 struct type
*selector_type
= NULL
;
779 struct value
*ret
= NULL
;
782 selector
= exp
->elts
[pc
+ 1].longconst
;
783 nargs
= exp
->elts
[pc
+ 2].longconst
;
784 argvec
= (struct value
**) alloca (sizeof (struct value
*)
789 selector_type
= lookup_pointer_type (builtin_type_void
);
790 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
791 sub_no_side
= EVAL_NORMAL
;
793 sub_no_side
= noside
;
795 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
797 if (value_as_long (target
) == 0)
798 return value_from_longest (builtin_type_long
, 0);
800 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
803 /* Find the method dispatch (Apple runtime) or method lookup
804 (GNU runtime) function for Objective-C. These will be used
805 to lookup the symbol information for the method. If we
806 can't find any symbol information, then we'll use these to
807 call the method, otherwise we can call the method
808 directly. The msg_send_stret function is used in the special
809 case of a method that returns a structure (Apple runtime
814 type
= lookup_pointer_type (builtin_type_void
);
815 type
= lookup_function_type (type
);
816 type
= lookup_pointer_type (type
);
817 type
= lookup_function_type (type
);
818 type
= lookup_pointer_type (type
);
820 msg_send
= find_function_in_inferior ("objc_msg_lookup");
821 msg_send_stret
= find_function_in_inferior ("objc_msg_lookup");
823 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
824 msg_send_stret
= value_from_pointer (type
,
825 value_as_address (msg_send_stret
));
829 msg_send
= find_function_in_inferior ("objc_msgSend");
830 /* Special dispatcher for methods returning structs */
831 msg_send_stret
= find_function_in_inferior ("objc_msgSend_stret");
834 /* Verify the target object responds to this method. The
835 standard top-level 'Object' class uses a different name for
836 the verification method than the non-standard, but more
837 often used, 'NSObject' class. Make sure we check for both. */
839 responds_selector
= lookup_child_selector ("respondsToSelector:");
840 if (responds_selector
== 0)
841 responds_selector
= lookup_child_selector ("respondsTo:");
843 if (responds_selector
== 0)
844 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
846 method_selector
= lookup_child_selector ("methodForSelector:");
847 if (method_selector
== 0)
848 method_selector
= lookup_child_selector ("methodFor:");
850 if (method_selector
== 0)
851 error (_("no 'methodFor:' or 'methodForSelector:' method"));
853 /* Call the verification method, to make sure that the target
854 class implements the desired method. */
856 argvec
[0] = msg_send
;
858 argvec
[2] = value_from_longest (builtin_type_long
, responds_selector
);
859 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
862 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
865 /* Function objc_msg_lookup returns a pointer. */
867 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
869 if (value_as_long (ret
) == 0)
870 error (_("Target does not respond to this message selector."));
872 /* Call "methodForSelector:" method, to get the address of a
873 function method that implements this selector for this
874 class. If we can find a symbol at that address, then we
875 know the return type, parameter types etc. (that's a good
878 argvec
[0] = msg_send
;
880 argvec
[2] = value_from_longest (builtin_type_long
, method_selector
);
881 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
884 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
888 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
891 /* ret should now be the selector. */
893 addr
= value_as_long (ret
);
896 struct symbol
*sym
= NULL
;
897 /* Is it a high_level symbol? */
899 sym
= find_pc_function (addr
);
901 method
= value_of_variable (sym
, 0);
904 /* If we found a method with symbol information, check to see
905 if it returns a struct. Otherwise assume it doesn't. */
911 struct type
*value_type
;
913 funaddr
= find_function_addr (method
, &value_type
);
915 b
= block_for_pc (funaddr
);
917 /* If compiled without -g, assume GCC 2. */
918 using_gcc
= (b
== NULL
? 2 : BLOCK_GCC_COMPILED (b
));
920 CHECK_TYPEDEF (value_type
);
922 if ((value_type
== NULL
)
923 || (TYPE_CODE(value_type
) == TYPE_CODE_ERROR
))
925 if (expect_type
!= NULL
)
926 value_type
= expect_type
;
929 struct_return
= using_struct_return (value_type
, using_gcc
);
931 else if (expect_type
!= NULL
)
933 struct_return
= using_struct_return (check_typedef (expect_type
), using_gcc
);
936 /* Found a function symbol. Now we will substitute its
937 value in place of the message dispatcher (obj_msgSend),
938 so that we call the method directly instead of thru
939 the dispatcher. The main reason for doing this is that
940 we can now evaluate the return value and parameter values
941 according to their known data types, in case we need to
942 do things like promotion, dereferencing, special handling
943 of structs and doubles, etc.
945 We want to use the type signature of 'method', but still
946 jump to objc_msgSend() or objc_msgSend_stret() to better
947 mimic the behavior of the runtime. */
951 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
952 error (_("method address has symbol information with non-function type; skipping"));
954 VALUE_ADDRESS (method
) = value_as_address (msg_send_stret
);
956 VALUE_ADDRESS (method
) = value_as_address (msg_send
);
957 called_method
= method
;
962 called_method
= msg_send_stret
;
964 called_method
= msg_send
;
967 if (noside
== EVAL_SKIP
)
970 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
972 /* If the return type doesn't look like a function type,
973 call an error. This can happen if somebody tries to
974 turn a variable into a function call. This is here
975 because people often want to call, eg, strcmp, which
976 gdb doesn't know is a function. If gdb isn't asked for
977 it's opinion (ie. through "whatis"), it won't offer
980 struct type
*type
= value_type (called_method
);
981 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
982 type
= TYPE_TARGET_TYPE (type
);
983 type
= TYPE_TARGET_TYPE (type
);
987 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
988 return allocate_value (expect_type
);
990 return allocate_value (type
);
993 error (_("Expression of type other than \"method returning ...\" used as a method"));
996 /* Now depending on whether we found a symbol for the method,
997 we will either call the runtime dispatcher or the method
1000 argvec
[0] = called_method
;
1002 argvec
[2] = value_from_longest (builtin_type_long
, selector
);
1003 /* User-supplied arguments. */
1004 for (tem
= 0; tem
< nargs
; tem
++)
1005 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1006 argvec
[tem
+ 3] = 0;
1008 if (gnu_runtime
&& (method
!= NULL
))
1010 /* Function objc_msg_lookup returns a pointer. */
1011 deprecated_set_value_type (argvec
[0],
1012 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1013 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1016 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1023 op
= exp
->elts
[*pos
].opcode
;
1024 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1025 /* Allocate arg vector, including space for the function to be
1026 called in argvec[0] and a terminating NULL */
1027 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1028 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1031 /* First, evaluate the structure into arg2 */
1034 if (noside
== EVAL_SKIP
)
1037 if (op
== STRUCTOP_MEMBER
)
1039 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1043 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1046 /* If the function is a virtual function, then the
1047 aggregate value (providing the structure) plays
1048 its part by providing the vtable. Otherwise,
1049 it is just along for the ride: call the function
1052 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1054 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1055 != TYPE_CODE_METHODPTR
)
1056 error (_("Non-pointer-to-member value used in pointer-to-member "
1059 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1061 struct type
*method_type
= check_typedef (value_type (arg1
));
1062 arg1
= value_zero (method_type
, not_lval
);
1065 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1067 /* Now, say which argument to start evaluating from */
1070 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1072 /* Hair for method invocations */
1076 /* First, evaluate the structure into arg2 */
1078 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1079 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1080 if (noside
== EVAL_SKIP
)
1083 if (op
== STRUCTOP_STRUCT
)
1085 /* If v is a variable in a register, and the user types
1086 v.method (), this will produce an error, because v has
1089 A possible way around this would be to allocate a
1090 copy of the variable on the stack, copy in the
1091 contents, call the function, and copy out the
1092 contents. I.e. convert this from call by reference
1093 to call by copy-return (or whatever it's called).
1094 However, this does not work because it is not the
1095 same: the method being called could stash a copy of
1096 the address, and then future uses through that address
1097 (after the method returns) would be expected to
1098 use the variable itself, not some copy of it. */
1099 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1103 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1105 /* Now, say which argument to start evaluating from */
1110 /* Non-method function call */
1112 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1114 type
= value_type (argvec
[0]);
1115 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1116 type
= TYPE_TARGET_TYPE (type
);
1117 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1119 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1121 /* pai: FIXME This seems to be coercing arguments before
1122 * overload resolution has been done! */
1123 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1129 /* Evaluate arguments */
1130 for (; tem
<= nargs
; tem
++)
1132 /* Ensure that array expressions are coerced into pointer objects. */
1133 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1136 /* signal end of arglist */
1139 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1141 int static_memfuncp
;
1144 /* Method invocation : stuff "this" as first parameter */
1146 /* Name of method from expression */
1147 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1149 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1151 /* Language is C++, do some overload resolution before evaluation */
1152 struct value
*valp
= NULL
;
1154 /* Prepare list of argument types for overload resolution */
1155 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1156 for (ix
= 1; ix
<= nargs
; ix
++)
1157 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1159 (void) find_overload_match (arg_types
, nargs
, tstr
,
1160 1 /* method */ , 0 /* strict match */ ,
1161 &arg2
/* the object */ , NULL
,
1162 &valp
, NULL
, &static_memfuncp
);
1165 argvec
[1] = arg2
; /* the ``this'' pointer */
1166 argvec
[0] = valp
; /* use the method found after overload resolution */
1169 /* Non-C++ case -- or no overload resolution */
1171 struct value
*temp
= arg2
;
1172 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1174 op
== STRUCTOP_STRUCT
1175 ? "structure" : "structure pointer");
1176 /* value_struct_elt updates temp with the correct value
1177 of the ``this'' pointer if necessary, so modify argvec[1] to
1178 reflect any ``this'' changes. */
1179 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1180 VALUE_ADDRESS (temp
) + value_offset (temp
)
1181 + value_embedded_offset (temp
));
1182 argvec
[1] = arg2
; /* the ``this'' pointer */
1185 if (static_memfuncp
)
1187 argvec
[1] = argvec
[0];
1192 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1197 else if (op
== OP_VAR_VALUE
)
1199 /* Non-member function being called */
1200 /* fn: This can only be done for C++ functions. A C-style function
1201 in a C++ program, for instance, does not have the fields that
1202 are expected here */
1204 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1206 /* Language is C++, do some overload resolution before evaluation */
1207 struct symbol
*symp
;
1209 /* Prepare list of argument types for overload resolution */
1210 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1211 for (ix
= 1; ix
<= nargs
; ix
++)
1212 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1214 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1215 0 /* not method */ , 0 /* strict match */ ,
1216 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1219 /* Now fix the expression being evaluated */
1220 exp
->elts
[save_pos1
+2].symbol
= symp
;
1221 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1225 /* Not C++, or no overload resolution allowed */
1226 /* nothing to be done; argvec already correctly set up */
1231 /* It is probably a C-style function */
1232 /* nothing to be done; argvec already correctly set up */
1237 if (noside
== EVAL_SKIP
)
1239 if (argvec
[0] == NULL
)
1240 error (_("Cannot evaluate function -- may be inlined"));
1241 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1243 /* If the return type doesn't look like a function type, call an
1244 error. This can happen if somebody tries to turn a variable into
1245 a function call. This is here because people often want to
1246 call, eg, strcmp, which gdb doesn't know is a function. If
1247 gdb isn't asked for it's opinion (ie. through "whatis"),
1248 it won't offer it. */
1250 struct type
*ftype
=
1251 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1254 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1256 error (_("Expression of type other than \"Function returning ...\" used as function"));
1258 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1259 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1261 case OP_F77_UNDETERMINED_ARGLIST
:
1263 /* Remember that in F77, functions, substring ops and
1264 array subscript operations cannot be disambiguated
1265 at parse time. We have made all array subscript operations,
1266 substring operations as well as function calls come here
1267 and we now have to discover what the heck this thing actually was.
1268 If it is a function, we process just as if we got an OP_FUNCALL. */
1270 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1273 /* First determine the type code we are dealing with. */
1274 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1275 type
= check_typedef (value_type (arg1
));
1276 code
= TYPE_CODE (type
);
1278 if (code
== TYPE_CODE_PTR
)
1280 /* Fortran always passes variable to subroutines as pointer.
1281 So we need to look into its target type to see if it is
1282 array, string or function. If it is, we need to switch
1283 to the target value the original one points to. */
1284 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1286 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1287 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1288 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1290 arg1
= value_ind (arg1
);
1291 type
= check_typedef (value_type (arg1
));
1292 code
= TYPE_CODE (type
);
1298 case TYPE_CODE_ARRAY
:
1299 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1300 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1302 goto multi_f77_subscript
;
1304 case TYPE_CODE_STRING
:
1305 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1306 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1309 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1310 return value_subscript (arg1
, arg2
);
1314 case TYPE_CODE_FUNC
:
1315 /* It's a function call. */
1316 /* Allocate arg vector, including space for the function to be
1317 called in argvec[0] and a terminating NULL */
1318 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1321 for (; tem
<= nargs
; tem
++)
1322 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1323 argvec
[tem
] = 0; /* signal end of arglist */
1327 error (_("Cannot perform substring on this type"));
1331 /* We have a complex number, There should be 2 floating
1332 point numbers that compose it */
1333 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1334 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1336 return value_literal_complex (arg1
, arg2
, builtin_type_f_complex_s16
);
1338 case STRUCTOP_STRUCT
:
1339 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1340 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1341 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1342 if (noside
== EVAL_SKIP
)
1344 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1345 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1346 &exp
->elts
[pc
+ 2].string
,
1351 struct value
*temp
= arg1
;
1352 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1357 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1358 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1359 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1360 if (noside
== EVAL_SKIP
)
1363 /* JYG: if print object is on we need to replace the base type
1364 with rtti type in order to continue on with successful
1365 lookup of member / method only available in the rtti type. */
1367 struct type
*type
= value_type (arg1
);
1368 struct type
*real_type
;
1369 int full
, top
, using_enc
;
1371 if (objectprint
&& TYPE_TARGET_TYPE(type
) &&
1372 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1374 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1377 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1378 real_type
= lookup_pointer_type (real_type
);
1380 real_type
= lookup_reference_type (real_type
);
1382 arg1
= value_cast (real_type
, arg1
);
1387 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1388 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1389 &exp
->elts
[pc
+ 2].string
,
1394 struct value
*temp
= arg1
;
1395 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1396 NULL
, "structure pointer");
1399 case STRUCTOP_MEMBER
:
1401 if (op
== STRUCTOP_MEMBER
)
1402 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1404 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1406 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1408 if (noside
== EVAL_SKIP
)
1411 type
= check_typedef (value_type (arg2
));
1412 switch (TYPE_CODE (type
))
1414 case TYPE_CODE_METHODPTR
:
1415 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1416 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1419 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1420 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1421 return value_ind (arg2
);
1424 case TYPE_CODE_MEMBERPTR
:
1425 /* Now, convert these values to an address. */
1426 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1429 mem_offset
= value_as_long (arg2
);
1431 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1432 value_as_long (arg1
) + mem_offset
);
1433 return value_ind (arg3
);
1436 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1440 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1441 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1442 if (noside
== EVAL_SKIP
)
1444 if (binop_user_defined_p (op
, arg1
, arg2
))
1445 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1447 return value_concat (arg1
, arg2
);
1450 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1451 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1453 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1455 if (binop_user_defined_p (op
, arg1
, arg2
))
1456 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1458 return value_assign (arg1
, arg2
);
1460 case BINOP_ASSIGN_MODIFY
:
1462 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1463 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1464 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1466 op
= exp
->elts
[pc
+ 1].opcode
;
1467 if (binop_user_defined_p (op
, arg1
, arg2
))
1468 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1469 else if (op
== BINOP_ADD
)
1470 arg2
= value_add (arg1
, arg2
);
1471 else if (op
== BINOP_SUB
)
1472 arg2
= value_sub (arg1
, arg2
);
1474 arg2
= value_binop (arg1
, arg2
, op
);
1475 return value_assign (arg1
, arg2
);
1478 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1479 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1480 if (noside
== EVAL_SKIP
)
1482 if (binop_user_defined_p (op
, arg1
, arg2
))
1483 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1485 return value_add (arg1
, arg2
);
1488 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1489 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1490 if (noside
== EVAL_SKIP
)
1492 if (binop_user_defined_p (op
, arg1
, arg2
))
1493 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1495 return value_sub (arg1
, arg2
);
1504 case BINOP_BITWISE_AND
:
1505 case BINOP_BITWISE_IOR
:
1506 case BINOP_BITWISE_XOR
:
1507 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1508 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1509 if (noside
== EVAL_SKIP
)
1511 if (binop_user_defined_p (op
, arg1
, arg2
))
1512 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1513 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
1514 && (op
== BINOP_DIV
|| op
== BINOP_REM
|| op
== BINOP_MOD
))
1515 return value_zero (value_type (arg1
), not_lval
);
1517 return value_binop (arg1
, arg2
, op
);
1520 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1521 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1522 if (noside
== EVAL_SKIP
)
1524 error (_("':' operator used in invalid context"));
1526 case BINOP_SUBSCRIPT
:
1527 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1528 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1529 if (noside
== EVAL_SKIP
)
1531 if (binop_user_defined_p (op
, arg1
, arg2
))
1532 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1535 /* If the user attempts to subscript something that is not an
1536 array or pointer type (like a plain int variable for example),
1537 then report this as an error. */
1539 arg1
= coerce_ref (arg1
);
1540 type
= check_typedef (value_type (arg1
));
1541 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1542 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1544 if (TYPE_NAME (type
))
1545 error (_("cannot subscript something of type `%s'"),
1548 error (_("cannot subscript requested type"));
1551 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1552 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1554 return value_subscript (arg1
, arg2
);
1558 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1559 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1560 if (noside
== EVAL_SKIP
)
1562 return value_in (arg1
, arg2
);
1564 case MULTI_SUBSCRIPT
:
1566 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1567 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1570 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1571 /* FIXME: EVAL_SKIP handling may not be correct. */
1572 if (noside
== EVAL_SKIP
)
1583 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1584 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1586 /* If the user attempts to subscript something that has no target
1587 type (like a plain int variable for example), then report this
1590 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1593 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1599 error (_("cannot subscript something of type `%s'"),
1600 TYPE_NAME (value_type (arg1
)));
1604 if (binop_user_defined_p (op
, arg1
, arg2
))
1606 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1610 arg1
= value_subscript (arg1
, arg2
);
1615 multi_f77_subscript
:
1617 int subscript_array
[MAX_FORTRAN_DIMS
];
1618 int array_size_array
[MAX_FORTRAN_DIMS
];
1619 int ndimensions
= 1, i
;
1620 struct type
*tmp_type
;
1621 int offset_item
; /* The array offset where the item lives */
1623 if (nargs
> MAX_FORTRAN_DIMS
)
1624 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1626 tmp_type
= check_typedef (value_type (arg1
));
1627 ndimensions
= calc_f77_array_dims (type
);
1629 if (nargs
!= ndimensions
)
1630 error (_("Wrong number of subscripts"));
1632 /* Now that we know we have a legal array subscript expression
1633 let us actually find out where this element exists in the array. */
1636 /* Take array indices left to right */
1637 for (i
= 0; i
< nargs
; i
++)
1639 /* Evaluate each subscript, It must be a legal integer in F77 */
1640 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1642 /* Fill in the subscript and array size arrays */
1644 subscript_array
[i
] = value_as_long (arg2
);
1647 /* Internal type of array is arranged right to left */
1648 for (i
= 0; i
< nargs
; i
++)
1650 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1651 if (retcode
== BOUND_FETCH_ERROR
)
1652 error (_("Cannot obtain dynamic upper bound"));
1654 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1655 if (retcode
== BOUND_FETCH_ERROR
)
1656 error (_("Cannot obtain dynamic lower bound"));
1658 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
1660 /* Zero-normalize subscripts so that offsetting will work. */
1662 subscript_array
[nargs
- i
- 1] -= lower
;
1664 /* If we are at the bottom of a multidimensional
1665 array type then keep a ptr to the last ARRAY
1666 type around for use when calling value_subscript()
1667 below. This is done because we pretend to value_subscript
1668 that we actually have a one-dimensional array
1669 of base element type that we apply a simple
1673 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1676 /* Now let us calculate the offset for this item */
1678 offset_item
= subscript_array
[ndimensions
- 1];
1680 for (i
= ndimensions
- 1; i
> 0; --i
)
1682 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
1684 /* Construct a value node with the value of the offset */
1686 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
);
1688 /* Let us now play a dirty trick: we will take arg1
1689 which is a value node pointing to the topmost level
1690 of the multidimensional array-set and pretend
1691 that it is actually a array of the final element
1692 type, this will ensure that value_subscript()
1693 returns the correct type value */
1695 deprecated_set_value_type (arg1
, tmp_type
);
1696 return value_ind (value_add (value_coerce_array (arg1
), arg2
));
1699 case BINOP_LOGICAL_AND
:
1700 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1701 if (noside
== EVAL_SKIP
)
1703 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1708 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1711 if (binop_user_defined_p (op
, arg1
, arg2
))
1713 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1714 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1718 tem
= value_logical_not (arg1
);
1719 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1720 (tem
? EVAL_SKIP
: noside
));
1721 return value_from_longest (LA_BOOL_TYPE
,
1722 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
1725 case BINOP_LOGICAL_OR
:
1726 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1727 if (noside
== EVAL_SKIP
)
1729 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1734 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1737 if (binop_user_defined_p (op
, arg1
, arg2
))
1739 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1740 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1744 tem
= value_logical_not (arg1
);
1745 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1746 (!tem
? EVAL_SKIP
: noside
));
1747 return value_from_longest (LA_BOOL_TYPE
,
1748 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
1752 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1753 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1754 if (noside
== EVAL_SKIP
)
1756 if (binop_user_defined_p (op
, arg1
, arg2
))
1758 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1762 tem
= value_equal (arg1
, arg2
);
1763 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1766 case BINOP_NOTEQUAL
:
1767 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1768 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1769 if (noside
== EVAL_SKIP
)
1771 if (binop_user_defined_p (op
, arg1
, arg2
))
1773 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1777 tem
= value_equal (arg1
, arg2
);
1778 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) ! tem
);
1782 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1783 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1784 if (noside
== EVAL_SKIP
)
1786 if (binop_user_defined_p (op
, arg1
, arg2
))
1788 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1792 tem
= value_less (arg1
, arg2
);
1793 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1797 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1798 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1799 if (noside
== EVAL_SKIP
)
1801 if (binop_user_defined_p (op
, arg1
, arg2
))
1803 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1807 tem
= value_less (arg2
, arg1
);
1808 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1812 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1813 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1814 if (noside
== EVAL_SKIP
)
1816 if (binop_user_defined_p (op
, arg1
, arg2
))
1818 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1822 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1823 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1827 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1828 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1829 if (noside
== EVAL_SKIP
)
1831 if (binop_user_defined_p (op
, arg1
, arg2
))
1833 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1837 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1838 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1842 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1843 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1844 if (noside
== EVAL_SKIP
)
1846 type
= check_typedef (value_type (arg2
));
1847 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
1848 error (_("Non-integral right operand for \"@\" operator."));
1849 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1851 return allocate_repeat_value (value_type (arg1
),
1852 longest_to_int (value_as_long (arg2
)));
1855 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1858 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1859 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1862 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1863 if (noside
== EVAL_SKIP
)
1865 if (unop_user_defined_p (op
, arg1
))
1866 return value_x_unop (arg1
, op
, noside
);
1868 return value_pos (arg1
);
1871 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1872 if (noside
== EVAL_SKIP
)
1874 if (unop_user_defined_p (op
, arg1
))
1875 return value_x_unop (arg1
, op
, noside
);
1877 return value_neg (arg1
);
1879 case UNOP_COMPLEMENT
:
1880 /* C++: check for and handle destructor names. */
1881 op
= exp
->elts
[*pos
].opcode
;
1883 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1884 if (noside
== EVAL_SKIP
)
1886 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1887 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1889 return value_complement (arg1
);
1891 case UNOP_LOGICAL_NOT
:
1892 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1893 if (noside
== EVAL_SKIP
)
1895 if (unop_user_defined_p (op
, arg1
))
1896 return value_x_unop (arg1
, op
, noside
);
1898 return value_from_longest (LA_BOOL_TYPE
,
1899 (LONGEST
) value_logical_not (arg1
));
1902 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
1903 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
1904 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1905 type
= check_typedef (value_type (arg1
));
1906 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
1907 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
1908 error (_("Attempt to dereference pointer to member without an object"));
1909 if (noside
== EVAL_SKIP
)
1911 if (unop_user_defined_p (op
, arg1
))
1912 return value_x_unop (arg1
, op
, noside
);
1913 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1915 type
= check_typedef (value_type (arg1
));
1916 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1917 || TYPE_CODE (type
) == TYPE_CODE_REF
1918 /* In C you can dereference an array to get the 1st elt. */
1919 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1921 return value_zero (TYPE_TARGET_TYPE (type
),
1923 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1924 /* GDB allows dereferencing an int. */
1925 return value_zero (builtin_type_int
, lval_memory
);
1927 error (_("Attempt to take contents of a non-pointer value."));
1929 return value_ind (arg1
);
1932 /* C++: check for and handle pointer to members. */
1934 op
= exp
->elts
[*pos
].opcode
;
1936 if (noside
== EVAL_SKIP
)
1938 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1943 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
1948 if (noside
== EVAL_SKIP
)
1950 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1953 return evaluate_subexp_for_sizeof (exp
, pos
);
1957 type
= exp
->elts
[pc
+ 1].type
;
1958 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
1959 if (noside
== EVAL_SKIP
)
1961 if (type
!= value_type (arg1
))
1962 arg1
= value_cast (type
, arg1
);
1967 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1968 if (noside
== EVAL_SKIP
)
1970 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1971 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
1973 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
1974 value_as_address (arg1
));
1976 case UNOP_MEMVAL_TLS
:
1978 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1979 if (noside
== EVAL_SKIP
)
1981 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1982 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
1986 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
1987 value_as_address (arg1
));
1988 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
1991 case UNOP_PREINCREMENT
:
1992 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1993 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1995 else if (unop_user_defined_p (op
, arg1
))
1997 return value_x_unop (arg1
, op
, noside
);
2001 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
2003 return value_assign (arg1
, arg2
);
2006 case UNOP_PREDECREMENT
:
2007 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2008 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2010 else if (unop_user_defined_p (op
, arg1
))
2012 return value_x_unop (arg1
, op
, noside
);
2016 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2018 return value_assign (arg1
, arg2
);
2021 case UNOP_POSTINCREMENT
:
2022 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2023 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2025 else if (unop_user_defined_p (op
, arg1
))
2027 return value_x_unop (arg1
, op
, noside
);
2031 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
2033 value_assign (arg1
, arg2
);
2037 case UNOP_POSTDECREMENT
:
2038 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2039 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2041 else if (unop_user_defined_p (op
, arg1
))
2043 return value_x_unop (arg1
, op
, noside
);
2047 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2049 value_assign (arg1
, arg2
);
2055 return value_of_this (1);
2059 return value_of_local ("self", 1);
2062 /* The value is not supposed to be used. This is here to make it
2063 easier to accommodate expressions that contain types. */
2065 if (noside
== EVAL_SKIP
)
2067 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2068 return allocate_value (exp
->elts
[pc
+ 1].type
);
2070 error (_("Attempt to use a type name as an expression"));
2073 /* Removing this case and compiling with gcc -Wall reveals that
2074 a lot of cases are hitting this case. Some of these should
2075 probably be removed from expression.h; others are legitimate
2076 expressions which are (apparently) not fully implemented.
2078 If there are any cases landing here which mean a user error,
2079 then they should be separate cases, with more descriptive
2083 GDB does not (yet) know how to evaluate that kind of expression"));
2087 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
2090 /* Evaluate a subexpression of EXP, at index *POS,
2091 and return the address of that subexpression.
2092 Advance *POS over the subexpression.
2093 If the subexpression isn't an lvalue, get an error.
2094 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2095 then only the type of the result need be correct. */
2097 static struct value
*
2098 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2108 op
= exp
->elts
[pc
].opcode
;
2114 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2116 /* We can't optimize out "&*" if there's a user-defined operator*. */
2117 if (unop_user_defined_p (op
, x
))
2119 x
= value_x_unop (x
, op
, noside
);
2120 goto default_case_after_eval
;
2127 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2128 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2131 var
= exp
->elts
[pc
+ 2].symbol
;
2133 /* C++: The "address" of a reference should yield the address
2134 * of the object pointed to. Let value_addr() deal with it. */
2135 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2139 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2142 lookup_pointer_type (SYMBOL_TYPE (var
));
2143 enum address_class sym_class
= SYMBOL_CLASS (var
);
2145 if (sym_class
== LOC_CONST
2146 || sym_class
== LOC_CONST_BYTES
2147 || sym_class
== LOC_REGISTER
2148 || sym_class
== LOC_REGPARM
)
2149 error (_("Attempt to take address of register or constant."));
2152 value_zero (type
, not_lval
);
2158 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2161 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2162 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2163 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2164 &exp
->elts
[pc
+ 3].string
,
2167 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2172 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2173 default_case_after_eval
:
2174 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2176 struct type
*type
= check_typedef (value_type (x
));
2178 if (VALUE_LVAL (x
) == lval_memory
)
2179 return value_zero (lookup_pointer_type (value_type (x
)),
2181 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2182 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2185 error (_("Attempt to take address of non-lval"));
2187 return value_addr (x
);
2191 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2192 When used in contexts where arrays will be coerced anyway, this is
2193 equivalent to `evaluate_subexp' but much faster because it avoids
2194 actually fetching array contents (perhaps obsolete now that we have
2197 Note that we currently only do the coercion for C expressions, where
2198 arrays are zero based and the coercion is correct. For other languages,
2199 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2200 to decide if coercion is appropriate.
2205 evaluate_subexp_with_coercion (struct expression
*exp
,
2206 int *pos
, enum noside noside
)
2214 op
= exp
->elts
[pc
].opcode
;
2219 var
= exp
->elts
[pc
+ 2].symbol
;
2220 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
2221 && CAST_IS_CONVERSION
)
2226 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2227 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
2233 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2237 /* Evaluate a subexpression of EXP, at index *POS,
2238 and return a value for the size of that subexpression.
2239 Advance *POS over the subexpression. */
2241 static struct value
*
2242 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2250 op
= exp
->elts
[pc
].opcode
;
2254 /* This case is handled specially
2255 so that we avoid creating a value for the result type.
2256 If the result type is very big, it's desirable not to
2257 create a value unnecessarily. */
2260 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2261 type
= check_typedef (value_type (val
));
2262 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2263 && TYPE_CODE (type
) != TYPE_CODE_REF
2264 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2265 error (_("Attempt to take contents of a non-pointer value."));
2266 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2267 return value_from_longest (builtin_type_int
, (LONGEST
)
2268 TYPE_LENGTH (type
));
2272 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2273 return value_from_longest (builtin_type_int
,
2274 (LONGEST
) TYPE_LENGTH (type
));
2278 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2280 value_from_longest (builtin_type_int
, (LONGEST
) TYPE_LENGTH (type
));
2283 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2284 return value_from_longest (builtin_type_int
,
2285 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2289 /* Parse a type expression in the string [P..P+LENGTH). */
2292 parse_and_eval_type (char *p
, int length
)
2294 char *tmp
= (char *) alloca (length
+ 4);
2295 struct expression
*expr
;
2297 memcpy (tmp
+ 1, p
, length
);
2298 tmp
[length
+ 1] = ')';
2299 tmp
[length
+ 2] = '0';
2300 tmp
[length
+ 3] = '\0';
2301 expr
= parse_expression (tmp
);
2302 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2303 error (_("Internal error in eval_type."));
2304 return expr
->elts
[1].type
;
2308 calc_f77_array_dims (struct type
*array_type
)
2311 struct type
*tmp_type
;
2313 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2314 error (_("Can't get dimensions for a non-array type"));
2316 tmp_type
= array_type
;
2318 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2320 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)