* eval.c (parse_and_eval_address_1): Remove function.
[binutils-gdb.git] / gdb / eval.c
1 /* Evaluate expressions for GDB.
2
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 2009, 2010, 2011 Free Software Foundation, Inc.
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22 #include "defs.h"
23 #include "gdb_string.h"
24 #include "symtab.h"
25 #include "gdbtypes.h"
26 #include "value.h"
27 #include "expression.h"
28 #include "target.h"
29 #include "frame.h"
30 #include "language.h" /* For CAST_IS_CONVERSION. */
31 #include "f-lang.h" /* For array bound stuff. */
32 #include "cp-abi.h"
33 #include "infcall.h"
34 #include "objc-lang.h"
35 #include "block.h"
36 #include "parser-defs.h"
37 #include "cp-support.h"
38 #include "ui-out.h"
39 #include "exceptions.h"
40 #include "regcache.h"
41 #include "user-regs.h"
42 #include "valprint.h"
43 #include "gdb_obstack.h"
44 #include "objfiles.h"
45 #include "python/python.h"
46 #include "wrapper.h"
47
48 #include "gdb_assert.h"
49
50 #include <ctype.h>
51
52 /* This is defined in valops.c */
53 extern int overload_resolution;
54
55 /* Prototypes for local functions. */
56
57 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
58
59 static struct value *evaluate_subexp_for_address (struct expression *,
60 int *, enum noside);
61
62 static char *get_label (struct expression *, int *);
63
64 static struct value *evaluate_struct_tuple (struct value *,
65 struct expression *, int *,
66 enum noside, int);
67
68 static LONGEST init_array_element (struct value *, struct value *,
69 struct expression *, int *, enum noside,
70 LONGEST, LONGEST);
71
72 struct value *
73 evaluate_subexp (struct type *expect_type, struct expression *exp,
74 int *pos, enum noside noside)
75 {
76 return (*exp->language_defn->la_exp_desc->evaluate_exp)
77 (expect_type, exp, pos, noside);
78 }
79 \f
80 /* Parse the string EXP as a C expression, evaluate it,
81 and return the result as a number. */
82
83 CORE_ADDR
84 parse_and_eval_address (char *exp)
85 {
86 struct expression *expr = parse_expression (exp);
87 CORE_ADDR addr;
88 struct cleanup *old_chain =
89 make_cleanup (free_current_contents, &expr);
90
91 addr = value_as_address (evaluate_expression (expr));
92 do_cleanups (old_chain);
93 return addr;
94 }
95
96 /* Like parse_and_eval_address, but treats the value of the expression
97 as an integer, not an address, returns a LONGEST, not a CORE_ADDR. */
98 LONGEST
99 parse_and_eval_long (char *exp)
100 {
101 struct expression *expr = parse_expression (exp);
102 LONGEST retval;
103 struct cleanup *old_chain =
104 make_cleanup (free_current_contents, &expr);
105
106 retval = value_as_long (evaluate_expression (expr));
107 do_cleanups (old_chain);
108 return (retval);
109 }
110
111 struct value *
112 parse_and_eval (char *exp)
113 {
114 struct expression *expr = parse_expression (exp);
115 struct value *val;
116 struct cleanup *old_chain =
117 make_cleanup (free_current_contents, &expr);
118
119 val = evaluate_expression (expr);
120 do_cleanups (old_chain);
121 return val;
122 }
123
124 /* Parse up to a comma (or to a closeparen)
125 in the string EXPP as an expression, evaluate it, and return the value.
126 EXPP is advanced to point to the comma. */
127
128 struct value *
129 parse_to_comma_and_eval (char **expp)
130 {
131 struct expression *expr = parse_exp_1 (expp, (struct block *) 0, 1);
132 struct value *val;
133 struct cleanup *old_chain =
134 make_cleanup (free_current_contents, &expr);
135
136 val = evaluate_expression (expr);
137 do_cleanups (old_chain);
138 return val;
139 }
140 \f
141 /* Evaluate an expression in internal prefix form
142 such as is constructed by parse.y.
143
144 See expression.h for info on the format of an expression. */
145
146 struct value *
147 evaluate_expression (struct expression *exp)
148 {
149 int pc = 0;
150
151 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
152 }
153
154 /* Evaluate an expression, avoiding all memory references
155 and getting a value whose type alone is correct. */
156
157 struct value *
158 evaluate_type (struct expression *exp)
159 {
160 int pc = 0;
161
162 return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
163 }
164
165 /* Evaluate a subexpression, avoiding all memory references and
166 getting a value whose type alone is correct. */
167
168 struct value *
169 evaluate_subexpression_type (struct expression *exp, int subexp)
170 {
171 return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
172 }
173
174 /* Find the current value of a watchpoint on EXP. Return the value in
175 *VALP and *RESULTP and the chain of intermediate and final values
176 in *VAL_CHAIN. RESULTP and VAL_CHAIN may be NULL if the caller does
177 not need them.
178
179 If a memory error occurs while evaluating the expression, *RESULTP will
180 be set to NULL. *RESULTP may be a lazy value, if the result could
181 not be read from memory. It is used to determine whether a value
182 is user-specified (we should watch the whole value) or intermediate
183 (we should watch only the bit used to locate the final value).
184
185 If the final value, or any intermediate value, could not be read
186 from memory, *VALP will be set to NULL. *VAL_CHAIN will still be
187 set to any referenced values. *VALP will never be a lazy value.
188 This is the value which we store in struct breakpoint.
189
190 If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
191 value chain. The caller must free the values individually. If
192 VAL_CHAIN is NULL, all generated values will be left on the value
193 chain. */
194
195 void
196 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
197 struct value **resultp, struct value **val_chain)
198 {
199 struct value *mark, *new_mark, *result;
200 volatile struct gdb_exception ex;
201
202 *valp = NULL;
203 if (resultp)
204 *resultp = NULL;
205 if (val_chain)
206 *val_chain = NULL;
207
208 /* Evaluate the expression. */
209 mark = value_mark ();
210 result = NULL;
211
212 TRY_CATCH (ex, RETURN_MASK_ALL)
213 {
214 result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
215 }
216 if (ex.reason < 0)
217 {
218 /* Ignore memory errors, we want watchpoints pointing at
219 inaccessible memory to still be created; otherwise, throw the
220 error to some higher catcher. */
221 switch (ex.error)
222 {
223 case MEMORY_ERROR:
224 break;
225 default:
226 throw_exception (ex);
227 break;
228 }
229 }
230
231 new_mark = value_mark ();
232 if (mark == new_mark)
233 return;
234 if (resultp)
235 *resultp = result;
236
237 /* Make sure it's not lazy, so that after the target stops again we
238 have a non-lazy previous value to compare with. */
239 if (result != NULL
240 && (!value_lazy (result) || gdb_value_fetch_lazy (result)))
241 *valp = result;
242
243 if (val_chain)
244 {
245 /* Return the chain of intermediate values. We use this to
246 decide which addresses to watch. */
247 *val_chain = new_mark;
248 value_release_to_mark (mark);
249 }
250 }
251
252 /* Extract a field operation from an expression. If the subexpression
253 of EXP starting at *SUBEXP is not a structure dereference
254 operation, return NULL. Otherwise, return the name of the
255 dereferenced field, and advance *SUBEXP to point to the
256 subexpression of the left-hand-side of the dereference. This is
257 used when completing field names. */
258
259 char *
260 extract_field_op (struct expression *exp, int *subexp)
261 {
262 int tem;
263 char *result;
264
265 if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
266 && exp->elts[*subexp].opcode != STRUCTOP_PTR)
267 return NULL;
268 tem = longest_to_int (exp->elts[*subexp + 1].longconst);
269 result = &exp->elts[*subexp + 2].string;
270 (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
271 return result;
272 }
273
274 /* If the next expression is an OP_LABELED, skips past it,
275 returning the label. Otherwise, does nothing and returns NULL. */
276
277 static char *
278 get_label (struct expression *exp, int *pos)
279 {
280 if (exp->elts[*pos].opcode == OP_LABELED)
281 {
282 int pc = (*pos)++;
283 char *name = &exp->elts[pc + 2].string;
284 int tem = longest_to_int (exp->elts[pc + 1].longconst);
285
286 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
287 return name;
288 }
289 else
290 return NULL;
291 }
292
293 /* This function evaluates tuples (in (the deleted) Chill) or
294 brace-initializers (in C/C++) for structure types. */
295
296 static struct value *
297 evaluate_struct_tuple (struct value *struct_val,
298 struct expression *exp,
299 int *pos, enum noside noside, int nargs)
300 {
301 struct type *struct_type = check_typedef (value_type (struct_val));
302 struct type *substruct_type = struct_type;
303 struct type *field_type;
304 int fieldno = -1;
305 int variantno = -1;
306 int subfieldno = -1;
307
308 while (--nargs >= 0)
309 {
310 int pc = *pos;
311 struct value *val = NULL;
312 int nlabels = 0;
313 int bitpos, bitsize;
314 bfd_byte *addr;
315
316 /* Skip past the labels, and count them. */
317 while (get_label (exp, pos) != NULL)
318 nlabels++;
319
320 do
321 {
322 char *label = get_label (exp, &pc);
323
324 if (label)
325 {
326 for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type);
327 fieldno++)
328 {
329 char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
330
331 if (field_name != NULL && strcmp (field_name, label) == 0)
332 {
333 variantno = -1;
334 subfieldno = fieldno;
335 substruct_type = struct_type;
336 goto found;
337 }
338 }
339 for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type);
340 fieldno++)
341 {
342 char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
343
344 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
345 if ((field_name == 0 || *field_name == '\0')
346 && TYPE_CODE (field_type) == TYPE_CODE_UNION)
347 {
348 variantno = 0;
349 for (; variantno < TYPE_NFIELDS (field_type);
350 variantno++)
351 {
352 substruct_type
353 = TYPE_FIELD_TYPE (field_type, variantno);
354 if (TYPE_CODE (substruct_type) == TYPE_CODE_STRUCT)
355 {
356 for (subfieldno = 0;
357 subfieldno < TYPE_NFIELDS (substruct_type);
358 subfieldno++)
359 {
360 if (strcmp(TYPE_FIELD_NAME (substruct_type,
361 subfieldno),
362 label) == 0)
363 {
364 goto found;
365 }
366 }
367 }
368 }
369 }
370 }
371 error (_("there is no field named %s"), label);
372 found:
373 ;
374 }
375 else
376 {
377 /* Unlabelled tuple element - go to next field. */
378 if (variantno >= 0)
379 {
380 subfieldno++;
381 if (subfieldno >= TYPE_NFIELDS (substruct_type))
382 {
383 variantno = -1;
384 substruct_type = struct_type;
385 }
386 }
387 if (variantno < 0)
388 {
389 fieldno++;
390 /* Skip static fields. */
391 while (fieldno < TYPE_NFIELDS (struct_type)
392 && field_is_static (&TYPE_FIELD (struct_type,
393 fieldno)))
394 fieldno++;
395 subfieldno = fieldno;
396 if (fieldno >= TYPE_NFIELDS (struct_type))
397 error (_("too many initializers"));
398 field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
399 if (TYPE_CODE (field_type) == TYPE_CODE_UNION
400 && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
401 error (_("don't know which variant you want to set"));
402 }
403 }
404
405 /* Here, struct_type is the type of the inner struct,
406 while substruct_type is the type of the inner struct.
407 These are the same for normal structures, but a variant struct
408 contains anonymous union fields that contain substruct fields.
409 The value fieldno is the index of the top-level (normal or
410 anonymous union) field in struct_field, while the value
411 subfieldno is the index of the actual real (named inner) field
412 in substruct_type. */
413
414 field_type = TYPE_FIELD_TYPE (substruct_type, subfieldno);
415 if (val == 0)
416 val = evaluate_subexp (field_type, exp, pos, noside);
417
418 /* Now actually set the field in struct_val. */
419
420 /* Assign val to field fieldno. */
421 if (value_type (val) != field_type)
422 val = value_cast (field_type, val);
423
424 bitsize = TYPE_FIELD_BITSIZE (substruct_type, subfieldno);
425 bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
426 if (variantno >= 0)
427 bitpos += TYPE_FIELD_BITPOS (substruct_type, subfieldno);
428 addr = value_contents_writeable (struct_val) + bitpos / 8;
429 if (bitsize)
430 modify_field (struct_type, addr,
431 value_as_long (val), bitpos % 8, bitsize);
432 else
433 memcpy (addr, value_contents (val),
434 TYPE_LENGTH (value_type (val)));
435 }
436 while (--nlabels > 0);
437 }
438 return struct_val;
439 }
440
441 /* Recursive helper function for setting elements of array tuples for
442 (the deleted) Chill. The target is ARRAY (which has bounds
443 LOW_BOUND to HIGH_BOUND); the element value is ELEMENT; EXP, POS
444 and NOSIDE are as usual. Evaluates index expresions and sets the
445 specified element(s) of ARRAY to ELEMENT. Returns last index
446 value. */
447
448 static LONGEST
449 init_array_element (struct value *array, struct value *element,
450 struct expression *exp, int *pos,
451 enum noside noside, LONGEST low_bound, LONGEST high_bound)
452 {
453 LONGEST index;
454 int element_size = TYPE_LENGTH (value_type (element));
455
456 if (exp->elts[*pos].opcode == BINOP_COMMA)
457 {
458 (*pos)++;
459 init_array_element (array, element, exp, pos, noside,
460 low_bound, high_bound);
461 return init_array_element (array, element,
462 exp, pos, noside, low_bound, high_bound);
463 }
464 else if (exp->elts[*pos].opcode == BINOP_RANGE)
465 {
466 LONGEST low, high;
467
468 (*pos)++;
469 low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
470 high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
471 if (low < low_bound || high > high_bound)
472 error (_("tuple range index out of range"));
473 for (index = low; index <= high; index++)
474 {
475 memcpy (value_contents_raw (array)
476 + (index - low_bound) * element_size,
477 value_contents (element), element_size);
478 }
479 }
480 else
481 {
482 index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
483 if (index < low_bound || index > high_bound)
484 error (_("tuple index out of range"));
485 memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
486 value_contents (element), element_size);
487 }
488 return index;
489 }
490
491 static struct value *
492 value_f90_subarray (struct value *array,
493 struct expression *exp, int *pos, enum noside noside)
494 {
495 int pc = (*pos) + 1;
496 LONGEST low_bound, high_bound;
497 struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
498 enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);
499
500 *pos += 3;
501
502 if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
503 low_bound = TYPE_LOW_BOUND (range);
504 else
505 low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
506
507 if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
508 high_bound = TYPE_HIGH_BOUND (range);
509 else
510 high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
511
512 return value_slice (array, low_bound, high_bound - low_bound + 1);
513 }
514
515
516 /* Promote value ARG1 as appropriate before performing a unary operation
517 on this argument.
518 If the result is not appropriate for any particular language then it
519 needs to patch this function. */
520
521 void
522 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
523 struct value **arg1)
524 {
525 struct type *type1;
526
527 *arg1 = coerce_ref (*arg1);
528 type1 = check_typedef (value_type (*arg1));
529
530 if (is_integral_type (type1))
531 {
532 switch (language->la_language)
533 {
534 default:
535 /* Perform integral promotion for ANSI C/C++.
536 If not appropropriate for any particular language
537 it needs to modify this function. */
538 {
539 struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
540
541 if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
542 *arg1 = value_cast (builtin_int, *arg1);
543 }
544 break;
545 }
546 }
547 }
548
549 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
550 operation on those two operands.
551 If the result is not appropriate for any particular language then it
552 needs to patch this function. */
553
554 void
555 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
556 struct value **arg1, struct value **arg2)
557 {
558 struct type *promoted_type = NULL;
559 struct type *type1;
560 struct type *type2;
561
562 *arg1 = coerce_ref (*arg1);
563 *arg2 = coerce_ref (*arg2);
564
565 type1 = check_typedef (value_type (*arg1));
566 type2 = check_typedef (value_type (*arg2));
567
568 if ((TYPE_CODE (type1) != TYPE_CODE_FLT
569 && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
570 && !is_integral_type (type1))
571 || (TYPE_CODE (type2) != TYPE_CODE_FLT
572 && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
573 && !is_integral_type (type2)))
574 return;
575
576 if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
577 || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
578 {
579 /* No promotion required. */
580 }
581 else if (TYPE_CODE (type1) == TYPE_CODE_FLT
582 || TYPE_CODE (type2) == TYPE_CODE_FLT)
583 {
584 switch (language->la_language)
585 {
586 case language_c:
587 case language_cplus:
588 case language_asm:
589 case language_objc:
590 case language_opencl:
591 /* No promotion required. */
592 break;
593
594 default:
595 /* For other languages the result type is unchanged from gdb
596 version 6.7 for backward compatibility.
597 If either arg was long double, make sure that value is also long
598 double. Otherwise use double. */
599 if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
600 || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
601 promoted_type = builtin_type (gdbarch)->builtin_long_double;
602 else
603 promoted_type = builtin_type (gdbarch)->builtin_double;
604 break;
605 }
606 }
607 else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
608 && TYPE_CODE (type2) == TYPE_CODE_BOOL)
609 {
610 /* No promotion required. */
611 }
612 else
613 /* Integral operations here. */
614 /* FIXME: Also mixed integral/booleans, with result an integer. */
615 {
616 const struct builtin_type *builtin = builtin_type (gdbarch);
617 unsigned int promoted_len1 = TYPE_LENGTH (type1);
618 unsigned int promoted_len2 = TYPE_LENGTH (type2);
619 int is_unsigned1 = TYPE_UNSIGNED (type1);
620 int is_unsigned2 = TYPE_UNSIGNED (type2);
621 unsigned int result_len;
622 int unsigned_operation;
623
624 /* Determine type length and signedness after promotion for
625 both operands. */
626 if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
627 {
628 is_unsigned1 = 0;
629 promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
630 }
631 if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
632 {
633 is_unsigned2 = 0;
634 promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
635 }
636
637 if (promoted_len1 > promoted_len2)
638 {
639 unsigned_operation = is_unsigned1;
640 result_len = promoted_len1;
641 }
642 else if (promoted_len2 > promoted_len1)
643 {
644 unsigned_operation = is_unsigned2;
645 result_len = promoted_len2;
646 }
647 else
648 {
649 unsigned_operation = is_unsigned1 || is_unsigned2;
650 result_len = promoted_len1;
651 }
652
653 switch (language->la_language)
654 {
655 case language_c:
656 case language_cplus:
657 case language_asm:
658 case language_objc:
659 if (result_len <= TYPE_LENGTH (builtin->builtin_int))
660 {
661 promoted_type = (unsigned_operation
662 ? builtin->builtin_unsigned_int
663 : builtin->builtin_int);
664 }
665 else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
666 {
667 promoted_type = (unsigned_operation
668 ? builtin->builtin_unsigned_long
669 : builtin->builtin_long);
670 }
671 else
672 {
673 promoted_type = (unsigned_operation
674 ? builtin->builtin_unsigned_long_long
675 : builtin->builtin_long_long);
676 }
677 break;
678 case language_opencl:
679 if (result_len <= TYPE_LENGTH (lookup_signed_typename
680 (language, gdbarch, "int")))
681 {
682 promoted_type =
683 (unsigned_operation
684 ? lookup_unsigned_typename (language, gdbarch, "int")
685 : lookup_signed_typename (language, gdbarch, "int"));
686 }
687 else if (result_len <= TYPE_LENGTH (lookup_signed_typename
688 (language, gdbarch, "long")))
689 {
690 promoted_type =
691 (unsigned_operation
692 ? lookup_unsigned_typename (language, gdbarch, "long")
693 : lookup_signed_typename (language, gdbarch,"long"));
694 }
695 break;
696 default:
697 /* For other languages the result type is unchanged from gdb
698 version 6.7 for backward compatibility.
699 If either arg was long long, make sure that value is also long
700 long. Otherwise use long. */
701 if (unsigned_operation)
702 {
703 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
704 promoted_type = builtin->builtin_unsigned_long_long;
705 else
706 promoted_type = builtin->builtin_unsigned_long;
707 }
708 else
709 {
710 if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
711 promoted_type = builtin->builtin_long_long;
712 else
713 promoted_type = builtin->builtin_long;
714 }
715 break;
716 }
717 }
718
719 if (promoted_type)
720 {
721 /* Promote both operands to common type. */
722 *arg1 = value_cast (promoted_type, *arg1);
723 *arg2 = value_cast (promoted_type, *arg2);
724 }
725 }
726
727 static int
728 ptrmath_type_p (const struct language_defn *lang, struct type *type)
729 {
730 type = check_typedef (type);
731 if (TYPE_CODE (type) == TYPE_CODE_REF)
732 type = TYPE_TARGET_TYPE (type);
733
734 switch (TYPE_CODE (type))
735 {
736 case TYPE_CODE_PTR:
737 case TYPE_CODE_FUNC:
738 return 1;
739
740 case TYPE_CODE_ARRAY:
741 return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
742
743 default:
744 return 0;
745 }
746 }
747
748 /* Constructs a fake method with the given parameter types.
749 This function is used by the parser to construct an "expected"
750 type for method overload resolution. */
751
752 static struct type *
753 make_params (int num_types, struct type **param_types)
754 {
755 struct type *type = XZALLOC (struct type);
756 TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
757 TYPE_LENGTH (type) = 1;
758 TYPE_CODE (type) = TYPE_CODE_METHOD;
759 TYPE_VPTR_FIELDNO (type) = -1;
760 TYPE_CHAIN (type) = type;
761 TYPE_NFIELDS (type) = num_types;
762 TYPE_FIELDS (type) = (struct field *)
763 TYPE_ZALLOC (type, sizeof (struct field) * num_types);
764
765 while (num_types-- > 0)
766 TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
767
768 return type;
769 }
770
771 struct value *
772 evaluate_subexp_standard (struct type *expect_type,
773 struct expression *exp, int *pos,
774 enum noside noside)
775 {
776 enum exp_opcode op;
777 int tem, tem2, tem3;
778 int pc, pc2 = 0, oldpos;
779 struct value *arg1 = NULL;
780 struct value *arg2 = NULL;
781 struct value *arg3;
782 struct type *type;
783 int nargs;
784 struct value **argvec;
785 int upper, lower;
786 int code;
787 int ix;
788 long mem_offset;
789 struct type **arg_types;
790 int save_pos1;
791 struct symbol *function = NULL;
792 char *function_name = NULL;
793
794 pc = (*pos)++;
795 op = exp->elts[pc].opcode;
796
797 switch (op)
798 {
799 case OP_SCOPE:
800 tem = longest_to_int (exp->elts[pc + 2].longconst);
801 (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
802 if (noside == EVAL_SKIP)
803 goto nosideret;
804 arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
805 &exp->elts[pc + 3].string,
806 expect_type, 0, noside);
807 if (arg1 == NULL)
808 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
809 return arg1;
810
811 case OP_LONG:
812 (*pos) += 3;
813 return value_from_longest (exp->elts[pc + 1].type,
814 exp->elts[pc + 2].longconst);
815
816 case OP_DOUBLE:
817 (*pos) += 3;
818 return value_from_double (exp->elts[pc + 1].type,
819 exp->elts[pc + 2].doubleconst);
820
821 case OP_DECFLOAT:
822 (*pos) += 3;
823 return value_from_decfloat (exp->elts[pc + 1].type,
824 exp->elts[pc + 2].decfloatconst);
825
826 case OP_ADL_FUNC:
827 case OP_VAR_VALUE:
828 (*pos) += 3;
829 if (noside == EVAL_SKIP)
830 goto nosideret;
831
832 /* JYG: We used to just return value_zero of the symbol type
833 if we're asked to avoid side effects. Otherwise we return
834 value_of_variable (...). However I'm not sure if
835 value_of_variable () has any side effect.
836 We need a full value object returned here for whatis_exp ()
837 to call evaluate_type () and then pass the full value to
838 value_rtti_target_type () if we are dealing with a pointer
839 or reference to a base class and print object is on. */
840
841 {
842 volatile struct gdb_exception except;
843 struct value *ret = NULL;
844
845 TRY_CATCH (except, RETURN_MASK_ERROR)
846 {
847 ret = value_of_variable (exp->elts[pc + 2].symbol,
848 exp->elts[pc + 1].block);
849 }
850
851 if (except.reason < 0)
852 {
853 if (noside == EVAL_AVOID_SIDE_EFFECTS)
854 ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
855 not_lval);
856 else
857 throw_exception (except);
858 }
859
860 return ret;
861 }
862
863 case OP_LAST:
864 (*pos) += 2;
865 return
866 access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
867
868 case OP_REGISTER:
869 {
870 const char *name = &exp->elts[pc + 2].string;
871 int regno;
872 struct value *val;
873
874 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
875 regno = user_reg_map_name_to_regnum (exp->gdbarch,
876 name, strlen (name));
877 if (regno == -1)
878 error (_("Register $%s not available."), name);
879
880 /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
881 a value with the appropriate register type. Unfortunately,
882 we don't have easy access to the type of user registers.
883 So for these registers, we fetch the register value regardless
884 of the evaluation mode. */
885 if (noside == EVAL_AVOID_SIDE_EFFECTS
886 && regno < gdbarch_num_regs (exp->gdbarch)
887 + gdbarch_num_pseudo_regs (exp->gdbarch))
888 val = value_zero (register_type (exp->gdbarch, regno), not_lval);
889 else
890 val = value_of_register (regno, get_selected_frame (NULL));
891 if (val == NULL)
892 error (_("Value of register %s not available."), name);
893 else
894 return val;
895 }
896 case OP_BOOL:
897 (*pos) += 2;
898 type = language_bool_type (exp->language_defn, exp->gdbarch);
899 return value_from_longest (type, exp->elts[pc + 1].longconst);
900
901 case OP_INTERNALVAR:
902 (*pos) += 2;
903 return value_of_internalvar (exp->gdbarch,
904 exp->elts[pc + 1].internalvar);
905
906 case OP_STRING:
907 tem = longest_to_int (exp->elts[pc + 1].longconst);
908 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
909 if (noside == EVAL_SKIP)
910 goto nosideret;
911 type = language_string_char_type (exp->language_defn, exp->gdbarch);
912 return value_string (&exp->elts[pc + 2].string, tem, type);
913
914 case OP_OBJC_NSSTRING: /* Objective C Foundation Class
915 NSString constant. */
916 tem = longest_to_int (exp->elts[pc + 1].longconst);
917 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
918 if (noside == EVAL_SKIP)
919 {
920 goto nosideret;
921 }
922 return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
923
924 case OP_BITSTRING:
925 tem = longest_to_int (exp->elts[pc + 1].longconst);
926 (*pos)
927 += 3 + BYTES_TO_EXP_ELEM ((tem + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
928 if (noside == EVAL_SKIP)
929 goto nosideret;
930 return value_bitstring (&exp->elts[pc + 2].string, tem,
931 builtin_type (exp->gdbarch)->builtin_int);
932 break;
933
934 case OP_ARRAY:
935 (*pos) += 3;
936 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
937 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
938 nargs = tem3 - tem2 + 1;
939 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
940
941 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
942 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
943 {
944 struct value *rec = allocate_value (expect_type);
945
946 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
947 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
948 }
949
950 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
951 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
952 {
953 struct type *range_type = TYPE_INDEX_TYPE (type);
954 struct type *element_type = TYPE_TARGET_TYPE (type);
955 struct value *array = allocate_value (expect_type);
956 int element_size = TYPE_LENGTH (check_typedef (element_type));
957 LONGEST low_bound, high_bound, index;
958
959 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
960 {
961 low_bound = 0;
962 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
963 }
964 index = low_bound;
965 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
966 for (tem = nargs; --nargs >= 0;)
967 {
968 struct value *element;
969 int index_pc = 0;
970
971 if (exp->elts[*pos].opcode == BINOP_RANGE)
972 {
973 index_pc = ++(*pos);
974 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
975 }
976 element = evaluate_subexp (element_type, exp, pos, noside);
977 if (value_type (element) != element_type)
978 element = value_cast (element_type, element);
979 if (index_pc)
980 {
981 int continue_pc = *pos;
982
983 *pos = index_pc;
984 index = init_array_element (array, element, exp, pos, noside,
985 low_bound, high_bound);
986 *pos = continue_pc;
987 }
988 else
989 {
990 if (index > high_bound)
991 /* To avoid memory corruption. */
992 error (_("Too many array elements"));
993 memcpy (value_contents_raw (array)
994 + (index - low_bound) * element_size,
995 value_contents (element),
996 element_size);
997 }
998 index++;
999 }
1000 return array;
1001 }
1002
1003 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
1004 && TYPE_CODE (type) == TYPE_CODE_SET)
1005 {
1006 struct value *set = allocate_value (expect_type);
1007 gdb_byte *valaddr = value_contents_raw (set);
1008 struct type *element_type = TYPE_INDEX_TYPE (type);
1009 struct type *check_type = element_type;
1010 LONGEST low_bound, high_bound;
1011
1012 /* Get targettype of elementtype. */
1013 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
1014 || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
1015 check_type = TYPE_TARGET_TYPE (check_type);
1016
1017 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
1018 error (_("(power)set type with unknown size"));
1019 memset (valaddr, '\0', TYPE_LENGTH (type));
1020 for (tem = 0; tem < nargs; tem++)
1021 {
1022 LONGEST range_low, range_high;
1023 struct type *range_low_type, *range_high_type;
1024 struct value *elem_val;
1025
1026 if (exp->elts[*pos].opcode == BINOP_RANGE)
1027 {
1028 (*pos)++;
1029 elem_val = evaluate_subexp (element_type, exp, pos, noside);
1030 range_low_type = value_type (elem_val);
1031 range_low = value_as_long (elem_val);
1032 elem_val = evaluate_subexp (element_type, exp, pos, noside);
1033 range_high_type = value_type (elem_val);
1034 range_high = value_as_long (elem_val);
1035 }
1036 else
1037 {
1038 elem_val = evaluate_subexp (element_type, exp, pos, noside);
1039 range_low_type = range_high_type = value_type (elem_val);
1040 range_low = range_high = value_as_long (elem_val);
1041 }
1042 /* Check types of elements to avoid mixture of elements from
1043 different types. Also check if type of element is "compatible"
1044 with element type of powerset. */
1045 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
1046 range_low_type = TYPE_TARGET_TYPE (range_low_type);
1047 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
1048 range_high_type = TYPE_TARGET_TYPE (range_high_type);
1049 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
1050 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
1051 && (range_low_type != range_high_type)))
1052 /* different element modes. */
1053 error (_("POWERSET tuple elements of different mode"));
1054 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
1055 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
1056 && range_low_type != check_type))
1057 error (_("incompatible POWERSET tuple elements"));
1058 if (range_low > range_high)
1059 {
1060 warning (_("empty POWERSET tuple range"));
1061 continue;
1062 }
1063 if (range_low < low_bound || range_high > high_bound)
1064 error (_("POWERSET tuple element out of range"));
1065 range_low -= low_bound;
1066 range_high -= low_bound;
1067 for (; range_low <= range_high; range_low++)
1068 {
1069 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
1070
1071 if (gdbarch_bits_big_endian (exp->gdbarch))
1072 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
1073 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
1074 |= 1 << bit_index;
1075 }
1076 }
1077 return set;
1078 }
1079
1080 argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
1081 for (tem = 0; tem < nargs; tem++)
1082 {
1083 /* Ensure that array expressions are coerced into pointer
1084 objects. */
1085 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1086 }
1087 if (noside == EVAL_SKIP)
1088 goto nosideret;
1089 return value_array (tem2, tem3, argvec);
1090
1091 case TERNOP_SLICE:
1092 {
1093 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1094 int lowbound
1095 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1096 int upper
1097 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1098
1099 if (noside == EVAL_SKIP)
1100 goto nosideret;
1101 return value_slice (array, lowbound, upper - lowbound + 1);
1102 }
1103
1104 case TERNOP_SLICE_COUNT:
1105 {
1106 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1107 int lowbound
1108 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1109 int length
1110 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
1111
1112 return value_slice (array, lowbound, length);
1113 }
1114
1115 case TERNOP_COND:
1116 /* Skip third and second args to evaluate the first one. */
1117 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1118 if (value_logical_not (arg1))
1119 {
1120 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1121 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1122 }
1123 else
1124 {
1125 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1126 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1127 return arg2;
1128 }
1129
1130 case OP_OBJC_SELECTOR:
1131 { /* Objective C @selector operator. */
1132 char *sel = &exp->elts[pc + 2].string;
1133 int len = longest_to_int (exp->elts[pc + 1].longconst);
1134 struct type *selector_type;
1135
1136 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1137 if (noside == EVAL_SKIP)
1138 goto nosideret;
1139
1140 if (sel[len] != 0)
1141 sel[len] = 0; /* Make sure it's terminated. */
1142
1143 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1144 return value_from_longest (selector_type,
1145 lookup_child_selector (exp->gdbarch, sel));
1146 }
1147
1148 case OP_OBJC_MSGCALL:
1149 { /* Objective C message (method) call. */
1150
1151 CORE_ADDR responds_selector = 0;
1152 CORE_ADDR method_selector = 0;
1153
1154 CORE_ADDR selector = 0;
1155
1156 int struct_return = 0;
1157 int sub_no_side = 0;
1158
1159 struct value *msg_send = NULL;
1160 struct value *msg_send_stret = NULL;
1161 int gnu_runtime = 0;
1162
1163 struct value *target = NULL;
1164 struct value *method = NULL;
1165 struct value *called_method = NULL;
1166
1167 struct type *selector_type = NULL;
1168 struct type *long_type;
1169
1170 struct value *ret = NULL;
1171 CORE_ADDR addr = 0;
1172
1173 selector = exp->elts[pc + 1].longconst;
1174 nargs = exp->elts[pc + 2].longconst;
1175 argvec = (struct value **) alloca (sizeof (struct value *)
1176 * (nargs + 5));
1177
1178 (*pos) += 3;
1179
1180 long_type = builtin_type (exp->gdbarch)->builtin_long;
1181 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1182
1183 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1184 sub_no_side = EVAL_NORMAL;
1185 else
1186 sub_no_side = noside;
1187
1188 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1189
1190 if (value_as_long (target) == 0)
1191 return value_from_longest (long_type, 0);
1192
1193 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1194 gnu_runtime = 1;
1195
1196 /* Find the method dispatch (Apple runtime) or method lookup
1197 (GNU runtime) function for Objective-C. These will be used
1198 to lookup the symbol information for the method. If we
1199 can't find any symbol information, then we'll use these to
1200 call the method, otherwise we can call the method
1201 directly. The msg_send_stret function is used in the special
1202 case of a method that returns a structure (Apple runtime
1203 only). */
1204 if (gnu_runtime)
1205 {
1206 struct type *type = selector_type;
1207
1208 type = lookup_function_type (type);
1209 type = lookup_pointer_type (type);
1210 type = lookup_function_type (type);
1211 type = lookup_pointer_type (type);
1212
1213 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1214 msg_send_stret
1215 = find_function_in_inferior ("objc_msg_lookup", NULL);
1216
1217 msg_send = value_from_pointer (type, value_as_address (msg_send));
1218 msg_send_stret = value_from_pointer (type,
1219 value_as_address (msg_send_stret));
1220 }
1221 else
1222 {
1223 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1224 /* Special dispatcher for methods returning structs. */
1225 msg_send_stret
1226 = find_function_in_inferior ("objc_msgSend_stret", NULL);
1227 }
1228
1229 /* Verify the target object responds to this method. The
1230 standard top-level 'Object' class uses a different name for
1231 the verification method than the non-standard, but more
1232 often used, 'NSObject' class. Make sure we check for both. */
1233
1234 responds_selector
1235 = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1236 if (responds_selector == 0)
1237 responds_selector
1238 = lookup_child_selector (exp->gdbarch, "respondsTo:");
1239
1240 if (responds_selector == 0)
1241 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1242
1243 method_selector
1244 = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1245 if (method_selector == 0)
1246 method_selector
1247 = lookup_child_selector (exp->gdbarch, "methodFor:");
1248
1249 if (method_selector == 0)
1250 error (_("no 'methodFor:' or 'methodForSelector:' method"));
1251
1252 /* Call the verification method, to make sure that the target
1253 class implements the desired method. */
1254
1255 argvec[0] = msg_send;
1256 argvec[1] = target;
1257 argvec[2] = value_from_longest (long_type, responds_selector);
1258 argvec[3] = value_from_longest (long_type, selector);
1259 argvec[4] = 0;
1260
1261 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1262 if (gnu_runtime)
1263 {
1264 /* Function objc_msg_lookup returns a pointer. */
1265 argvec[0] = ret;
1266 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1267 }
1268 if (value_as_long (ret) == 0)
1269 error (_("Target does not respond to this message selector."));
1270
1271 /* Call "methodForSelector:" method, to get the address of a
1272 function method that implements this selector for this
1273 class. If we can find a symbol at that address, then we
1274 know the return type, parameter types etc. (that's a good
1275 thing). */
1276
1277 argvec[0] = msg_send;
1278 argvec[1] = target;
1279 argvec[2] = value_from_longest (long_type, method_selector);
1280 argvec[3] = value_from_longest (long_type, selector);
1281 argvec[4] = 0;
1282
1283 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1284 if (gnu_runtime)
1285 {
1286 argvec[0] = ret;
1287 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1288 }
1289
1290 /* ret should now be the selector. */
1291
1292 addr = value_as_long (ret);
1293 if (addr)
1294 {
1295 struct symbol *sym = NULL;
1296
1297 /* The address might point to a function descriptor;
1298 resolve it to the actual code address instead. */
1299 addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1300 &current_target);
1301
1302 /* Is it a high_level symbol? */
1303 sym = find_pc_function (addr);
1304 if (sym != NULL)
1305 method = value_of_variable (sym, 0);
1306 }
1307
1308 /* If we found a method with symbol information, check to see
1309 if it returns a struct. Otherwise assume it doesn't. */
1310
1311 if (method)
1312 {
1313 CORE_ADDR funaddr;
1314 struct type *val_type;
1315
1316 funaddr = find_function_addr (method, &val_type);
1317
1318 block_for_pc (funaddr);
1319
1320 CHECK_TYPEDEF (val_type);
1321
1322 if ((val_type == NULL)
1323 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1324 {
1325 if (expect_type != NULL)
1326 val_type = expect_type;
1327 }
1328
1329 struct_return = using_struct_return (exp->gdbarch,
1330 value_type (method),
1331 val_type);
1332 }
1333 else if (expect_type != NULL)
1334 {
1335 struct_return = using_struct_return (exp->gdbarch, NULL,
1336 check_typedef (expect_type));
1337 }
1338
1339 /* Found a function symbol. Now we will substitute its
1340 value in place of the message dispatcher (obj_msgSend),
1341 so that we call the method directly instead of thru
1342 the dispatcher. The main reason for doing this is that
1343 we can now evaluate the return value and parameter values
1344 according to their known data types, in case we need to
1345 do things like promotion, dereferencing, special handling
1346 of structs and doubles, etc.
1347
1348 We want to use the type signature of 'method', but still
1349 jump to objc_msgSend() or objc_msgSend_stret() to better
1350 mimic the behavior of the runtime. */
1351
1352 if (method)
1353 {
1354 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1355 error (_("method address has symbol information "
1356 "with non-function type; skipping"));
1357
1358 /* Create a function pointer of the appropriate type, and
1359 replace its value with the value of msg_send or
1360 msg_send_stret. We must use a pointer here, as
1361 msg_send and msg_send_stret are of pointer type, and
1362 the representation may be different on systems that use
1363 function descriptors. */
1364 if (struct_return)
1365 called_method
1366 = value_from_pointer (lookup_pointer_type (value_type (method)),
1367 value_as_address (msg_send_stret));
1368 else
1369 called_method
1370 = value_from_pointer (lookup_pointer_type (value_type (method)),
1371 value_as_address (msg_send));
1372 }
1373 else
1374 {
1375 if (struct_return)
1376 called_method = msg_send_stret;
1377 else
1378 called_method = msg_send;
1379 }
1380
1381 if (noside == EVAL_SKIP)
1382 goto nosideret;
1383
1384 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1385 {
1386 /* If the return type doesn't look like a function type,
1387 call an error. This can happen if somebody tries to
1388 turn a variable into a function call. This is here
1389 because people often want to call, eg, strcmp, which
1390 gdb doesn't know is a function. If gdb isn't asked for
1391 it's opinion (ie. through "whatis"), it won't offer
1392 it. */
1393
1394 struct type *type = value_type (called_method);
1395
1396 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1397 type = TYPE_TARGET_TYPE (type);
1398 type = TYPE_TARGET_TYPE (type);
1399
1400 if (type)
1401 {
1402 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1403 return allocate_value (expect_type);
1404 else
1405 return allocate_value (type);
1406 }
1407 else
1408 error (_("Expression of type other than "
1409 "\"method returning ...\" used as a method"));
1410 }
1411
1412 /* Now depending on whether we found a symbol for the method,
1413 we will either call the runtime dispatcher or the method
1414 directly. */
1415
1416 argvec[0] = called_method;
1417 argvec[1] = target;
1418 argvec[2] = value_from_longest (long_type, selector);
1419 /* User-supplied arguments. */
1420 for (tem = 0; tem < nargs; tem++)
1421 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1422 argvec[tem + 3] = 0;
1423
1424 if (gnu_runtime && (method != NULL))
1425 {
1426 /* Function objc_msg_lookup returns a pointer. */
1427 deprecated_set_value_type (argvec[0],
1428 lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1429 argvec[0]
1430 = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1431 }
1432
1433 ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1434 return ret;
1435 }
1436 break;
1437
1438 case OP_FUNCALL:
1439 (*pos) += 2;
1440 op = exp->elts[*pos].opcode;
1441 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1442 /* Allocate arg vector, including space for the function to be
1443 called in argvec[0] and a terminating NULL. */
1444 argvec = (struct value **)
1445 alloca (sizeof (struct value *) * (nargs + 3));
1446 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1447 {
1448 nargs++;
1449 /* First, evaluate the structure into arg2. */
1450 pc2 = (*pos)++;
1451
1452 if (noside == EVAL_SKIP)
1453 goto nosideret;
1454
1455 if (op == STRUCTOP_MEMBER)
1456 {
1457 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1458 }
1459 else
1460 {
1461 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1462 }
1463
1464 /* If the function is a virtual function, then the
1465 aggregate value (providing the structure) plays
1466 its part by providing the vtable. Otherwise,
1467 it is just along for the ride: call the function
1468 directly. */
1469
1470 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1471
1472 if (TYPE_CODE (check_typedef (value_type (arg1)))
1473 != TYPE_CODE_METHODPTR)
1474 error (_("Non-pointer-to-member value used in pointer-to-member "
1475 "construct"));
1476
1477 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1478 {
1479 struct type *method_type = check_typedef (value_type (arg1));
1480
1481 arg1 = value_zero (method_type, not_lval);
1482 }
1483 else
1484 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1485
1486 /* Now, say which argument to start evaluating from. */
1487 tem = 2;
1488 }
1489 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1490 {
1491 /* Hair for method invocations. */
1492 int tem2;
1493
1494 nargs++;
1495 /* First, evaluate the structure into arg2. */
1496 pc2 = (*pos)++;
1497 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1498 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1499 if (noside == EVAL_SKIP)
1500 goto nosideret;
1501
1502 if (op == STRUCTOP_STRUCT)
1503 {
1504 /* If v is a variable in a register, and the user types
1505 v.method (), this will produce an error, because v has
1506 no address.
1507
1508 A possible way around this would be to allocate a
1509 copy of the variable on the stack, copy in the
1510 contents, call the function, and copy out the
1511 contents. I.e. convert this from call by reference
1512 to call by copy-return (or whatever it's called).
1513 However, this does not work because it is not the
1514 same: the method being called could stash a copy of
1515 the address, and then future uses through that address
1516 (after the method returns) would be expected to
1517 use the variable itself, not some copy of it. */
1518 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1519 }
1520 else
1521 {
1522 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1523
1524 /* Check to see if the operator '->' has been
1525 overloaded. If the operator has been overloaded
1526 replace arg2 with the value returned by the custom
1527 operator and continue evaluation. */
1528 while (unop_user_defined_p (op, arg2))
1529 {
1530 volatile struct gdb_exception except;
1531 struct value *value = NULL;
1532 TRY_CATCH (except, RETURN_MASK_ERROR)
1533 {
1534 value = value_x_unop (arg2, op, noside);
1535 }
1536
1537 if (except.reason < 0)
1538 {
1539 if (except.error == NOT_FOUND_ERROR)
1540 break;
1541 else
1542 throw_exception (except);
1543 }
1544 arg2 = value;
1545 }
1546 }
1547 /* Now, say which argument to start evaluating from. */
1548 tem = 2;
1549 }
1550 else if (op == OP_SCOPE
1551 && overload_resolution
1552 && (exp->language_defn->la_language == language_cplus))
1553 {
1554 /* Unpack it locally so we can properly handle overload
1555 resolution. */
1556 char *name;
1557 int local_tem;
1558
1559 pc2 = (*pos)++;
1560 local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
1561 (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
1562 type = exp->elts[pc2 + 1].type;
1563 name = &exp->elts[pc2 + 3].string;
1564
1565 function = NULL;
1566 function_name = NULL;
1567 if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
1568 {
1569 function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
1570 name,
1571 get_selected_block (0),
1572 VAR_DOMAIN);
1573 if (function == NULL)
1574 error (_("No symbol \"%s\" in namespace \"%s\"."),
1575 name, TYPE_TAG_NAME (type));
1576
1577 tem = 1;
1578 }
1579 else
1580 {
1581 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1582 || TYPE_CODE (type) == TYPE_CODE_UNION);
1583 function_name = name;
1584
1585 arg2 = value_zero (type, lval_memory);
1586 ++nargs;
1587 tem = 2;
1588 }
1589 }
1590 else if (op == OP_ADL_FUNC)
1591 {
1592 /* Save the function position and move pos so that the arguments
1593 can be evaluated. */
1594 int func_name_len;
1595
1596 save_pos1 = *pos;
1597 tem = 1;
1598
1599 func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1600 (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1601 }
1602 else
1603 {
1604 /* Non-method function call. */
1605 save_pos1 = *pos;
1606 tem = 1;
1607
1608 /* If this is a C++ function wait until overload resolution. */
1609 if (op == OP_VAR_VALUE
1610 && overload_resolution
1611 && (exp->language_defn->la_language == language_cplus))
1612 {
1613 (*pos) += 4; /* Skip the evaluation of the symbol. */
1614 argvec[0] = NULL;
1615 }
1616 else
1617 {
1618 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1619 type = value_type (argvec[0]);
1620 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1621 type = TYPE_TARGET_TYPE (type);
1622 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1623 {
1624 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1625 {
1626 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1627 tem - 1),
1628 exp, pos, noside);
1629 }
1630 }
1631 }
1632 }
1633
1634 /* Evaluate arguments. */
1635 for (; tem <= nargs; tem++)
1636 {
1637 /* Ensure that array expressions are coerced into pointer
1638 objects. */
1639 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1640 }
1641
1642 /* Signal end of arglist. */
1643 argvec[tem] = 0;
1644 if (op == OP_ADL_FUNC)
1645 {
1646 struct symbol *symp;
1647 char *func_name;
1648 int name_len;
1649 int string_pc = save_pos1 + 3;
1650
1651 /* Extract the function name. */
1652 name_len = longest_to_int (exp->elts[string_pc].longconst);
1653 func_name = (char *) alloca (name_len + 1);
1654 strcpy (func_name, &exp->elts[string_pc + 1].string);
1655
1656 /* Prepare list of argument types for overload resolution. */
1657 arg_types = (struct type **)
1658 alloca (nargs * (sizeof (struct type *)));
1659 for (ix = 1; ix <= nargs; ix++)
1660 arg_types[ix - 1] = value_type (argvec[ix]);
1661
1662 find_overload_match (arg_types, nargs, func_name,
1663 NON_METHOD, /* not method */
1664 0, /* strict match */
1665 NULL, NULL, /* pass NULL symbol since
1666 symbol is unknown */
1667 NULL, &symp, NULL, 0);
1668
1669 /* Now fix the expression being evaluated. */
1670 exp->elts[save_pos1 + 2].symbol = symp;
1671 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1672 }
1673
1674 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1675 || (op == OP_SCOPE && function_name != NULL))
1676 {
1677 int static_memfuncp;
1678 char *tstr;
1679
1680 /* Method invocation : stuff "this" as first parameter. */
1681 argvec[1] = arg2;
1682
1683 if (op != OP_SCOPE)
1684 {
1685 /* Name of method from expression. */
1686 tstr = &exp->elts[pc2 + 2].string;
1687 }
1688 else
1689 tstr = function_name;
1690
1691 if (overload_resolution && (exp->language_defn->la_language
1692 == language_cplus))
1693 {
1694 /* Language is C++, do some overload resolution before
1695 evaluation. */
1696 struct value *valp = NULL;
1697
1698 /* Prepare list of argument types for overload resolution. */
1699 arg_types = (struct type **)
1700 alloca (nargs * (sizeof (struct type *)));
1701 for (ix = 1; ix <= nargs; ix++)
1702 arg_types[ix - 1] = value_type (argvec[ix]);
1703
1704 (void) find_overload_match (arg_types, nargs, tstr,
1705 METHOD, /* method */
1706 0, /* strict match */
1707 &arg2, /* the object */
1708 NULL, &valp, NULL,
1709 &static_memfuncp, 0);
1710
1711 if (op == OP_SCOPE && !static_memfuncp)
1712 {
1713 /* For the time being, we don't handle this. */
1714 error (_("Call to overloaded function %s requires "
1715 "`this' pointer"),
1716 function_name);
1717 }
1718 argvec[1] = arg2; /* the ``this'' pointer */
1719 argvec[0] = valp; /* Use the method found after overload
1720 resolution. */
1721 }
1722 else
1723 /* Non-C++ case -- or no overload resolution. */
1724 {
1725 struct value *temp = arg2;
1726
1727 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1728 &static_memfuncp,
1729 op == STRUCTOP_STRUCT
1730 ? "structure" : "structure pointer");
1731 /* value_struct_elt updates temp with the correct value
1732 of the ``this'' pointer if necessary, so modify argvec[1] to
1733 reflect any ``this'' changes. */
1734 arg2
1735 = value_from_longest (lookup_pointer_type(value_type (temp)),
1736 value_address (temp)
1737 + value_embedded_offset (temp));
1738 argvec[1] = arg2; /* the ``this'' pointer */
1739 }
1740
1741 if (static_memfuncp)
1742 {
1743 argvec[1] = argvec[0];
1744 nargs--;
1745 argvec++;
1746 }
1747 }
1748 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1749 {
1750 argvec[1] = arg2;
1751 argvec[0] = arg1;
1752 }
1753 else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1754 {
1755 /* Non-member function being called. */
1756 /* fn: This can only be done for C++ functions. A C-style function
1757 in a C++ program, for instance, does not have the fields that
1758 are expected here. */
1759
1760 if (overload_resolution && (exp->language_defn->la_language
1761 == language_cplus))
1762 {
1763 /* Language is C++, do some overload resolution before
1764 evaluation. */
1765 struct symbol *symp;
1766 int no_adl = 0;
1767
1768 /* If a scope has been specified disable ADL. */
1769 if (op == OP_SCOPE)
1770 no_adl = 1;
1771
1772 if (op == OP_VAR_VALUE)
1773 function = exp->elts[save_pos1+2].symbol;
1774
1775 /* Prepare list of argument types for overload resolution. */
1776 arg_types = (struct type **)
1777 alloca (nargs * (sizeof (struct type *)));
1778 for (ix = 1; ix <= nargs; ix++)
1779 arg_types[ix - 1] = value_type (argvec[ix]);
1780
1781 (void) find_overload_match (arg_types, nargs,
1782 NULL, /* no need for name */
1783 NON_METHOD, /* not method */
1784 0, /* strict match */
1785 NULL, function, /* the function */
1786 NULL, &symp, NULL, no_adl);
1787
1788 if (op == OP_VAR_VALUE)
1789 {
1790 /* Now fix the expression being evaluated. */
1791 exp->elts[save_pos1+2].symbol = symp;
1792 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1793 noside);
1794 }
1795 else
1796 argvec[0] = value_of_variable (symp, get_selected_block (0));
1797 }
1798 else
1799 {
1800 /* Not C++, or no overload resolution allowed. */
1801 /* Nothing to be done; argvec already correctly set up. */
1802 }
1803 }
1804 else
1805 {
1806 /* It is probably a C-style function. */
1807 /* Nothing to be done; argvec already correctly set up. */
1808 }
1809
1810 do_call_it:
1811
1812 if (noside == EVAL_SKIP)
1813 goto nosideret;
1814 if (argvec[0] == NULL)
1815 error (_("Cannot evaluate function -- may be inlined"));
1816 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1817 {
1818 /* If the return type doesn't look like a function type, call an
1819 error. This can happen if somebody tries to turn a variable into
1820 a function call. This is here because people often want to
1821 call, eg, strcmp, which gdb doesn't know is a function. If
1822 gdb isn't asked for it's opinion (ie. through "whatis"),
1823 it won't offer it. */
1824
1825 struct type *ftype = value_type (argvec[0]);
1826
1827 if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
1828 {
1829 /* We don't know anything about what the internal
1830 function might return, but we have to return
1831 something. */
1832 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
1833 not_lval);
1834 }
1835 else if (TYPE_TARGET_TYPE (ftype))
1836 return allocate_value (TYPE_TARGET_TYPE (ftype));
1837 else
1838 error (_("Expression of type other than "
1839 "\"Function returning ...\" used as function"));
1840 }
1841 if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_INTERNAL_FUNCTION)
1842 return call_internal_function (exp->gdbarch, exp->language_defn,
1843 argvec[0], nargs, argvec + 1);
1844
1845 return call_function_by_hand (argvec[0], nargs, argvec + 1);
1846 /* pai: FIXME save value from call_function_by_hand, then adjust
1847 pc by adjust_fn_pc if +ve. */
1848
1849 case OP_F77_UNDETERMINED_ARGLIST:
1850
1851 /* Remember that in F77, functions, substring ops and
1852 array subscript operations cannot be disambiguated
1853 at parse time. We have made all array subscript operations,
1854 substring operations as well as function calls come here
1855 and we now have to discover what the heck this thing actually was.
1856 If it is a function, we process just as if we got an OP_FUNCALL. */
1857
1858 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1859 (*pos) += 2;
1860
1861 /* First determine the type code we are dealing with. */
1862 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1863 type = check_typedef (value_type (arg1));
1864 code = TYPE_CODE (type);
1865
1866 if (code == TYPE_CODE_PTR)
1867 {
1868 /* Fortran always passes variable to subroutines as pointer.
1869 So we need to look into its target type to see if it is
1870 array, string or function. If it is, we need to switch
1871 to the target value the original one points to. */
1872 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1873
1874 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1875 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1876 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1877 {
1878 arg1 = value_ind (arg1);
1879 type = check_typedef (value_type (arg1));
1880 code = TYPE_CODE (type);
1881 }
1882 }
1883
1884 switch (code)
1885 {
1886 case TYPE_CODE_ARRAY:
1887 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1888 return value_f90_subarray (arg1, exp, pos, noside);
1889 else
1890 goto multi_f77_subscript;
1891
1892 case TYPE_CODE_STRING:
1893 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1894 return value_f90_subarray (arg1, exp, pos, noside);
1895 else
1896 {
1897 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1898 return value_subscript (arg1, value_as_long (arg2));
1899 }
1900
1901 case TYPE_CODE_PTR:
1902 case TYPE_CODE_FUNC:
1903 /* It's a function call. */
1904 /* Allocate arg vector, including space for the function to be
1905 called in argvec[0] and a terminating NULL. */
1906 argvec = (struct value **)
1907 alloca (sizeof (struct value *) * (nargs + 2));
1908 argvec[0] = arg1;
1909 tem = 1;
1910 for (; tem <= nargs; tem++)
1911 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1912 argvec[tem] = 0; /* signal end of arglist */
1913 goto do_call_it;
1914
1915 default:
1916 error (_("Cannot perform substring on this type"));
1917 }
1918
1919 case OP_COMPLEX:
1920 /* We have a complex number, There should be 2 floating
1921 point numbers that compose it. */
1922 (*pos) += 2;
1923 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1924 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1925
1926 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1927
1928 case STRUCTOP_STRUCT:
1929 tem = longest_to_int (exp->elts[pc + 1].longconst);
1930 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1931 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1932 if (noside == EVAL_SKIP)
1933 goto nosideret;
1934 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1935 return value_zero (lookup_struct_elt_type (value_type (arg1),
1936 &exp->elts[pc + 2].string,
1937 0),
1938 lval_memory);
1939 else
1940 {
1941 struct value *temp = arg1;
1942
1943 return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
1944 NULL, "structure");
1945 }
1946
1947 case STRUCTOP_PTR:
1948 tem = longest_to_int (exp->elts[pc + 1].longconst);
1949 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1950 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1951 if (noside == EVAL_SKIP)
1952 goto nosideret;
1953
1954 /* Check to see if operator '->' has been overloaded. If so replace
1955 arg1 with the value returned by evaluating operator->(). */
1956 while (unop_user_defined_p (op, arg1))
1957 {
1958 volatile struct gdb_exception except;
1959 struct value *value = NULL;
1960 TRY_CATCH (except, RETURN_MASK_ERROR)
1961 {
1962 value = value_x_unop (arg1, op, noside);
1963 }
1964
1965 if (except.reason < 0)
1966 {
1967 if (except.error == NOT_FOUND_ERROR)
1968 break;
1969 else
1970 throw_exception (except);
1971 }
1972 arg1 = value;
1973 }
1974
1975 /* JYG: if print object is on we need to replace the base type
1976 with rtti type in order to continue on with successful
1977 lookup of member / method only available in the rtti type. */
1978 {
1979 struct type *type = value_type (arg1);
1980 struct type *real_type;
1981 int full, top, using_enc;
1982 struct value_print_options opts;
1983
1984 get_user_print_options (&opts);
1985 if (opts.objectprint && TYPE_TARGET_TYPE(type)
1986 && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
1987 {
1988 real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
1989 if (real_type)
1990 {
1991 if (TYPE_CODE (type) == TYPE_CODE_PTR)
1992 real_type = lookup_pointer_type (real_type);
1993 else
1994 real_type = lookup_reference_type (real_type);
1995
1996 arg1 = value_cast (real_type, arg1);
1997 }
1998 }
1999 }
2000
2001 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2002 return value_zero (lookup_struct_elt_type (value_type (arg1),
2003 &exp->elts[pc + 2].string,
2004 0),
2005 lval_memory);
2006 else
2007 {
2008 struct value *temp = arg1;
2009
2010 return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
2011 NULL, "structure pointer");
2012 }
2013
2014 case STRUCTOP_MEMBER:
2015 case STRUCTOP_MPTR:
2016 if (op == STRUCTOP_MEMBER)
2017 arg1 = evaluate_subexp_for_address (exp, pos, noside);
2018 else
2019 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2020
2021 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2022
2023 if (noside == EVAL_SKIP)
2024 goto nosideret;
2025
2026 type = check_typedef (value_type (arg2));
2027 switch (TYPE_CODE (type))
2028 {
2029 case TYPE_CODE_METHODPTR:
2030 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2031 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
2032 else
2033 {
2034 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
2035 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
2036 return value_ind (arg2);
2037 }
2038
2039 case TYPE_CODE_MEMBERPTR:
2040 /* Now, convert these values to an address. */
2041 arg1 = value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
2042 arg1);
2043
2044 mem_offset = value_as_long (arg2);
2045
2046 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2047 value_as_long (arg1) + mem_offset);
2048 return value_ind (arg3);
2049
2050 default:
2051 error (_("non-pointer-to-member value used "
2052 "in pointer-to-member construct"));
2053 }
2054
2055 case TYPE_INSTANCE:
2056 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2057 arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
2058 for (ix = 0; ix < nargs; ++ix)
2059 arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
2060
2061 expect_type = make_params (nargs, arg_types);
2062 *(pos) += 3 + nargs;
2063 arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
2064 xfree (TYPE_FIELDS (expect_type));
2065 xfree (TYPE_MAIN_TYPE (expect_type));
2066 xfree (expect_type);
2067 return arg1;
2068
2069 case BINOP_CONCAT:
2070 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2071 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2072 if (noside == EVAL_SKIP)
2073 goto nosideret;
2074 if (binop_user_defined_p (op, arg1, arg2))
2075 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2076 else
2077 return value_concat (arg1, arg2);
2078
2079 case BINOP_ASSIGN:
2080 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2081 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2082
2083 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2084 return arg1;
2085 if (binop_user_defined_p (op, arg1, arg2))
2086 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2087 else
2088 return value_assign (arg1, arg2);
2089
2090 case BINOP_ASSIGN_MODIFY:
2091 (*pos) += 2;
2092 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2093 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2094 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2095 return arg1;
2096 op = exp->elts[pc + 1].opcode;
2097 if (binop_user_defined_p (op, arg1, arg2))
2098 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
2099 else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
2100 value_type (arg1))
2101 && is_integral_type (value_type (arg2)))
2102 arg2 = value_ptradd (arg1, value_as_long (arg2));
2103 else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
2104 value_type (arg1))
2105 && is_integral_type (value_type (arg2)))
2106 arg2 = value_ptradd (arg1, - value_as_long (arg2));
2107 else
2108 {
2109 struct value *tmp = arg1;
2110
2111 /* For shift and integer exponentiation operations,
2112 only promote the first argument. */
2113 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2114 && is_integral_type (value_type (arg2)))
2115 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
2116 else
2117 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2118
2119 arg2 = value_binop (tmp, arg2, op);
2120 }
2121 return value_assign (arg1, arg2);
2122
2123 case BINOP_ADD:
2124 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2125 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2126 if (noside == EVAL_SKIP)
2127 goto nosideret;
2128 if (binop_user_defined_p (op, arg1, arg2))
2129 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2130 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2131 && is_integral_type (value_type (arg2)))
2132 return value_ptradd (arg1, value_as_long (arg2));
2133 else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2134 && is_integral_type (value_type (arg1)))
2135 return value_ptradd (arg2, value_as_long (arg1));
2136 else
2137 {
2138 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2139 return value_binop (arg1, arg2, BINOP_ADD);
2140 }
2141
2142 case BINOP_SUB:
2143 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2144 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2145 if (noside == EVAL_SKIP)
2146 goto nosideret;
2147 if (binop_user_defined_p (op, arg1, arg2))
2148 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2149 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2150 && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2151 {
2152 /* FIXME -- should be ptrdiff_t */
2153 type = builtin_type (exp->gdbarch)->builtin_long;
2154 return value_from_longest (type, value_ptrdiff (arg1, arg2));
2155 }
2156 else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2157 && is_integral_type (value_type (arg2)))
2158 return value_ptradd (arg1, - value_as_long (arg2));
2159 else
2160 {
2161 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2162 return value_binop (arg1, arg2, BINOP_SUB);
2163 }
2164
2165 case BINOP_EXP:
2166 case BINOP_MUL:
2167 case BINOP_DIV:
2168 case BINOP_INTDIV:
2169 case BINOP_REM:
2170 case BINOP_MOD:
2171 case BINOP_LSH:
2172 case BINOP_RSH:
2173 case BINOP_BITWISE_AND:
2174 case BINOP_BITWISE_IOR:
2175 case BINOP_BITWISE_XOR:
2176 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2177 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2178 if (noside == EVAL_SKIP)
2179 goto nosideret;
2180 if (binop_user_defined_p (op, arg1, arg2))
2181 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2182 else
2183 {
2184 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2185 fudge arg2 to avoid division-by-zero, the caller is
2186 (theoretically) only looking for the type of the result. */
2187 if (noside == EVAL_AVOID_SIDE_EFFECTS
2188 /* ??? Do we really want to test for BINOP_MOD here?
2189 The implementation of value_binop gives it a well-defined
2190 value. */
2191 && (op == BINOP_DIV
2192 || op == BINOP_INTDIV
2193 || op == BINOP_REM
2194 || op == BINOP_MOD)
2195 && value_logical_not (arg2))
2196 {
2197 struct value *v_one, *retval;
2198
2199 v_one = value_one (value_type (arg2), not_lval);
2200 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2201 retval = value_binop (arg1, v_one, op);
2202 return retval;
2203 }
2204 else
2205 {
2206 /* For shift and integer exponentiation operations,
2207 only promote the first argument. */
2208 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2209 && is_integral_type (value_type (arg2)))
2210 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2211 else
2212 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2213
2214 return value_binop (arg1, arg2, op);
2215 }
2216 }
2217
2218 case BINOP_RANGE:
2219 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2220 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2221 if (noside == EVAL_SKIP)
2222 goto nosideret;
2223 error (_("':' operator used in invalid context"));
2224
2225 case BINOP_SUBSCRIPT:
2226 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2227 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2228 if (noside == EVAL_SKIP)
2229 goto nosideret;
2230 if (binop_user_defined_p (op, arg1, arg2))
2231 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2232 else
2233 {
2234 /* If the user attempts to subscript something that is not an
2235 array or pointer type (like a plain int variable for example),
2236 then report this as an error. */
2237
2238 arg1 = coerce_ref (arg1);
2239 type = check_typedef (value_type (arg1));
2240 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2241 && TYPE_CODE (type) != TYPE_CODE_PTR)
2242 {
2243 if (TYPE_NAME (type))
2244 error (_("cannot subscript something of type `%s'"),
2245 TYPE_NAME (type));
2246 else
2247 error (_("cannot subscript requested type"));
2248 }
2249
2250 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2251 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2252 else
2253 return value_subscript (arg1, value_as_long (arg2));
2254 }
2255
2256 case BINOP_IN:
2257 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2258 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2259 if (noside == EVAL_SKIP)
2260 goto nosideret;
2261 type = language_bool_type (exp->language_defn, exp->gdbarch);
2262 return value_from_longest (type, (LONGEST) value_in (arg1, arg2));
2263
2264 case MULTI_SUBSCRIPT:
2265 (*pos) += 2;
2266 nargs = longest_to_int (exp->elts[pc + 1].longconst);
2267 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2268 while (nargs-- > 0)
2269 {
2270 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2271 /* FIXME: EVAL_SKIP handling may not be correct. */
2272 if (noside == EVAL_SKIP)
2273 {
2274 if (nargs > 0)
2275 {
2276 continue;
2277 }
2278 else
2279 {
2280 goto nosideret;
2281 }
2282 }
2283 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
2284 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2285 {
2286 /* If the user attempts to subscript something that has no target
2287 type (like a plain int variable for example), then report this
2288 as an error. */
2289
2290 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2291 if (type != NULL)
2292 {
2293 arg1 = value_zero (type, VALUE_LVAL (arg1));
2294 noside = EVAL_SKIP;
2295 continue;
2296 }
2297 else
2298 {
2299 error (_("cannot subscript something of type `%s'"),
2300 TYPE_NAME (value_type (arg1)));
2301 }
2302 }
2303
2304 if (binop_user_defined_p (op, arg1, arg2))
2305 {
2306 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2307 }
2308 else
2309 {
2310 arg1 = coerce_ref (arg1);
2311 type = check_typedef (value_type (arg1));
2312
2313 switch (TYPE_CODE (type))
2314 {
2315 case TYPE_CODE_PTR:
2316 case TYPE_CODE_ARRAY:
2317 case TYPE_CODE_STRING:
2318 arg1 = value_subscript (arg1, value_as_long (arg2));
2319 break;
2320
2321 case TYPE_CODE_BITSTRING:
2322 type = language_bool_type (exp->language_defn, exp->gdbarch);
2323 arg1 = value_bitstring_subscript (type, arg1,
2324 value_as_long (arg2));
2325 break;
2326
2327 default:
2328 if (TYPE_NAME (type))
2329 error (_("cannot subscript something of type `%s'"),
2330 TYPE_NAME (type));
2331 else
2332 error (_("cannot subscript requested type"));
2333 }
2334 }
2335 }
2336 return (arg1);
2337
2338 multi_f77_subscript:
2339 {
2340 LONGEST subscript_array[MAX_FORTRAN_DIMS];
2341 int ndimensions = 1, i;
2342 struct value *array = arg1;
2343
2344 if (nargs > MAX_FORTRAN_DIMS)
2345 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2346
2347 ndimensions = calc_f77_array_dims (type);
2348
2349 if (nargs != ndimensions)
2350 error (_("Wrong number of subscripts"));
2351
2352 gdb_assert (nargs > 0);
2353
2354 /* Now that we know we have a legal array subscript expression
2355 let us actually find out where this element exists in the array. */
2356
2357 /* Take array indices left to right. */
2358 for (i = 0; i < nargs; i++)
2359 {
2360 /* Evaluate each subscript; it must be a legal integer in F77. */
2361 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2362
2363 /* Fill in the subscript array. */
2364
2365 subscript_array[i] = value_as_long (arg2);
2366 }
2367
2368 /* Internal type of array is arranged right to left. */
2369 for (i = nargs; i > 0; i--)
2370 {
2371 struct type *array_type = check_typedef (value_type (array));
2372 LONGEST index = subscript_array[i - 1];
2373
2374 lower = f77_get_lowerbound (array_type);
2375 array = value_subscripted_rvalue (array, index, lower);
2376 }
2377
2378 return array;
2379 }
2380
2381 case BINOP_LOGICAL_AND:
2382 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2383 if (noside == EVAL_SKIP)
2384 {
2385 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2386 goto nosideret;
2387 }
2388
2389 oldpos = *pos;
2390 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2391 *pos = oldpos;
2392
2393 if (binop_user_defined_p (op, arg1, arg2))
2394 {
2395 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2396 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2397 }
2398 else
2399 {
2400 tem = value_logical_not (arg1);
2401 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2402 (tem ? EVAL_SKIP : noside));
2403 type = language_bool_type (exp->language_defn, exp->gdbarch);
2404 return value_from_longest (type,
2405 (LONGEST) (!tem && !value_logical_not (arg2)));
2406 }
2407
2408 case BINOP_LOGICAL_OR:
2409 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2410 if (noside == EVAL_SKIP)
2411 {
2412 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2413 goto nosideret;
2414 }
2415
2416 oldpos = *pos;
2417 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2418 *pos = oldpos;
2419
2420 if (binop_user_defined_p (op, arg1, arg2))
2421 {
2422 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2423 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2424 }
2425 else
2426 {
2427 tem = value_logical_not (arg1);
2428 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2429 (!tem ? EVAL_SKIP : noside));
2430 type = language_bool_type (exp->language_defn, exp->gdbarch);
2431 return value_from_longest (type,
2432 (LONGEST) (!tem || !value_logical_not (arg2)));
2433 }
2434
2435 case BINOP_EQUAL:
2436 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2437 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2438 if (noside == EVAL_SKIP)
2439 goto nosideret;
2440 if (binop_user_defined_p (op, arg1, arg2))
2441 {
2442 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2443 }
2444 else
2445 {
2446 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2447 tem = value_equal (arg1, arg2);
2448 type = language_bool_type (exp->language_defn, exp->gdbarch);
2449 return value_from_longest (type, (LONGEST) tem);
2450 }
2451
2452 case BINOP_NOTEQUAL:
2453 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2454 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2455 if (noside == EVAL_SKIP)
2456 goto nosideret;
2457 if (binop_user_defined_p (op, arg1, arg2))
2458 {
2459 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2460 }
2461 else
2462 {
2463 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2464 tem = value_equal (arg1, arg2);
2465 type = language_bool_type (exp->language_defn, exp->gdbarch);
2466 return value_from_longest (type, (LONGEST) ! tem);
2467 }
2468
2469 case BINOP_LESS:
2470 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2471 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2472 if (noside == EVAL_SKIP)
2473 goto nosideret;
2474 if (binop_user_defined_p (op, arg1, arg2))
2475 {
2476 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2477 }
2478 else
2479 {
2480 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2481 tem = value_less (arg1, arg2);
2482 type = language_bool_type (exp->language_defn, exp->gdbarch);
2483 return value_from_longest (type, (LONGEST) tem);
2484 }
2485
2486 case BINOP_GTR:
2487 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2488 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2489 if (noside == EVAL_SKIP)
2490 goto nosideret;
2491 if (binop_user_defined_p (op, arg1, arg2))
2492 {
2493 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2494 }
2495 else
2496 {
2497 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2498 tem = value_less (arg2, arg1);
2499 type = language_bool_type (exp->language_defn, exp->gdbarch);
2500 return value_from_longest (type, (LONGEST) tem);
2501 }
2502
2503 case BINOP_GEQ:
2504 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2505 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2506 if (noside == EVAL_SKIP)
2507 goto nosideret;
2508 if (binop_user_defined_p (op, arg1, arg2))
2509 {
2510 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2511 }
2512 else
2513 {
2514 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2515 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2516 type = language_bool_type (exp->language_defn, exp->gdbarch);
2517 return value_from_longest (type, (LONGEST) tem);
2518 }
2519
2520 case BINOP_LEQ:
2521 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2522 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2523 if (noside == EVAL_SKIP)
2524 goto nosideret;
2525 if (binop_user_defined_p (op, arg1, arg2))
2526 {
2527 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2528 }
2529 else
2530 {
2531 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2532 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2533 type = language_bool_type (exp->language_defn, exp->gdbarch);
2534 return value_from_longest (type, (LONGEST) tem);
2535 }
2536
2537 case BINOP_REPEAT:
2538 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2539 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2540 if (noside == EVAL_SKIP)
2541 goto nosideret;
2542 type = check_typedef (value_type (arg2));
2543 if (TYPE_CODE (type) != TYPE_CODE_INT)
2544 error (_("Non-integral right operand for \"@\" operator."));
2545 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2546 {
2547 return allocate_repeat_value (value_type (arg1),
2548 longest_to_int (value_as_long (arg2)));
2549 }
2550 else
2551 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2552
2553 case BINOP_COMMA:
2554 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2555 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2556
2557 case UNOP_PLUS:
2558 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2559 if (noside == EVAL_SKIP)
2560 goto nosideret;
2561 if (unop_user_defined_p (op, arg1))
2562 return value_x_unop (arg1, op, noside);
2563 else
2564 {
2565 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2566 return value_pos (arg1);
2567 }
2568
2569 case UNOP_NEG:
2570 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2571 if (noside == EVAL_SKIP)
2572 goto nosideret;
2573 if (unop_user_defined_p (op, arg1))
2574 return value_x_unop (arg1, op, noside);
2575 else
2576 {
2577 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2578 return value_neg (arg1);
2579 }
2580
2581 case UNOP_COMPLEMENT:
2582 /* C++: check for and handle destructor names. */
2583 op = exp->elts[*pos].opcode;
2584
2585 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2586 if (noside == EVAL_SKIP)
2587 goto nosideret;
2588 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2589 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2590 else
2591 {
2592 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2593 return value_complement (arg1);
2594 }
2595
2596 case UNOP_LOGICAL_NOT:
2597 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2598 if (noside == EVAL_SKIP)
2599 goto nosideret;
2600 if (unop_user_defined_p (op, arg1))
2601 return value_x_unop (arg1, op, noside);
2602 else
2603 {
2604 type = language_bool_type (exp->language_defn, exp->gdbarch);
2605 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2606 }
2607
2608 case UNOP_IND:
2609 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2610 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2611 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2612 type = check_typedef (value_type (arg1));
2613 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2614 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2615 error (_("Attempt to dereference pointer "
2616 "to member without an object"));
2617 if (noside == EVAL_SKIP)
2618 goto nosideret;
2619 if (unop_user_defined_p (op, arg1))
2620 return value_x_unop (arg1, op, noside);
2621 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2622 {
2623 type = check_typedef (value_type (arg1));
2624 if (TYPE_CODE (type) == TYPE_CODE_PTR
2625 || TYPE_CODE (type) == TYPE_CODE_REF
2626 /* In C you can dereference an array to get the 1st elt. */
2627 || TYPE_CODE (type) == TYPE_CODE_ARRAY
2628 )
2629 return value_zero (TYPE_TARGET_TYPE (type),
2630 lval_memory);
2631 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2632 /* GDB allows dereferencing an int. */
2633 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2634 lval_memory);
2635 else
2636 error (_("Attempt to take contents of a non-pointer value."));
2637 }
2638
2639 /* Allow * on an integer so we can cast it to whatever we want.
2640 This returns an int, which seems like the most C-like thing to
2641 do. "long long" variables are rare enough that
2642 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2643 if (TYPE_CODE (type) == TYPE_CODE_INT)
2644 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2645 (CORE_ADDR) value_as_address (arg1));
2646 return value_ind (arg1);
2647
2648 case UNOP_ADDR:
2649 /* C++: check for and handle pointer to members. */
2650
2651 op = exp->elts[*pos].opcode;
2652
2653 if (noside == EVAL_SKIP)
2654 {
2655 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2656 goto nosideret;
2657 }
2658 else
2659 {
2660 struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2661 noside);
2662
2663 return retvalp;
2664 }
2665
2666 case UNOP_SIZEOF:
2667 if (noside == EVAL_SKIP)
2668 {
2669 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2670 goto nosideret;
2671 }
2672 return evaluate_subexp_for_sizeof (exp, pos);
2673
2674 case UNOP_CAST:
2675 (*pos) += 2;
2676 type = exp->elts[pc + 1].type;
2677 arg1 = evaluate_subexp (type, exp, pos, noside);
2678 if (noside == EVAL_SKIP)
2679 goto nosideret;
2680 if (type != value_type (arg1))
2681 arg1 = value_cast (type, arg1);
2682 return arg1;
2683
2684 case UNOP_DYNAMIC_CAST:
2685 (*pos) += 2;
2686 type = exp->elts[pc + 1].type;
2687 arg1 = evaluate_subexp (type, exp, pos, noside);
2688 if (noside == EVAL_SKIP)
2689 goto nosideret;
2690 return value_dynamic_cast (type, arg1);
2691
2692 case UNOP_REINTERPRET_CAST:
2693 (*pos) += 2;
2694 type = exp->elts[pc + 1].type;
2695 arg1 = evaluate_subexp (type, exp, pos, noside);
2696 if (noside == EVAL_SKIP)
2697 goto nosideret;
2698 return value_reinterpret_cast (type, arg1);
2699
2700 case UNOP_MEMVAL:
2701 (*pos) += 2;
2702 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2703 if (noside == EVAL_SKIP)
2704 goto nosideret;
2705 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2706 return value_zero (exp->elts[pc + 1].type, lval_memory);
2707 else
2708 return value_at_lazy (exp->elts[pc + 1].type,
2709 value_as_address (arg1));
2710
2711 case UNOP_MEMVAL_TLS:
2712 (*pos) += 3;
2713 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2714 if (noside == EVAL_SKIP)
2715 goto nosideret;
2716 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2717 return value_zero (exp->elts[pc + 2].type, lval_memory);
2718 else
2719 {
2720 CORE_ADDR tls_addr;
2721
2722 tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2723 value_as_address (arg1));
2724 return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
2725 }
2726
2727 case UNOP_PREINCREMENT:
2728 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2729 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2730 return arg1;
2731 else if (unop_user_defined_p (op, arg1))
2732 {
2733 return value_x_unop (arg1, op, noside);
2734 }
2735 else
2736 {
2737 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2738 arg2 = value_ptradd (arg1, 1);
2739 else
2740 {
2741 struct value *tmp = arg1;
2742
2743 arg2 = value_one (value_type (arg1), not_lval);
2744 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2745 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2746 }
2747
2748 return value_assign (arg1, arg2);
2749 }
2750
2751 case UNOP_PREDECREMENT:
2752 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2753 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2754 return arg1;
2755 else if (unop_user_defined_p (op, arg1))
2756 {
2757 return value_x_unop (arg1, op, noside);
2758 }
2759 else
2760 {
2761 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2762 arg2 = value_ptradd (arg1, -1);
2763 else
2764 {
2765 struct value *tmp = arg1;
2766
2767 arg2 = value_one (value_type (arg1), not_lval);
2768 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2769 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2770 }
2771
2772 return value_assign (arg1, arg2);
2773 }
2774
2775 case UNOP_POSTINCREMENT:
2776 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2777 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2778 return arg1;
2779 else if (unop_user_defined_p (op, arg1))
2780 {
2781 return value_x_unop (arg1, op, noside);
2782 }
2783 else
2784 {
2785 arg3 = value_non_lval (arg1);
2786
2787 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2788 arg2 = value_ptradd (arg1, 1);
2789 else
2790 {
2791 struct value *tmp = arg1;
2792
2793 arg2 = value_one (value_type (arg1), not_lval);
2794 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2795 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2796 }
2797
2798 value_assign (arg1, arg2);
2799 return arg3;
2800 }
2801
2802 case UNOP_POSTDECREMENT:
2803 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2804 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2805 return arg1;
2806 else if (unop_user_defined_p (op, arg1))
2807 {
2808 return value_x_unop (arg1, op, noside);
2809 }
2810 else
2811 {
2812 arg3 = value_non_lval (arg1);
2813
2814 if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2815 arg2 = value_ptradd (arg1, -1);
2816 else
2817 {
2818 struct value *tmp = arg1;
2819
2820 arg2 = value_one (value_type (arg1), not_lval);
2821 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2822 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2823 }
2824
2825 value_assign (arg1, arg2);
2826 return arg3;
2827 }
2828
2829 case OP_THIS:
2830 (*pos) += 1;
2831 return value_of_this (1);
2832
2833 case OP_OBJC_SELF:
2834 (*pos) += 1;
2835 return value_of_local ("self", 1);
2836
2837 case OP_TYPE:
2838 /* The value is not supposed to be used. This is here to make it
2839 easier to accommodate expressions that contain types. */
2840 (*pos) += 2;
2841 if (noside == EVAL_SKIP)
2842 goto nosideret;
2843 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2844 {
2845 struct type *type = exp->elts[pc + 1].type;
2846
2847 /* If this is a typedef, then find its immediate target. We
2848 use check_typedef to resolve stubs, but we ignore its
2849 result because we do not want to dig past all
2850 typedefs. */
2851 check_typedef (type);
2852 if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2853 type = TYPE_TARGET_TYPE (type);
2854 return allocate_value (type);
2855 }
2856 else
2857 error (_("Attempt to use a type name as an expression"));
2858
2859 default:
2860 /* Removing this case and compiling with gcc -Wall reveals that
2861 a lot of cases are hitting this case. Some of these should
2862 probably be removed from expression.h; others are legitimate
2863 expressions which are (apparently) not fully implemented.
2864
2865 If there are any cases landing here which mean a user error,
2866 then they should be separate cases, with more descriptive
2867 error messages. */
2868
2869 error (_("GDB does not (yet) know how to "
2870 "evaluate that kind of expression"));
2871 }
2872
2873 nosideret:
2874 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
2875 }
2876 \f
2877 /* Evaluate a subexpression of EXP, at index *POS,
2878 and return the address of that subexpression.
2879 Advance *POS over the subexpression.
2880 If the subexpression isn't an lvalue, get an error.
2881 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2882 then only the type of the result need be correct. */
2883
2884 static struct value *
2885 evaluate_subexp_for_address (struct expression *exp, int *pos,
2886 enum noside noside)
2887 {
2888 enum exp_opcode op;
2889 int pc;
2890 struct symbol *var;
2891 struct value *x;
2892 int tem;
2893
2894 pc = (*pos);
2895 op = exp->elts[pc].opcode;
2896
2897 switch (op)
2898 {
2899 case UNOP_IND:
2900 (*pos)++;
2901 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2902
2903 /* We can't optimize out "&*" if there's a user-defined operator*. */
2904 if (unop_user_defined_p (op, x))
2905 {
2906 x = value_x_unop (x, op, noside);
2907 goto default_case_after_eval;
2908 }
2909
2910 return coerce_array (x);
2911
2912 case UNOP_MEMVAL:
2913 (*pos) += 3;
2914 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2915 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2916
2917 case OP_VAR_VALUE:
2918 var = exp->elts[pc + 2].symbol;
2919
2920 /* C++: The "address" of a reference should yield the address
2921 * of the object pointed to. Let value_addr() deal with it. */
2922 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
2923 goto default_case;
2924
2925 (*pos) += 4;
2926 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2927 {
2928 struct type *type =
2929 lookup_pointer_type (SYMBOL_TYPE (var));
2930 enum address_class sym_class = SYMBOL_CLASS (var);
2931
2932 if (sym_class == LOC_CONST
2933 || sym_class == LOC_CONST_BYTES
2934 || sym_class == LOC_REGISTER)
2935 error (_("Attempt to take address of register or constant."));
2936
2937 return
2938 value_zero (type, not_lval);
2939 }
2940 else
2941 return address_of_variable (var, exp->elts[pc + 1].block);
2942
2943 case OP_SCOPE:
2944 tem = longest_to_int (exp->elts[pc + 2].longconst);
2945 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2946 x = value_aggregate_elt (exp->elts[pc + 1].type,
2947 &exp->elts[pc + 3].string,
2948 NULL, 1, noside);
2949 if (x == NULL)
2950 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2951 return x;
2952
2953 default:
2954 default_case:
2955 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2956 default_case_after_eval:
2957 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2958 {
2959 struct type *type = check_typedef (value_type (x));
2960
2961 if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2962 return value_zero (lookup_pointer_type (value_type (x)),
2963 not_lval);
2964 else if (TYPE_CODE (type) == TYPE_CODE_REF)
2965 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2966 not_lval);
2967 else
2968 error (_("Attempt to take address of "
2969 "value not located in memory."));
2970 }
2971 return value_addr (x);
2972 }
2973 }
2974
2975 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2976 When used in contexts where arrays will be coerced anyway, this is
2977 equivalent to `evaluate_subexp' but much faster because it avoids
2978 actually fetching array contents (perhaps obsolete now that we have
2979 value_lazy()).
2980
2981 Note that we currently only do the coercion for C expressions, where
2982 arrays are zero based and the coercion is correct. For other languages,
2983 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2984 to decide if coercion is appropriate. */
2985
2986 struct value *
2987 evaluate_subexp_with_coercion (struct expression *exp,
2988 int *pos, enum noside noside)
2989 {
2990 enum exp_opcode op;
2991 int pc;
2992 struct value *val;
2993 struct symbol *var;
2994 struct type *type;
2995
2996 pc = (*pos);
2997 op = exp->elts[pc].opcode;
2998
2999 switch (op)
3000 {
3001 case OP_VAR_VALUE:
3002 var = exp->elts[pc + 2].symbol;
3003 type = check_typedef (SYMBOL_TYPE (var));
3004 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
3005 && !TYPE_VECTOR (type)
3006 && CAST_IS_CONVERSION (exp->language_defn))
3007 {
3008 (*pos) += 4;
3009 val = address_of_variable (var, exp->elts[pc + 1].block);
3010 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
3011 val);
3012 }
3013 /* FALLTHROUGH */
3014
3015 default:
3016 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
3017 }
3018 }
3019
3020 /* Evaluate a subexpression of EXP, at index *POS,
3021 and return a value for the size of that subexpression.
3022 Advance *POS over the subexpression. */
3023
3024 static struct value *
3025 evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
3026 {
3027 /* FIXME: This should be size_t. */
3028 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
3029 enum exp_opcode op;
3030 int pc;
3031 struct type *type;
3032 struct value *val;
3033
3034 pc = (*pos);
3035 op = exp->elts[pc].opcode;
3036
3037 switch (op)
3038 {
3039 /* This case is handled specially
3040 so that we avoid creating a value for the result type.
3041 If the result type is very big, it's desirable not to
3042 create a value unnecessarily. */
3043 case UNOP_IND:
3044 (*pos)++;
3045 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3046 type = check_typedef (value_type (val));
3047 if (TYPE_CODE (type) != TYPE_CODE_PTR
3048 && TYPE_CODE (type) != TYPE_CODE_REF
3049 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
3050 error (_("Attempt to take contents of a non-pointer value."));
3051 type = check_typedef (TYPE_TARGET_TYPE (type));
3052 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3053
3054 case UNOP_MEMVAL:
3055 (*pos) += 3;
3056 type = check_typedef (exp->elts[pc + 1].type);
3057 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3058
3059 case OP_VAR_VALUE:
3060 (*pos) += 4;
3061 type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
3062 return
3063 value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3064
3065 default:
3066 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3067 return value_from_longest (size_type,
3068 (LONGEST) TYPE_LENGTH (value_type (val)));
3069 }
3070 }
3071
3072 /* Parse a type expression in the string [P..P+LENGTH). */
3073
3074 struct type *
3075 parse_and_eval_type (char *p, int length)
3076 {
3077 char *tmp = (char *) alloca (length + 4);
3078 struct expression *expr;
3079
3080 tmp[0] = '(';
3081 memcpy (tmp + 1, p, length);
3082 tmp[length + 1] = ')';
3083 tmp[length + 2] = '0';
3084 tmp[length + 3] = '\0';
3085 expr = parse_expression (tmp);
3086 if (expr->elts[0].opcode != UNOP_CAST)
3087 error (_("Internal error in eval_type."));
3088 return expr->elts[1].type;
3089 }
3090
3091 int
3092 calc_f77_array_dims (struct type *array_type)
3093 {
3094 int ndimen = 1;
3095 struct type *tmp_type;
3096
3097 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3098 error (_("Can't get dimensions for a non-array type"));
3099
3100 tmp_type = array_type;
3101
3102 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3103 {
3104 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)
3105 ++ndimen;
3106 }
3107 return ndimen;
3108 }