1 /* Evaluate expressions for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 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, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
27 #include "expression.h"
30 #include "language.h" /* For CAST_IS_CONVERSION */
31 #include "f-lang.h" /* for array bound stuff */
34 #include "objc-lang.h"
36 #include "parser-defs.h"
37 #include "cp-support.h"
39 #include "exceptions.h"
41 #include "user-regs.h"
43 #include "gdb_assert.h"
45 /* This is defined in valops.c */
46 extern int overload_resolution
;
48 /* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
49 on with successful lookup for member/method of the rtti type. */
50 extern int objectprint
;
52 /* Prototypes for local functions. */
54 static struct value
*evaluate_subexp_for_sizeof (struct expression
*, int *);
56 static struct value
*evaluate_subexp_for_address (struct expression
*,
59 static struct value
*evaluate_subexp (struct type
*, struct expression
*,
62 static char *get_label (struct expression
*, int *);
64 static struct value
*evaluate_struct_tuple (struct value
*,
65 struct expression
*, int *,
68 static LONGEST
init_array_element (struct value
*, struct value
*,
69 struct expression
*, int *, enum noside
,
73 evaluate_subexp (struct type
*expect_type
, struct expression
*exp
,
74 int *pos
, enum noside noside
)
76 return (*exp
->language_defn
->la_exp_desc
->evaluate_exp
)
77 (expect_type
, exp
, pos
, noside
);
80 /* Parse the string EXP as a C expression, evaluate it,
81 and return the result as a number. */
84 parse_and_eval_address (char *exp
)
86 struct expression
*expr
= parse_expression (exp
);
88 struct cleanup
*old_chain
=
89 make_cleanup (free_current_contents
, &expr
);
91 addr
= value_as_address (evaluate_expression (expr
));
92 do_cleanups (old_chain
);
96 /* Like parse_and_eval_address but takes a pointer to a char * variable
97 and advanced that variable across the characters parsed. */
100 parse_and_eval_address_1 (char **expptr
)
102 struct expression
*expr
= parse_exp_1 (expptr
, (struct block
*) 0, 0);
104 struct cleanup
*old_chain
=
105 make_cleanup (free_current_contents
, &expr
);
107 addr
= value_as_address (evaluate_expression (expr
));
108 do_cleanups (old_chain
);
112 /* Like parse_and_eval_address, but treats the value of the expression
113 as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
115 parse_and_eval_long (char *exp
)
117 struct expression
*expr
= parse_expression (exp
);
119 struct cleanup
*old_chain
=
120 make_cleanup (free_current_contents
, &expr
);
122 retval
= value_as_long (evaluate_expression (expr
));
123 do_cleanups (old_chain
);
128 parse_and_eval (char *exp
)
130 struct expression
*expr
= parse_expression (exp
);
132 struct cleanup
*old_chain
=
133 make_cleanup (free_current_contents
, &expr
);
135 val
= evaluate_expression (expr
);
136 do_cleanups (old_chain
);
140 /* Parse up to a comma (or to a closeparen)
141 in the string EXPP as an expression, evaluate it, and return the value.
142 EXPP is advanced to point to the comma. */
145 parse_to_comma_and_eval (char **expp
)
147 struct expression
*expr
= parse_exp_1 (expp
, (struct block
*) 0, 1);
149 struct cleanup
*old_chain
=
150 make_cleanup (free_current_contents
, &expr
);
152 val
= evaluate_expression (expr
);
153 do_cleanups (old_chain
);
157 /* Evaluate an expression in internal prefix form
158 such as is constructed by parse.y.
160 See expression.h for info on the format of an expression. */
163 evaluate_expression (struct expression
*exp
)
166 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_NORMAL
);
169 /* Evaluate an expression, avoiding all memory references
170 and getting a value whose type alone is correct. */
173 evaluate_type (struct expression
*exp
)
176 return evaluate_subexp (NULL_TYPE
, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
179 /* Evaluate a subexpression, avoiding all memory references and
180 getting a value whose type alone is correct. */
183 evaluate_subexpression_type (struct expression
*exp
, int subexp
)
185 return evaluate_subexp (NULL_TYPE
, exp
, &subexp
, EVAL_AVOID_SIDE_EFFECTS
);
188 /* Extract a field operation from an expression. If the subexpression
189 of EXP starting at *SUBEXP is not a structure dereference
190 operation, return NULL. Otherwise, return the name of the
191 dereferenced field, and advance *SUBEXP to point to the
192 subexpression of the left-hand-side of the dereference. This is
193 used when completing field names. */
196 extract_field_op (struct expression
*exp
, int *subexp
)
200 if (exp
->elts
[*subexp
].opcode
!= STRUCTOP_STRUCT
201 && exp
->elts
[*subexp
].opcode
!= STRUCTOP_PTR
)
203 tem
= longest_to_int (exp
->elts
[*subexp
+ 1].longconst
);
204 result
= &exp
->elts
[*subexp
+ 2].string
;
205 (*subexp
) += 1 + 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
209 /* If the next expression is an OP_LABELED, skips past it,
210 returning the label. Otherwise, does nothing and returns NULL. */
213 get_label (struct expression
*exp
, int *pos
)
215 if (exp
->elts
[*pos
].opcode
== OP_LABELED
)
218 char *name
= &exp
->elts
[pc
+ 2].string
;
219 int tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
220 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
227 /* This function evaluates tuples (in (the deleted) Chill) or
228 brace-initializers (in C/C++) for structure types. */
230 static struct value
*
231 evaluate_struct_tuple (struct value
*struct_val
,
232 struct expression
*exp
,
233 int *pos
, enum noside noside
, int nargs
)
235 struct type
*struct_type
= check_typedef (value_type (struct_val
));
236 struct type
*substruct_type
= struct_type
;
237 struct type
*field_type
;
244 struct value
*val
= NULL
;
249 /* Skip past the labels, and count them. */
250 while (get_label (exp
, pos
) != NULL
)
255 char *label
= get_label (exp
, &pc
);
258 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
261 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
262 if (field_name
!= NULL
&& strcmp (field_name
, label
) == 0)
265 subfieldno
= fieldno
;
266 substruct_type
= struct_type
;
270 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (struct_type
);
273 char *field_name
= TYPE_FIELD_NAME (struct_type
, fieldno
);
274 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
275 if ((field_name
== 0 || *field_name
== '\0')
276 && TYPE_CODE (field_type
) == TYPE_CODE_UNION
)
279 for (; variantno
< TYPE_NFIELDS (field_type
);
283 = TYPE_FIELD_TYPE (field_type
, variantno
);
284 if (TYPE_CODE (substruct_type
) == TYPE_CODE_STRUCT
)
287 subfieldno
< TYPE_NFIELDS (substruct_type
);
290 if (strcmp(TYPE_FIELD_NAME (substruct_type
,
301 error (_("there is no field named %s"), label
);
307 /* Unlabelled tuple element - go to next field. */
311 if (subfieldno
>= TYPE_NFIELDS (substruct_type
))
314 substruct_type
= struct_type
;
320 /* Skip static fields. */
321 while (fieldno
< TYPE_NFIELDS (struct_type
)
322 && TYPE_FIELD_STATIC_KIND (struct_type
, fieldno
))
324 subfieldno
= fieldno
;
325 if (fieldno
>= TYPE_NFIELDS (struct_type
))
326 error (_("too many initializers"));
327 field_type
= TYPE_FIELD_TYPE (struct_type
, fieldno
);
328 if (TYPE_CODE (field_type
) == TYPE_CODE_UNION
329 && TYPE_FIELD_NAME (struct_type
, fieldno
)[0] == '0')
330 error (_("don't know which variant you want to set"));
334 /* Here, struct_type is the type of the inner struct,
335 while substruct_type is the type of the inner struct.
336 These are the same for normal structures, but a variant struct
337 contains anonymous union fields that contain substruct fields.
338 The value fieldno is the index of the top-level (normal or
339 anonymous union) field in struct_field, while the value
340 subfieldno is the index of the actual real (named inner) field
341 in substruct_type. */
343 field_type
= TYPE_FIELD_TYPE (substruct_type
, subfieldno
);
345 val
= evaluate_subexp (field_type
, exp
, pos
, noside
);
347 /* Now actually set the field in struct_val. */
349 /* Assign val to field fieldno. */
350 if (value_type (val
) != field_type
)
351 val
= value_cast (field_type
, val
);
353 bitsize
= TYPE_FIELD_BITSIZE (substruct_type
, subfieldno
);
354 bitpos
= TYPE_FIELD_BITPOS (struct_type
, fieldno
);
356 bitpos
+= TYPE_FIELD_BITPOS (substruct_type
, subfieldno
);
357 addr
= value_contents_writeable (struct_val
) + bitpos
/ 8;
359 modify_field (addr
, value_as_long (val
),
360 bitpos
% 8, bitsize
);
362 memcpy (addr
, value_contents (val
),
363 TYPE_LENGTH (value_type (val
)));
365 while (--nlabels
> 0);
370 /* Recursive helper function for setting elements of array tuples for
371 (the deleted) Chill. The target is ARRAY (which has bounds
372 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
373 and NOSIDE are as usual. Evaluates index expresions and sets the
374 specified element(s) of ARRAY to ELEMENT. Returns last index
378 init_array_element (struct value
*array
, struct value
*element
,
379 struct expression
*exp
, int *pos
,
380 enum noside noside
, LONGEST low_bound
, LONGEST high_bound
)
383 int element_size
= TYPE_LENGTH (value_type (element
));
384 if (exp
->elts
[*pos
].opcode
== BINOP_COMMA
)
387 init_array_element (array
, element
, exp
, pos
, noside
,
388 low_bound
, high_bound
);
389 return init_array_element (array
, element
,
390 exp
, pos
, noside
, low_bound
, high_bound
);
392 else if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
396 low
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
397 high
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
398 if (low
< low_bound
|| high
> high_bound
)
399 error (_("tuple range index out of range"));
400 for (index
= low
; index
<= high
; index
++)
402 memcpy (value_contents_raw (array
)
403 + (index
- low_bound
) * element_size
,
404 value_contents (element
), element_size
);
409 index
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
410 if (index
< low_bound
|| index
> high_bound
)
411 error (_("tuple index out of range"));
412 memcpy (value_contents_raw (array
) + (index
- low_bound
) * element_size
,
413 value_contents (element
), element_size
);
419 value_f90_subarray (struct value
*array
,
420 struct expression
*exp
, int *pos
, enum noside noside
)
423 LONGEST low_bound
, high_bound
;
424 struct type
*range
= check_typedef (TYPE_INDEX_TYPE (value_type (array
)));
425 enum f90_range_type range_type
= longest_to_int (exp
->elts
[pc
].longconst
);
429 if (range_type
== LOW_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
430 low_bound
= TYPE_LOW_BOUND (range
);
432 low_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
434 if (range_type
== HIGH_BOUND_DEFAULT
|| range_type
== BOTH_BOUND_DEFAULT
)
435 high_bound
= TYPE_HIGH_BOUND (range
);
437 high_bound
= value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
439 return value_slice (array
, low_bound
, high_bound
- low_bound
+ 1);
443 evaluate_subexp_standard (struct type
*expect_type
,
444 struct expression
*exp
, int *pos
,
449 int pc
, pc2
= 0, oldpos
;
450 struct value
*arg1
= NULL
;
451 struct value
*arg2
= NULL
;
455 struct value
**argvec
;
456 int upper
, lower
, retcode
;
460 struct type
**arg_types
;
464 op
= exp
->elts
[pc
].opcode
;
469 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
470 (*pos
) += 4 + BYTES_TO_EXP_ELEM (tem
+ 1);
471 if (noside
== EVAL_SKIP
)
473 arg1
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
474 &exp
->elts
[pc
+ 3].string
,
477 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
482 return value_from_longest (exp
->elts
[pc
+ 1].type
,
483 exp
->elts
[pc
+ 2].longconst
);
487 return value_from_double (exp
->elts
[pc
+ 1].type
,
488 exp
->elts
[pc
+ 2].doubleconst
);
492 return value_from_decfloat (exp
->elts
[pc
+ 1].type
,
493 exp
->elts
[pc
+ 2].decfloatconst
);
497 if (noside
== EVAL_SKIP
)
500 /* JYG: We used to just return value_zero of the symbol type
501 if we're asked to avoid side effects. Otherwise we return
502 value_of_variable (...). However I'm not sure if
503 value_of_variable () has any side effect.
504 We need a full value object returned here for whatis_exp ()
505 to call evaluate_type () and then pass the full value to
506 value_rtti_target_type () if we are dealing with a pointer
507 or reference to a base class and print object is on. */
510 volatile struct gdb_exception except
;
511 struct value
*ret
= NULL
;
513 TRY_CATCH (except
, RETURN_MASK_ERROR
)
515 ret
= value_of_variable (exp
->elts
[pc
+ 2].symbol
,
516 exp
->elts
[pc
+ 1].block
);
519 if (except
.reason
< 0)
521 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
522 ret
= value_zero (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
), not_lval
);
524 throw_exception (except
);
533 access_value_history (longest_to_int (exp
->elts
[pc
+ 1].longconst
));
537 const char *name
= &exp
->elts
[pc
+ 2].string
;
541 (*pos
) += 3 + BYTES_TO_EXP_ELEM (exp
->elts
[pc
+ 1].longconst
+ 1);
542 regno
= user_reg_map_name_to_regnum (current_gdbarch
,
543 name
, strlen (name
));
545 error (_("Register $%s not available."), name
);
547 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
548 a value with the appropriate register type. Unfortunately,
549 we don't have easy access to the type of user registers.
550 So for these registers, we fetch the register value regardless
551 of the evaluation mode. */
552 if (noside
== EVAL_AVOID_SIDE_EFFECTS
553 && regno
< gdbarch_num_regs (current_gdbarch
)
554 + gdbarch_num_pseudo_regs (current_gdbarch
))
555 val
= value_zero (register_type (current_gdbarch
, regno
), not_lval
);
557 val
= value_of_register (regno
, get_selected_frame (NULL
));
559 error (_("Value of register %s not available."), name
);
565 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
566 return value_from_longest (type
, exp
->elts
[pc
+ 1].longconst
);
570 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
573 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
574 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
575 if (noside
== EVAL_SKIP
)
577 return value_string (&exp
->elts
[pc
+ 2].string
, tem
);
579 case OP_OBJC_NSSTRING
: /* Objective C Foundation Class NSString constant. */
580 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
581 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
582 if (noside
== EVAL_SKIP
)
586 return (struct value
*) value_nsstring (&exp
->elts
[pc
+ 2].string
, tem
+ 1);
589 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
591 += 3 + BYTES_TO_EXP_ELEM ((tem
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
592 if (noside
== EVAL_SKIP
)
594 return value_bitstring (&exp
->elts
[pc
+ 2].string
, tem
);
599 tem2
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
600 tem3
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
601 nargs
= tem3
- tem2
+ 1;
602 type
= expect_type
? check_typedef (expect_type
) : NULL_TYPE
;
604 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
605 && TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
607 struct value
*rec
= allocate_value (expect_type
);
608 memset (value_contents_raw (rec
), '\0', TYPE_LENGTH (type
));
609 return evaluate_struct_tuple (rec
, exp
, pos
, noside
, nargs
);
612 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
613 && TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
615 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
616 struct type
*element_type
= TYPE_TARGET_TYPE (type
);
617 struct value
*array
= allocate_value (expect_type
);
618 int element_size
= TYPE_LENGTH (check_typedef (element_type
));
619 LONGEST low_bound
, high_bound
, index
;
620 if (get_discrete_bounds (range_type
, &low_bound
, &high_bound
) < 0)
623 high_bound
= (TYPE_LENGTH (type
) / element_size
) - 1;
626 memset (value_contents_raw (array
), 0, TYPE_LENGTH (expect_type
));
627 for (tem
= nargs
; --nargs
>= 0;)
629 struct value
*element
;
631 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
634 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
636 element
= evaluate_subexp (element_type
, exp
, pos
, noside
);
637 if (value_type (element
) != element_type
)
638 element
= value_cast (element_type
, element
);
641 int continue_pc
= *pos
;
643 index
= init_array_element (array
, element
, exp
, pos
, noside
,
644 low_bound
, high_bound
);
649 if (index
> high_bound
)
650 /* to avoid memory corruption */
651 error (_("Too many array elements"));
652 memcpy (value_contents_raw (array
)
653 + (index
- low_bound
) * element_size
,
654 value_contents (element
),
662 if (expect_type
!= NULL_TYPE
&& noside
!= EVAL_SKIP
663 && TYPE_CODE (type
) == TYPE_CODE_SET
)
665 struct value
*set
= allocate_value (expect_type
);
666 gdb_byte
*valaddr
= value_contents_raw (set
);
667 struct type
*element_type
= TYPE_INDEX_TYPE (type
);
668 struct type
*check_type
= element_type
;
669 LONGEST low_bound
, high_bound
;
671 /* get targettype of elementtype */
672 while (TYPE_CODE (check_type
) == TYPE_CODE_RANGE
||
673 TYPE_CODE (check_type
) == TYPE_CODE_TYPEDEF
)
674 check_type
= TYPE_TARGET_TYPE (check_type
);
676 if (get_discrete_bounds (element_type
, &low_bound
, &high_bound
) < 0)
677 error (_("(power)set type with unknown size"));
678 memset (valaddr
, '\0', TYPE_LENGTH (type
));
679 for (tem
= 0; tem
< nargs
; tem
++)
681 LONGEST range_low
, range_high
;
682 struct type
*range_low_type
, *range_high_type
;
683 struct value
*elem_val
;
684 if (exp
->elts
[*pos
].opcode
== BINOP_RANGE
)
687 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
688 range_low_type
= value_type (elem_val
);
689 range_low
= value_as_long (elem_val
);
690 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
691 range_high_type
= value_type (elem_val
);
692 range_high
= value_as_long (elem_val
);
696 elem_val
= evaluate_subexp (element_type
, exp
, pos
, noside
);
697 range_low_type
= range_high_type
= value_type (elem_val
);
698 range_low
= range_high
= value_as_long (elem_val
);
700 /* check types of elements to avoid mixture of elements from
701 different types. Also check if type of element is "compatible"
702 with element type of powerset */
703 if (TYPE_CODE (range_low_type
) == TYPE_CODE_RANGE
)
704 range_low_type
= TYPE_TARGET_TYPE (range_low_type
);
705 if (TYPE_CODE (range_high_type
) == TYPE_CODE_RANGE
)
706 range_high_type
= TYPE_TARGET_TYPE (range_high_type
);
707 if ((TYPE_CODE (range_low_type
) != TYPE_CODE (range_high_type
)) ||
708 (TYPE_CODE (range_low_type
) == TYPE_CODE_ENUM
&&
709 (range_low_type
!= range_high_type
)))
710 /* different element modes */
711 error (_("POWERSET tuple elements of different mode"));
712 if ((TYPE_CODE (check_type
) != TYPE_CODE (range_low_type
)) ||
713 (TYPE_CODE (check_type
) == TYPE_CODE_ENUM
&&
714 range_low_type
!= check_type
))
715 error (_("incompatible POWERSET tuple elements"));
716 if (range_low
> range_high
)
718 warning (_("empty POWERSET tuple range"));
721 if (range_low
< low_bound
|| range_high
> high_bound
)
722 error (_("POWERSET tuple element out of range"));
723 range_low
-= low_bound
;
724 range_high
-= low_bound
;
725 for (; range_low
<= range_high
; range_low
++)
727 int bit_index
= (unsigned) range_low
% TARGET_CHAR_BIT
;
728 if (gdbarch_bits_big_endian (current_gdbarch
))
729 bit_index
= TARGET_CHAR_BIT
- 1 - bit_index
;
730 valaddr
[(unsigned) range_low
/ TARGET_CHAR_BIT
]
737 argvec
= (struct value
**) alloca (sizeof (struct value
*) * nargs
);
738 for (tem
= 0; tem
< nargs
; tem
++)
740 /* Ensure that array expressions are coerced into pointer objects. */
741 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
743 if (noside
== EVAL_SKIP
)
745 return value_array (tem2
, tem3
, argvec
);
749 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
751 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
753 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
754 if (noside
== EVAL_SKIP
)
756 return value_slice (array
, lowbound
, upper
- lowbound
+ 1);
759 case TERNOP_SLICE_COUNT
:
761 struct value
*array
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
763 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
765 = value_as_long (evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
766 return value_slice (array
, lowbound
, length
);
770 /* Skip third and second args to evaluate the first one. */
771 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
772 if (value_logical_not (arg1
))
774 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
775 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
779 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
780 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
784 case OP_OBJC_SELECTOR
:
785 { /* Objective C @selector operator. */
786 char *sel
= &exp
->elts
[pc
+ 2].string
;
787 int len
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
789 (*pos
) += 3 + BYTES_TO_EXP_ELEM (len
+ 1);
790 if (noside
== EVAL_SKIP
)
794 sel
[len
] = 0; /* Make sure it's terminated. */
795 return value_from_longest (lookup_pointer_type (builtin_type_void
),
796 lookup_child_selector (sel
));
799 case OP_OBJC_MSGCALL
:
800 { /* Objective C message (method) call. */
802 static CORE_ADDR responds_selector
= 0;
803 static CORE_ADDR method_selector
= 0;
805 CORE_ADDR selector
= 0;
807 int struct_return
= 0;
810 static struct value
*msg_send
= NULL
;
811 static struct value
*msg_send_stret
= NULL
;
812 static int gnu_runtime
= 0;
814 struct value
*target
= NULL
;
815 struct value
*method
= NULL
;
816 struct value
*called_method
= NULL
;
818 struct type
*selector_type
= NULL
;
820 struct value
*ret
= NULL
;
823 selector
= exp
->elts
[pc
+ 1].longconst
;
824 nargs
= exp
->elts
[pc
+ 2].longconst
;
825 argvec
= (struct value
**) alloca (sizeof (struct value
*)
830 selector_type
= lookup_pointer_type (builtin_type_void
);
831 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
832 sub_no_side
= EVAL_NORMAL
;
834 sub_no_side
= noside
;
836 target
= evaluate_subexp (selector_type
, exp
, pos
, sub_no_side
);
838 if (value_as_long (target
) == 0)
839 return value_from_longest (builtin_type_long
, 0);
841 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
844 /* Find the method dispatch (Apple runtime) or method lookup
845 (GNU runtime) function for Objective-C. These will be used
846 to lookup the symbol information for the method. If we
847 can't find any symbol information, then we'll use these to
848 call the method, otherwise we can call the method
849 directly. The msg_send_stret function is used in the special
850 case of a method that returns a structure (Apple runtime
855 type
= lookup_pointer_type (builtin_type_void
);
856 type
= lookup_function_type (type
);
857 type
= lookup_pointer_type (type
);
858 type
= lookup_function_type (type
);
859 type
= lookup_pointer_type (type
);
861 msg_send
= find_function_in_inferior ("objc_msg_lookup");
862 msg_send_stret
= find_function_in_inferior ("objc_msg_lookup");
864 msg_send
= value_from_pointer (type
, value_as_address (msg_send
));
865 msg_send_stret
= value_from_pointer (type
,
866 value_as_address (msg_send_stret
));
870 msg_send
= find_function_in_inferior ("objc_msgSend");
871 /* Special dispatcher for methods returning structs */
872 msg_send_stret
= find_function_in_inferior ("objc_msgSend_stret");
875 /* Verify the target object responds to this method. The
876 standard top-level 'Object' class uses a different name for
877 the verification method than the non-standard, but more
878 often used, 'NSObject' class. Make sure we check for both. */
880 responds_selector
= lookup_child_selector ("respondsToSelector:");
881 if (responds_selector
== 0)
882 responds_selector
= lookup_child_selector ("respondsTo:");
884 if (responds_selector
== 0)
885 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
887 method_selector
= lookup_child_selector ("methodForSelector:");
888 if (method_selector
== 0)
889 method_selector
= lookup_child_selector ("methodFor:");
891 if (method_selector
== 0)
892 error (_("no 'methodFor:' or 'methodForSelector:' method"));
894 /* Call the verification method, to make sure that the target
895 class implements the desired method. */
897 argvec
[0] = msg_send
;
899 argvec
[2] = value_from_longest (builtin_type_long
, responds_selector
);
900 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
903 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
906 /* Function objc_msg_lookup returns a pointer. */
908 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
910 if (value_as_long (ret
) == 0)
911 error (_("Target does not respond to this message selector."));
913 /* Call "methodForSelector:" method, to get the address of a
914 function method that implements this selector for this
915 class. If we can find a symbol at that address, then we
916 know the return type, parameter types etc. (that's a good
919 argvec
[0] = msg_send
;
921 argvec
[2] = value_from_longest (builtin_type_long
, method_selector
);
922 argvec
[3] = value_from_longest (builtin_type_long
, selector
);
925 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
929 ret
= call_function_by_hand (argvec
[0], 3, argvec
+ 1);
932 /* ret should now be the selector. */
934 addr
= value_as_long (ret
);
937 struct symbol
*sym
= NULL
;
938 /* Is it a high_level symbol? */
940 sym
= find_pc_function (addr
);
942 method
= value_of_variable (sym
, 0);
945 /* If we found a method with symbol information, check to see
946 if it returns a struct. Otherwise assume it doesn't. */
952 struct type
*val_type
;
954 funaddr
= find_function_addr (method
, &val_type
);
956 b
= block_for_pc (funaddr
);
958 CHECK_TYPEDEF (val_type
);
960 if ((val_type
== NULL
)
961 || (TYPE_CODE(val_type
) == TYPE_CODE_ERROR
))
963 if (expect_type
!= NULL
)
964 val_type
= expect_type
;
967 struct_return
= using_struct_return (value_type (method
), val_type
);
969 else if (expect_type
!= NULL
)
971 struct_return
= using_struct_return (NULL
,
972 check_typedef (expect_type
));
975 /* Found a function symbol. Now we will substitute its
976 value in place of the message dispatcher (obj_msgSend),
977 so that we call the method directly instead of thru
978 the dispatcher. The main reason for doing this is that
979 we can now evaluate the return value and parameter values
980 according to their known data types, in case we need to
981 do things like promotion, dereferencing, special handling
982 of structs and doubles, etc.
984 We want to use the type signature of 'method', but still
985 jump to objc_msgSend() or objc_msgSend_stret() to better
986 mimic the behavior of the runtime. */
990 if (TYPE_CODE (value_type (method
)) != TYPE_CODE_FUNC
)
991 error (_("method address has symbol information with non-function type; skipping"));
993 VALUE_ADDRESS (method
) = value_as_address (msg_send_stret
);
995 VALUE_ADDRESS (method
) = value_as_address (msg_send
);
996 called_method
= method
;
1001 called_method
= msg_send_stret
;
1003 called_method
= msg_send
;
1006 if (noside
== EVAL_SKIP
)
1009 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1011 /* If the return type doesn't look like a function type,
1012 call an error. This can happen if somebody tries to
1013 turn a variable into a function call. This is here
1014 because people often want to call, eg, strcmp, which
1015 gdb doesn't know is a function. If gdb isn't asked for
1016 it's opinion (ie. through "whatis"), it won't offer
1019 struct type
*type
= value_type (called_method
);
1020 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1021 type
= TYPE_TARGET_TYPE (type
);
1022 type
= TYPE_TARGET_TYPE (type
);
1026 if ((TYPE_CODE (type
) == TYPE_CODE_ERROR
) && expect_type
)
1027 return allocate_value (expect_type
);
1029 return allocate_value (type
);
1032 error (_("Expression of type other than \"method returning ...\" used as a method"));
1035 /* Now depending on whether we found a symbol for the method,
1036 we will either call the runtime dispatcher or the method
1039 argvec
[0] = called_method
;
1041 argvec
[2] = value_from_longest (builtin_type_long
, selector
);
1042 /* User-supplied arguments. */
1043 for (tem
= 0; tem
< nargs
; tem
++)
1044 argvec
[tem
+ 3] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1045 argvec
[tem
+ 3] = 0;
1047 if (gnu_runtime
&& (method
!= NULL
))
1049 /* Function objc_msg_lookup returns a pointer. */
1050 deprecated_set_value_type (argvec
[0],
1051 lookup_function_type (lookup_pointer_type (value_type (argvec
[0]))));
1052 argvec
[0] = call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1055 ret
= call_function_by_hand (argvec
[0], nargs
+ 2, argvec
+ 1);
1062 op
= exp
->elts
[*pos
].opcode
;
1063 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1064 /* Allocate arg vector, including space for the function to be
1065 called in argvec[0] and a terminating NULL */
1066 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 3));
1067 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1070 /* First, evaluate the structure into arg2 */
1073 if (noside
== EVAL_SKIP
)
1076 if (op
== STRUCTOP_MEMBER
)
1078 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1082 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1085 /* If the function is a virtual function, then the
1086 aggregate value (providing the structure) plays
1087 its part by providing the vtable. Otherwise,
1088 it is just along for the ride: call the function
1091 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1093 if (TYPE_CODE (check_typedef (value_type (arg1
)))
1094 != TYPE_CODE_METHODPTR
)
1095 error (_("Non-pointer-to-member value used in pointer-to-member "
1098 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1100 struct type
*method_type
= check_typedef (value_type (arg1
));
1101 arg1
= value_zero (method_type
, not_lval
);
1104 arg1
= cplus_method_ptr_to_value (&arg2
, arg1
);
1106 /* Now, say which argument to start evaluating from */
1109 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1111 /* Hair for method invocations */
1115 /* First, evaluate the structure into arg2 */
1117 tem2
= longest_to_int (exp
->elts
[pc2
+ 1].longconst
);
1118 *pos
+= 3 + BYTES_TO_EXP_ELEM (tem2
+ 1);
1119 if (noside
== EVAL_SKIP
)
1122 if (op
== STRUCTOP_STRUCT
)
1124 /* If v is a variable in a register, and the user types
1125 v.method (), this will produce an error, because v has
1128 A possible way around this would be to allocate a
1129 copy of the variable on the stack, copy in the
1130 contents, call the function, and copy out the
1131 contents. I.e. convert this from call by reference
1132 to call by copy-return (or whatever it's called).
1133 However, this does not work because it is not the
1134 same: the method being called could stash a copy of
1135 the address, and then future uses through that address
1136 (after the method returns) would be expected to
1137 use the variable itself, not some copy of it. */
1138 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
1142 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1144 /* Now, say which argument to start evaluating from */
1149 /* Non-method function call */
1151 argvec
[0] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1153 type
= value_type (argvec
[0]);
1154 if (type
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
1155 type
= TYPE_TARGET_TYPE (type
);
1156 if (type
&& TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1158 for (; tem
<= nargs
&& tem
<= TYPE_NFIELDS (type
); tem
++)
1160 /* pai: FIXME This seems to be coercing arguments before
1161 * overload resolution has been done! */
1162 argvec
[tem
] = evaluate_subexp (TYPE_FIELD_TYPE (type
, tem
- 1),
1168 /* Evaluate arguments */
1169 for (; tem
<= nargs
; tem
++)
1171 /* Ensure that array expressions are coerced into pointer objects. */
1172 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1175 /* signal end of arglist */
1178 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
1180 int static_memfuncp
;
1183 /* Method invocation : stuff "this" as first parameter */
1185 /* Name of method from expression */
1186 strcpy (tstr
, &exp
->elts
[pc2
+ 2].string
);
1188 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1190 /* Language is C++, do some overload resolution before evaluation */
1191 struct value
*valp
= NULL
;
1193 /* Prepare list of argument types for overload resolution */
1194 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1195 for (ix
= 1; ix
<= nargs
; ix
++)
1196 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1198 (void) find_overload_match (arg_types
, nargs
, tstr
,
1199 1 /* method */ , 0 /* strict match */ ,
1200 &arg2
/* the object */ , NULL
,
1201 &valp
, NULL
, &static_memfuncp
);
1204 argvec
[1] = arg2
; /* the ``this'' pointer */
1205 argvec
[0] = valp
; /* use the method found after overload resolution */
1208 /* Non-C++ case -- or no overload resolution */
1210 struct value
*temp
= arg2
;
1211 argvec
[0] = value_struct_elt (&temp
, argvec
+ 1, tstr
,
1213 op
== STRUCTOP_STRUCT
1214 ? "structure" : "structure pointer");
1215 /* value_struct_elt updates temp with the correct value
1216 of the ``this'' pointer if necessary, so modify argvec[1] to
1217 reflect any ``this'' changes. */
1218 arg2
= value_from_longest (lookup_pointer_type(value_type (temp
)),
1219 VALUE_ADDRESS (temp
) + value_offset (temp
)
1220 + value_embedded_offset (temp
));
1221 argvec
[1] = arg2
; /* the ``this'' pointer */
1224 if (static_memfuncp
)
1226 argvec
[1] = argvec
[0];
1231 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
1236 else if (op
== OP_VAR_VALUE
)
1238 /* Non-member function being called */
1239 /* fn: This can only be done for C++ functions. A C-style function
1240 in a C++ program, for instance, does not have the fields that
1241 are expected here */
1243 if (overload_resolution
&& (exp
->language_defn
->la_language
== language_cplus
))
1245 /* Language is C++, do some overload resolution before evaluation */
1246 struct symbol
*symp
;
1248 /* Prepare list of argument types for overload resolution */
1249 arg_types
= (struct type
**) alloca (nargs
* (sizeof (struct type
*)));
1250 for (ix
= 1; ix
<= nargs
; ix
++)
1251 arg_types
[ix
- 1] = value_type (argvec
[ix
]);
1253 (void) find_overload_match (arg_types
, nargs
, NULL
/* no need for name */ ,
1254 0 /* not method */ , 0 /* strict match */ ,
1255 NULL
, exp
->elts
[save_pos1
+2].symbol
/* the function */ ,
1258 /* Now fix the expression being evaluated */
1259 exp
->elts
[save_pos1
+2].symbol
= symp
;
1260 argvec
[0] = evaluate_subexp_with_coercion (exp
, &save_pos1
, noside
);
1264 /* Not C++, or no overload resolution allowed */
1265 /* nothing to be done; argvec already correctly set up */
1270 /* It is probably a C-style function */
1271 /* nothing to be done; argvec already correctly set up */
1276 if (noside
== EVAL_SKIP
)
1278 if (argvec
[0] == NULL
)
1279 error (_("Cannot evaluate function -- may be inlined"));
1280 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1282 /* If the return type doesn't look like a function type, call an
1283 error. This can happen if somebody tries to turn a variable into
1284 a function call. This is here because people often want to
1285 call, eg, strcmp, which gdb doesn't know is a function. If
1286 gdb isn't asked for it's opinion (ie. through "whatis"),
1287 it won't offer it. */
1289 struct type
*ftype
=
1290 TYPE_TARGET_TYPE (value_type (argvec
[0]));
1293 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec
[0])));
1295 error (_("Expression of type other than \"Function returning ...\" used as function"));
1297 return call_function_by_hand (argvec
[0], nargs
, argvec
+ 1);
1298 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1300 case OP_F77_UNDETERMINED_ARGLIST
:
1302 /* Remember that in F77, functions, substring ops and
1303 array subscript operations cannot be disambiguated
1304 at parse time. We have made all array subscript operations,
1305 substring operations as well as function calls come here
1306 and we now have to discover what the heck this thing actually was.
1307 If it is a function, we process just as if we got an OP_FUNCALL. */
1309 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1312 /* First determine the type code we are dealing with. */
1313 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1314 type
= check_typedef (value_type (arg1
));
1315 code
= TYPE_CODE (type
);
1317 if (code
== TYPE_CODE_PTR
)
1319 /* Fortran always passes variable to subroutines as pointer.
1320 So we need to look into its target type to see if it is
1321 array, string or function. If it is, we need to switch
1322 to the target value the original one points to. */
1323 struct type
*target_type
= check_typedef (TYPE_TARGET_TYPE (type
));
1325 if (TYPE_CODE (target_type
) == TYPE_CODE_ARRAY
1326 || TYPE_CODE (target_type
) == TYPE_CODE_STRING
1327 || TYPE_CODE (target_type
) == TYPE_CODE_FUNC
)
1329 arg1
= value_ind (arg1
);
1330 type
= check_typedef (value_type (arg1
));
1331 code
= TYPE_CODE (type
);
1337 case TYPE_CODE_ARRAY
:
1338 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1339 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1341 goto multi_f77_subscript
;
1343 case TYPE_CODE_STRING
:
1344 if (exp
->elts
[*pos
].opcode
== OP_F90_RANGE
)
1345 return value_f90_subarray (arg1
, exp
, pos
, noside
);
1348 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1349 return value_subscript (arg1
, arg2
);
1353 case TYPE_CODE_FUNC
:
1354 /* It's a function call. */
1355 /* Allocate arg vector, including space for the function to be
1356 called in argvec[0] and a terminating NULL */
1357 argvec
= (struct value
**) alloca (sizeof (struct value
*) * (nargs
+ 2));
1360 for (; tem
<= nargs
; tem
++)
1361 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
1362 argvec
[tem
] = 0; /* signal end of arglist */
1366 error (_("Cannot perform substring on this type"));
1370 /* We have a complex number, There should be 2 floating
1371 point numbers that compose it */
1372 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1373 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1375 return value_literal_complex (arg1
, arg2
, builtin_type_f_complex_s16
);
1377 case STRUCTOP_STRUCT
:
1378 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1379 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1380 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1381 if (noside
== EVAL_SKIP
)
1383 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1384 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1385 &exp
->elts
[pc
+ 2].string
,
1390 struct value
*temp
= arg1
;
1391 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1396 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1397 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
1398 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1399 if (noside
== EVAL_SKIP
)
1402 /* JYG: if print object is on we need to replace the base type
1403 with rtti type in order to continue on with successful
1404 lookup of member / method only available in the rtti type. */
1406 struct type
*type
= value_type (arg1
);
1407 struct type
*real_type
;
1408 int full
, top
, using_enc
;
1410 if (objectprint
&& TYPE_TARGET_TYPE(type
) &&
1411 (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_CLASS
))
1413 real_type
= value_rtti_target_type (arg1
, &full
, &top
, &using_enc
);
1416 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
1417 real_type
= lookup_pointer_type (real_type
);
1419 real_type
= lookup_reference_type (real_type
);
1421 arg1
= value_cast (real_type
, arg1
);
1426 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1427 return value_zero (lookup_struct_elt_type (value_type (arg1
),
1428 &exp
->elts
[pc
+ 2].string
,
1433 struct value
*temp
= arg1
;
1434 return value_struct_elt (&temp
, NULL
, &exp
->elts
[pc
+ 2].string
,
1435 NULL
, "structure pointer");
1438 case STRUCTOP_MEMBER
:
1440 if (op
== STRUCTOP_MEMBER
)
1441 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
1443 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1445 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1447 if (noside
== EVAL_SKIP
)
1450 type
= check_typedef (value_type (arg2
));
1451 switch (TYPE_CODE (type
))
1453 case TYPE_CODE_METHODPTR
:
1454 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1455 return value_zero (TYPE_TARGET_TYPE (type
), not_lval
);
1458 arg2
= cplus_method_ptr_to_value (&arg1
, arg2
);
1459 gdb_assert (TYPE_CODE (value_type (arg2
)) == TYPE_CODE_PTR
);
1460 return value_ind (arg2
);
1463 case TYPE_CODE_MEMBERPTR
:
1464 /* Now, convert these values to an address. */
1465 arg1
= value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type
)),
1468 mem_offset
= value_as_long (arg2
);
1470 arg3
= value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
1471 value_as_long (arg1
) + mem_offset
);
1472 return value_ind (arg3
);
1475 error (_("non-pointer-to-member value used in pointer-to-member construct"));
1479 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1480 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1481 if (noside
== EVAL_SKIP
)
1483 if (binop_user_defined_p (op
, arg1
, arg2
))
1484 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1486 return value_concat (arg1
, arg2
);
1489 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1490 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1492 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1494 if (binop_user_defined_p (op
, arg1
, arg2
))
1495 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1497 return value_assign (arg1
, arg2
);
1499 case BINOP_ASSIGN_MODIFY
:
1501 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1502 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1503 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
1505 op
= exp
->elts
[pc
+ 1].opcode
;
1506 if (binop_user_defined_p (op
, arg1
, arg2
))
1507 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
, noside
);
1508 else if (op
== BINOP_ADD
)
1509 arg2
= value_add (arg1
, arg2
);
1510 else if (op
== BINOP_SUB
)
1511 arg2
= value_sub (arg1
, arg2
);
1513 arg2
= value_binop (arg1
, arg2
, op
);
1514 return value_assign (arg1
, arg2
);
1517 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1518 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1519 if (noside
== EVAL_SKIP
)
1521 if (binop_user_defined_p (op
, arg1
, arg2
))
1522 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1524 return value_add (arg1
, arg2
);
1527 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1528 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1529 if (noside
== EVAL_SKIP
)
1531 if (binop_user_defined_p (op
, arg1
, arg2
))
1532 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1534 return value_sub (arg1
, arg2
);
1544 case BINOP_BITWISE_AND
:
1545 case BINOP_BITWISE_IOR
:
1546 case BINOP_BITWISE_XOR
:
1547 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1548 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1549 if (noside
== EVAL_SKIP
)
1551 if (binop_user_defined_p (op
, arg1
, arg2
))
1552 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1555 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1556 fudge arg2 to avoid division-by-zero, the caller is
1557 (theoretically) only looking for the type of the result. */
1558 if (noside
== EVAL_AVOID_SIDE_EFFECTS
1559 /* ??? Do we really want to test for BINOP_MOD here?
1560 The implementation of value_binop gives it a well-defined
1563 || op
== BINOP_INTDIV
1566 && value_logical_not (arg2
))
1568 struct value
*v_one
, *retval
;
1570 v_one
= value_one (value_type (arg2
), not_lval
);
1571 retval
= value_binop (arg1
, v_one
, op
);
1575 return value_binop (arg1
, arg2
, op
);
1579 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1580 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1581 if (noside
== EVAL_SKIP
)
1583 error (_("':' operator used in invalid context"));
1585 case BINOP_SUBSCRIPT
:
1586 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1587 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1588 if (noside
== EVAL_SKIP
)
1590 if (binop_user_defined_p (op
, arg1
, arg2
))
1591 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1594 /* If the user attempts to subscript something that is not an
1595 array or pointer type (like a plain int variable for example),
1596 then report this as an error. */
1598 arg1
= coerce_ref (arg1
);
1599 type
= check_typedef (value_type (arg1
));
1600 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
1601 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
1603 if (TYPE_NAME (type
))
1604 error (_("cannot subscript something of type `%s'"),
1607 error (_("cannot subscript requested type"));
1610 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1611 return value_zero (TYPE_TARGET_TYPE (type
), VALUE_LVAL (arg1
));
1613 return value_subscript (arg1
, arg2
);
1617 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1618 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1619 if (noside
== EVAL_SKIP
)
1621 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1622 return value_from_longest (type
, (LONGEST
) value_in (arg1
, arg2
));
1624 case MULTI_SUBSCRIPT
:
1626 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
1627 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1630 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1631 /* FIXME: EVAL_SKIP handling may not be correct. */
1632 if (noside
== EVAL_SKIP
)
1643 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1644 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1646 /* If the user attempts to subscript something that has no target
1647 type (like a plain int variable for example), then report this
1650 type
= TYPE_TARGET_TYPE (check_typedef (value_type (arg1
)));
1653 arg1
= value_zero (type
, VALUE_LVAL (arg1
));
1659 error (_("cannot subscript something of type `%s'"),
1660 TYPE_NAME (value_type (arg1
)));
1664 if (binop_user_defined_p (op
, arg1
, arg2
))
1666 arg1
= value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1670 arg1
= coerce_ref (arg1
);
1671 type
= check_typedef (value_type (arg1
));
1673 switch (TYPE_CODE (type
))
1676 case TYPE_CODE_ARRAY
:
1677 case TYPE_CODE_STRING
:
1678 arg1
= value_subscript (arg1
, arg2
);
1681 case TYPE_CODE_BITSTRING
:
1682 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1683 arg1
= value_bitstring_subscript (type
, arg1
, arg2
);
1687 if (TYPE_NAME (type
))
1688 error (_("cannot subscript something of type `%s'"),
1691 error (_("cannot subscript requested type"));
1697 multi_f77_subscript
:
1699 int subscript_array
[MAX_FORTRAN_DIMS
];
1700 int array_size_array
[MAX_FORTRAN_DIMS
];
1701 int ndimensions
= 1, i
;
1702 struct type
*tmp_type
;
1703 int offset_item
; /* The array offset where the item lives */
1705 if (nargs
> MAX_FORTRAN_DIMS
)
1706 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS
);
1708 tmp_type
= check_typedef (value_type (arg1
));
1709 ndimensions
= calc_f77_array_dims (type
);
1711 if (nargs
!= ndimensions
)
1712 error (_("Wrong number of subscripts"));
1714 /* Now that we know we have a legal array subscript expression
1715 let us actually find out where this element exists in the array. */
1718 /* Take array indices left to right */
1719 for (i
= 0; i
< nargs
; i
++)
1721 /* Evaluate each subscript, It must be a legal integer in F77 */
1722 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
1724 /* Fill in the subscript and array size arrays */
1726 subscript_array
[i
] = value_as_long (arg2
);
1729 /* Internal type of array is arranged right to left */
1730 for (i
= 0; i
< nargs
; i
++)
1732 retcode
= f77_get_dynamic_upperbound (tmp_type
, &upper
);
1733 if (retcode
== BOUND_FETCH_ERROR
)
1734 error (_("Cannot obtain dynamic upper bound"));
1736 retcode
= f77_get_dynamic_lowerbound (tmp_type
, &lower
);
1737 if (retcode
== BOUND_FETCH_ERROR
)
1738 error (_("Cannot obtain dynamic lower bound"));
1740 array_size_array
[nargs
- i
- 1] = upper
- lower
+ 1;
1742 /* Zero-normalize subscripts so that offsetting will work. */
1744 subscript_array
[nargs
- i
- 1] -= lower
;
1746 /* If we are at the bottom of a multidimensional
1747 array type then keep a ptr to the last ARRAY
1748 type around for use when calling value_subscript()
1749 below. This is done because we pretend to value_subscript
1750 that we actually have a one-dimensional array
1751 of base element type that we apply a simple
1755 tmp_type
= check_typedef (TYPE_TARGET_TYPE (tmp_type
));
1758 /* Now let us calculate the offset for this item */
1760 offset_item
= subscript_array
[ndimensions
- 1];
1762 for (i
= ndimensions
- 1; i
> 0; --i
)
1764 array_size_array
[i
- 1] * offset_item
+ subscript_array
[i
- 1];
1766 /* Construct a value node with the value of the offset */
1768 arg2
= value_from_longest (builtin_type_f_integer
, offset_item
);
1770 /* Let us now play a dirty trick: we will take arg1
1771 which is a value node pointing to the topmost level
1772 of the multidimensional array-set and pretend
1773 that it is actually a array of the final element
1774 type, this will ensure that value_subscript()
1775 returns the correct type value */
1777 deprecated_set_value_type (arg1
, tmp_type
);
1778 return value_subscripted_rvalue (arg1
, arg2
, 0);
1781 case BINOP_LOGICAL_AND
:
1782 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1783 if (noside
== EVAL_SKIP
)
1785 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1790 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1793 if (binop_user_defined_p (op
, arg1
, arg2
))
1795 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1796 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1800 tem
= value_logical_not (arg1
);
1801 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1802 (tem
? EVAL_SKIP
: noside
));
1803 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1804 return value_from_longest (type
,
1805 (LONGEST
) (!tem
&& !value_logical_not (arg2
)));
1808 case BINOP_LOGICAL_OR
:
1809 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1810 if (noside
== EVAL_SKIP
)
1812 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1817 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
1820 if (binop_user_defined_p (op
, arg1
, arg2
))
1822 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1823 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1827 tem
= value_logical_not (arg1
);
1828 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
,
1829 (!tem
? EVAL_SKIP
: noside
));
1830 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1831 return value_from_longest (type
,
1832 (LONGEST
) (!tem
|| !value_logical_not (arg2
)));
1836 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1837 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1838 if (noside
== EVAL_SKIP
)
1840 if (binop_user_defined_p (op
, arg1
, arg2
))
1842 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1846 tem
= value_equal (arg1
, arg2
);
1847 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1848 return value_from_longest (type
, (LONGEST
) tem
);
1851 case BINOP_NOTEQUAL
:
1852 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1853 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1854 if (noside
== EVAL_SKIP
)
1856 if (binop_user_defined_p (op
, arg1
, arg2
))
1858 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1862 tem
= value_equal (arg1
, arg2
);
1863 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1864 return value_from_longest (type
, (LONGEST
) ! tem
);
1868 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1869 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1870 if (noside
== EVAL_SKIP
)
1872 if (binop_user_defined_p (op
, arg1
, arg2
))
1874 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1878 tem
= value_less (arg1
, arg2
);
1879 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1880 return value_from_longest (type
, (LONGEST
) tem
);
1884 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1885 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1886 if (noside
== EVAL_SKIP
)
1888 if (binop_user_defined_p (op
, arg1
, arg2
))
1890 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1894 tem
= value_less (arg2
, arg1
);
1895 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1896 return value_from_longest (type
, (LONGEST
) tem
);
1900 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1901 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1902 if (noside
== EVAL_SKIP
)
1904 if (binop_user_defined_p (op
, arg1
, arg2
))
1906 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1910 tem
= value_less (arg2
, arg1
) || value_equal (arg1
, arg2
);
1911 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1912 return value_from_longest (type
, (LONGEST
) tem
);
1916 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1917 arg2
= evaluate_subexp (value_type (arg1
), exp
, pos
, noside
);
1918 if (noside
== EVAL_SKIP
)
1920 if (binop_user_defined_p (op
, arg1
, arg2
))
1922 return value_x_binop (arg1
, arg2
, op
, OP_NULL
, noside
);
1926 tem
= value_less (arg1
, arg2
) || value_equal (arg1
, arg2
);
1927 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1928 return value_from_longest (type
, (LONGEST
) tem
);
1932 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1933 arg2
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1934 if (noside
== EVAL_SKIP
)
1936 type
= check_typedef (value_type (arg2
));
1937 if (TYPE_CODE (type
) != TYPE_CODE_INT
)
1938 error (_("Non-integral right operand for \"@\" operator."));
1939 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
1941 return allocate_repeat_value (value_type (arg1
),
1942 longest_to_int (value_as_long (arg2
)));
1945 return value_repeat (arg1
, longest_to_int (value_as_long (arg2
)));
1948 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1949 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1952 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1953 if (noside
== EVAL_SKIP
)
1955 if (unop_user_defined_p (op
, arg1
))
1956 return value_x_unop (arg1
, op
, noside
);
1958 return value_pos (arg1
);
1961 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1962 if (noside
== EVAL_SKIP
)
1964 if (unop_user_defined_p (op
, arg1
))
1965 return value_x_unop (arg1
, op
, noside
);
1967 return value_neg (arg1
);
1969 case UNOP_COMPLEMENT
:
1970 /* C++: check for and handle destructor names. */
1971 op
= exp
->elts
[*pos
].opcode
;
1973 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1974 if (noside
== EVAL_SKIP
)
1976 if (unop_user_defined_p (UNOP_COMPLEMENT
, arg1
))
1977 return value_x_unop (arg1
, UNOP_COMPLEMENT
, noside
);
1979 return value_complement (arg1
);
1981 case UNOP_LOGICAL_NOT
:
1982 arg1
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
1983 if (noside
== EVAL_SKIP
)
1985 if (unop_user_defined_p (op
, arg1
))
1986 return value_x_unop (arg1
, op
, noside
);
1989 type
= language_bool_type (exp
->language_defn
, exp
->gdbarch
);
1990 return value_from_longest (type
, (LONGEST
) value_logical_not (arg1
));
1994 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
1995 expect_type
= TYPE_TARGET_TYPE (check_typedef (expect_type
));
1996 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
1997 type
= check_typedef (value_type (arg1
));
1998 if (TYPE_CODE (type
) == TYPE_CODE_METHODPTR
1999 || TYPE_CODE (type
) == TYPE_CODE_MEMBERPTR
)
2000 error (_("Attempt to dereference pointer to member without an object"));
2001 if (noside
== EVAL_SKIP
)
2003 if (unop_user_defined_p (op
, arg1
))
2004 return value_x_unop (arg1
, op
, noside
);
2005 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2007 type
= check_typedef (value_type (arg1
));
2008 if (TYPE_CODE (type
) == TYPE_CODE_PTR
2009 || TYPE_CODE (type
) == TYPE_CODE_REF
2010 /* In C you can dereference an array to get the 1st elt. */
2011 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
2013 return value_zero (TYPE_TARGET_TYPE (type
),
2015 else if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2016 /* GDB allows dereferencing an int. */
2017 return value_zero (builtin_type_int
, lval_memory
);
2019 error (_("Attempt to take contents of a non-pointer value."));
2021 return value_ind (arg1
);
2024 /* C++: check for and handle pointer to members. */
2026 op
= exp
->elts
[*pos
].opcode
;
2028 if (noside
== EVAL_SKIP
)
2030 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2035 struct value
*retvalp
= evaluate_subexp_for_address (exp
, pos
, noside
);
2040 if (noside
== EVAL_SKIP
)
2042 evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_SKIP
);
2045 return evaluate_subexp_for_sizeof (exp
, pos
);
2049 type
= exp
->elts
[pc
+ 1].type
;
2050 arg1
= evaluate_subexp (type
, exp
, pos
, noside
);
2051 if (noside
== EVAL_SKIP
)
2053 if (type
!= value_type (arg1
))
2054 arg1
= value_cast (type
, arg1
);
2059 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2060 if (noside
== EVAL_SKIP
)
2062 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2063 return value_zero (exp
->elts
[pc
+ 1].type
, lval_memory
);
2065 return value_at_lazy (exp
->elts
[pc
+ 1].type
,
2066 value_as_address (arg1
));
2068 case UNOP_MEMVAL_TLS
:
2070 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2071 if (noside
== EVAL_SKIP
)
2073 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2074 return value_zero (exp
->elts
[pc
+ 2].type
, lval_memory
);
2078 tls_addr
= target_translate_tls_address (exp
->elts
[pc
+ 1].objfile
,
2079 value_as_address (arg1
));
2080 return value_at_lazy (exp
->elts
[pc
+ 2].type
, tls_addr
);
2083 case UNOP_PREINCREMENT
:
2084 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2085 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2087 else if (unop_user_defined_p (op
, arg1
))
2089 return value_x_unop (arg1
, op
, noside
);
2093 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
2095 return value_assign (arg1
, arg2
);
2098 case UNOP_PREDECREMENT
:
2099 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2100 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2102 else if (unop_user_defined_p (op
, arg1
))
2104 return value_x_unop (arg1
, op
, noside
);
2108 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2110 return value_assign (arg1
, arg2
);
2113 case UNOP_POSTINCREMENT
:
2114 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2115 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2117 else if (unop_user_defined_p (op
, arg1
))
2119 return value_x_unop (arg1
, op
, noside
);
2123 arg2
= value_add (arg1
, value_from_longest (builtin_type_char
,
2125 value_assign (arg1
, arg2
);
2129 case UNOP_POSTDECREMENT
:
2130 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
2131 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
2133 else if (unop_user_defined_p (op
, arg1
))
2135 return value_x_unop (arg1
, op
, noside
);
2139 arg2
= value_sub (arg1
, value_from_longest (builtin_type_char
,
2141 value_assign (arg1
, arg2
);
2147 return value_of_this (1);
2151 return value_of_local ("self", 1);
2154 /* The value is not supposed to be used. This is here to make it
2155 easier to accommodate expressions that contain types. */
2157 if (noside
== EVAL_SKIP
)
2159 else if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2160 return allocate_value (exp
->elts
[pc
+ 1].type
);
2162 error (_("Attempt to use a type name as an expression"));
2165 /* Removing this case and compiling with gcc -Wall reveals that
2166 a lot of cases are hitting this case. Some of these should
2167 probably be removed from expression.h; others are legitimate
2168 expressions which are (apparently) not fully implemented.
2170 If there are any cases landing here which mean a user error,
2171 then they should be separate cases, with more descriptive
2175 GDB does not (yet) know how to evaluate that kind of expression"));
2179 return value_from_longest (builtin_type_long
, (LONGEST
) 1);
2182 /* Evaluate a subexpression of EXP, at index *POS,
2183 and return the address of that subexpression.
2184 Advance *POS over the subexpression.
2185 If the subexpression isn't an lvalue, get an error.
2186 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2187 then only the type of the result need be correct. */
2189 static struct value
*
2190 evaluate_subexp_for_address (struct expression
*exp
, int *pos
,
2200 op
= exp
->elts
[pc
].opcode
;
2206 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2208 /* We can't optimize out "&*" if there's a user-defined operator*. */
2209 if (unop_user_defined_p (op
, x
))
2211 x
= value_x_unop (x
, op
, noside
);
2212 goto default_case_after_eval
;
2219 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
2220 evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
));
2223 var
= exp
->elts
[pc
+ 2].symbol
;
2225 /* C++: The "address" of a reference should yield the address
2226 * of the object pointed to. Let value_addr() deal with it. */
2227 if (TYPE_CODE (SYMBOL_TYPE (var
)) == TYPE_CODE_REF
)
2231 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2234 lookup_pointer_type (SYMBOL_TYPE (var
));
2235 enum address_class sym_class
= SYMBOL_CLASS (var
);
2237 if (sym_class
== LOC_CONST
2238 || sym_class
== LOC_CONST_BYTES
2239 || sym_class
== LOC_REGISTER
)
2240 error (_("Attempt to take address of register or constant."));
2243 value_zero (type
, not_lval
);
2245 else if (symbol_read_needs_frame (var
))
2249 block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2251 return locate_var_value (var
, NULL
);
2254 tem
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
2255 (*pos
) += 5 + BYTES_TO_EXP_ELEM (tem
+ 1);
2256 x
= value_aggregate_elt (exp
->elts
[pc
+ 1].type
,
2257 &exp
->elts
[pc
+ 3].string
,
2260 error (_("There is no field named %s"), &exp
->elts
[pc
+ 3].string
);
2265 x
= evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2266 default_case_after_eval
:
2267 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
2269 struct type
*type
= check_typedef (value_type (x
));
2271 if (VALUE_LVAL (x
) == lval_memory
|| value_must_coerce_to_target (x
))
2272 return value_zero (lookup_pointer_type (value_type (x
)),
2274 else if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2275 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type
)),
2278 error (_("Attempt to take address of value not located in memory."));
2280 return value_addr (x
);
2284 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2285 When used in contexts where arrays will be coerced anyway, this is
2286 equivalent to `evaluate_subexp' but much faster because it avoids
2287 actually fetching array contents (perhaps obsolete now that we have
2290 Note that we currently only do the coercion for C expressions, where
2291 arrays are zero based and the coercion is correct. For other languages,
2292 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2293 to decide if coercion is appropriate.
2298 evaluate_subexp_with_coercion (struct expression
*exp
,
2299 int *pos
, enum noside noside
)
2307 op
= exp
->elts
[pc
].opcode
;
2312 var
= exp
->elts
[pc
+ 2].symbol
;
2313 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var
))) == TYPE_CODE_ARRAY
2314 && CAST_IS_CONVERSION
)
2319 (var
, block_innermost_frame (exp
->elts
[pc
+ 1].block
));
2320 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var
)))),
2326 return evaluate_subexp (NULL_TYPE
, exp
, pos
, noside
);
2330 /* Evaluate a subexpression of EXP, at index *POS,
2331 and return a value for the size of that subexpression.
2332 Advance *POS over the subexpression. */
2334 static struct value
*
2335 evaluate_subexp_for_sizeof (struct expression
*exp
, int *pos
)
2343 op
= exp
->elts
[pc
].opcode
;
2347 /* This case is handled specially
2348 so that we avoid creating a value for the result type.
2349 If the result type is very big, it's desirable not to
2350 create a value unnecessarily. */
2353 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2354 type
= check_typedef (value_type (val
));
2355 if (TYPE_CODE (type
) != TYPE_CODE_PTR
2356 && TYPE_CODE (type
) != TYPE_CODE_REF
2357 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
2358 error (_("Attempt to take contents of a non-pointer value."));
2359 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2360 return value_from_longest (builtin_type_int
, (LONGEST
)
2361 TYPE_LENGTH (type
));
2365 type
= check_typedef (exp
->elts
[pc
+ 1].type
);
2366 return value_from_longest (builtin_type_int
,
2367 (LONGEST
) TYPE_LENGTH (type
));
2371 type
= check_typedef (SYMBOL_TYPE (exp
->elts
[pc
+ 2].symbol
));
2373 value_from_longest (builtin_type_int
, (LONGEST
) TYPE_LENGTH (type
));
2376 val
= evaluate_subexp (NULL_TYPE
, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
2377 return value_from_longest (builtin_type_int
,
2378 (LONGEST
) TYPE_LENGTH (value_type (val
)));
2382 /* Parse a type expression in the string [P..P+LENGTH). */
2385 parse_and_eval_type (char *p
, int length
)
2387 char *tmp
= (char *) alloca (length
+ 4);
2388 struct expression
*expr
;
2390 memcpy (tmp
+ 1, p
, length
);
2391 tmp
[length
+ 1] = ')';
2392 tmp
[length
+ 2] = '0';
2393 tmp
[length
+ 3] = '\0';
2394 expr
= parse_expression (tmp
);
2395 if (expr
->elts
[0].opcode
!= UNOP_CAST
)
2396 error (_("Internal error in eval_type."));
2397 return expr
->elts
[1].type
;
2401 calc_f77_array_dims (struct type
*array_type
)
2404 struct type
*tmp_type
;
2406 if ((TYPE_CODE (array_type
) != TYPE_CODE_ARRAY
))
2407 error (_("Can't get dimensions for a non-array type"));
2409 tmp_type
= array_type
;
2411 while ((tmp_type
= TYPE_TARGET_TYPE (tmp_type
)))
2413 if (TYPE_CODE (tmp_type
) == TYPE_CODE_ARRAY
)