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
)
339 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
340 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
341 if (low
< low_bound
|| high
> high_bound
)
342 error ("tuple range index out of range");
343 for (index
= low
; index
<= high
; index
++)
345 memcpy (VALUE_CONTENTS_RAW (array
)
346 + (index
- low_bound
) * element_size
,
347 VALUE_CONTENTS (element
), element_size
);
352 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
353 if (index
< low_bound
|| index
> high_bound
)
354 error ("tuple index out of range");
355 memcpy (VALUE_CONTENTS_RAW (array
) + (index
- low_bound
) * element_size
,
356 VALUE_CONTENTS (element
), element_size
);
362 evaluate_subexp_standard (expect_type
, exp
, pos
, noside
)
363 struct type
*expect_type
;
364 register struct expression
*exp
;
370 register int pc
, pc2
= 0, oldpos
;
371 register value_ptr arg1
= NULL
, arg2
= NULL
, arg3
;
375 int upper
, lower
, retcode
;
378 /* This expect_type crap should not be used for C. C expressions do
379 not have any notion of expected types, never has and (goddess
380 willing) never will. The C++ code uses it for some twisted
381 purpose (I haven't investigated but I suspect it just the usual
382 combination of Stroustrup figuring out some crazy language
383 feature and Tiemann figuring out some crazier way to try to
384 implement it). CHILL has the tuple stuff; I don't know enough
385 about CHILL to know whether expected types is the way to do it.
386 FORTRAN I don't know. */
387 if (exp
->language_defn
->la_language
!= language_cplus
388 && exp
->language_defn
->la_language
!= language_chill
)
389 expect_type
= NULL_TYPE
;
392 op
= exp
->elts
[pc
].opcode
;
397 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
398 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
399 arg1
= value_struct_elt_for_reference (exp
->elts
[pc
+ 1].type
,
401 exp
->elts
[pc
+ 1].type
,
402 &exp
->elts
[pc
+ 3].string
,
405 error ("There is no field named %s", &exp
->elts
[pc
+ 3].string
);
410 return value_from_longest (exp
->elts
[pc
+ 1].type
,
411 exp
->elts
[pc
+ 2].longconst
);
415 return value_from_double (exp
->elts
[pc
+ 1].type
,
416 exp
->elts
[pc
+ 2].doubleconst
);
420 if (noside
== EVAL_SKIP
)
422 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
424 struct symbol
* sym
= exp
->elts
[pc
+ 2].symbol
;
427 switch (SYMBOL_CLASS (sym
))
431 case LOC_CONST_BYTES
:
445 return value_zero (SYMBOL_TYPE (sym
), lv
);
448 return value_of_variable (exp
->elts
[pc
+ 2].symbol
,
449 exp
->elts
[pc
+ 1].block
);
454 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
458 return value_of_register (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
462 return value_from_longest (LA_BOOL_TYPE
,
463 exp
->elts
[pc
+ 1].longconst
);
467 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
470 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
471 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
472 if (noside
== EVAL_SKIP
)
474 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
477 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
479 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
480 if (noside
== EVAL_SKIP
)
482 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
487 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
488 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
489 nargs
= tem3
- tem2
+ 1;
490 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
492 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
493 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
495 value_ptr rec
= allocate_value (expect_type
);
496 memset (VALUE_CONTENTS_RAW (rec
), '\0', TYPE_LENGTH (type
));
497 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
500 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
501 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
503 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
504 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
505 value_ptr array
= allocate_value (expect_type
);
506 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
507 LONGEST low_bound
, high_bound
, index
;
508 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
511 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
514 memset (VALUE_CONTENTS_RAW (array
), 0, TYPE_LENGTH (expect_type
));
515 for (tem
= nargs
; --nargs
>= 0; )
519 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
522 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
524 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
525 if (VALUE_TYPE (element
) != element_type
)
526 element
= value_cast (element_type
, element
);
529 int continue_pc
= *pos
;
531 index
= init_array_element (array
, element
, exp
, pos
, noside
,
532 low_bound
, high_bound
);
537 memcpy (VALUE_CONTENTS_RAW (array
)
538 + (index
- low_bound
) * element_size
,
539 VALUE_CONTENTS (element
),
547 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
548 && TYPE_CODE (type
) == TYPE_CODE_SET
)
550 value_ptr set
= allocate_value (expect_type
);
551 char *valaddr
= VALUE_CONTENTS_RAW (set
);
552 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
553 LONGEST low_bound
, high_bound
;
554 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
555 error ("(power)set type with unknown size");
556 memset (valaddr
, '\0', TYPE_LENGTH (type
));
557 for (tem
= 0; tem
< nargs
; tem
++)
559 LONGEST range_low
, range_high
;
561 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
564 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
565 range_low
= value_as_long (elem_val
);
566 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
567 range_high
= value_as_long (elem_val
);
571 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
572 range_low
= range_high
= value_as_long (elem_val
);
574 if (range_low
> range_high
)
576 warning ("empty POWERSET tuple range");
579 if (range_low
< low_bound
|| range_high
> high_bound
)
580 error ("POWERSET tuple element out of range");
581 range_low
-= low_bound
;
582 range_high
-= low_bound
;
583 for ( ; range_low
<= range_high
; range_low
++)
585 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
587 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
588 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
595 argvec
= (value_ptr
*) alloca (sizeof (value_ptr
) * nargs
);
596 for (tem
= 0; tem
< nargs
; tem
++)
598 /* Ensure that array expressions are coerced into pointer objects. */
599 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
601 if (noside
== EVAL_SKIP
)
603 return value_array (tem2
, tem3
, argvec
);
607 value_ptr array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
609 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
611 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
612 if (noside
== EVAL_SKIP
)
614 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
617 case TERNOP_SLICE_COUNT
:
619 value_ptr array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
621 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
623 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
624 return value_slice (array
, lowbound
, length
);
628 /* Skip third and second args to evaluate the first one. */
629 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
630 if (value_logical_not (arg1
))
632 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
633 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
637 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
638 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
644 op
= exp
->elts
[*pos
].opcode
;
645 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
646 /* Allocate arg vector, including space for the function to be
647 called in argvec[0] and a terminating NULL */
648 argvec
= (value_ptr
*) alloca (sizeof (value_ptr
) * (nargs
+ 3));
649 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
654 /* First, evaluate the structure into arg2 */
657 if (noside
== EVAL_SKIP
)
660 if (op
== STRUCTOP_MEMBER
)
662 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
666 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
669 /* If the function is a virtual function, then the
670 aggregate value (providing the structure) plays
671 its part by providing the vtable. Otherwise,
672 it is just along for the ride: call the function
675 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
677 fnptr
= value_as_long (arg1
);
679 if (METHOD_PTR_IS_VIRTUAL(fnptr
))
681 int fnoffset
= METHOD_PTR_TO_VOFFSET(fnptr
);
682 struct type
*basetype
;
683 struct type
*domain_type
=
684 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
686 basetype
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
687 if (domain_type
!= basetype
)
688 arg2
= value_cast(lookup_pointer_type (domain_type
), arg2
);
689 basetype
= TYPE_VPTR_BASETYPE (domain_type
);
690 for (i
= TYPE_NFN_FIELDS (basetype
) - 1; i
>= 0; i
--)
692 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (basetype
, i
);
693 /* If one is virtual, then all are virtual. */
694 if (TYPE_FN_FIELD_VIRTUAL_P (f
, 0))
695 for (j
= TYPE_FN_FIELDLIST_LENGTH (basetype
, i
) - 1; j
>= 0; --j
)
696 if ((int) TYPE_FN_FIELD_VOFFSET (f
, j
) == fnoffset
)
698 value_ptr temp
= value_ind (arg2
);
699 arg1
= value_virtual_fn_field (&temp
, f
, j
, domain_type
, 0);
700 arg2
= value_addr (temp
);
705 error ("virtual function at index %d not found", fnoffset
);
709 VALUE_TYPE (arg1
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
713 /* Now, say which argument to start evaluating from */
716 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
718 /* Hair for method invocations */
722 /* First, evaluate the structure into arg2 */
724 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
725 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
726 if (noside
== EVAL_SKIP
)
729 if (op
== STRUCTOP_STRUCT
)
731 /* If v is a variable in a register, and the user types
732 v.method (), this will produce an error, because v has
735 A possible way around this would be to allocate a
736 copy of the variable on the stack, copy in the
737 contents, call the function, and copy out the
738 contents. I.e. convert this from call by reference
739 to call by copy-return (or whatever it's called).
740 However, this does not work because it is not the
741 same: the method being called could stash a copy of
742 the address, and then future uses through that address
743 (after the method returns) would be expected to
744 use the variable itself, not some copy of it. */
745 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
749 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
751 /* Now, say which argument to start evaluating from */
756 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
758 type
= VALUE_TYPE (argvec
[0]);
759 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
760 type
= TYPE_TARGET_TYPE (type
);
761 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
763 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
765 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
-1),
771 for (; tem
<= nargs
; tem
++)
773 /* Ensure that array expressions are coerced into pointer objects. */
775 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
778 /* signal end of arglist */
781 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
784 value_ptr temp
= arg2
;
789 strcpy(tstr
, &exp
->elts
[pc2
+2].string
);
794 value_struct_elt (&temp
, argvec
+1, tstr
,
796 op
== STRUCTOP_STRUCT
797 ? "structure" : "structure pointer");
799 arg2
= value_from_longest (lookup_pointer_type(VALUE_TYPE (temp
)),
800 VALUE_ADDRESS (temp
)+VALUE_OFFSET (temp
));
805 argvec
[1] = argvec
[0];
810 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
818 if (noside
== EVAL_SKIP
)
820 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
822 /* If the return type doesn't look like a function type, call an
823 error. This can happen if somebody tries to turn a variable into
824 a function call. This is here because people often want to
825 call, eg, strcmp, which gdb doesn't know is a function. If
826 gdb isn't asked for it's opinion (ie. through "whatis"),
827 it won't offer it. */
830 TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0]));
833 return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0])));
835 error ("Expression of type other than \"Function returning ...\" used as function");
837 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
839 case OP_F77_UNDETERMINED_ARGLIST
:
841 /* Remember that in F77, functions, substring ops and
842 array subscript operations cannot be disambiguated
843 at parse time. We have made all array subscript operations,
844 substring operations as well as function calls come here
845 and we now have to discover what the heck this thing actually was.
846 If it is a function, we process just as if we got an OP_FUNCALL. */
848 nargs
= longest_to_int (exp
->elts
[pc
+1].longconst
);
851 /* First determine the type code we are dealing with. */
852 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
853 type
= check_typedef (VALUE_TYPE (arg1
));
854 code
= TYPE_CODE (type
);
858 case TYPE_CODE_ARRAY
:
859 goto multi_f77_subscript
;
861 case TYPE_CODE_STRING
:
866 /* It's a function call. */
867 /* Allocate arg vector, including space for the function to be
868 called in argvec[0] and a terminating NULL */
869 argvec
= (value_ptr
*) alloca (sizeof (value_ptr
) * (nargs
+ 2));
872 for (; tem
<= nargs
; tem
++)
873 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
874 argvec
[tem
] = 0; /* signal end of arglist */
878 error ("Cannot perform substring on this type");
882 /* We have a substring operation on our hands here,
883 let us get the string we will be dealing with */
885 /* Now evaluate the 'from' and 'to' */
887 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
890 return value_subscript (arg1
, arg2
);
892 arg3
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
894 if (noside
== EVAL_SKIP
)
897 tem2
= value_as_long (arg2
);
898 tem3
= value_as_long (arg3
);
900 return value_slice (arg1
, tem2
, tem3
- tem2
+ 1);
903 /* We have a complex number, There should be 2 floating
904 point numbers that compose it */
905 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
906 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
908 return value_literal_complex (arg1
, arg2
, builtin_type_f_complex_s16
);
910 case STRUCTOP_STRUCT
:
911 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
912 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
913 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
914 if (noside
== EVAL_SKIP
)
916 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
917 return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1
),
918 &exp
->elts
[pc
+ 2].string
,
923 value_ptr temp
= arg1
;
924 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
929 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
930 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
931 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
932 if (noside
== EVAL_SKIP
)
934 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
935 return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1
),
936 &exp
->elts
[pc
+ 2].string
,
941 value_ptr temp
= arg1
;
942 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
943 NULL
, "structure pointer");
946 /* start-sanitize-gm */
949 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
950 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
951 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
952 if (noside
== EVAL_SKIP
)
955 CORE_ADDR object
= value_as_long (arg1
);
956 struct type
*type
= type_of_object (object
);
958 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
959 return value_zero (lookup_struct_elt_type (type
,
960 &exp
->elts
[pc
+ 2].string
,
965 value_ptr temp
= value_from_longest (builtin_type_unsigned_long
,
966 baseptr_of_object (value_as_long(arg1
)));
968 VALUE_TYPE (temp
) = type
;
969 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
970 NULL
, "structure pointer");
973 #endif /* GENERAL_MAGIC */
974 /* end-sanitize-gm */
976 case STRUCTOP_MEMBER
:
977 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
978 goto handle_pointer_to_member
;
980 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
981 handle_pointer_to_member
:
982 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
983 if (noside
== EVAL_SKIP
)
985 type
= check_typedef (VALUE_TYPE (arg2
));
986 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
987 goto bad_pointer_to_member
;
988 type
= check_typedef (TYPE_TARGET_TYPE (type
));
989 if (TYPE_CODE (type
) == TYPE_CODE_METHOD
)
990 error ("not implemented: pointer-to-method in pointer-to-member construct");
991 if (TYPE_CODE (type
) != TYPE_CODE_MEMBER
)
992 goto bad_pointer_to_member
;
993 /* Now, convert these values to an address. */
994 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
996 arg3
= value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
997 value_as_long (arg1
) + value_as_long (arg2
));
998 return value_ind (arg3
);
999 bad_pointer_to_member
:
1000 error("non-pointer-to-member value used in pointer-to-member construct");
1003 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1004 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1005 if (noside
== EVAL_SKIP
)
1007 if (binop_user_defined_p (op
, arg1
, arg2
))
1008 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1010 return value_concat (arg1
, arg2
);
1013 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1014 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1015 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1017 if (binop_user_defined_p (op
, arg1
, arg2
))
1018 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1020 return value_assign (arg1
, arg2
);
1022 case BINOP_ASSIGN_MODIFY
:
1024 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1025 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1026 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1028 op
= exp
->elts
[pc
+ 1].opcode
;
1029 if (binop_user_defined_p (op
, arg1
, arg2
))
1030 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
);
1031 else if (op
== BINOP_ADD
)
1032 arg2
= value_add (arg1
, arg2
);
1033 else if (op
== BINOP_SUB
)
1034 arg2
= value_sub (arg1
, arg2
);
1036 arg2
= value_binop (arg1
, arg2
, op
);
1037 return value_assign (arg1
, arg2
);
1040 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1041 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1042 if (noside
== EVAL_SKIP
)
1044 if (binop_user_defined_p (op
, arg1
, arg2
))
1045 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1047 return value_add (arg1
, arg2
);
1050 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1051 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1052 if (noside
== EVAL_SKIP
)
1054 if (binop_user_defined_p (op
, arg1
, arg2
))
1055 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1057 return value_sub (arg1
, arg2
);
1065 case BINOP_BITWISE_AND
:
1066 case BINOP_BITWISE_IOR
:
1067 case BINOP_BITWISE_XOR
:
1068 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1069 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1070 if (noside
== EVAL_SKIP
)
1072 if (binop_user_defined_p (op
, arg1
, arg2
))
1073 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1075 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1076 && (op
== BINOP_DIV
|| op
== BINOP_REM
|| op
== BINOP_MOD
))
1077 return value_zero (VALUE_TYPE (arg1
), not_lval
);
1079 return value_binop (arg1
, arg2
, op
);
1082 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1083 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1084 if (noside
== EVAL_SKIP
)
1086 error ("':' operator used in invalid context");
1088 case BINOP_SUBSCRIPT
:
1089 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1090 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1091 if (noside
== EVAL_SKIP
)
1093 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1095 /* If the user attempts to subscript something that has no target
1096 type (like a plain int variable for example), then report this
1099 type
= TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1
)));
1101 return value_zero (type
, VALUE_LVAL (arg1
));
1103 error ("cannot subscript something of type `%s'",
1104 TYPE_NAME (VALUE_TYPE (arg1
)));
1107 if (binop_user_defined_p (op
, arg1
, arg2
))
1108 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1110 return value_subscript (arg1
, arg2
);
1113 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1114 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1115 if (noside
== EVAL_SKIP
)
1117 return value_in (arg1
, arg2
);
1119 case MULTI_SUBSCRIPT
:
1121 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1122 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1125 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1126 /* FIXME: EVAL_SKIP handling may not be correct. */
1127 if (noside
== EVAL_SKIP
)
1138 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1139 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1141 /* If the user attempts to subscript something that has no target
1142 type (like a plain int variable for example), then report this
1145 type
= TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1
)));
1148 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1154 error ("cannot subscript something of type `%s'",
1155 TYPE_NAME (VALUE_TYPE (arg1
)));
1159 if (binop_user_defined_p (op
, arg1
, arg2
))
1161 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1165 arg1
= value_subscript (arg1
, arg2
);
1170 multi_f77_subscript
:
1172 int subscript_array
[MAX_FORTRAN_DIMS
+1]; /* 1-based array of
1173 subscripts, max == 7 */
1174 int array_size_array
[MAX_FORTRAN_DIMS
+1];
1175 int ndimensions
=1,i
;
1176 struct type
*tmp_type
;
1177 int offset_item
; /* The array offset where the item lives */
1179 if (nargs
> MAX_FORTRAN_DIMS
)
1180 error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS
);
1182 tmp_type
= check_typedef (VALUE_TYPE (arg1
));
1183 ndimensions
= calc_f77_array_dims (type
);
1185 if (nargs
!= ndimensions
)
1186 error ("Wrong number of subscripts");
1188 /* Now that we know we have a legal array subscript expression
1189 let us actually find out where this element exists in the array. */
1192 for (i
= 1; i
<= nargs
; i
++)
1194 /* Evaluate each subscript, It must be a legal integer in F77 */
1195 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1197 /* Fill in the subscript and array size arrays */
1199 subscript_array
[i
] = value_as_long (arg2
);
1201 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1202 if (retcode
== BOUND_FETCH_ERROR
)
1203 error ("Cannot obtain dynamic upper bound");
1205 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1206 if (retcode
== BOUND_FETCH_ERROR
)
1207 error("Cannot obtain dynamic lower bound");
1209 array_size_array
[i
] = upper
- lower
+ 1;
1211 /* Zero-normalize subscripts so that offsetting will work. */
1213 subscript_array
[i
] -= lower
;
1215 /* If we are at the bottom of a multidimensional
1216 array type then keep a ptr to the last ARRAY
1217 type around for use when calling value_subscript()
1218 below. This is done because we pretend to value_subscript
1219 that we actually have a one-dimensional array
1220 of base element type that we apply a simple
1224 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1227 /* Now let us calculate the offset for this item */
1229 offset_item
= subscript_array
[ndimensions
];
1231 for (i
= ndimensions
- 1; i
>= 1; i
--)
1233 array_size_array
[i
] * offset_item
+ subscript_array
[i
];
1235 /* Construct a value node with the value of the offset */
1237 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
);
1239 /* Let us now play a dirty trick: we will take arg1
1240 which is a value node pointing to the topmost level
1241 of the multidimensional array-set and pretend
1242 that it is actually a array of the final element
1243 type, this will ensure that value_subscript()
1244 returns the correct type value */
1246 VALUE_TYPE (arg1
) = tmp_type
;
1247 return value_ind (value_add (value_coerce_array (arg1
), arg2
));
1250 case BINOP_LOGICAL_AND
:
1251 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1252 if (noside
== EVAL_SKIP
)
1254 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1259 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1262 if (binop_user_defined_p (op
, arg1
, arg2
))
1264 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1265 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1269 tem
= value_logical_not (arg1
);
1270 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1271 (tem
? EVAL_SKIP
: noside
));
1272 return value_from_longest (LA_BOOL_TYPE
,
1273 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
1276 case BINOP_LOGICAL_OR
:
1277 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1278 if (noside
== EVAL_SKIP
)
1280 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1285 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1288 if (binop_user_defined_p (op
, arg1
, arg2
))
1290 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1291 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1295 tem
= value_logical_not (arg1
);
1296 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1297 (!tem
? EVAL_SKIP
: noside
));
1298 return value_from_longest (LA_BOOL_TYPE
,
1299 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
1303 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1304 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1305 if (noside
== EVAL_SKIP
)
1307 if (binop_user_defined_p (op
, arg1
, arg2
))
1309 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1313 tem
= value_equal (arg1
, arg2
);
1314 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1317 case BINOP_NOTEQUAL
:
1318 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1319 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1320 if (noside
== EVAL_SKIP
)
1322 if (binop_user_defined_p (op
, arg1
, arg2
))
1324 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1328 tem
= value_equal (arg1
, arg2
);
1329 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) ! tem
);
1333 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1334 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1335 if (noside
== EVAL_SKIP
)
1337 if (binop_user_defined_p (op
, arg1
, arg2
))
1339 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1343 tem
= value_less (arg1
, arg2
);
1344 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1348 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1349 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1350 if (noside
== EVAL_SKIP
)
1352 if (binop_user_defined_p (op
, arg1
, arg2
))
1354 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1358 tem
= value_less (arg2
, arg1
);
1359 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1363 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1364 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1365 if (noside
== EVAL_SKIP
)
1367 if (binop_user_defined_p (op
, arg1
, arg2
))
1369 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1373 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1374 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1378 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1379 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1380 if (noside
== EVAL_SKIP
)
1382 if (binop_user_defined_p (op
, arg1
, arg2
))
1384 return value_x_binop (arg1
, arg2
, op
, OP_NULL
);
1388 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1389 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1393 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1394 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1395 if (noside
== EVAL_SKIP
)
1397 if (TYPE_CODE (VALUE_TYPE (arg2
)) != TYPE_CODE_INT
)
1398 error ("Non-integral right operand for \"@\" operator.");
1399 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1401 return allocate_repeat_value (VALUE_TYPE (arg1
),
1402 longest_to_int (value_as_long (arg2
)));
1405 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1408 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1409 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1412 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1413 if (noside
== EVAL_SKIP
)
1415 if (unop_user_defined_p (op
, arg1
))
1416 return value_x_unop (arg1
, op
);
1418 return value_neg (arg1
);
1420 case UNOP_COMPLEMENT
:
1421 /* C++: check for and handle destructor names. */
1422 op
= exp
->elts
[*pos
].opcode
;
1424 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1425 if (noside
== EVAL_SKIP
)
1427 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1428 return value_x_unop (arg1
, UNOP_COMPLEMENT
);
1430 return value_complement (arg1
);
1432 case UNOP_LOGICAL_NOT
:
1433 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1434 if (noside
== EVAL_SKIP
)
1436 if (unop_user_defined_p (op
, arg1
))
1437 return value_x_unop (arg1
, op
);
1439 return value_from_longest (builtin_type_int
,
1440 (LONGEST
) value_logical_not (arg1
));
1443 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
1444 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
1445 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1446 if (noside
== EVAL_SKIP
)
1448 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1450 type
= check_typedef (VALUE_TYPE (arg1
));
1451 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1452 || TYPE_CODE (type
) == TYPE_CODE_REF
1453 /* In C you can dereference an array to get the 1st elt. */
1454 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1456 return value_zero (TYPE_TARGET_TYPE (type
),
1458 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1459 /* GDB allows dereferencing an int. */
1460 return value_zero (builtin_type_int
, lval_memory
);
1462 error ("Attempt to take contents of a non-pointer value.");
1464 return value_ind (arg1
);
1467 /* C++: check for and handle pointer to members. */
1469 op
= exp
->elts
[*pos
].opcode
;
1471 if (noside
== EVAL_SKIP
)
1475 int temm
= longest_to_int (exp
->elts
[pc
+3].longconst
);
1476 (*pos
) += 3 + BYTES_TO_EXP_ELEM (temm
+ 1);
1479 evaluate_subexp (expect_type
, exp
, pos
, EVAL_SKIP
);
1483 return evaluate_subexp_for_address (exp
, pos
, noside
);
1486 if (noside
== EVAL_SKIP
)
1488 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1491 return evaluate_subexp_for_sizeof (exp
, pos
);
1495 type
= exp
->elts
[pc
+ 1].type
;
1496 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
1497 if (noside
== EVAL_SKIP
)
1499 if (type
!= VALUE_TYPE (arg1
))
1500 arg1
= value_cast (type
, arg1
);
1505 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1506 if (noside
== EVAL_SKIP
)
1508 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1509 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
1511 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
1512 value_as_pointer (arg1
));
1514 case UNOP_PREINCREMENT
:
1515 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1516 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1518 else if (unop_user_defined_p (op
, arg1
))
1520 return value_x_unop (arg1
, op
);
1524 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
1526 return value_assign (arg1
, arg2
);
1529 case UNOP_PREDECREMENT
:
1530 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1531 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1533 else if (unop_user_defined_p (op
, arg1
))
1535 return value_x_unop (arg1
, op
);
1539 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
1541 return value_assign (arg1
, arg2
);
1544 case UNOP_POSTINCREMENT
:
1545 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1546 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1548 else if (unop_user_defined_p (op
, arg1
))
1550 return value_x_unop (arg1
, op
);
1554 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
1556 value_assign (arg1
, arg2
);
1560 case UNOP_POSTDECREMENT
:
1561 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1562 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1564 else if (unop_user_defined_p (op
, arg1
))
1566 return value_x_unop (arg1
, op
);
1570 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
1572 value_assign (arg1
, arg2
);
1578 return value_of_this (1);
1581 error ("Attempt to use a type name as an expression");
1584 /* Removing this case and compiling with gcc -Wall reveals that
1585 a lot of cases are hitting this case. Some of these should
1586 probably be removed from expression.h (e.g. do we need a BINOP_SCOPE
1587 and an OP_SCOPE?); others are legitimate expressions which are
1588 (apparently) not fully implemented.
1590 If there are any cases landing here which mean a user error,
1591 then they should be separate cases, with more descriptive
1595 GDB does not (yet) know how to evaluate that kind of expression");
1599 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
1602 /* Evaluate a subexpression of EXP, at index *POS,
1603 and return the address of that subexpression.
1604 Advance *POS over the subexpression.
1605 If the subexpression isn't an lvalue, get an error.
1606 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
1607 then only the type of the result need be correct. */
1610 evaluate_subexp_for_address (exp
, pos
, noside
)
1611 register struct expression
*exp
;
1620 op
= exp
->elts
[pc
].opcode
;
1626 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1630 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
1631 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1634 var
= exp
->elts
[pc
+ 2].symbol
;
1636 /* C++: The "address" of a reference should yield the address
1637 * of the object pointed to. Let value_addr() deal with it. */
1638 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
1642 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1645 lookup_pointer_type (SYMBOL_TYPE (var
));
1646 enum address_class sym_class
= SYMBOL_CLASS (var
);
1648 if (sym_class
== LOC_CONST
1649 || sym_class
== LOC_CONST_BYTES
1650 || sym_class
== LOC_REGISTER
1651 || sym_class
== LOC_REGPARM
)
1652 error ("Attempt to take address of register or constant.");
1655 value_zero (type
, not_lval
);
1661 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
1665 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1667 value_ptr x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1668 if (VALUE_LVAL (x
) == lval_memory
)
1669 return value_zero (lookup_pointer_type (VALUE_TYPE (x
)),
1672 error ("Attempt to take address of non-lval");
1674 return value_addr (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
1678 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
1679 When used in contexts where arrays will be coerced anyway, this is
1680 equivalent to `evaluate_subexp' but much faster because it avoids
1681 actually fetching array contents (perhaps obsolete now that we have
1684 Note that we currently only do the coercion for C expressions, where
1685 arrays are zero based and the coercion is correct. For other languages,
1686 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
1687 to decide if coercion is appropriate.
1692 evaluate_subexp_with_coercion (exp
, pos
, noside
)
1693 register struct expression
*exp
;
1697 register enum exp_opcode op
;
1699 register value_ptr val
;
1703 op
= exp
->elts
[pc
].opcode
;
1708 var
= exp
->elts
[pc
+ 2].symbol
;
1709 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
1710 && CAST_IS_CONVERSION
)
1715 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
1716 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (var
))),
1722 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1726 /* Evaluate a subexpression of EXP, at index *POS,
1727 and return a value for the size of that subexpression.
1728 Advance *POS over the subexpression. */
1731 evaluate_subexp_for_sizeof (exp
, pos
)
1732 register struct expression
*exp
;
1741 op
= exp
->elts
[pc
].opcode
;
1745 /* This case is handled specially
1746 so that we avoid creating a value for the result type.
1747 If the result type is very big, it's desirable not to
1748 create a value unnecessarily. */
1751 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1752 type
= check_typedef (VALUE_TYPE (val
));
1753 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1754 return value_from_longest (builtin_type_int
, (LONGEST
)
1755 TYPE_LENGTH (type
));
1759 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
1760 return value_from_longest (builtin_type_int
,
1761 (LONGEST
) TYPE_LENGTH (type
));
1765 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
1767 value_from_longest (builtin_type_int
, (LONGEST
) TYPE_LENGTH (type
));
1770 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1771 return value_from_longest (builtin_type_int
,
1772 (LONGEST
) TYPE_LENGTH (VALUE_TYPE (val
)));
1776 /* Parse a type expression in the string [P..P+LENGTH). */
1779 parse_and_eval_type (p
, length
)
1783 char *tmp
= (char *)alloca (length
+ 4);
1784 struct expression
*expr
;
1786 memcpy (tmp
+1, p
, length
);
1787 tmp
[length
+1] = ')';
1788 tmp
[length
+2] = '0';
1789 tmp
[length
+3] = '\0';
1790 expr
= parse_expression (tmp
);
1791 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
1792 error ("Internal error in eval_type.");
1793 return expr
->elts
[1].type
;
1797 calc_f77_array_dims (array_type
)
1798 struct type
*array_type
;
1801 struct type
*tmp_type
;
1803 if ((TYPE_CODE(array_type
) != TYPE_CODE_ARRAY
))
1804 error ("Can't get dimensions for a non-array type");
1806 tmp_type
= array_type
;
1808 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
1810 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)