1 /* Evaluate expressions for GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
29 #include "expression.h"
32 #include "language.h" /* For CAST_IS_CONVERSION */
33 #include "f-lang.h" /* for array bound stuff */
36 #include "objc-lang.h"
39 /* Defined in symtab.c */
40 extern int hp_som_som_object_present
;
42 /* This is defined in valops.c */
43 extern int overload_resolution
;
45 /* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
46 on with successful lookup for member/method of the rtti type. */
47 extern int objectprint
;
49 /* Prototypes for local functions. */
51 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
53 static struct value
*evaluate_subexp_for_address (struct expression
*,
56 static struct value
*evaluate_subexp (struct type
*, struct expression
*,
59 static char *get_label (struct expression
*, int *);
61 static struct value
*evaluate_struct_tuple (struct value
*,
62 struct expression
*, int *,
65 static LONGEST
init_array_element (struct value
*, struct value
*,
66 struct expression
*, int *, enum noside
,
70 evaluate_subexp (struct type
*expect_type
, register struct expression
*exp
,
71 register int *pos
, enum noside noside
)
73 return (*exp
->language_defn
->evaluate_exp
) (expect_type
, exp
, pos
, noside
);
76 /* Parse the string EXP as a C expression, evaluate it,
77 and return the result as a number. */
80 parse_and_eval_address (char *exp
)
82 struct expression
*expr
= parse_expression (exp
);
83 register CORE_ADDR addr
;
84 register struct cleanup
*old_chain
=
85 make_cleanup (free_current_contents
, &expr
);
87 addr
= value_as_address (evaluate_expression (expr
));
88 do_cleanups (old_chain
);
92 /* Like parse_and_eval_address but takes a pointer to a char * variable
93 and advanced that variable across the characters parsed. */
96 parse_and_eval_address_1 (char **expptr
)
98 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*) 0, 0);
99 register CORE_ADDR addr
;
100 register struct cleanup
*old_chain
=
101 make_cleanup (free_current_contents
, &expr
);
103 addr
= value_as_address (evaluate_expression (expr
));
104 do_cleanups (old_chain
);
108 /* Like parse_and_eval_address, but treats the value of the expression
109 as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
111 parse_and_eval_long (char *exp
)
113 struct expression
*expr
= parse_expression (exp
);
114 register LONGEST retval
;
115 register struct cleanup
*old_chain
=
116 make_cleanup (free_current_contents
, &expr
);
118 retval
= value_as_long (evaluate_expression (expr
));
119 do_cleanups (old_chain
);
124 parse_and_eval (char *exp
)
126 struct expression
*expr
= parse_expression (exp
);
128 register struct cleanup
*old_chain
=
129 make_cleanup (free_current_contents
, &expr
);
131 val
= evaluate_expression (expr
);
132 do_cleanups (old_chain
);
136 /* Parse up to a comma (or to a closeparen)
137 in the string EXPP as an expression, evaluate it, and return the value.
138 EXPP is advanced to point to the comma. */
141 parse_to_comma_and_eval (char **expp
)
143 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
145 register struct cleanup
*old_chain
=
146 make_cleanup (free_current_contents
, &expr
);
148 val
= evaluate_expression (expr
);
149 do_cleanups (old_chain
);
153 /* Evaluate an expression in internal prefix form
154 such as is constructed by parse.y.
156 See expression.h for info on the format of an expression. */
159 evaluate_expression (struct expression
*exp
)
162 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
165 /* Evaluate an expression, avoiding all memory references
166 and getting a value whose type alone is correct. */
169 evaluate_type (struct expression
*exp
)
172 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
175 /* If the next expression is an OP_LABELED, skips past it,
176 returning the label. Otherwise, does nothing and returns NULL. */
179 get_label (register struct expression
*exp
, int *pos
)
181 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
184 char *name
= &exp
->elts
[pc
+ 2].string
;
185 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
186 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
193 /* This function evaluates tuples (in (the deleted) Chill) or
194 brace-initializers (in C/C++) for structure types. */
196 static struct value
*
197 evaluate_struct_tuple (struct value
*struct_val
,
198 register struct expression
*exp
,
199 register int *pos
, enum noside noside
, int nargs
)
201 struct type
*struct_type
= check_typedef (VALUE_TYPE (struct_val
));
202 struct type
*substruct_type
= struct_type
;
203 struct type
*field_type
;
210 struct value
*val
= NULL
;
215 /* Skip past the labels, and count them. */
216 while (get_label (exp
, pos
) != NULL
)
221 char *label
= get_label (exp
, &pc
);
224 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
227 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
228 if (field_name
!= NULL
&& STREQ (field_name
, label
))
231 subfieldno
= fieldno
;
232 substruct_type
= struct_type
;
236 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
239 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
240 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
241 if ((field_name
== 0 || *field_name
== '\0')
242 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
245 for (; variantno
< TYPE_NFIELDS (field_type
);
249 = TYPE_FIELD_TYPE (field_type
, variantno
);
250 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
253 subfieldno
< TYPE_NFIELDS (substruct_type
);
256 if (STREQ (TYPE_FIELD_NAME (substruct_type
,
267 error ("there is no field named %s", label
);
273 /* Unlabelled tuple element - go to next field. */
277 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
280 substruct_type
= struct_type
;
286 subfieldno
= fieldno
;
287 if (fieldno
>= TYPE_NFIELDS (struct_type
))
288 error ("too many initializers");
289 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
290 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
291 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
292 error ("don't know which variant you want to set");
296 /* Here, struct_type is the type of the inner struct,
297 while substruct_type is the type of the inner struct.
298 These are the same for normal structures, but a variant struct
299 contains anonymous union fields that contain substruct fields.
300 The value fieldno is the index of the top-level (normal or
301 anonymous union) field in struct_field, while the value
302 subfieldno is the index of the actual real (named inner) field
303 in substruct_type. */
305 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
307 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
309 /* Now actually set the field in struct_val. */
311 /* Assign val to field fieldno. */
312 if (VALUE_TYPE (val
) != field_type
)
313 val
= value_cast (field_type
, val
);
315 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
316 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
318 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
319 addr
= VALUE_CONTENTS (struct_val
) + bitpos
/ 8;
321 modify_field (addr
, value_as_long (val
),
322 bitpos
% 8, bitsize
);
324 memcpy (addr
, VALUE_CONTENTS (val
),
325 TYPE_LENGTH (VALUE_TYPE (val
)));
327 while (--nlabels
> 0);
332 /* Recursive helper function for setting elements of array tuples for
333 (the deleted) Chill. The target is ARRAY (which has bounds
334 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
335 and NOSIDE are as usual. Evaluates index expresions and sets the
336 specified element(s) of ARRAY to ELEMENT. Returns last index
340 init_array_element (struct value
*array
, struct value
*element
,
341 register struct expression
*exp
, register int *pos
,
342 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
345 int element_size
= TYPE_LENGTH (VALUE_TYPE (element
));
346 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
349 init_array_element (array
, element
, exp
, pos
, noside
,
350 low_bound
, high_bound
);
351 return init_array_element (array
, element
,
352 exp
, pos
, noside
, low_bound
, high_bound
);
354 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
358 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
359 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
360 if (low
< low_bound
|| high
> high_bound
)
361 error ("tuple range index out of range");
362 for (index
= low
; index
<= high
; index
++)
364 memcpy (VALUE_CONTENTS_RAW (array
)
365 + (index
- low_bound
) * element_size
,
366 VALUE_CONTENTS (element
), element_size
);
371 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
372 if (index
< low_bound
|| index
> high_bound
)
373 error ("tuple index out of range");
374 memcpy (VALUE_CONTENTS_RAW (array
) + (index
- low_bound
) * element_size
,
375 VALUE_CONTENTS (element
), element_size
);
381 evaluate_subexp_standard (struct type
*expect_type
,
382 register struct expression
*exp
, register int *pos
,
387 register int pc
, pc2
= 0, oldpos
;
388 struct value
*arg1
= NULL
;
389 struct value
*arg2
= NULL
;
393 struct value
**argvec
;
394 int upper
, lower
, retcode
;
398 struct type
**arg_types
;
402 op
= exp
->elts
[pc
].opcode
;
407 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
408 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
409 arg1
= value_struct_elt_for_reference (exp
->elts
[pc
+ 1].type
,
411 exp
->elts
[pc
+ 1].type
,
412 &exp
->elts
[pc
+ 3].string
,
415 error ("There is no field named %s", &exp
->elts
[pc
+ 3].string
);
420 return value_from_longest (exp
->elts
[pc
+ 1].type
,
421 exp
->elts
[pc
+ 2].longconst
);
425 return value_from_double (exp
->elts
[pc
+ 1].type
,
426 exp
->elts
[pc
+ 2].doubleconst
);
430 if (noside
== EVAL_SKIP
)
433 /* JYG: We used to just return value_zero of the symbol type
434 if we're asked to avoid side effects. Otherwise we return
435 value_of_variable (...). However I'm not sure if
436 value_of_variable () has any side effect.
437 We need a full value object returned here for whatis_exp ()
438 to call evaluate_type () and then pass the full value to
439 value_rtti_target_type () if we are dealing with a pointer
440 or reference to a base class and print object is on. */
442 return value_of_variable (exp
->elts
[pc
+ 2].symbol
,
443 exp
->elts
[pc
+ 1].block
);
448 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
452 int regno
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
453 struct value
*val
= value_of_register (regno
, get_selected_frame ());
456 error ("Value of register %s not available.",
457 frame_map_regnum_to_name (get_selected_frame (), regno
));
463 return value_from_longest (LA_BOOL_TYPE
,
464 exp
->elts
[pc
+ 1].longconst
);
468 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
471 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
472 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
473 if (noside
== EVAL_SKIP
)
475 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
477 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
478 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
479 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
480 if (noside
== EVAL_SKIP
)
484 return (struct value
*) value_nsstring (&exp
->elts
[pc
+ 2].string
, tem
+ 1);
487 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
489 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
490 if (noside
== EVAL_SKIP
)
492 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
497 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
498 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
499 nargs
= tem3
- tem2
+ 1;
500 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
502 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
503 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
505 struct value
*rec
= allocate_value (expect_type
);
506 memset (VALUE_CONTENTS_RAW (rec
), '\0', TYPE_LENGTH (type
));
507 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
510 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
511 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
513 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
514 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
515 struct value
*array
= allocate_value (expect_type
);
516 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
517 LONGEST low_bound
, high_bound
, index
;
518 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
521 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
524 memset (VALUE_CONTENTS_RAW (array
), 0, TYPE_LENGTH (expect_type
));
525 for (tem
= nargs
; --nargs
>= 0;)
527 struct value
*element
;
529 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
532 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
534 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
535 if (VALUE_TYPE (element
) != element_type
)
536 element
= value_cast (element_type
, element
);
539 int continue_pc
= *pos
;
541 index
= init_array_element (array
, element
, exp
, pos
, noside
,
542 low_bound
, high_bound
);
547 if (index
> high_bound
)
548 /* to avoid memory corruption */
549 error ("Too many array elements");
550 memcpy (VALUE_CONTENTS_RAW (array
)
551 + (index
- low_bound
) * element_size
,
552 VALUE_CONTENTS (element
),
560 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
561 && TYPE_CODE (type
) == TYPE_CODE_SET
)
563 struct value
*set
= allocate_value (expect_type
);
564 char *valaddr
= VALUE_CONTENTS_RAW (set
);
565 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
566 struct type
*check_type
= element_type
;
567 LONGEST low_bound
, high_bound
;
569 /* get targettype of elementtype */
570 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
571 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
572 check_type
= TYPE_TARGET_TYPE (check_type
);
574 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
575 error ("(power)set type with unknown size");
576 memset (valaddr
, '\0', TYPE_LENGTH (type
));
577 for (tem
= 0; tem
< nargs
; tem
++)
579 LONGEST range_low
, range_high
;
580 struct type
*range_low_type
, *range_high_type
;
581 struct value
*elem_val
;
582 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
585 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
586 range_low_type
= VALUE_TYPE (elem_val
);
587 range_low
= value_as_long (elem_val
);
588 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
589 range_high_type
= VALUE_TYPE (elem_val
);
590 range_high
= value_as_long (elem_val
);
594 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
595 range_low_type
= range_high_type
= VALUE_TYPE (elem_val
);
596 range_low
= range_high
= value_as_long (elem_val
);
598 /* check types of elements to avoid mixture of elements from
599 different types. Also check if type of element is "compatible"
600 with element type of powerset */
601 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
602 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
603 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
604 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
605 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
606 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
607 (range_low_type
!= range_high_type
)))
608 /* different element modes */
609 error ("POWERSET tuple elements of different mode");
610 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
611 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
612 range_low_type
!= check_type
))
613 error ("incompatible POWERSET tuple elements");
614 if (range_low
> range_high
)
616 warning ("empty POWERSET tuple range");
619 if (range_low
< low_bound
|| range_high
> high_bound
)
620 error ("POWERSET tuple element out of range");
621 range_low
-= low_bound
;
622 range_high
-= low_bound
;
623 for (; range_low
<= range_high
; range_low
++)
625 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
627 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
628 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
635 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
636 for (tem
= 0; tem
< nargs
; tem
++)
638 /* Ensure that array expressions are coerced into pointer objects. */
639 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
641 if (noside
== EVAL_SKIP
)
643 return value_array (tem2
, tem3
, argvec
);
647 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
649 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
651 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
652 if (noside
== EVAL_SKIP
)
654 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
657 case TERNOP_SLICE_COUNT
:
659 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
661 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
663 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
664 return value_slice (array
, lowbound
, length
);
668 /* Skip third and second args to evaluate the first one. */
669 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
670 if (value_logical_not (arg1
))
672 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
673 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
677 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
678 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
682 case OP_OBJC_SELECTOR
:
683 { /* Objective C @selector operator. */
684 char *sel
= &exp
->elts
[pc
+ 2].string
;
685 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
687 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
688 if (noside
== EVAL_SKIP
)
692 sel
[len
] = 0; /* Make sure it's terminated. */
693 return value_from_longest (lookup_pointer_type (builtin_type_void
),
694 lookup_child_selector (sel
));
697 case OP_OBJC_MSGCALL
:
698 { /* Objective C message (method) call. */
700 static unsigned long responds_selector
= 0;
701 static unsigned long method_selector
= 0;
703 unsigned long selector
= 0;
706 int struct_return
= 0;
709 static struct value
*msg_send
= NULL
;
710 static struct value
*msg_send_stret
= NULL
;
711 static int gnu_runtime
= 0;
713 struct value
*target
= NULL
;
714 struct value
*method
= NULL
;
715 struct value
*called_method
= NULL
;
717 struct type
*selector_type
= NULL
;
719 struct value
*ret
= NULL
;
722 selector
= exp
->elts
[pc
+ 1].longconst
;
723 nargs
= exp
->elts
[pc
+ 2].longconst
;
724 argvec
= (struct value
**) alloca (sizeof (struct value
*)
729 selector_type
= lookup_pointer_type (builtin_type_void
);
730 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
731 sub_no_side
= EVAL_NORMAL
;
733 sub_no_side
= noside
;
735 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
737 if (value_as_long (target
) == 0)
738 return value_from_longest (builtin_type_long
, 0);
740 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
743 /* Find the method dispatch (Apple runtime) or method lookup
744 (GNU runtime) function for Objective-C. These will be used
745 to lookup the symbol information for the method. If we
746 can't find any symbol information, then we'll use these to
747 call the method, otherwise we can call the method
748 directly. The msg_send_stret function is used in the special
749 case of a method that returns a structure (Apple runtime
753 msg_send
= find_function_in_inferior ("objc_msg_lookup");
754 msg_send_stret
= find_function_in_inferior ("objc_msg_lookup");
758 msg_send
= find_function_in_inferior ("objc_msgSend");
759 /* Special dispatcher for methods returning structs */
760 msg_send_stret
= find_function_in_inferior ("objc_msgSend_stret");
763 /* Verify the target object responds to this method. The
764 standard top-level 'Object' class uses a different name for
765 the verification method than the non-standard, but more
766 often used, 'NSObject' class. Make sure we check for both. */
768 responds_selector
= lookup_child_selector ("respondsToSelector:");
769 if (responds_selector
== 0)
770 responds_selector
= lookup_child_selector ("respondsTo:");
772 if (responds_selector
== 0)
773 error ("no 'respondsTo:' or 'respondsToSelector:' method");
775 method_selector
= lookup_child_selector ("methodForSelector:");
776 if (method_selector
== 0)
777 method_selector
= lookup_child_selector ("methodFor:");
779 if (method_selector
== 0)
780 error ("no 'methodFor:' or 'methodForSelector:' method");
782 /* Call the verification method, to make sure that the target
783 class implements the desired method. */
785 argvec
[0] = msg_send
;
787 argvec
[2] = value_from_longest (builtin_type_long
, responds_selector
);
788 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
791 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
794 /* Function objc_msg_lookup returns a pointer. */
796 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
798 if (value_as_long (ret
) == 0)
799 error ("Target does not respond to this message selector.");
801 /* Call "methodForSelector:" method, to get the address of a
802 function method that implements this selector for this
803 class. If we can find a symbol at that address, then we
804 know the return type, parameter types etc. (that's a good
807 argvec
[0] = msg_send
;
809 argvec
[2] = value_from_longest (builtin_type_long
, method_selector
);
810 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
813 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
817 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
820 /* ret should now be the selector. */
822 addr
= value_as_long (ret
);
825 struct symbol
*sym
= NULL
;
826 /* Is it a high_level symbol? */
828 sym
= find_pc_function (addr
);
830 method
= value_of_variable (sym
, 0);
833 /* If we found a method with symbol information, check to see
834 if it returns a struct. Otherwise assume it doesn't. */
840 struct type
*value_type
;
842 funaddr
= find_function_addr (method
, &value_type
);
844 b
= block_for_pc (funaddr
);
846 /* If compiled without -g, assume GCC 2. */
847 using_gcc
= (b
== NULL
? 2 : BLOCK_GCC_COMPILED (b
));
849 CHECK_TYPEDEF (value_type
);
851 if ((value_type
== NULL
)
852 || (TYPE_CODE(value_type
) == TYPE_CODE_ERROR
))
854 if (expect_type
!= NULL
)
855 value_type
= expect_type
;
858 struct_return
= using_struct_return (method
, funaddr
, value_type
, using_gcc
);
860 else if (expect_type
!= NULL
)
862 struct_return
= using_struct_return (NULL
, addr
, check_typedef (expect_type
), using_gcc
);
865 /* Found a function symbol. Now we will substitute its
866 value in place of the message dispatcher (obj_msgSend),
867 so that we call the method directly instead of thru
868 the dispatcher. The main reason for doing this is that
869 we can now evaluate the return value and parameter values
870 according to their known data types, in case we need to
871 do things like promotion, dereferencing, special handling
872 of structs and doubles, etc.
874 We want to use the type signature of 'method', but still
875 jump to objc_msgSend() or objc_msgSend_stret() to better
876 mimic the behavior of the runtime. */
880 if (TYPE_CODE (VALUE_TYPE (method
)) != TYPE_CODE_FUNC
)
881 error ("method address has symbol information with non-function type; skipping");
883 VALUE_ADDRESS (method
) = value_as_address (msg_send_stret
);
885 VALUE_ADDRESS (method
) = value_as_address (msg_send
);
886 called_method
= method
;
891 called_method
= msg_send_stret
;
893 called_method
= msg_send
;
896 if (noside
== EVAL_SKIP
)
899 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
901 /* If the return type doesn't look like a function type,
902 call an error. This can happen if somebody tries to
903 turn a variable into a function call. This is here
904 because people often want to call, eg, strcmp, which
905 gdb doesn't know is a function. If gdb isn't asked for
906 it's opinion (ie. through "whatis"), it won't offer
909 struct type
*type
= VALUE_TYPE (called_method
);
910 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
911 type
= TYPE_TARGET_TYPE (type
);
912 type
= TYPE_TARGET_TYPE (type
);
916 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
917 return allocate_value (expect_type
);
919 return allocate_value (type
);
922 error ("Expression of type other than \"method returning ...\" used as a method");
925 /* Now depending on whether we found a symbol for the method,
926 we will either call the runtime dispatcher or the method
929 argvec
[0] = called_method
;
931 argvec
[2] = value_from_longest (builtin_type_long
, selector
);
932 /* User-supplied arguments. */
933 for (tem
= 0; tem
< nargs
; tem
++)
934 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
937 if (gnu_runtime
&& (method
!= NULL
))
939 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
940 /* Function objc_msg_lookup returns a pointer. */
942 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
945 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
953 op
= exp
->elts
[*pos
].opcode
;
954 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
955 /* Allocate arg vector, including space for the function to be
956 called in argvec[0] and a terminating NULL */
957 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
958 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
962 /* 1997-08-01 Currently we do not support function invocation
963 via pointers-to-methods with HP aCC. Pointer does not point
964 to the function, but possibly to some thunk. */
965 if (hp_som_som_object_present
)
967 error ("Not implemented: function invocation through pointer to method with HP aCC");
971 /* First, evaluate the structure into arg2 */
974 if (noside
== EVAL_SKIP
)
977 if (op
== STRUCTOP_MEMBER
)
979 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
983 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
986 /* If the function is a virtual function, then the
987 aggregate value (providing the structure) plays
988 its part by providing the vtable. Otherwise,
989 it is just along for the ride: call the function
992 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
994 fnptr
= value_as_long (arg1
);
996 if (METHOD_PTR_IS_VIRTUAL (fnptr
))
998 int fnoffset
= METHOD_PTR_TO_VOFFSET (fnptr
);
999 struct type
*basetype
;
1000 struct type
*domain_type
=
1001 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
1003 basetype
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
1004 if (domain_type
!= basetype
)
1005 arg2
= value_cast (lookup_pointer_type (domain_type
), arg2
);
1006 basetype
= TYPE_VPTR_BASETYPE (domain_type
);
1007 for (i
= TYPE_NFN_FIELDS (basetype
) - 1; i
>= 0; i
--)
1009 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (basetype
, i
);
1010 /* If one is virtual, then all are virtual. */
1011 if (TYPE_FN_FIELD_VIRTUAL_P (f
, 0))
1012 for (j
= TYPE_FN_FIELDLIST_LENGTH (basetype
, i
) - 1; j
>= 0; --j
)
1013 if ((int) TYPE_FN_FIELD_VOFFSET (f
, j
) == fnoffset
)
1015 struct value
*temp
= value_ind (arg2
);
1016 arg1
= value_virtual_fn_field (&temp
, f
, j
, domain_type
, 0);
1017 arg2
= value_addr (temp
);
1022 error ("virtual function at index %d not found", fnoffset
);
1026 VALUE_TYPE (arg1
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
1030 /* Now, say which argument to start evaluating from */
1033 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1035 /* Hair for method invocations */
1039 /* First, evaluate the structure into arg2 */
1041 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1042 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1043 if (noside
== EVAL_SKIP
)
1046 if (op
== STRUCTOP_STRUCT
)
1048 /* If v is a variable in a register, and the user types
1049 v.method (), this will produce an error, because v has
1052 A possible way around this would be to allocate a
1053 copy of the variable on the stack, copy in the
1054 contents, call the function, and copy out the
1055 contents. I.e. convert this from call by reference
1056 to call by copy-return (or whatever it's called).
1057 However, this does not work because it is not the
1058 same: the method being called could stash a copy of
1059 the address, and then future uses through that address
1060 (after the method returns) would be expected to
1061 use the variable itself, not some copy of it. */
1062 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1066 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1068 /* Now, say which argument to start evaluating from */
1073 /* Non-method function call */
1075 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1077 type
= VALUE_TYPE (argvec
[0]);
1078 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1079 type
= TYPE_TARGET_TYPE (type
);
1080 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1082 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1084 /* pai: FIXME This seems to be coercing arguments before
1085 * overload resolution has been done! */
1086 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1092 /* Evaluate arguments */
1093 for (; tem
<= nargs
; tem
++)
1095 /* Ensure that array expressions are coerced into pointer objects. */
1096 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1099 /* signal end of arglist */
1102 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1104 int static_memfuncp
;
1107 /* Method invocation : stuff "this" as first parameter */
1109 /* Name of method from expression */
1110 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1112 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1114 /* Language is C++, do some overload resolution before evaluation */
1115 struct value
*valp
= NULL
;
1117 /* Prepare list of argument types for overload resolution */
1118 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1119 for (ix
= 1; ix
<= nargs
; ix
++)
1120 arg_types
[ix
- 1] = VALUE_TYPE (argvec
[ix
]);
1122 (void) find_overload_match (arg_types
, nargs
, tstr
,
1123 1 /* method */ , 0 /* strict match */ ,
1124 &arg2
/* the object */ , NULL
,
1125 &valp
, NULL
, &static_memfuncp
);
1128 argvec
[1] = arg2
; /* the ``this'' pointer */
1129 argvec
[0] = valp
; /* use the method found after overload resolution */
1132 /* Non-C++ case -- or no overload resolution */
1134 struct value
*temp
= arg2
;
1135 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1137 op
== STRUCTOP_STRUCT
1138 ? "structure" : "structure pointer");
1139 /* value_struct_elt updates temp with the correct value
1140 of the ``this'' pointer if necessary, so modify argvec[1] to
1141 reflect any ``this'' changes. */
1142 arg2
= value_from_longest (lookup_pointer_type(VALUE_TYPE (temp
)),
1143 VALUE_ADDRESS (temp
) + VALUE_OFFSET (temp
)
1144 + VALUE_EMBEDDED_OFFSET (temp
));
1145 argvec
[1] = arg2
; /* the ``this'' pointer */
1148 if (static_memfuncp
)
1150 argvec
[1] = argvec
[0];
1155 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1160 else if (op
== OP_VAR_VALUE
)
1162 /* Non-member function being called */
1163 /* fn: This can only be done for C++ functions. A C-style function
1164 in a C++ program, for instance, does not have the fields that
1165 are expected here */
1167 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1169 /* Language is C++, do some overload resolution before evaluation */
1170 struct symbol
*symp
;
1172 /* Prepare list of argument types for overload resolution */
1173 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1174 for (ix
= 1; ix
<= nargs
; ix
++)
1175 arg_types
[ix
- 1] = VALUE_TYPE (argvec
[ix
]);
1177 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1178 0 /* not method */ , 0 /* strict match */ ,
1179 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1182 /* Now fix the expression being evaluated */
1183 exp
->elts
[save_pos1
+2].symbol
= symp
;
1184 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1188 /* Not C++, or no overload resolution allowed */
1189 /* nothing to be done; argvec already correctly set up */
1194 /* It is probably a C-style function */
1195 /* nothing to be done; argvec already correctly set up */
1200 if (noside
== EVAL_SKIP
)
1202 if (argvec
[0] == NULL
)
1203 error ("Cannot evaluate function -- may be inlined");
1204 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1206 /* If the return type doesn't look like a function type, call an
1207 error. This can happen if somebody tries to turn a variable into
1208 a function call. This is here because people often want to
1209 call, eg, strcmp, which gdb doesn't know is a function. If
1210 gdb isn't asked for it's opinion (ie. through "whatis"),
1211 it won't offer it. */
1213 struct type
*ftype
=
1214 TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0]));
1217 return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0])));
1219 error ("Expression of type other than \"Function returning ...\" used as function");
1221 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1222 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1224 case OP_F77_UNDETERMINED_ARGLIST
:
1226 /* Remember that in F77, functions, substring ops and
1227 array subscript operations cannot be disambiguated
1228 at parse time. We have made all array subscript operations,
1229 substring operations as well as function calls come here
1230 and we now have to discover what the heck this thing actually was.
1231 If it is a function, we process just as if we got an OP_FUNCALL. */
1233 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1236 /* First determine the type code we are dealing with. */
1237 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1238 type
= check_typedef (VALUE_TYPE (arg1
));
1239 code
= TYPE_CODE (type
);
1243 case TYPE_CODE_ARRAY
:
1244 goto multi_f77_subscript
;
1246 case TYPE_CODE_STRING
:
1250 case TYPE_CODE_FUNC
:
1251 /* It's a function call. */
1252 /* Allocate arg vector, including space for the function to be
1253 called in argvec[0] and a terminating NULL */
1254 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1257 for (; tem
<= nargs
; tem
++)
1258 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1259 argvec
[tem
] = 0; /* signal end of arglist */
1263 error ("Cannot perform substring on this type");
1267 /* We have a substring operation on our hands here,
1268 let us get the string we will be dealing with */
1270 /* Now evaluate the 'from' and 'to' */
1272 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1275 return value_subscript (arg1
, arg2
);
1277 arg3
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1279 if (noside
== EVAL_SKIP
)
1282 tem2
= value_as_long (arg2
);
1283 tem3
= value_as_long (arg3
);
1285 return value_slice (arg1
, tem2
, tem3
- tem2
+ 1);
1288 /* We have a complex number, There should be 2 floating
1289 point numbers that compose it */
1290 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1291 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1293 return value_literal_complex (arg1
, arg2
, builtin_type_f_complex_s16
);
1295 case STRUCTOP_STRUCT
:
1296 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1297 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1298 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1299 if (noside
== EVAL_SKIP
)
1301 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1302 return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1
),
1303 &exp
->elts
[pc
+ 2].string
,
1308 struct value
*temp
= arg1
;
1309 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1314 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1315 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1316 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1317 if (noside
== EVAL_SKIP
)
1320 /* JYG: if print object is on we need to replace the base type
1321 with rtti type in order to continue on with successful
1322 lookup of member / method only available in the rtti type. */
1324 struct type
*type
= VALUE_TYPE (arg1
);
1325 struct type
*real_type
;
1326 int full
, top
, using_enc
;
1328 if (objectprint
&& TYPE_TARGET_TYPE(type
) &&
1329 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1331 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1334 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1335 real_type
= lookup_pointer_type (real_type
);
1337 real_type
= lookup_reference_type (real_type
);
1339 arg1
= value_cast (real_type
, arg1
);
1344 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1345 return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1
),
1346 &exp
->elts
[pc
+ 2].string
,
1351 struct value
*temp
= arg1
;
1352 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1353 NULL
, "structure pointer");
1356 case STRUCTOP_MEMBER
:
1357 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1358 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1360 /* With HP aCC, pointers to methods do not point to the function code */
1361 if (hp_som_som_object_present
&&
1362 (TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_PTR
) &&
1363 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2
))) == TYPE_CODE_METHOD
))
1364 error ("Pointers to methods not supported with HP aCC"); /* 1997-08-19 */
1366 mem_offset
= value_as_long (arg2
);
1367 goto handle_pointer_to_member
;
1370 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1371 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1373 /* With HP aCC, pointers to methods do not point to the function code */
1374 if (hp_som_som_object_present
&&
1375 (TYPE_CODE (VALUE_TYPE (arg2
)) == TYPE_CODE_PTR
) &&
1376 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2
))) == TYPE_CODE_METHOD
))
1377 error ("Pointers to methods not supported with HP aCC"); /* 1997-08-19 */
1379 mem_offset
= value_as_long (arg2
);
1381 handle_pointer_to_member
:
1382 /* HP aCC generates offsets that have bit #29 set; turn it off to get
1383 a real offset to the member. */
1384 if (hp_som_som_object_present
)
1386 if (!mem_offset
) /* no bias -> really null */
1387 error ("Attempted dereference of null pointer-to-member");
1388 mem_offset
&= ~0x20000000;
1390 if (noside
== EVAL_SKIP
)
1392 type
= check_typedef (VALUE_TYPE (arg2
));
1393 if (TYPE_CODE (type
) != TYPE_CODE_PTR
)
1394 goto bad_pointer_to_member
;
1395 type
= check_typedef (TYPE_TARGET_TYPE (type
));
1396 if (TYPE_CODE (type
) == TYPE_CODE_METHOD
)
1397 error ("not implemented: pointer-to-method in pointer-to-member construct");
1398 if (TYPE_CODE (type
) != TYPE_CODE_MEMBER
)
1399 goto bad_pointer_to_member
;
1400 /* Now, convert these values to an address. */
1401 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1403 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1404 value_as_long (arg1
) + mem_offset
);
1405 return value_ind (arg3
);
1406 bad_pointer_to_member
:
1407 error ("non-pointer-to-member value used in pointer-to-member construct");
1410 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1411 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1412 if (noside
== EVAL_SKIP
)
1414 if (binop_user_defined_p (op
, arg1
, arg2
))
1415 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1417 return value_concat (arg1
, arg2
);
1420 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1421 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1423 /* Do special stuff for HP aCC pointers to members */
1424 if (hp_som_som_object_present
)
1426 /* 1997-08-19 Can't assign HP aCC pointers to methods. No details of
1427 the implementation yet; but the pointer appears to point to a code
1428 sequence (thunk) in memory -- in any case it is *not* the address
1429 of the function as it would be in a naive implementation. */
1430 if ((TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
) &&
1431 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_METHOD
))
1432 error ("Assignment to pointers to methods not implemented with HP aCC");
1434 /* HP aCC pointers to data members require a constant bias */
1435 if ((TYPE_CODE (VALUE_TYPE (arg1
)) == TYPE_CODE_PTR
) &&
1436 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_MEMBER
))
1438 unsigned int *ptr
= (unsigned int *) VALUE_CONTENTS (arg2
); /* forces evaluation */
1439 *ptr
|= 0x20000000; /* set 29th bit */
1443 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1445 if (binop_user_defined_p (op
, arg1
, arg2
))
1446 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1448 return value_assign (arg1
, arg2
);
1450 case BINOP_ASSIGN_MODIFY
:
1452 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1453 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1454 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1456 op
= exp
->elts
[pc
+ 1].opcode
;
1457 if (binop_user_defined_p (op
, arg1
, arg2
))
1458 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1459 else if (op
== BINOP_ADD
)
1460 arg2
= value_add (arg1
, arg2
);
1461 else if (op
== BINOP_SUB
)
1462 arg2
= value_sub (arg1
, arg2
);
1464 arg2
= value_binop (arg1
, arg2
, op
);
1465 return value_assign (arg1
, arg2
);
1468 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1469 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1470 if (noside
== EVAL_SKIP
)
1472 if (binop_user_defined_p (op
, arg1
, arg2
))
1473 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1475 return value_add (arg1
, arg2
);
1478 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1479 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1480 if (noside
== EVAL_SKIP
)
1482 if (binop_user_defined_p (op
, arg1
, arg2
))
1483 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1485 return value_sub (arg1
, arg2
);
1493 case BINOP_BITWISE_AND
:
1494 case BINOP_BITWISE_IOR
:
1495 case BINOP_BITWISE_XOR
:
1496 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1497 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1498 if (noside
== EVAL_SKIP
)
1500 if (binop_user_defined_p (op
, arg1
, arg2
))
1501 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1502 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
1503 && (op
== BINOP_DIV
|| op
== BINOP_REM
|| op
== BINOP_MOD
))
1504 return value_zero (VALUE_TYPE (arg1
), not_lval
);
1506 return value_binop (arg1
, arg2
, op
);
1509 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1510 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1511 if (noside
== EVAL_SKIP
)
1513 error ("':' operator used in invalid context");
1515 case BINOP_SUBSCRIPT
:
1516 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1517 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1518 if (noside
== EVAL_SKIP
)
1520 if (binop_user_defined_p (op
, arg1
, arg2
))
1521 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1524 /* If the user attempts to subscript something that is not an
1525 array or pointer type (like a plain int variable for example),
1526 then report this as an error. */
1529 type
= check_typedef (VALUE_TYPE (arg1
));
1530 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1531 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1533 if (TYPE_NAME (type
))
1534 error ("cannot subscript something of type `%s'",
1537 error ("cannot subscript requested type");
1540 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1541 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1543 return value_subscript (arg1
, arg2
);
1547 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1548 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1549 if (noside
== EVAL_SKIP
)
1551 return value_in (arg1
, arg2
);
1553 case MULTI_SUBSCRIPT
:
1555 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1556 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1559 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1560 /* FIXME: EVAL_SKIP handling may not be correct. */
1561 if (noside
== EVAL_SKIP
)
1572 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1573 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1575 /* If the user attempts to subscript something that has no target
1576 type (like a plain int variable for example), then report this
1579 type
= TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1
)));
1582 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1588 error ("cannot subscript something of type `%s'",
1589 TYPE_NAME (VALUE_TYPE (arg1
)));
1593 if (binop_user_defined_p (op
, arg1
, arg2
))
1595 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1599 arg1
= value_subscript (arg1
, arg2
);
1604 multi_f77_subscript
:
1606 int subscript_array
[MAX_FORTRAN_DIMS
+ 1]; /* 1-based array of
1607 subscripts, max == 7 */
1608 int array_size_array
[MAX_FORTRAN_DIMS
+ 1];
1609 int ndimensions
= 1, i
;
1610 struct type
*tmp_type
;
1611 int offset_item
; /* The array offset where the item lives */
1613 if (nargs
> MAX_FORTRAN_DIMS
)
1614 error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS
);
1616 tmp_type
= check_typedef (VALUE_TYPE (arg1
));
1617 ndimensions
= calc_f77_array_dims (type
);
1619 if (nargs
!= ndimensions
)
1620 error ("Wrong number of subscripts");
1622 /* Now that we know we have a legal array subscript expression
1623 let us actually find out where this element exists in the array. */
1626 for (i
= 1; i
<= nargs
; i
++)
1628 /* Evaluate each subscript, It must be a legal integer in F77 */
1629 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1631 /* Fill in the subscript and array size arrays */
1633 subscript_array
[i
] = value_as_long (arg2
);
1635 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1636 if (retcode
== BOUND_FETCH_ERROR
)
1637 error ("Cannot obtain dynamic upper bound");
1639 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1640 if (retcode
== BOUND_FETCH_ERROR
)
1641 error ("Cannot obtain dynamic lower bound");
1643 array_size_array
[i
] = upper
- lower
+ 1;
1645 /* Zero-normalize subscripts so that offsetting will work. */
1647 subscript_array
[i
] -= lower
;
1649 /* If we are at the bottom of a multidimensional
1650 array type then keep a ptr to the last ARRAY
1651 type around for use when calling value_subscript()
1652 below. This is done because we pretend to value_subscript
1653 that we actually have a one-dimensional array
1654 of base element type that we apply a simple
1658 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1661 /* Now let us calculate the offset for this item */
1663 offset_item
= subscript_array
[ndimensions
];
1665 for (i
= ndimensions
- 1; i
>= 1; i
--)
1667 array_size_array
[i
] * offset_item
+ subscript_array
[i
];
1669 /* Let us now play a dirty trick: we will take arg1
1670 which is a value node pointing to the topmost level
1671 of the multidimensional array-set and pretend
1672 that it is actually a array of the final element
1673 type, this will ensure that value_subscript()
1674 returns the correct type value */
1676 VALUE_TYPE (arg1
) = tmp_type
;
1678 f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1680 /* Construct a value node with the value of the offset */
1681 /* lower will get subtracted off in value_subscript, hence add it here */
1683 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
+ lower
);
1685 return value_subscript(arg1
, arg2
);
1688 case BINOP_LOGICAL_AND
:
1689 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1690 if (noside
== EVAL_SKIP
)
1692 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1697 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1700 if (binop_user_defined_p (op
, arg1
, arg2
))
1702 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1703 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1707 tem
= value_logical_not (arg1
);
1708 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1709 (tem
? EVAL_SKIP
: noside
));
1710 return value_from_longest (LA_BOOL_TYPE
,
1711 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
1714 case BINOP_LOGICAL_OR
:
1715 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1716 if (noside
== EVAL_SKIP
)
1718 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1723 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1726 if (binop_user_defined_p (op
, arg1
, arg2
))
1728 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1729 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1733 tem
= value_logical_not (arg1
);
1734 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1735 (!tem
? EVAL_SKIP
: noside
));
1736 return value_from_longest (LA_BOOL_TYPE
,
1737 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
1741 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1742 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1743 if (noside
== EVAL_SKIP
)
1745 if (binop_user_defined_p (op
, arg1
, arg2
))
1747 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1751 tem
= value_equal (arg1
, arg2
);
1752 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1755 case BINOP_NOTEQUAL
:
1756 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1757 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1758 if (noside
== EVAL_SKIP
)
1760 if (binop_user_defined_p (op
, arg1
, arg2
))
1762 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1766 tem
= value_equal (arg1
, arg2
);
1767 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) ! tem
);
1771 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1772 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1773 if (noside
== EVAL_SKIP
)
1775 if (binop_user_defined_p (op
, arg1
, arg2
))
1777 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1781 tem
= value_less (arg1
, arg2
);
1782 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1786 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1787 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1788 if (noside
== EVAL_SKIP
)
1790 if (binop_user_defined_p (op
, arg1
, arg2
))
1792 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1796 tem
= value_less (arg2
, arg1
);
1797 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1801 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1802 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1803 if (noside
== EVAL_SKIP
)
1805 if (binop_user_defined_p (op
, arg1
, arg2
))
1807 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1811 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1812 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1816 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1817 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
1818 if (noside
== EVAL_SKIP
)
1820 if (binop_user_defined_p (op
, arg1
, arg2
))
1822 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1826 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1827 return value_from_longest (LA_BOOL_TYPE
, (LONGEST
) tem
);
1831 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1832 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1833 if (noside
== EVAL_SKIP
)
1835 type
= check_typedef (VALUE_TYPE (arg2
));
1836 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
1837 error ("Non-integral right operand for \"@\" operator.");
1838 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1840 return allocate_repeat_value (VALUE_TYPE (arg1
),
1841 longest_to_int (value_as_long (arg2
)));
1844 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1847 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1848 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1851 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1852 if (noside
== EVAL_SKIP
)
1854 if (unop_user_defined_p (op
, arg1
))
1855 return value_x_unop (arg1
, op
, noside
);
1857 return value_neg (arg1
);
1859 case UNOP_COMPLEMENT
:
1860 /* C++: check for and handle destructor names. */
1861 op
= exp
->elts
[*pos
].opcode
;
1863 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1864 if (noside
== EVAL_SKIP
)
1866 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1867 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1869 return value_complement (arg1
);
1871 case UNOP_LOGICAL_NOT
:
1872 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1873 if (noside
== EVAL_SKIP
)
1875 if (unop_user_defined_p (op
, arg1
))
1876 return value_x_unop (arg1
, op
, noside
);
1878 return value_from_longest (LA_BOOL_TYPE
,
1879 (LONGEST
) value_logical_not (arg1
));
1882 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
1883 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
1884 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1885 if ((TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) &&
1886 ((TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_METHOD
) ||
1887 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
))) == TYPE_CODE_MEMBER
)))
1888 error ("Attempt to dereference pointer to member without an object");
1889 if (noside
== EVAL_SKIP
)
1891 if (unop_user_defined_p (op
, arg1
))
1892 return value_x_unop (arg1
, op
, noside
);
1893 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1895 type
= check_typedef (VALUE_TYPE (arg1
));
1896 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1897 || TYPE_CODE (type
) == TYPE_CODE_REF
1898 /* In C you can dereference an array to get the 1st elt. */
1899 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1901 return value_zero (TYPE_TARGET_TYPE (type
),
1903 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
1904 /* GDB allows dereferencing an int. */
1905 return value_zero (builtin_type_int
, lval_memory
);
1907 error ("Attempt to take contents of a non-pointer value.");
1909 return value_ind (arg1
);
1912 /* C++: check for and handle pointer to members. */
1914 op
= exp
->elts
[*pos
].opcode
;
1916 if (noside
== EVAL_SKIP
)
1920 int temm
= longest_to_int (exp
->elts
[pc
+ 3].longconst
);
1921 (*pos
) += 3 + BYTES_TO_EXP_ELEM (temm
+ 1);
1924 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1929 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
1930 /* If HP aCC object, use bias for pointers to members */
1931 if (hp_som_som_object_present
&&
1932 (TYPE_CODE (VALUE_TYPE (retvalp
)) == TYPE_CODE_PTR
) &&
1933 (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (retvalp
))) == TYPE_CODE_MEMBER
))
1935 unsigned int *ptr
= (unsigned int *) VALUE_CONTENTS (retvalp
); /* forces evaluation */
1936 *ptr
|= 0x20000000; /* set 29th bit */
1942 if (noside
== EVAL_SKIP
)
1944 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
1947 return evaluate_subexp_for_sizeof (exp
, pos
);
1951 type
= exp
->elts
[pc
+ 1].type
;
1952 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
1953 if (noside
== EVAL_SKIP
)
1955 if (type
!= VALUE_TYPE (arg1
))
1956 arg1
= value_cast (type
, arg1
);
1961 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1962 if (noside
== EVAL_SKIP
)
1964 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1965 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
1967 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
1968 value_as_address (arg1
),
1971 case UNOP_PREINCREMENT
:
1972 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1973 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1975 else if (unop_user_defined_p (op
, arg1
))
1977 return value_x_unop (arg1
, op
, noside
);
1981 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
1983 return value_assign (arg1
, arg2
);
1986 case UNOP_PREDECREMENT
:
1987 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1988 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1990 else if (unop_user_defined_p (op
, arg1
))
1992 return value_x_unop (arg1
, op
, noside
);
1996 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
1998 return value_assign (arg1
, arg2
);
2001 case UNOP_POSTINCREMENT
:
2002 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2003 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2005 else if (unop_user_defined_p (op
, arg1
))
2007 return value_x_unop (arg1
, op
, noside
);
2011 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
2013 value_assign (arg1
, arg2
);
2017 case UNOP_POSTDECREMENT
:
2018 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2019 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2021 else if (unop_user_defined_p (op
, arg1
))
2023 return value_x_unop (arg1
, op
, noside
);
2027 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2029 value_assign (arg1
, arg2
);
2035 return value_of_this (1);
2039 return value_of_local ("self", 1);
2042 error ("Attempt to use a type name as an expression");
2045 /* Removing this case and compiling with gcc -Wall reveals that
2046 a lot of cases are hitting this case. Some of these should
2047 probably be removed from expression.h; others are legitimate
2048 expressions which are (apparently) not fully implemented.
2050 If there are any cases landing here which mean a user error,
2051 then they should be separate cases, with more descriptive
2055 GDB does not (yet) know how to evaluate that kind of expression");
2059 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
2062 /* Evaluate a subexpression of EXP, at index *POS,
2063 and return the address of that subexpression.
2064 Advance *POS over the subexpression.
2065 If the subexpression isn't an lvalue, get an error.
2066 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2067 then only the type of the result need be correct. */
2069 static struct value
*
2070 evaluate_subexp_for_address (register struct expression
*exp
, register int *pos
,
2078 op
= exp
->elts
[pc
].opcode
;
2084 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2088 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2089 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2092 var
= exp
->elts
[pc
+ 2].symbol
;
2094 /* C++: The "address" of a reference should yield the address
2095 * of the object pointed to. Let value_addr() deal with it. */
2096 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2100 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2103 lookup_pointer_type (SYMBOL_TYPE (var
));
2104 enum address_class sym_class
= SYMBOL_CLASS (var
);
2106 if (sym_class
== LOC_CONST
2107 || sym_class
== LOC_CONST_BYTES
2108 || sym_class
== LOC_REGISTER
2109 || sym_class
== LOC_REGPARM
)
2110 error ("Attempt to take address of register or constant.");
2113 value_zero (type
, not_lval
);
2119 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2123 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2125 struct value
*x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2126 if (VALUE_LVAL (x
) == lval_memory
)
2127 return value_zero (lookup_pointer_type (VALUE_TYPE (x
)),
2130 error ("Attempt to take address of non-lval");
2132 return value_addr (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2136 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2137 When used in contexts where arrays will be coerced anyway, this is
2138 equivalent to `evaluate_subexp' but much faster because it avoids
2139 actually fetching array contents (perhaps obsolete now that we have
2142 Note that we currently only do the coercion for C expressions, where
2143 arrays are zero based and the coercion is correct. For other languages,
2144 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2145 to decide if coercion is appropriate.
2150 evaluate_subexp_with_coercion (register struct expression
*exp
,
2151 register int *pos
, enum noside noside
)
2153 register enum exp_opcode op
;
2159 op
= exp
->elts
[pc
].opcode
;
2164 var
= exp
->elts
[pc
+ 2].symbol
;
2165 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
2166 && CAST_IS_CONVERSION
)
2171 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2172 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
2178 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2182 /* Evaluate a subexpression of EXP, at index *POS,
2183 and return a value for the size of that subexpression.
2184 Advance *POS over the subexpression. */
2186 static struct value
*
2187 evaluate_subexp_for_sizeof (register struct expression
*exp
, register int *pos
)
2195 op
= exp
->elts
[pc
].opcode
;
2199 /* This case is handled specially
2200 so that we avoid creating a value for the result type.
2201 If the result type is very big, it's desirable not to
2202 create a value unnecessarily. */
2205 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2206 type
= check_typedef (VALUE_TYPE (val
));
2207 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2208 && TYPE_CODE (type
) != TYPE_CODE_REF
2209 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2210 error ("Attempt to take contents of a non-pointer value.");
2211 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2212 return value_from_longest (builtin_type_int
, (LONGEST
)
2213 TYPE_LENGTH (type
));
2217 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2218 return value_from_longest (builtin_type_int
,
2219 (LONGEST
) TYPE_LENGTH (type
));
2223 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2225 value_from_longest (builtin_type_int
, (LONGEST
) TYPE_LENGTH (type
));
2228 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2229 return value_from_longest (builtin_type_int
,
2230 (LONGEST
) TYPE_LENGTH (VALUE_TYPE (val
)));
2234 /* Parse a type expression in the string [P..P+LENGTH). */
2237 parse_and_eval_type (char *p
, int length
)
2239 char *tmp
= (char *) alloca (length
+ 4);
2240 struct expression
*expr
;
2242 memcpy (tmp
+ 1, p
, length
);
2243 tmp
[length
+ 1] = ')';
2244 tmp
[length
+ 2] = '0';
2245 tmp
[length
+ 3] = '\0';
2246 expr
= parse_expression (tmp
);
2247 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2248 error ("Internal error in eval_type.");
2249 return expr
->elts
[1].type
;
2253 calc_f77_array_dims (struct type
*array_type
)
2256 struct type
*tmp_type
;
2258 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2259 error ("Can't get dimensions for a non-array type");
2261 tmp_type
= array_type
;
2263 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2265 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)