1 /* Evaluate expressions for GDB.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "gdb_string.h"
26 #include "expression.h"
30 #include "language.h" /* For CAST_IS_CONVERSION */
31 #include "f-lang.h" /* for array bound stuff */
32 /* start-sanitize-gm */
35 #endif /* GENERAL_MAGIC */
38 /* Prototypes for local functions. */
40 static value_ptr evaluate_subexp_for_sizeof
PARAMS ((struct expression
*,
43 static value_ptr evaluate_subexp_for_address
PARAMS ((struct expression
*,
50 evaluate_subexp (expect_type
, exp
, pos
, noside
)
51 struct type
*expect_type
;
52 register struct expression
*exp
;
56 return (*exp
->language_defn
->evaluate_exp
) (expect_type
, exp
, pos
, noside
);
59 /* Parse the string EXP as a C expression, evaluate it,
60 and return the result as a number. */
63 parse_and_eval_address (exp
)
66 struct expression
*expr
= parse_expression (exp
);
67 register CORE_ADDR addr
;
68 register struct cleanup
*old_chain
=
69 make_cleanup (free_current_contents
, &expr
);
71 addr
= value_as_pointer (evaluate_expression (expr
));
72 do_cleanups (old_chain
);
76 /* Like parse_and_eval_address but takes a pointer to a char * variable
77 and advanced that variable across the characters parsed. */
80 parse_and_eval_address_1 (expptr
)
83 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*)0, 0);
84 register CORE_ADDR addr
;
85 register struct cleanup
*old_chain
=
86 make_cleanup (free_current_contents
, &expr
);
88 addr
= value_as_pointer (evaluate_expression (expr
));
89 do_cleanups (old_chain
);
97 struct expression
*expr
= parse_expression (exp
);
98 register value_ptr val
;
99 register struct cleanup
*old_chain
100 = make_cleanup (free_current_contents
, &expr
);
102 val
= evaluate_expression (expr
);
103 do_cleanups (old_chain
);
107 /* Parse up to a comma (or to a closeparen)
108 in the string EXPP as an expression, evaluate it, and return the value.
109 EXPP is advanced to point to the comma. */
112 parse_to_comma_and_eval (expp
)
115 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
116 register value_ptr val
;
117 register struct cleanup
*old_chain
118 = make_cleanup (free_current_contents
, &expr
);
120 val
= evaluate_expression (expr
);
121 do_cleanups (old_chain
);
125 /* Evaluate an expression in internal prefix form
126 such as is constructed by parse.y.
128 See expression.h for info on the format of an expression. */
131 evaluate_expression (exp
)
132 struct expression
*exp
;
135 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
138 /* Evaluate an expression, avoiding all memory references
139 and getting a value whose type alone is correct. */
143 struct expression
*exp
;
146 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
149 /* If the next expression is an OP_LABELED, skips past it,
150 returning the label. Otherwise, does nothing and returns NULL. */
154 register struct expression
*exp
;
157 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
160 char *name
= &exp
->elts
[pc
+ 2].string
;
161 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
162 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
169 /* This function evaluates tupes (in Chill) or brace-initializers
170 (in C/C++) for structure types. */
173 evaluate_struct_tuple (struct_val
, exp
, pos
, noside
, nargs
)
174 value_ptr struct_val
;
175 register struct expression
*exp
;
180 struct type
*struct_type
= check_typedef (VALUE_TYPE (struct_val
));
181 struct type
*substruct_type
= struct_type
;
182 struct type
*field_type
;
189 value_ptr val
= NULL
;
194 /* Skip past the labels, and count them. */
195 while (get_label (exp
, pos
) != NULL
)
200 char *label
= get_label (exp
, &pc
);
203 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
206 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
207 if (field_name
!= NULL
&& STREQ (field_name
, label
))
210 subfieldno
= fieldno
;
211 substruct_type
= struct_type
;
215 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
218 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
219 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
220 if ((field_name
== 0 || *field_name
== '\0')
221 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
224 for (; variantno
< TYPE_NFIELDS (field_type
);
228 = TYPE_FIELD_TYPE (field_type
, variantno
);
229 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
232 subfieldno
< TYPE_NFIELDS (substruct_type
);
235 if (STREQ (TYPE_FIELD_NAME (substruct_type
,
246 error ("there is no field named %s", label
);
252 /* Unlabelled tuple element - go to next field. */
256 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
259 substruct_type
= struct_type
;
265 subfieldno
= fieldno
;
266 if (fieldno
>= TYPE_NFIELDS (struct_type
))
267 error ("too many initializers");
268 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
269 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
270 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
271 error ("don't know which variant you want to set");
275 /* Here, struct_type is the type of the inner struct,
276 while substruct_type is the type of the inner struct.
277 These are the same for normal structures, but a variant struct
278 contains anonymous union fields that contain substruct fields.
279 The value fieldno is the index of the top-level (normal or
280 anonymous union) field in struct_field, while the value
281 subfieldno is the index of the actual real (named inner) field
282 in substruct_type. */
284 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
286 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
288 /* Now actually set the field in struct_val. */
290 /* Assign val to field fieldno. */
291 if (VALUE_TYPE (val
) != field_type
)
292 val
= value_cast (field_type
, val
);
294 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
295 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
297 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
298 addr
= VALUE_CONTENTS (struct_val
) + bitpos
/ 8;
300 modify_field (addr
, value_as_long (val
),
301 bitpos
% 8, bitsize
);
303 memcpy (addr
, VALUE_CONTENTS (val
),
304 TYPE_LENGTH (VALUE_TYPE (val
)));
305 } while (--nlabels
> 0);
310 /* Recursive helper function for setting elements of array tuples for Chill.
311 The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND);
312 the element value is ELEMENT;
313 EXP, POS and NOSIDE are as usual.
314 Evaluates index expresions and sets the specified element(s) of
316 Returns last index value. */
319 init_array_element (array
, element
, exp
, pos
, noside
, low_bound
, high_bound
)
320 value_ptr array
, element
;
321 register struct expression
*exp
;
326 int element_size
= TYPE_LENGTH (VALUE_TYPE (element
));
327 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
330 init_array_element (array
, element
, exp
, pos
, noside
,
331 low_bound
, high_bound
);
332 return init_array_element (array
, element
,
333 exp
, pos
, noside
, low_bound
, high_bound
);
335 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
340 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
341 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
342 if (low
< low_bound
|| high
> high_bound
)
343 error ("tuple range index out of range");
344 for (index
= low
; index
<= high
; index
++)
346 memcpy (VALUE_CONTENTS_RAW (array
)
347 + (index
- low_bound
) * element_size
,
348 VALUE_CONTENTS (element
), element_size
);
353 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
354 if (index
< low_bound
|| index
> high_bound
)
355 error ("tuple index out of range");
356 memcpy (VALUE_CONTENTS_RAW (array
) + (index
- low_bound
) * element_size
,
357 VALUE_CONTENTS (element
), element_size
);
363 evaluate_subexp_standard (expect_type
, exp
, pos
, noside
)
364 struct type
*expect_type
;
365 register struct expression
*exp
;
371 register int pc
, pc2
= 0, oldpos
;
372 register value_ptr arg1
= NULL
, arg2
= NULL
, arg3
;
376 int upper
, lower
, retcode
;
379 /* This expect_type crap should not be used for C. C expressions do
380 not have any notion of expected types, never has and (goddess
381 willing) never will. The C++ code uses it for some twisted
382 purpose (I haven't investigated but I suspect it just the usual
383 combination of Stroustrup figuring out some crazy language
384 feature and Tiemann figuring out some crazier way to try to
385 implement it). CHILL has the tuple stuff; I don't know enough
386 about CHILL to know whether expected types is the way to do it.
387 FORTRAN I don't know. */
388 if (exp
->language_defn
->la_language
!= language_cplus
389 && exp
->language_defn
->la_language
!= language_chill
)
390 expect_type
= NULL_TYPE
;
393 op
= exp
->elts
[pc
].opcode
;
398 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
399 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
400 arg1
= value_struct_elt_for_reference (exp
->elts
[pc
+ 1].type
,
402 exp
->elts
[pc
+ 1].type
,
403 &exp
->elts
[pc
+ 3].string
,
406 error ("There is no field named %s", &exp
->elts
[pc
+ 3].string
);
411 return value_from_longest (exp
->elts
[pc
+ 1].type
,
412 exp
->elts
[pc
+ 2].longconst
);
416 return value_from_double (exp
->elts
[pc
+ 1].type
,
417 exp
->elts
[pc
+ 2].doubleconst
);
421 if (noside
== EVAL_SKIP
)
423 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
425 struct symbol
* sym
= exp
->elts
[pc
+ 2].symbol
;
428 switch (SYMBOL_CLASS (sym
))
432 case LOC_CONST_BYTES
:
446 return value_zero (SYMBOL_TYPE (sym
), lv
);
449 return value_of_variable (exp
->elts
[pc
+ 2].symbol
,
450 exp
->elts
[pc
+ 1].block
);
455 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
459 return value_of_register (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
463 if (current_language
->la_language
== language_fortran
)
464 return value_from_longest (builtin_type_f_logical_s2
,
465 exp
->elts
[pc
+ 1].longconst
);
467 return value_from_longest (builtin_type_chill_bool
,
468 exp
->elts
[pc
+ 1].longconst
);
472 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
475 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
476 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
477 if (noside
== EVAL_SKIP
)
479 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
482 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
484 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
485 if (noside
== EVAL_SKIP
)
487 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
492 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
493 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
494 nargs
= tem3
- tem2
+ 1;
495 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
497 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
498 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
500 value_ptr rec
= allocate_value (expect_type
);
501 memset (VALUE_CONTENTS_RAW (rec
), '\0', TYPE_LENGTH (type
));
502 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
505 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
506 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
508 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
509 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
510 value_ptr array
= allocate_value (expect_type
);
511 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
512 LONGEST low_bound
, high_bound
, index
;
513 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
516 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
519 memset (VALUE_CONTENTS_RAW (array
), 0, TYPE_LENGTH (expect_type
));
520 for (tem
= nargs
; --nargs
>= 0; )
524 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
527 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
529 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
530 if (VALUE_TYPE (element
) != element_type
)
531 element
= value_cast (element_type
, element
);
534 int continue_pc
= *pos
;
536 index
= init_array_element (array
, element
, exp
, pos
, noside
,
537 low_bound
, high_bound
);
542 memcpy (VALUE_CONTENTS_RAW (array
)
543 + (index
- low_bound
) * element_size
,
544 VALUE_CONTENTS (element
),
552 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
553 && TYPE_CODE (type
) == TYPE_CODE_SET
)
555 value_ptr set
= allocate_value (expect_type
);
556 char *valaddr
= VALUE_CONTENTS_RAW (set
);
557 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
558 LONGEST low_bound
, high_bound
;
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
;
566 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
569 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
570 range_low
= value_as_long (elem_val
);
571 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
572 range_high
= value_as_long (elem_val
);
576 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
577 range_low
= range_high
= value_as_long (elem_val
);
579 if (range_low
> range_high
)
581 warning ("empty POWERSET tuple range");
584 if (range_low
< low_bound
|| range_high
> high_bound
)
585 error ("POWERSET tuple element out of range");
586 range_low
-= low_bound
;
587 range_high
-= low_bound
;
588 for ( ; range_low
<= range_high
; range_low
++)
590 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
592 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
593 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
600 argvec
= (value_ptr
*) alloca (sizeof (value_ptr
) * nargs
);
601 for (tem
= 0; tem
< nargs
; tem
++)
603 /* Ensure that array expressions are coerced into pointer objects. */
604 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
606 if (noside
== EVAL_SKIP
)
608 return value_array (tem2
, tem3
, argvec
);
612 value_ptr array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
614 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
616 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
617 if (noside
== EVAL_SKIP
)
619 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
622 case TERNOP_SLICE_COUNT
:
624 value_ptr array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
626 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
628 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
629 return value_slice (array
, lowbound
, length
);
633 /* Skip third and second args to evaluate the first one. */
634 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
635 if (value_logical_not (arg1
))
637 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
638 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
642 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
643 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
649 op
= exp
->elts
[*pos
].opcode
;
650 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
651 /* Allocate arg vector, including space for the function to be
652 called in argvec[0] and a terminating NULL */
653 argvec
= (value_ptr
*) alloca (sizeof (value_ptr
) * (nargs
+ 3));
654 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
659 /* First, evaluate the structure into arg2 */
662 if (noside
== EVAL_SKIP
)
665 if (op
== STRUCTOP_MEMBER
)
667 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
671 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
674 /* If the function is a virtual function, then the
675 aggregate value (providing the structure) plays
676 its part by providing the vtable. Otherwise,
677 it is just along for the ride: call the function
680 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
682 fnptr
= value_as_long (arg1
);
684 if (METHOD_PTR_IS_VIRTUAL(fnptr
))
686 int fnoffset
= METHOD_PTR_TO_VOFFSET(fnptr
);
687 struct type
*basetype
;
688 struct type
*domain_type
=
689 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
691 basetype
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
692 if (domain_type
!= basetype
)
693 arg2
= value_cast(lookup_pointer_type (domain_type
), arg2
);
694 basetype
= TYPE_VPTR_BASETYPE (domain_type
);
695 for (i
= TYPE_NFN_FIELDS (basetype
) - 1; i
>= 0; i
--)
697 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (basetype
, i
);
698 /* If one is virtual, then all are virtual. */
699 if (TYPE_FN_FIELD_VIRTUAL_P (f
, 0))
700 for (j
= TYPE_FN_FIELDLIST_LENGTH (basetype
, i
) - 1; j
>= 0; --j
)
701 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == fnoffset
)
703 value_ptr temp
= value_ind (arg2
);
704 arg1
= value_virtual_fn_field (&temp
, f
, j
, domain_type
, 0);
705 arg2
= value_addr (temp
);
710 error ("virtual function at index %d not found", fnoffset
);
714 VALUE_TYPE (arg1
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
718 /* Now, say which argument to start evaluating from */
721 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
723 /* Hair for method invocations */
727 /* First, evaluate the structure into arg2 */
729 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
730 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
731 if (noside
== EVAL_SKIP
)
734 if (op
== STRUCTOP_STRUCT
)
736 /* If v is a variable in a register, and the user types
737 v.method (), this will produce an error, because v has
740 A possible way around this would be to allocate a
741 copy of the variable on the stack, copy in the
742 contents, call the function, and copy out the
743 contents. I.e. convert this from call by reference
744 to call by copy-return (or whatever it's called).
745 However, this does not work because it is not the
746 same: the method being called could stash a copy of
747 the address, and then future uses through that address
748 (after the method returns) would be expected to
749 use the variable itself, not some copy of it. */
750 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
754 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
756 /* Now, say which argument to start evaluating from */
761 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
763 type
= VALUE_TYPE (argvec
[0]);
764 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
765 type
= TYPE_TARGET_TYPE (type
);
766 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
768 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
770 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
-1),
776 for (; tem
<= nargs
; tem
++)
778 /* Ensure that array expressions are coerced into pointer objects. */
780 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
783 /* signal end of arglist */
786 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
789 value_ptr temp
= arg2
;
794 strcpy(tstr
, &exp
->elts
[pc2
+2].string
);
799 value_struct_elt (&temp
, argvec
+1, tstr
,
801 op
== STRUCTOP_STRUCT
802 ? "structure" : "structure pointer");
804 arg2
= value_from_longest (lookup_pointer_type(VALUE_TYPE (temp
)),
805 VALUE_ADDRESS (temp
)+VALUE_OFFSET (temp
));
810 argvec
[1] = argvec
[0];
815 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
823 if (noside
== EVAL_SKIP
)
825 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
827 /* If the return type doesn't look like a function type, call an
828 error. This can happen if somebody tries to turn a variable into
829 a function call. This is here because people often want to
830 call, eg, strcmp, which gdb doesn't know is a function. If
831 gdb isn't asked for it's opinion (ie. through "whatis"),
832 it won't offer it. */
835 TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0]));
838 return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0])));
840 error ("Expression of type other than \"Function returning ...\" used as function");
842 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
844 case OP_F77_UNDETERMINED_ARGLIST
:
846 /* Remember that in F77, functions, substring ops and
847 array subscript operations cannot be disambiguated
848 at parse time. We have made all array subscript operations,
849 substring operations as well as function calls come here
850 and we now have to discover what the heck this thing actually was.
851 If it is a function, we process just as if we got an OP_FUNCALL. */
853 nargs
= longest_to_int (exp
->elts
[pc
+1].longconst
);
856 /* First determine the type code we are dealing with. */
857 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
858 type
= check_typedef (VALUE_TYPE (arg1
));
859 code
= TYPE_CODE (type
);
863 case TYPE_CODE_ARRAY
:
864 goto multi_f77_subscript
;
866 case TYPE_CODE_STRING
:
871 /* It's a function call. */
872 /* Allocate arg vector, including space for the function to be
873 called in argvec[0] and a terminating NULL */
874 argvec
= (value_ptr
*) alloca (sizeof (value_ptr
) * (nargs
+ 2));
877 for (; tem
<= nargs
; tem
++)
878 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
879 argvec
[tem
] = 0; /* signal end of arglist */
883 error ("Cannot perform substring on this type");
887 /* We have a substring operation on our hands here,
888 let us get the string we will be dealing with */
890 /* Now evaluate the 'from' and 'to' */
892 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
895 return value_subscript (arg1
, arg2
);
897 arg3
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
899 if (noside
== EVAL_SKIP
)
902 tem2
= value_as_long (arg2
);
903 tem3
= value_as_long (arg3
);
905 return value_slice (arg1
, tem2
, tem3
- tem2
+ 1);
908 /* We have a complex number, There should be 2 floating
909 point numbers that compose it */
910 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
911 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
913 return value_literal_complex (arg1
, arg2
, builtin_type_f_complex_s16
);
915 case STRUCTOP_STRUCT
:
916 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
917 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
918 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
919 if (noside
== EVAL_SKIP
)
921 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
922 return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1
),
923 &exp
->elts
[pc
+ 2].string
,
928 value_ptr temp
= arg1
;
929 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
934 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
935 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
936 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
937 if (noside
== EVAL_SKIP
)
939 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
940 return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1
),
941 &exp
->elts
[pc
+ 2].string
,
946 value_ptr temp
= arg1
;
947 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
948 NULL
, "structure pointer");
951 /* start-sanitize-gm */
954 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
955 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
956 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
957 if (noside
== EVAL_SKIP
)
960 CORE_ADDR object
= value_as_long (arg1
);
961 struct type
*type
= type_of_object (object
);
963 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
964 return value_zero (lookup_struct_elt_type (type
,
965 &exp
->elts
[pc
+ 2].string
,
970 value_ptr temp
= value_from_longest (builtin_type_unsigned_long
,
971 baseptr_of_object (value_as_long(arg1
)));
973 VALUE_TYPE (temp
) = type
;
974 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
975 NULL
, "structure pointer");
978 #endif /* GENERAL_MAGIC */
979 /* end-sanitize-gm */
981 case STRUCTOP_MEMBER
:
982 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
983 goto handle_pointer_to_member
;
985 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
986 handle_pointer_to_member
:
987 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
988 if (noside
== EVAL_SKIP
)
990 type
= check_typedef (VALUE_TYPE (arg2
));
991 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
992 goto bad_pointer_to_member
;
993 type
= check_typedef (TYPE_TARGET_TYPE (type
));
994 if (TYPE_CODE (type
) == TYPE_CODE_METHOD
)
995 error ("not implemented: pointer-to-method in pointer-to-member construct");
996 if (TYPE_CODE (type
) != TYPE_CODE_MEMBER
)
997 goto bad_pointer_to_member
;
998 /* Now, convert these values to an address. */
999 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1001 arg3
= value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1002 value_as_long (arg1
) + value_as_long (arg2
));
1003 return value_ind (arg3
);
1004 bad_pointer_to_member
:
1005 error("non-pointer-to-member value used in pointer-to-member construct");
1008 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1009 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1010 if (noside
== EVAL_SKIP
)
1012 if (binop_user_defined_p (op
, arg1
, arg2
))
1013 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1015 return value_concat (arg1
, arg2
);
1018 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1019 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1020 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1022 if (binop_user_defined_p (op
, arg1
, arg2
))
1023 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1025 return value_assign (arg1
, arg2
);
1027 case BINOP_ASSIGN_MODIFY
:
1029 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1030 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1031 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1033 op
= exp
->elts
[pc
+ 1].opcode
;
1034 if (binop_user_defined_p (op
, arg1
, arg2
))
1035 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
);
1036 else if (op
== BINOP_ADD
)
1037 arg2
= value_add (arg1
, arg2
);
1038 else if (op
== BINOP_SUB
)
1039 arg2
= value_sub (arg1
, arg2
);
1041 arg2
= value_binop (arg1
, arg2
, op
);
1042 return value_assign (arg1
, arg2
);
1045 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1046 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1047 if (noside
== EVAL_SKIP
)
1049 if (binop_user_defined_p (op
, arg1
, arg2
))
1050 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1052 return value_add (arg1
, arg2
);
1055 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1056 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1057 if (noside
== EVAL_SKIP
)
1059 if (binop_user_defined_p (op
, arg1
, arg2
))
1060 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1062 return value_sub (arg1
, arg2
);
1070 case BINOP_BITWISE_AND
:
1071 case BINOP_BITWISE_IOR
:
1072 case BINOP_BITWISE_XOR
:
1073 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1074 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1075 if (noside
== EVAL_SKIP
)
1077 if (binop_user_defined_p (op
, arg1
, arg2
))
1078 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1080 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1081 && (op
== BINOP_DIV
|| op
== BINOP_REM
|| op
== BINOP_MOD
))
1082 return value_zero (VALUE_TYPE (arg1
), not_lval
);
1084 return value_binop (arg1
, arg2
, op
);
1087 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1088 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1089 if (noside
== EVAL_SKIP
)
1091 error ("':' operator used in invalid context");
1093 case BINOP_SUBSCRIPT
:
1094 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1095 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1096 if (noside
== EVAL_SKIP
)
1098 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1100 /* If the user attempts to subscript something that has no target
1101 type (like a plain int variable for example), then report this
1104 type
= TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1
)));
1106 return value_zero (type
, VALUE_LVAL (arg1
));
1108 error ("cannot subscript something of type `%s'",
1109 TYPE_NAME (VALUE_TYPE (arg1
)));
1112 if (binop_user_defined_p (op
, arg1
, arg2
))
1113 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1115 return value_subscript (arg1
, arg2
);
1118 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1119 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1120 if (noside
== EVAL_SKIP
)
1122 return value_in (arg1
, arg2
);
1124 case MULTI_SUBSCRIPT
:
1126 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1127 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1130 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1131 /* FIXME: EVAL_SKIP handling may not be correct. */
1132 if (noside
== EVAL_SKIP
)
1143 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1144 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1146 /* If the user attempts to subscript something that has no target
1147 type (like a plain int variable for example), then report this
1150 type
= TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1
)));
1153 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1159 error ("cannot subscript something of type `%s'",
1160 TYPE_NAME (VALUE_TYPE (arg1
)));
1164 if (binop_user_defined_p (op
, arg1
, arg2
))
1166 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1170 arg1
= value_subscript (arg1
, arg2
);
1175 multi_f77_subscript
:
1177 int subscript_array
[MAX_FORTRAN_DIMS
+1]; /* 1-based array of
1178 subscripts, max == 7 */
1179 int array_size_array
[MAX_FORTRAN_DIMS
+1];
1180 int ndimensions
=1,i
;
1181 struct type
*tmp_type
;
1182 int offset_item
; /* The array offset where the item lives */
1184 if (nargs
> MAX_FORTRAN_DIMS
)
1185 error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS
);
1187 tmp_type
= check_typedef (VALUE_TYPE (arg1
));
1188 ndimensions
= calc_f77_array_dims (type
);
1190 if (nargs
!= ndimensions
)
1191 error ("Wrong number of subscripts");
1193 /* Now that we know we have a legal array subscript expression
1194 let us actually find out where this element exists in the array. */
1197 for (i
= 1; i
<= nargs
; i
++)
1199 /* Evaluate each subscript, It must be a legal integer in F77 */
1200 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1202 /* Fill in the subscript and array size arrays */
1204 subscript_array
[i
] = value_as_long (arg2
);
1206 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1207 if (retcode
== BOUND_FETCH_ERROR
)
1208 error ("Cannot obtain dynamic upper bound");
1210 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1211 if (retcode
== BOUND_FETCH_ERROR
)
1212 error("Cannot obtain dynamic lower bound");
1214 array_size_array
[i
] = upper
- lower
+ 1;
1216 /* Zero-normalize subscripts so that offsetting will work. */
1218 subscript_array
[i
] -= lower
;
1220 /* If we are at the bottom of a multidimensional
1221 array type then keep a ptr to the last ARRAY
1222 type around for use when calling value_subscript()
1223 below. This is done because we pretend to value_subscript
1224 that we actually have a one-dimensional array
1225 of base element type that we apply a simple
1229 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1232 /* Now let us calculate the offset for this item */
1234 offset_item
= subscript_array
[ndimensions
];
1236 for (i
= ndimensions
- 1; i
>= 1; i
--)
1238 array_size_array
[i
] * offset_item
+ subscript_array
[i
];
1240 /* Construct a value node with the value of the offset */
1242 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
);
1244 /* Let us now play a dirty trick: we will take arg1
1245 which is a value node pointing to the topmost level
1246 of the multidimensional array-set and pretend
1247 that it is actually a array of the final element
1248 type, this will ensure that value_subscript()
1249 returns the correct type value */
1251 VALUE_TYPE (arg1
) = tmp_type
;
1252 return value_ind (value_add (value_coerce_array (arg1
), arg2
));
1255 case BINOP_LOGICAL_AND
:
1256 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1257 if (noside
== EVAL_SKIP
)
1259 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1264 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1267 if (binop_user_defined_p (op
, arg1
, arg2
))
1269 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1270 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1274 tem
= value_logical_not (arg1
);
1275 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1276 (tem
? EVAL_SKIP
: noside
));
1277 return value_from_longest (LA_BOOL_TYPE
,
1278 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
1281 case BINOP_LOGICAL_OR
:
1282 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1283 if (noside
== EVAL_SKIP
)
1285 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1290 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1293 if (binop_user_defined_p (op
, arg1
, arg2
))
1295 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1296 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1300 tem
= value_logical_not (arg1
);
1301 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1302 (!tem
? EVAL_SKIP
: noside
));
1303 return value_from_longest (LA_BOOL_TYPE
,
1304 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
1308 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1309 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1310 if (noside
== EVAL_SKIP
)
1312 if (binop_user_defined_p (op
, arg1
, arg2
))
1314 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1318 tem
= value_equal (arg1
, arg2
);
1319 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1322 case BINOP_NOTEQUAL
:
1323 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1324 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1325 if (noside
== EVAL_SKIP
)
1327 if (binop_user_defined_p (op
, arg1
, arg2
))
1329 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1333 tem
= value_equal (arg1
, arg2
);
1334 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) ! tem
);
1338 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1339 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1340 if (noside
== EVAL_SKIP
)
1342 if (binop_user_defined_p (op
, arg1
, arg2
))
1344 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1348 tem
= value_less (arg1
, arg2
);
1349 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1353 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1354 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1355 if (noside
== EVAL_SKIP
)
1357 if (binop_user_defined_p (op
, arg1
, arg2
))
1359 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1363 tem
= value_less (arg2
, arg1
);
1364 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1368 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1369 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1370 if (noside
== EVAL_SKIP
)
1372 if (binop_user_defined_p (op
, arg1
, arg2
))
1374 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1378 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1379 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1383 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1384 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1385 if (noside
== EVAL_SKIP
)
1387 if (binop_user_defined_p (op
, arg1
, arg2
))
1389 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1393 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1394 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1398 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1399 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1400 if (noside
== EVAL_SKIP
)
1402 if (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_INT
)
1403 error ("Non-integral right operand for \"@\" operator.");
1404 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1406 return allocate_repeat_value (VALUE_TYPE (arg1
),
1407 longest_to_int (value_as_long (arg2
)));
1410 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1413 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1414 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1417 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1418 if (noside
== EVAL_SKIP
)
1420 if (unop_user_defined_p (op
, arg1
))
1421 return value_x_unop (arg1
, op
);
1423 return value_neg (arg1
);
1425 case UNOP_COMPLEMENT
:
1426 /* C++: check for and handle destructor names. */
1427 op
= exp
->elts
[*pos
].opcode
;
1429 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1430 if (noside
== EVAL_SKIP
)
1432 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1433 return value_x_unop (arg1
, UNOP_COMPLEMENT
);
1435 return value_complement (arg1
);
1437 case UNOP_LOGICAL_NOT
:
1438 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1439 if (noside
== EVAL_SKIP
)
1441 if (unop_user_defined_p (op
, arg1
))
1442 return value_x_unop (arg1
, op
);
1444 return value_from_longest (builtin_type_int
,
1445 (LONGEST
) value_logical_not (arg1
));
1448 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
1449 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
1450 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1451 if (noside
== EVAL_SKIP
)
1453 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1455 type
= check_typedef (VALUE_TYPE (arg1
));
1456 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1457 || TYPE_CODE (type
) == TYPE_CODE_REF
1458 /* In C you can dereference an array to get the 1st elt. */
1459 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1461 return value_zero (TYPE_TARGET_TYPE (type
),
1463 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1464 /* GDB allows dereferencing an int. */
1465 return value_zero (builtin_type_int
, lval_memory
);
1467 error ("Attempt to take contents of a non-pointer value.");
1469 return value_ind (arg1
);
1472 /* C++: check for and handle pointer to members. */
1474 op
= exp
->elts
[*pos
].opcode
;
1476 if (noside
== EVAL_SKIP
)
1480 int temm
= longest_to_int (exp
->elts
[pc
+3].longconst
);
1481 (*pos
) += 3 + BYTES_TO_EXP_ELEM (temm
+ 1);
1484 evaluate_subexp (expect_type
, exp
, pos
, EVAL_SKIP
);
1488 return evaluate_subexp_for_address (exp
, pos
, noside
);
1491 if (noside
== EVAL_SKIP
)
1493 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1496 return evaluate_subexp_for_sizeof (exp
, pos
);
1500 type
= exp
->elts
[pc
+ 1].type
;
1501 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
1502 if (noside
== EVAL_SKIP
)
1504 if (type
!= VALUE_TYPE (arg1
))
1505 arg1
= value_cast (type
, arg1
);
1510 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1511 if (noside
== EVAL_SKIP
)
1513 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1514 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
1516 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
1517 value_as_pointer (arg1
));
1519 case UNOP_PREINCREMENT
:
1520 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1521 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1523 else if (unop_user_defined_p (op
, arg1
))
1525 return value_x_unop (arg1
, op
);
1529 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
1531 return value_assign (arg1
, arg2
);
1534 case UNOP_PREDECREMENT
:
1535 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1536 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1538 else if (unop_user_defined_p (op
, arg1
))
1540 return value_x_unop (arg1
, op
);
1544 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
1546 return value_assign (arg1
, arg2
);
1549 case UNOP_POSTINCREMENT
:
1550 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1551 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1553 else if (unop_user_defined_p (op
, arg1
))
1555 return value_x_unop (arg1
, op
);
1559 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
1561 value_assign (arg1
, arg2
);
1565 case UNOP_POSTDECREMENT
:
1566 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1567 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1569 else if (unop_user_defined_p (op
, arg1
))
1571 return value_x_unop (arg1
, op
);
1575 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
1577 value_assign (arg1
, arg2
);
1583 return value_of_this (1);
1586 error ("Attempt to use a type name as an expression");
1589 /* Removing this case and compiling with gcc -Wall reveals that
1590 a lot of cases are hitting this case. Some of these should
1591 probably be removed from expression.h (e.g. do we need a BINOP_SCOPE
1592 and an OP_SCOPE?); others are legitimate expressions which are
1593 (apparently) not fully implemented.
1595 If there are any cases landing here which mean a user error,
1596 then they should be separate cases, with more descriptive
1600 GDB does not (yet) know how to evaluate that kind of expression");
1604 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
1607 /* Evaluate a subexpression of EXP, at index *POS,
1608 and return the address of that subexpression.
1609 Advance *POS over the subexpression.
1610 If the subexpression isn't an lvalue, get an error.
1611 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
1612 then only the type of the result need be correct. */
1615 evaluate_subexp_for_address (exp
, pos
, noside
)
1616 register struct expression
*exp
;
1625 op
= exp
->elts
[pc
].opcode
;
1631 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1635 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
1636 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1639 var
= exp
->elts
[pc
+ 2].symbol
;
1641 /* C++: The "address" of a reference should yield the address
1642 * of the object pointed to. Let value_addr() deal with it. */
1643 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
1647 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1650 lookup_pointer_type (SYMBOL_TYPE (var
));
1651 enum address_class sym_class
= SYMBOL_CLASS (var
);
1653 if (sym_class
== LOC_CONST
1654 || sym_class
== LOC_CONST_BYTES
1655 || sym_class
== LOC_REGISTER
1656 || sym_class
== LOC_REGPARM
)
1657 error ("Attempt to take address of register or constant.");
1660 value_zero (type
, not_lval
);
1666 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
1670 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1672 value_ptr x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1673 if (VALUE_LVAL (x
) == lval_memory
)
1674 return value_zero (lookup_pointer_type (VALUE_TYPE (x
)),
1677 error ("Attempt to take address of non-lval");
1679 return value_addr (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1683 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
1684 When used in contexts where arrays will be coerced anyway, this is
1685 equivalent to `evaluate_subexp' but much faster because it avoids
1686 actually fetching array contents (perhaps obsolete now that we have
1689 Note that we currently only do the coercion for C expressions, where
1690 arrays are zero based and the coercion is correct. For other languages,
1691 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
1692 to decide if coercion is appropriate.
1697 evaluate_subexp_with_coercion (exp
, pos
, noside
)
1698 register struct expression
*exp
;
1702 register enum exp_opcode op
;
1704 register value_ptr val
;
1708 op
= exp
->elts
[pc
].opcode
;
1713 var
= exp
->elts
[pc
+ 2].symbol
;
1714 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
1715 && CAST_IS_CONVERSION
)
1720 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
1721 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (var
))),
1727 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1731 /* Evaluate a subexpression of EXP, at index *POS,
1732 and return a value for the size of that subexpression.
1733 Advance *POS over the subexpression. */
1736 evaluate_subexp_for_sizeof (exp
, pos
)
1737 register struct expression
*exp
;
1746 op
= exp
->elts
[pc
].opcode
;
1750 /* This case is handled specially
1751 so that we avoid creating a value for the result type.
1752 If the result type is very big, it's desirable not to
1753 create a value unnecessarily. */
1756 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1757 type
= check_typedef (VALUE_TYPE (val
));
1758 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1759 return value_from_longest (builtin_type_int
, (LONGEST
)
1760 TYPE_LENGTH (type
));
1764 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
1765 return value_from_longest (builtin_type_int
,
1766 (LONGEST
) TYPE_LENGTH (type
));
1770 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
1772 value_from_longest (builtin_type_int
, (LONGEST
) TYPE_LENGTH (type
));
1775 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1776 return value_from_longest (builtin_type_int
,
1777 (LONGEST
) TYPE_LENGTH (VALUE_TYPE (val
)));
1781 /* Parse a type expression in the string [P..P+LENGTH). */
1784 parse_and_eval_type (p
, length
)
1788 char *tmp
= (char *)alloca (length
+ 4);
1789 struct expression
*expr
;
1791 memcpy (tmp
+1, p
, length
);
1792 tmp
[length
+1] = ')';
1793 tmp
[length
+2] = '0';
1794 tmp
[length
+3] = '\0';
1795 expr
= parse_expression (tmp
);
1796 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
1797 error ("Internal error in eval_type.");
1798 return expr
->elts
[1].type
;
1802 calc_f77_array_dims (array_type
)
1803 struct type
*array_type
;
1806 struct type
*tmp_type
;
1808 if ((TYPE_CODE(array_type
) != TYPE_CODE_ARRAY
))
1809 error ("Can't get dimensions for a non-array type");
1811 tmp_type
= array_type
;
1813 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
1815 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)