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