1 /* Evaluate expressions for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
28 #include "expression.h"
31 #include "language.h" /* For CAST_IS_CONVERSION */
32 #include "f-lang.h" /* for array bound stuff */
35 /* Defined in symtab.c */
36 extern int hp_som_som_object_present
;
38 /* This is defined in valops.c */
39 extern int overload_resolution
;
41 /* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
42 on with successful lookup for member/method of the rtti type. */
43 extern int objectprint
;
45 /* Prototypes for local functions. */
47 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
49 static struct value
*evaluate_subexp_for_address (struct expression
*,
52 static struct value
*evaluate_subexp (struct type
*, struct expression
*,
55 static char *get_label (struct expression
*, int *);
57 static struct value
*evaluate_struct_tuple (struct value
*,
58 struct expression
*, int *,
61 static LONGEST
init_array_element (struct value
*, struct value
*,
62 struct expression
*, int *, enum noside
,
66 evaluate_subexp (struct type
*expect_type
, register struct expression
*exp
,
67 register int *pos
, enum noside noside
)
69 return (*exp
->language_defn
->evaluate_exp
) (expect_type
, exp
, pos
, noside
);
72 /* Parse the string EXP as a C expression, evaluate it,
73 and return the result as a number. */
76 parse_and_eval_address (char *exp
)
78 struct expression
*expr
= parse_expression (exp
);
79 register CORE_ADDR addr
;
80 register struct cleanup
*old_chain
=
81 make_cleanup (free_current_contents
, &expr
);
83 addr
= value_as_address (evaluate_expression (expr
));
84 do_cleanups (old_chain
);
88 /* Like parse_and_eval_address but takes a pointer to a char * variable
89 and advanced that variable across the characters parsed. */
92 parse_and_eval_address_1 (char **expptr
)
94 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*) 0, 0);
95 register CORE_ADDR addr
;
96 register struct cleanup
*old_chain
=
97 make_cleanup (free_current_contents
, &expr
);
99 addr
= value_as_address (evaluate_expression (expr
));
100 do_cleanups (old_chain
);
104 /* Like parse_and_eval_address, but treats the value of the expression
105 as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
107 parse_and_eval_long (char *exp
)
109 struct expression
*expr
= parse_expression (exp
);
110 register LONGEST retval
;
111 register struct cleanup
*old_chain
=
112 make_cleanup (free_current_contents
, &expr
);
114 retval
= value_as_long (evaluate_expression (expr
));
115 do_cleanups (old_chain
);
120 parse_and_eval (char *exp
)
122 struct expression
*expr
= parse_expression (exp
);
124 register struct cleanup
*old_chain
=
125 make_cleanup (free_current_contents
, &expr
);
127 val
= evaluate_expression (expr
);
128 do_cleanups (old_chain
);
132 /* Parse up to a comma (or to a closeparen)
133 in the string EXPP as an expression, evaluate it, and return the value.
134 EXPP is advanced to point to the comma. */
137 parse_to_comma_and_eval (char **expp
)
139 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
141 register struct cleanup
*old_chain
=
142 make_cleanup (free_current_contents
, &expr
);
144 val
= evaluate_expression (expr
);
145 do_cleanups (old_chain
);
149 /* Evaluate an expression in internal prefix form
150 such as is constructed by parse.y.
152 See expression.h for info on the format of an expression. */
155 evaluate_expression (struct expression
*exp
)
158 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
161 /* Evaluate an expression, avoiding all memory references
162 and getting a value whose type alone is correct. */
165 evaluate_type (struct expression
*exp
)
168 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
171 /* If the next expression is an OP_LABELED, skips past it,
172 returning the label. Otherwise, does nothing and returns NULL. */
175 get_label (register struct expression
*exp
, int *pos
)
177 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
180 char *name
= &exp
->elts
[pc
+ 2].string
;
181 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
182 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
189 /* This function evaluates tuples (in (OBSOLETE) Chill) or
190 brace-initializers (in C/C++) for structure types. */
192 static struct value
*
193 evaluate_struct_tuple (struct value
*struct_val
,
194 register struct expression
*exp
,
195 register int *pos
, enum noside noside
, int nargs
)
197 struct type
*struct_type
= check_typedef (VALUE_TYPE (struct_val
));
198 struct type
*substruct_type
= struct_type
;
199 struct type
*field_type
;
206 struct value
*val
= NULL
;
211 /* Skip past the labels, and count them. */
212 while (get_label (exp
, pos
) != NULL
)
217 char *label
= get_label (exp
, &pc
);
220 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
223 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
224 if (field_name
!= NULL
&& STREQ (field_name
, label
))
227 subfieldno
= fieldno
;
228 substruct_type
= struct_type
;
232 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
235 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
236 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
237 if ((field_name
== 0 || *field_name
== '\0')
238 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
241 for (; variantno
< TYPE_NFIELDS (field_type
);
245 = TYPE_FIELD_TYPE (field_type
, variantno
);
246 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
249 subfieldno
< TYPE_NFIELDS (substruct_type
);
252 if (STREQ (TYPE_FIELD_NAME (substruct_type
,
263 error ("there is no field named %s", label
);
269 /* Unlabelled tuple element - go to next field. */
273 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
276 substruct_type
= struct_type
;
282 subfieldno
= fieldno
;
283 if (fieldno
>= TYPE_NFIELDS (struct_type
))
284 error ("too many initializers");
285 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
286 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
287 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
288 error ("don't know which variant you want to set");
292 /* Here, struct_type is the type of the inner struct,
293 while substruct_type is the type of the inner struct.
294 These are the same for normal structures, but a variant struct
295 contains anonymous union fields that contain substruct fields.
296 The value fieldno is the index of the top-level (normal or
297 anonymous union) field in struct_field, while the value
298 subfieldno is the index of the actual real (named inner) field
299 in substruct_type. */
301 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
303 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
305 /* Now actually set the field in struct_val. */
307 /* Assign val to field fieldno. */
308 if (VALUE_TYPE (val
) != field_type
)
309 val
= value_cast (field_type
, val
);
311 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
312 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
314 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
315 addr
= VALUE_CONTENTS (struct_val
) + bitpos
/ 8;
317 modify_field (addr
, value_as_long (val
),
318 bitpos
% 8, bitsize
);
320 memcpy (addr
, VALUE_CONTENTS (val
),
321 TYPE_LENGTH (VALUE_TYPE (val
)));
323 while (--nlabels
> 0);
328 /* Recursive helper function for setting elements of array tuples for
329 (OBSOLETE) Chill. The target is ARRAY (which has bounds LOW_BOUND
330 to HIGH_BOUND); the element value is ELEMENT; EXP, POS and NOSIDE
331 are as usual. Evaluates index expresions and sets the specified
332 element(s) of ARRAY to ELEMENT. Returns last index value. */
335 init_array_element (struct value
*array
, struct value
*element
,
336 register struct expression
*exp
, register int *pos
,
337 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
340 int element_size
= TYPE_LENGTH (VALUE_TYPE (element
));
341 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
344 init_array_element (array
, element
, exp
, pos
, noside
,
345 low_bound
, high_bound
);
346 return init_array_element (array
, element
,
347 exp
, pos
, noside
, low_bound
, high_bound
);
349 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
353 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
354 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
355 if (low
< low_bound
|| high
> high_bound
)
356 error ("tuple range index out of range");
357 for (index
= low
; index
<= high
; index
++)
359 memcpy (VALUE_CONTENTS_RAW (array
)
360 + (index
- low_bound
) * element_size
,
361 VALUE_CONTENTS (element
), element_size
);
366 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
367 if (index
< low_bound
|| index
> high_bound
)
368 error ("tuple index out of range");
369 memcpy (VALUE_CONTENTS_RAW (array
) + (index
- low_bound
) * element_size
,
370 VALUE_CONTENTS (element
), element_size
);
376 evaluate_subexp_standard (struct type
*expect_type
,
377 register struct expression
*exp
, register int *pos
,
382 register int pc
, pc2
= 0, oldpos
;
383 struct value
*arg1
= NULL
;
384 struct value
*arg2
= NULL
;
388 struct value
**argvec
;
389 int upper
, lower
, retcode
;
393 struct type
**arg_types
;
397 op
= exp
->elts
[pc
].opcode
;
402 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
403 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
404 arg1
= value_struct_elt_for_reference (exp
->elts
[pc
+ 1].type
,
406 exp
->elts
[pc
+ 1].type
,
407 &exp
->elts
[pc
+ 3].string
,
410 error ("There is no field named %s", &exp
->elts
[pc
+ 3].string
);
415 return value_from_longest (exp
->elts
[pc
+ 1].type
,
416 exp
->elts
[pc
+ 2].longconst
);
420 return value_from_double (exp
->elts
[pc
+ 1].type
,
421 exp
->elts
[pc
+ 2].doubleconst
);
425 if (noside
== EVAL_SKIP
)
428 /* JYG: We used to just return value_zero of the symbol type
429 if we're asked to avoid side effects. Otherwise we return
430 value_of_variable (...). However I'm not sure if
431 value_of_variable () has any side effect.
432 We need a full value object returned here for whatis_exp ()
433 to call evaluate_type () and then pass the full value to
434 value_rtti_target_type () if we are dealing with a pointer
435 or reference to a base class and print object is on. */
437 return value_of_variable (exp
->elts
[pc
+ 2].symbol
,
438 exp
->elts
[pc
+ 1].block
);
443 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
447 int regno
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
448 struct value
*val
= value_of_register (regno
, selected_frame
);
451 error ("Value of register %s not available.", REGISTER_NAME (regno
));
457 return value_from_longest (LA_BOOL_TYPE
,
458 exp
->elts
[pc
+ 1].longconst
);
462 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
465 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
466 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
467 if (noside
== EVAL_SKIP
)
469 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
472 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
474 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
475 if (noside
== EVAL_SKIP
)
477 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
482 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
483 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
484 nargs
= tem3
- tem2
+ 1;
485 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
487 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
488 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
490 struct value
*rec
= allocate_value (expect_type
);
491 memset (VALUE_CONTENTS_RAW (rec
), '\0', TYPE_LENGTH (type
));
492 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
495 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
496 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
498 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
499 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
500 struct value
*array
= allocate_value (expect_type
);
501 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
502 LONGEST low_bound
, high_bound
, index
;
503 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
506 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
509 memset (VALUE_CONTENTS_RAW (array
), 0, TYPE_LENGTH (expect_type
));
510 for (tem
= nargs
; --nargs
>= 0;)
512 struct value
*element
;
514 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
517 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
519 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
520 if (VALUE_TYPE (element
) != element_type
)
521 element
= value_cast (element_type
, element
);
524 int continue_pc
= *pos
;
526 index
= init_array_element (array
, element
, exp
, pos
, noside
,
527 low_bound
, high_bound
);
532 if (index
> high_bound
)
533 /* to avoid memory corruption */
534 error ("Too many array elements");
535 memcpy (VALUE_CONTENTS_RAW (array
)
536 + (index
- low_bound
) * element_size
,
537 VALUE_CONTENTS (element
),
545 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
546 && TYPE_CODE (type
) == TYPE_CODE_SET
)
548 struct value
*set
= allocate_value (expect_type
);
549 char *valaddr
= VALUE_CONTENTS_RAW (set
);
550 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
551 struct type
*check_type
= element_type
;
552 LONGEST low_bound
, high_bound
;
554 /* get targettype of elementtype */
555 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
556 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
557 check_type
= TYPE_TARGET_TYPE (check_type
);
559 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
560 error ("(power)set type with unknown size");
561 memset (valaddr
, '\0', TYPE_LENGTH (type
));
562 for (tem
= 0; tem
< nargs
; tem
++)
564 LONGEST range_low
, range_high
;
565 struct type
*range_low_type
, *range_high_type
;
566 struct value
*elem_val
;
567 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
570 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
571 range_low_type
= VALUE_TYPE (elem_val
);
572 range_low
= value_as_long (elem_val
);
573 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
574 range_high_type
= VALUE_TYPE (elem_val
);
575 range_high
= value_as_long (elem_val
);
579 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
580 range_low_type
= range_high_type
= VALUE_TYPE (elem_val
);
581 range_low
= range_high
= value_as_long (elem_val
);
583 /* check types of elements to avoid mixture of elements from
584 different types. Also check if type of element is "compatible"
585 with element type of powerset */
586 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
587 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
588 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
589 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
590 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
591 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
592 (range_low_type
!= range_high_type
)))
593 /* different element modes */
594 error ("POWERSET tuple elements of different mode");
595 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
596 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
597 range_low_type
!= check_type
))
598 error ("incompatible POWERSET tuple elements");
599 if (range_low
> range_high
)
601 warning ("empty POWERSET tuple range");
604 if (range_low
< low_bound
|| range_high
> high_bound
)
605 error ("POWERSET tuple element out of range");
606 range_low
-= low_bound
;
607 range_high
-= low_bound
;
608 for (; range_low
<= range_high
; range_low
++)
610 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
612 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
613 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
620 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
621 for (tem
= 0; tem
< nargs
; tem
++)
623 /* Ensure that array expressions are coerced into pointer objects. */
624 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
626 if (noside
== EVAL_SKIP
)
628 return value_array (tem2
, tem3
, argvec
);
632 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
634 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
636 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
637 if (noside
== EVAL_SKIP
)
639 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
642 case TERNOP_SLICE_COUNT
:
644 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
646 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
648 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
649 return value_slice (array
, lowbound
, length
);
653 /* Skip third and second args to evaluate the first one. */
654 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
655 if (value_logical_not (arg1
))
657 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
658 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
662 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
663 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
669 op
= exp
->elts
[*pos
].opcode
;
670 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
671 /* Allocate arg vector, including space for the function to be
672 called in argvec[0] and a terminating NULL */
673 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
674 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
678 /* 1997-08-01 Currently we do not support function invocation
679 via pointers-to-methods with HP aCC. Pointer does not point
680 to the function, but possibly to some thunk. */
681 if (hp_som_som_object_present
)
683 error ("Not implemented: function invocation through pointer to method with HP aCC");
687 /* First, evaluate the structure into arg2 */
690 if (noside
== EVAL_SKIP
)
693 if (op
== STRUCTOP_MEMBER
)
695 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
699 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
702 /* If the function is a virtual function, then the
703 aggregate value (providing the structure) plays
704 its part by providing the vtable. Otherwise,
705 it is just along for the ride: call the function
708 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
710 fnptr
= value_as_long (arg1
);
712 if (METHOD_PTR_IS_VIRTUAL (fnptr
))
714 int fnoffset
= METHOD_PTR_TO_VOFFSET (fnptr
);
715 struct type
*basetype
;
716 struct type
*domain_type
=
717 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
719 basetype
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
720 if (domain_type
!= basetype
)
721 arg2
= value_cast (lookup_pointer_type (domain_type
), arg2
);
722 basetype
= TYPE_VPTR_BASETYPE (domain_type
);
723 for (i
= TYPE_NFN_FIELDS (basetype
) - 1; i
>= 0; i
--)
725 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (basetype
, i
);
726 /* If one is virtual, then all are virtual. */
727 if (TYPE_FN_FIELD_VIRTUAL_P (f
, 0))
728 for (j
= TYPE_FN_FIELDLIST_LENGTH (basetype
, i
) - 1; j
>= 0; --j
)
729 if ((int) TYPE_FN_FIELD_VOFFSET (f
, j
) == fnoffset
)
731 struct value
*temp
= value_ind (arg2
);
732 arg1
= value_virtual_fn_field (&temp
, f
, j
, domain_type
, 0);
733 arg2
= value_addr (temp
);
738 error ("virtual function at index %d not found", fnoffset
);
742 VALUE_TYPE (arg1
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
746 /* Now, say which argument to start evaluating from */
749 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
751 /* Hair for method invocations */
755 /* First, evaluate the structure into arg2 */
757 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
758 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
759 if (noside
== EVAL_SKIP
)
762 if (op
== STRUCTOP_STRUCT
)
764 /* If v is a variable in a register, and the user types
765 v.method (), this will produce an error, because v has
768 A possible way around this would be to allocate a
769 copy of the variable on the stack, copy in the
770 contents, call the function, and copy out the
771 contents. I.e. convert this from call by reference
772 to call by copy-return (or whatever it's called).
773 However, this does not work because it is not the
774 same: the method being called could stash a copy of
775 the address, and then future uses through that address
776 (after the method returns) would be expected to
777 use the variable itself, not some copy of it. */
778 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
782 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
784 /* Now, say which argument to start evaluating from */
789 /* Non-method function call */
791 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
793 type
= VALUE_TYPE (argvec
[0]);
794 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
795 type
= TYPE_TARGET_TYPE (type
);
796 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
798 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
800 /* pai: FIXME This seems to be coercing arguments before
801 * overload resolution has been done! */
802 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
808 /* Evaluate arguments */
809 for (; tem
<= nargs
; tem
++)
811 /* Ensure that array expressions are coerced into pointer objects. */
812 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
815 /* signal end of arglist */
818 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
823 /* Method invocation : stuff "this" as first parameter */
825 /* Name of method from expression */
826 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
828 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
830 /* Language is C++, do some overload resolution before evaluation */
831 struct value
*valp
= NULL
;
833 /* Prepare list of argument types for overload resolution */
834 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
835 for (ix
= 1; ix
<= nargs
; ix
++)
836 arg_types
[ix
- 1] = VALUE_TYPE (argvec
[ix
]);
838 (void) find_overload_match (arg_types
, nargs
, tstr
,
839 1 /* method */ , 0 /* strict match */ ,
840 &arg2
/* the object */ , NULL
,
841 &valp
, NULL
, &static_memfuncp
);
844 argvec
[1] = arg2
; /* the ``this'' pointer */
845 argvec
[0] = valp
; /* use the method found after overload resolution */
848 /* Non-C++ case -- or no overload resolution */
850 struct value
*temp
= arg2
;
851 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
853 op
== STRUCTOP_STRUCT
854 ? "structure" : "structure pointer");
855 /* value_struct_elt updates temp with the correct value
856 of the ``this'' pointer if necessary, so modify argvec[1] to
857 reflect any ``this'' changes. */
858 arg2
= value_from_longest (lookup_pointer_type(VALUE_TYPE (temp
)),
859 VALUE_ADDRESS (temp
) + VALUE_OFFSET (temp
)
860 + VALUE_EMBEDDED_OFFSET (temp
));
861 argvec
[1] = arg2
; /* the ``this'' pointer */
866 argvec
[1] = argvec
[0];
871 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
876 else if (op
== OP_VAR_VALUE
)
878 /* Non-member function being called */
879 /* fn: This can only be done for C++ functions. A C-style function
880 in a C++ program, for instance, does not have the fields that
883 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
885 /* Language is C++, do some overload resolution before evaluation */
888 /* Prepare list of argument types for overload resolution */
889 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
890 for (ix
= 1; ix
<= nargs
; ix
++)
891 arg_types
[ix
- 1] = VALUE_TYPE (argvec
[ix
]);
893 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
894 0 /* not method */ , 0 /* strict match */ ,
895 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
898 /* Now fix the expression being evaluated */
899 exp
->elts
[save_pos1
+2].symbol
= symp
;
900 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
904 /* Not C++, or no overload resolution allowed */
905 /* nothing to be done; argvec already correctly set up */
910 /* It is probably a C-style function */
911 /* nothing to be done; argvec already correctly set up */
916 if (noside
== EVAL_SKIP
)
918 if (argvec
[0] == NULL
)
919 error ("Cannot evaluate function -- may be inlined");
920 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
922 /* If the return type doesn't look like a function type, call an
923 error. This can happen if somebody tries to turn a variable into
924 a function call. This is here because people often want to
925 call, eg, strcmp, which gdb doesn't know is a function. If
926 gdb isn't asked for it's opinion (ie. through "whatis"),
927 it won't offer it. */
930 TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0]));
933 return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0])));
935 error ("Expression of type other than \"Function returning ...\" used as function");
937 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
938 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
940 case OP_F77_UNDETERMINED_ARGLIST
:
942 /* Remember that in F77, functions, substring ops and
943 array subscript operations cannot be disambiguated
944 at parse time. We have made all array subscript operations,
945 substring operations as well as function calls come here
946 and we now have to discover what the heck this thing actually was.
947 If it is a function, we process just as if we got an OP_FUNCALL. */
949 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
952 /* First determine the type code we are dealing with. */
953 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
954 type
= check_typedef (VALUE_TYPE (arg1
));
955 code
= TYPE_CODE (type
);
959 case TYPE_CODE_ARRAY
:
960 goto multi_f77_subscript
;
962 case TYPE_CODE_STRING
:
967 /* It's a function call. */
968 /* Allocate arg vector, including space for the function to be
969 called in argvec[0] and a terminating NULL */
970 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
973 for (; tem
<= nargs
; tem
++)
974 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
975 argvec
[tem
] = 0; /* signal end of arglist */
979 error ("Cannot perform substring on this type");
983 /* We have a substring operation on our hands here,
984 let us get the string we will be dealing with */
986 /* Now evaluate the 'from' and 'to' */
988 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
991 return value_subscript (arg1
, arg2
);
993 arg3
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
995 if (noside
== EVAL_SKIP
)
998 tem2
= value_as_long (arg2
);
999 tem3
= value_as_long (arg3
);
1001 return value_slice (arg1
, tem2
, tem3
- tem2
+ 1);
1004 /* We have a complex number, There should be 2 floating
1005 point numbers that compose it */
1006 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1007 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1009 return value_literal_complex (arg1
, arg2
, builtin_type_f_complex_s16
);
1011 case STRUCTOP_STRUCT
:
1012 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1013 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1014 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1015 if (noside
== EVAL_SKIP
)
1017 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1018 return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1
),
1019 &exp
->elts
[pc
+ 2].string
,
1024 struct value
*temp
= arg1
;
1025 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1030 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1031 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1032 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1033 if (noside
== EVAL_SKIP
)
1036 /* JYG: if print object is on we need to replace the base type
1037 with rtti type in order to continue on with successful
1038 lookup of member / method only available in the rtti type. */
1040 struct type
*type
= VALUE_TYPE (arg1
);
1041 struct type
*real_type
;
1042 int full
, top
, using_enc
;
1044 if (objectprint
&& TYPE_TARGET_TYPE(type
) &&
1045 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1047 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1050 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1051 real_type
= lookup_pointer_type (real_type
);
1053 real_type
= lookup_reference_type (real_type
);
1055 arg1
= value_cast (real_type
, arg1
);
1060 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1061 return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1
),
1062 &exp
->elts
[pc
+ 2].string
,
1067 struct value
*temp
= arg1
;
1068 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1069 NULL
, "structure pointer");
1072 case STRUCTOP_MEMBER
:
1073 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1074 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1076 /* With HP aCC, pointers to methods do not point to the function code */
1077 if (hp_som_som_object_present
&&
1078 (TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_PTR
) &&
1079 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2
))) == TYPE_CODE_METHOD
))
1080 error ("Pointers to methods not supported with HP aCC"); /* 1997-08-19 */
1082 mem_offset
= value_as_long (arg2
);
1083 goto handle_pointer_to_member
;
1086 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1087 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1089 /* With HP aCC, pointers to methods do not point to the function code */
1090 if (hp_som_som_object_present
&&
1091 (TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_PTR
) &&
1092 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2
))) == TYPE_CODE_METHOD
))
1093 error ("Pointers to methods not supported with HP aCC"); /* 1997-08-19 */
1095 mem_offset
= value_as_long (arg2
);
1097 handle_pointer_to_member
:
1098 /* HP aCC generates offsets that have bit #29 set; turn it off to get
1099 a real offset to the member. */
1100 if (hp_som_som_object_present
)
1102 if (!mem_offset
) /* no bias -> really null */
1103 error ("Attempted dereference of null pointer-to-member");
1104 mem_offset
&= ~0x20000000;
1106 if (noside
== EVAL_SKIP
)
1108 type
= check_typedef (VALUE_TYPE (arg2
));
1109 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
1110 goto bad_pointer_to_member
;
1111 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1112 if (TYPE_CODE (type
) == TYPE_CODE_METHOD
)
1113 error ("not implemented: pointer-to-method in pointer-to-member construct");
1114 if (TYPE_CODE (type
) != TYPE_CODE_MEMBER
)
1115 goto bad_pointer_to_member
;
1116 /* Now, convert these values to an address. */
1117 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1119 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1120 value_as_long (arg1
) + mem_offset
);
1121 return value_ind (arg3
);
1122 bad_pointer_to_member
:
1123 error ("non-pointer-to-member value used in pointer-to-member construct");
1126 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1127 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1128 if (noside
== EVAL_SKIP
)
1130 if (binop_user_defined_p (op
, arg1
, arg2
))
1131 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1133 return value_concat (arg1
, arg2
);
1136 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1137 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1139 /* Do special stuff for HP aCC pointers to members */
1140 if (hp_som_som_object_present
)
1142 /* 1997-08-19 Can't assign HP aCC pointers to methods. No details of
1143 the implementation yet; but the pointer appears to point to a code
1144 sequence (thunk) in memory -- in any case it is *not* the address
1145 of the function as it would be in a naive implementation. */
1146 if ((TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
) &&
1147 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_METHOD
))
1148 error ("Assignment to pointers to methods not implemented with HP aCC");
1150 /* HP aCC pointers to data members require a constant bias */
1151 if ((TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
) &&
1152 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_MEMBER
))
1154 unsigned int *ptr
= (unsigned int *) VALUE_CONTENTS (arg2
); /* forces evaluation */
1155 *ptr
|= 0x20000000; /* set 29th bit */
1159 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1161 if (binop_user_defined_p (op
, arg1
, arg2
))
1162 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1164 return value_assign (arg1
, arg2
);
1166 case BINOP_ASSIGN_MODIFY
:
1168 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1169 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1170 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1172 op
= exp
->elts
[pc
+ 1].opcode
;
1173 if (binop_user_defined_p (op
, arg1
, arg2
))
1174 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1175 else if (op
== BINOP_ADD
)
1176 arg2
= value_add (arg1
, arg2
);
1177 else if (op
== BINOP_SUB
)
1178 arg2
= value_sub (arg1
, arg2
);
1180 arg2
= value_binop (arg1
, arg2
, op
);
1181 return value_assign (arg1
, arg2
);
1184 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1185 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1186 if (noside
== EVAL_SKIP
)
1188 if (binop_user_defined_p (op
, arg1
, arg2
))
1189 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1191 return value_add (arg1
, arg2
);
1194 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1195 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1196 if (noside
== EVAL_SKIP
)
1198 if (binop_user_defined_p (op
, arg1
, arg2
))
1199 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1201 return value_sub (arg1
, arg2
);
1209 case BINOP_BITWISE_AND
:
1210 case BINOP_BITWISE_IOR
:
1211 case BINOP_BITWISE_XOR
:
1212 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1213 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1214 if (noside
== EVAL_SKIP
)
1216 if (binop_user_defined_p (op
, arg1
, arg2
))
1217 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1218 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
1219 && (op
== BINOP_DIV
|| op
== BINOP_REM
|| op
== BINOP_MOD
))
1220 return value_zero (VALUE_TYPE (arg1
), not_lval
);
1222 return value_binop (arg1
, arg2
, op
);
1225 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1226 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1227 if (noside
== EVAL_SKIP
)
1229 error ("':' operator used in invalid context");
1231 case BINOP_SUBSCRIPT
:
1232 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1233 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1234 if (noside
== EVAL_SKIP
)
1236 if (binop_user_defined_p (op
, arg1
, arg2
))
1237 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1240 /* If the user attempts to subscript something that is not an
1241 array or pointer type (like a plain int variable for example),
1242 then report this as an error. */
1245 type
= check_typedef (VALUE_TYPE (arg1
));
1246 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1247 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1249 if (TYPE_NAME (type
))
1250 error ("cannot subscript something of type `%s'",
1253 error ("cannot subscript requested type");
1256 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1257 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1259 return value_subscript (arg1
, arg2
);
1263 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1264 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1265 if (noside
== EVAL_SKIP
)
1267 return value_in (arg1
, arg2
);
1269 case MULTI_SUBSCRIPT
:
1271 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1272 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1275 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1276 /* FIXME: EVAL_SKIP handling may not be correct. */
1277 if (noside
== EVAL_SKIP
)
1288 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1289 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1291 /* If the user attempts to subscript something that has no target
1292 type (like a plain int variable for example), then report this
1295 type
= TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1
)));
1298 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1304 error ("cannot subscript something of type `%s'",
1305 TYPE_NAME (VALUE_TYPE (arg1
)));
1309 if (binop_user_defined_p (op
, arg1
, arg2
))
1311 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1315 arg1
= value_subscript (arg1
, arg2
);
1320 multi_f77_subscript
:
1322 int subscript_array
[MAX_FORTRAN_DIMS
+ 1]; /* 1-based array of
1323 subscripts, max == 7 */
1324 int array_size_array
[MAX_FORTRAN_DIMS
+ 1];
1325 int ndimensions
= 1, i
;
1326 struct type
*tmp_type
;
1327 int offset_item
; /* The array offset where the item lives */
1329 if (nargs
> MAX_FORTRAN_DIMS
)
1330 error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS
);
1332 tmp_type
= check_typedef (VALUE_TYPE (arg1
));
1333 ndimensions
= calc_f77_array_dims (type
);
1335 if (nargs
!= ndimensions
)
1336 error ("Wrong number of subscripts");
1338 /* Now that we know we have a legal array subscript expression
1339 let us actually find out where this element exists in the array. */
1342 for (i
= 1; i
<= nargs
; i
++)
1344 /* Evaluate each subscript, It must be a legal integer in F77 */
1345 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1347 /* Fill in the subscript and array size arrays */
1349 subscript_array
[i
] = value_as_long (arg2
);
1351 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1352 if (retcode
== BOUND_FETCH_ERROR
)
1353 error ("Cannot obtain dynamic upper bound");
1355 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1356 if (retcode
== BOUND_FETCH_ERROR
)
1357 error ("Cannot obtain dynamic lower bound");
1359 array_size_array
[i
] = upper
- lower
+ 1;
1361 /* Zero-normalize subscripts so that offsetting will work. */
1363 subscript_array
[i
] -= lower
;
1365 /* If we are at the bottom of a multidimensional
1366 array type then keep a ptr to the last ARRAY
1367 type around for use when calling value_subscript()
1368 below. This is done because we pretend to value_subscript
1369 that we actually have a one-dimensional array
1370 of base element type that we apply a simple
1374 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1377 /* Now let us calculate the offset for this item */
1379 offset_item
= subscript_array
[ndimensions
];
1381 for (i
= ndimensions
- 1; i
>= 1; i
--)
1383 array_size_array
[i
] * offset_item
+ subscript_array
[i
];
1385 /* Construct a value node with the value of the offset */
1387 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
);
1389 /* Let us now play a dirty trick: we will take arg1
1390 which is a value node pointing to the topmost level
1391 of the multidimensional array-set and pretend
1392 that it is actually a array of the final element
1393 type, this will ensure that value_subscript()
1394 returns the correct type value */
1396 VALUE_TYPE (arg1
) = tmp_type
;
1397 return value_ind (value_add (value_coerce_array (arg1
), arg2
));
1400 case BINOP_LOGICAL_AND
:
1401 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1402 if (noside
== EVAL_SKIP
)
1404 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1409 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1412 if (binop_user_defined_p (op
, arg1
, arg2
))
1414 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1415 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1419 tem
= value_logical_not (arg1
);
1420 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1421 (tem
? EVAL_SKIP
: noside
));
1422 return value_from_longest (LA_BOOL_TYPE
,
1423 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
1426 case BINOP_LOGICAL_OR
:
1427 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1428 if (noside
== EVAL_SKIP
)
1430 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1435 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1438 if (binop_user_defined_p (op
, arg1
, arg2
))
1440 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1441 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1445 tem
= value_logical_not (arg1
);
1446 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1447 (!tem
? EVAL_SKIP
: noside
));
1448 return value_from_longest (LA_BOOL_TYPE
,
1449 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
1453 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1454 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1455 if (noside
== EVAL_SKIP
)
1457 if (binop_user_defined_p (op
, arg1
, arg2
))
1459 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1463 tem
= value_equal (arg1
, arg2
);
1464 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1467 case BINOP_NOTEQUAL
:
1468 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1469 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1470 if (noside
== EVAL_SKIP
)
1472 if (binop_user_defined_p (op
, arg1
, arg2
))
1474 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1478 tem
= value_equal (arg1
, arg2
);
1479 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) ! tem
);
1483 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1484 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1485 if (noside
== EVAL_SKIP
)
1487 if (binop_user_defined_p (op
, arg1
, arg2
))
1489 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1493 tem
= value_less (arg1
, arg2
);
1494 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1498 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1499 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1500 if (noside
== EVAL_SKIP
)
1502 if (binop_user_defined_p (op
, arg1
, arg2
))
1504 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1508 tem
= value_less (arg2
, arg1
);
1509 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1513 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1514 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1515 if (noside
== EVAL_SKIP
)
1517 if (binop_user_defined_p (op
, arg1
, arg2
))
1519 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1523 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1524 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1528 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1529 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1530 if (noside
== EVAL_SKIP
)
1532 if (binop_user_defined_p (op
, arg1
, arg2
))
1534 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1538 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1539 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1543 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1544 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1545 if (noside
== EVAL_SKIP
)
1547 type
= check_typedef (VALUE_TYPE (arg2
));
1548 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
1549 error ("Non-integral right operand for \"@\" operator.");
1550 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1552 return allocate_repeat_value (VALUE_TYPE (arg1
),
1553 longest_to_int (value_as_long (arg2
)));
1556 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1559 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1560 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1563 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1564 if (noside
== EVAL_SKIP
)
1566 if (unop_user_defined_p (op
, arg1
))
1567 return value_x_unop (arg1
, op
, noside
);
1569 return value_neg (arg1
);
1571 case UNOP_COMPLEMENT
:
1572 /* C++: check for and handle destructor names. */
1573 op
= exp
->elts
[*pos
].opcode
;
1575 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1576 if (noside
== EVAL_SKIP
)
1578 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1579 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1581 return value_complement (arg1
);
1583 case UNOP_LOGICAL_NOT
:
1584 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1585 if (noside
== EVAL_SKIP
)
1587 if (unop_user_defined_p (op
, arg1
))
1588 return value_x_unop (arg1
, op
, noside
);
1590 return value_from_longest (LA_BOOL_TYPE
,
1591 (LONGEST
) value_logical_not (arg1
));
1594 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
1595 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
1596 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1597 if ((TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) &&
1598 ((TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_METHOD
) ||
1599 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_MEMBER
)))
1600 error ("Attempt to dereference pointer to member without an object");
1601 if (noside
== EVAL_SKIP
)
1603 if (unop_user_defined_p (op
, arg1
))
1604 return value_x_unop (arg1
, op
, noside
);
1605 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1607 type
= check_typedef (VALUE_TYPE (arg1
));
1608 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1609 || TYPE_CODE (type
) == TYPE_CODE_REF
1610 /* In C you can dereference an array to get the 1st elt. */
1611 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1613 return value_zero (TYPE_TARGET_TYPE (type
),
1615 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1616 /* GDB allows dereferencing an int. */
1617 return value_zero (builtin_type_int
, lval_memory
);
1619 error ("Attempt to take contents of a non-pointer value.");
1621 return value_ind (arg1
);
1624 /* C++: check for and handle pointer to members. */
1626 op
= exp
->elts
[*pos
].opcode
;
1628 if (noside
== EVAL_SKIP
)
1632 int temm
= longest_to_int (exp
->elts
[pc
+ 3].longconst
);
1633 (*pos
) += 3 + BYTES_TO_EXP_ELEM (temm
+ 1);
1636 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1641 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
1642 /* If HP aCC object, use bias for pointers to members */
1643 if (hp_som_som_object_present
&&
1644 (TYPE_CODE (VALUE_TYPE (retvalp
)) == TYPE_CODE_PTR
) &&
1645 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (retvalp
))) == TYPE_CODE_MEMBER
))
1647 unsigned int *ptr
= (unsigned int *) VALUE_CONTENTS (retvalp
); /* forces evaluation */
1648 *ptr
|= 0x20000000; /* set 29th bit */
1654 if (noside
== EVAL_SKIP
)
1656 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1659 return evaluate_subexp_for_sizeof (exp
, pos
);
1663 type
= exp
->elts
[pc
+ 1].type
;
1664 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
1665 if (noside
== EVAL_SKIP
)
1667 if (type
!= VALUE_TYPE (arg1
))
1668 arg1
= value_cast (type
, arg1
);
1673 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1674 if (noside
== EVAL_SKIP
)
1676 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1677 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
1679 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
1680 value_as_address (arg1
),
1683 case UNOP_PREINCREMENT
:
1684 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1685 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1687 else if (unop_user_defined_p (op
, arg1
))
1689 return value_x_unop (arg1
, op
, noside
);
1693 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
1695 return value_assign (arg1
, arg2
);
1698 case UNOP_PREDECREMENT
:
1699 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1700 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1702 else if (unop_user_defined_p (op
, arg1
))
1704 return value_x_unop (arg1
, op
, noside
);
1708 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
1710 return value_assign (arg1
, arg2
);
1713 case UNOP_POSTINCREMENT
:
1714 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1715 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1717 else if (unop_user_defined_p (op
, arg1
))
1719 return value_x_unop (arg1
, op
, noside
);
1723 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
1725 value_assign (arg1
, arg2
);
1729 case UNOP_POSTDECREMENT
:
1730 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1731 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1733 else if (unop_user_defined_p (op
, arg1
))
1735 return value_x_unop (arg1
, op
, noside
);
1739 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
1741 value_assign (arg1
, arg2
);
1747 return value_of_this (1);
1750 error ("Attempt to use a type name as an expression");
1753 /* Removing this case and compiling with gcc -Wall reveals that
1754 a lot of cases are hitting this case. Some of these should
1755 probably be removed from expression.h; others are legitimate
1756 expressions which are (apparently) not fully implemented.
1758 If there are any cases landing here which mean a user error,
1759 then they should be separate cases, with more descriptive
1763 GDB does not (yet) know how to evaluate that kind of expression");
1767 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
1770 /* Evaluate a subexpression of EXP, at index *POS,
1771 and return the address of that subexpression.
1772 Advance *POS over the subexpression.
1773 If the subexpression isn't an lvalue, get an error.
1774 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
1775 then only the type of the result need be correct. */
1777 static struct value
*
1778 evaluate_subexp_for_address (register struct expression
*exp
, register int *pos
,
1786 op
= exp
->elts
[pc
].opcode
;
1792 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1796 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
1797 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1800 var
= exp
->elts
[pc
+ 2].symbol
;
1802 /* C++: The "address" of a reference should yield the address
1803 * of the object pointed to. Let value_addr() deal with it. */
1804 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
1808 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1811 lookup_pointer_type (SYMBOL_TYPE (var
));
1812 enum address_class sym_class
= SYMBOL_CLASS (var
);
1814 if (sym_class
== LOC_CONST
1815 || sym_class
== LOC_CONST_BYTES
1816 || sym_class
== LOC_REGISTER
1817 || sym_class
== LOC_REGPARM
)
1818 error ("Attempt to take address of register or constant.");
1821 value_zero (type
, not_lval
);
1827 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
1831 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1833 struct value
*x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1834 if (VALUE_LVAL (x
) == lval_memory
)
1835 return value_zero (lookup_pointer_type (VALUE_TYPE (x
)),
1838 error ("Attempt to take address of non-lval");
1840 return value_addr (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1844 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
1845 When used in contexts where arrays will be coerced anyway, this is
1846 equivalent to `evaluate_subexp' but much faster because it avoids
1847 actually fetching array contents (perhaps obsolete now that we have
1850 Note that we currently only do the coercion for C expressions, where
1851 arrays are zero based and the coercion is correct. For other languages,
1852 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
1853 to decide if coercion is appropriate.
1858 evaluate_subexp_with_coercion (register struct expression
*exp
,
1859 register int *pos
, enum noside noside
)
1861 register enum exp_opcode op
;
1867 op
= exp
->elts
[pc
].opcode
;
1872 var
= exp
->elts
[pc
+ 2].symbol
;
1873 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
1874 && CAST_IS_CONVERSION
)
1879 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
1880 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
1886 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1890 /* Evaluate a subexpression of EXP, at index *POS,
1891 and return a value for the size of that subexpression.
1892 Advance *POS over the subexpression. */
1894 static struct value
*
1895 evaluate_subexp_for_sizeof (register struct expression
*exp
, register int *pos
)
1903 op
= exp
->elts
[pc
].opcode
;
1907 /* This case is handled specially
1908 so that we avoid creating a value for the result type.
1909 If the result type is very big, it's desirable not to
1910 create a value unnecessarily. */
1913 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1914 type
= check_typedef (VALUE_TYPE (val
));
1915 if (TYPE_CODE (type
) != TYPE_CODE_PTR
1916 && TYPE_CODE (type
) != TYPE_CODE_REF
1917 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
1918 error ("Attempt to take contents of a non-pointer value.");
1919 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1920 return value_from_longest (builtin_type_int
, (LONGEST
)
1921 TYPE_LENGTH (type
));
1925 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
1926 return value_from_longest (builtin_type_int
,
1927 (LONGEST
) TYPE_LENGTH (type
));
1931 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
1933 value_from_longest (builtin_type_int
, (LONGEST
) TYPE_LENGTH (type
));
1936 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1937 return value_from_longest (builtin_type_int
,
1938 (LONGEST
) TYPE_LENGTH (VALUE_TYPE (val
)));
1942 /* Parse a type expression in the string [P..P+LENGTH). */
1945 parse_and_eval_type (char *p
, int length
)
1947 char *tmp
= (char *) alloca (length
+ 4);
1948 struct expression
*expr
;
1950 memcpy (tmp
+ 1, p
, length
);
1951 tmp
[length
+ 1] = ')';
1952 tmp
[length
+ 2] = '0';
1953 tmp
[length
+ 3] = '\0';
1954 expr
= parse_expression (tmp
);
1955 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
1956 error ("Internal error in eval_type.");
1957 return expr
->elts
[1].type
;
1961 calc_f77_array_dims (struct type
*array_type
)
1964 struct type
*tmp_type
;
1966 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
1967 error ("Can't get dimensions for a non-array type");
1969 tmp_type
= array_type
;
1971 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
1973 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)