projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[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,
9b254dd1 4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
0d5de010 5 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"
c906108c 43
0d5de010
DJ		 44#include "gdb_assert.h"
45
c5aa993b 46/* This is defined in valops.c */
c906108c
SS		 47extern int overload_resolution;
48
c906108c
SS		 49/* Prototypes for local functions. */
50
61051030 51static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
c906108c 52
61051030
AC		 53static struct value *evaluate_subexp_for_address (struct expression *,
54 int *, enum noside);
c906108c 55
61051030
AC		 56static struct value *evaluate_subexp (struct type *, 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
61051030 69static struct 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
SS		 356 if (bitsize)
357 modify_field (addr, value_as_long (val),
358 bitpos % 8, bitsize);
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
0b4e1325
WZ		 416struct value *
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);
029a67e4
UW		 754 regno = user_reg_map_name_to_regnum (current_gdbarch,
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
765 && regno < gdbarch_num_regs (current_gdbarch)
766 + gdbarch_num_pseudo_regs (current_gdbarch))
123dc839
DJ		 767 val = value_zero (register_type (current_gdbarch, regno), not_lval);
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;
782 return value_of_internalvar (exp->elts[pc + 1].internalvar);
783
784 case OP_STRING:
785 tem = longest_to_int (exp->elts[pc + 1].longconst);
786 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
787 if (noside == EVAL_SKIP)
788 goto nosideret;
789 return value_string (&exp->elts[pc + 2].string, tem);
790
a9fa03de
AF		 791 case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant. */
792 tem = longest_to_int (exp->elts[pc + 1].longconst);
793 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
794 if (noside == EVAL_SKIP)
795 {
796 goto nosideret;
797 }
798 return (struct value *) value_nsstring (&exp->elts[pc + 2].string, tem + 1);
799
c906108c
SS		 800 case OP_BITSTRING:
801 tem = longest_to_int (exp->elts[pc + 1].longconst);
802 (*pos)
803 += 3 + BYTES_TO_EXP_ELEM ((tem + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
804 if (noside == EVAL_SKIP)
805 goto nosideret;
806 return value_bitstring (&exp->elts[pc + 2].string, tem);
807 break;
808
809 case OP_ARRAY:
810 (*pos) += 3;
811 tem2 = longest_to_int (exp->elts[pc + 1].longconst);
812 tem3 = longest_to_int (exp->elts[pc + 2].longconst);
813 nargs = tem3 - tem2 + 1;
814 type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
815
816 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
817 && TYPE_CODE (type) == TYPE_CODE_STRUCT)
818 {
61051030 819 struct value *rec = allocate_value (expect_type);
990a07ab 820 memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
c906108c
SS		 821 return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
822 }
823
824 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
825 && TYPE_CODE (type) == TYPE_CODE_ARRAY)
826 {
827 struct type *range_type = TYPE_FIELD_TYPE (type, 0);
828 struct type *element_type = TYPE_TARGET_TYPE (type);
61051030 829 struct value *array = allocate_value (expect_type);
c906108c
SS		 830 int element_size = TYPE_LENGTH (check_typedef (element_type));
831 LONGEST low_bound, high_bound, index;
832 if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
833 {
834 low_bound = 0;
835 high_bound = (TYPE_LENGTH (type) / element_size) - 1;
836 }
837 index = low_bound;
990a07ab 838 memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
c5aa993b 839 for (tem = nargs; --nargs >= 0;)
c906108c 840 {
61051030 841 struct value *element;
c906108c
SS		 842 int index_pc = 0;
843 if (exp->elts[*pos].opcode == BINOP_RANGE)
844 {
845 index_pc = ++(*pos);
846 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
847 }
848 element = evaluate_subexp (element_type, exp, pos, noside);
df407dfe 849 if (value_type (element) != element_type)
c906108c
SS		 850 element = value_cast (element_type, element);
851 if (index_pc)
852 {
853 int continue_pc = *pos;
854 *pos = index_pc;
855 index = init_array_element (array, element, exp, pos, noside,
856 low_bound, high_bound);
857 *pos = continue_pc;
858 }
859 else
860 {
861 if (index > high_bound)
862 /* to avoid memory corruption */
8a3fe4f8 863 error (_("Too many array elements"));
990a07ab 864 memcpy (value_contents_raw (array)
c906108c 865 + (index - low_bound) * element_size,
0fd88904 866 value_contents (element),
c906108c
SS		 867 element_size);
868 }
869 index++;
870 }
871 return array;
872 }
873
874 if (expect_type != NULL_TYPE && noside != EVAL_SKIP
875 && TYPE_CODE (type) == TYPE_CODE_SET)
876 {
61051030 877 struct value *set = allocate_value (expect_type);
47b667de 878 gdb_byte *valaddr = value_contents_raw (set);
c906108c
SS		 879 struct type *element_type = TYPE_INDEX_TYPE (type);
880 struct type *check_type = element_type;
881 LONGEST low_bound, high_bound;
882
883 /* get targettype of elementtype */
884 while (TYPE_CODE (check_type) == TYPE_CODE_RANGE ||
885 TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
886 check_type = TYPE_TARGET_TYPE (check_type);
887
888 if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
8a3fe4f8 889 error (_("(power)set type with unknown size"));
c906108c
SS		 890 memset (valaddr, '\0', TYPE_LENGTH (type));
891 for (tem = 0; tem < nargs; tem++)
892 {
893 LONGEST range_low, range_high;
894 struct type *range_low_type, *range_high_type;
61051030 895 struct value *elem_val;
c906108c
SS		 896 if (exp->elts[*pos].opcode == BINOP_RANGE)
897 {
898 (*pos)++;
899 elem_val = evaluate_subexp (element_type, exp, pos, noside);
df407dfe 900 range_low_type = value_type (elem_val);
c906108c
SS		 901 range_low = value_as_long (elem_val);
902 elem_val = evaluate_subexp (element_type, exp, pos, noside);
df407dfe 903 range_high_type = value_type (elem_val);
c906108c
SS		 904 range_high = value_as_long (elem_val);
905 }
906 else
907 {
908 elem_val = evaluate_subexp (element_type, exp, pos, noside);
df407dfe 909 range_low_type = range_high_type = value_type (elem_val);
c906108c
SS		 910 range_low = range_high = value_as_long (elem_val);
911 }
912 /* check types of elements to avoid mixture of elements from
c5aa993b
JM		 913 different types. Also check if type of element is "compatible"
914 with element type of powerset */
c906108c
SS		 915 if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
916 range_low_type = TYPE_TARGET_TYPE (range_low_type);
917 if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
918 range_high_type = TYPE_TARGET_TYPE (range_high_type);
919 if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type)) ||
920 (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM &&
921 (range_low_type != range_high_type)))
922 /* different element modes */
8a3fe4f8 923 error (_("POWERSET tuple elements of different mode"));
c906108c
SS		 924 if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) ||
925 (TYPE_CODE (check_type) == TYPE_CODE_ENUM &&
926 range_low_type != check_type))
8a3fe4f8 927 error (_("incompatible POWERSET tuple elements"));
c906108c
SS		 928 if (range_low > range_high)
929 {
8a3fe4f8 930 warning (_("empty POWERSET tuple range"));
c906108c
SS		 931 continue;
932 }
933 if (range_low < low_bound || range_high > high_bound)
8a3fe4f8 934 error (_("POWERSET tuple element out of range"));
c906108c
SS		 935 range_low -= low_bound;
936 range_high -= low_bound;
c5aa993b 937 for (; range_low <= range_high; range_low++)
c906108c
SS		 938 {
939 int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
32c9a795 940 if (gdbarch_bits_big_endian (current_gdbarch))
c906108c 941 bit_index = TARGET_CHAR_BIT - 1 - bit_index;
c5aa993b 942 valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
c906108c
SS		 943 |= 1 << bit_index;
944 }
945 }
946 return set;
947 }
948
f976f6d4 949 argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
c906108c
SS		 950 for (tem = 0; tem < nargs; tem++)
951 {
952 /* Ensure that array expressions are coerced into pointer objects. */
953 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
954 }
955 if (noside == EVAL_SKIP)
956 goto nosideret;
957 return value_array (tem2, tem3, argvec);
958
959 case TERNOP_SLICE:
960 {
61051030 961 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
c906108c 962 int lowbound
c5aa993b 963 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
c906108c 964 int upper
c5aa993b 965 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
c906108c
SS		 966 if (noside == EVAL_SKIP)
967 goto nosideret;
968 return value_slice (array, lowbound, upper - lowbound + 1);
969 }
970
971 case TERNOP_SLICE_COUNT:
972 {
61051030 973 struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
c906108c 974 int lowbound
c5aa993b 975 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
c906108c 976 int length
c5aa993b 977 = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
c906108c
SS		 978 return value_slice (array, lowbound, length);
979 }
980
981 case TERNOP_COND:
982 /* Skip third and second args to evaluate the first one. */
983 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
984 if (value_logical_not (arg1))
985 {
986 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
987 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
988 }
989 else
990 {
991 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
992 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
993 return arg2;
994 }
995
a9fa03de
AF		 996 case OP_OBJC_SELECTOR:
997 { /* Objective C @selector operator. */
998 char *sel = &exp->elts[pc + 2].string;
999 int len = longest_to_int (exp->elts[pc + 1].longconst);
d4dbb9c7 1000 struct type *selector_type;
a9fa03de
AF		 1001
1002 (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1003 if (noside == EVAL_SKIP)
1004 goto nosideret;
1005
1006 if (sel[len] != 0)
1007 sel[len] = 0; /* Make sure it's terminated. */
d4dbb9c7
UW		 1008
1009 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1010 return value_from_longest (selector_type, lookup_child_selector (sel));
a9fa03de
AF		 1011 }
1012
1013 case OP_OBJC_MSGCALL:
1014 { /* Objective C message (method) call. */
1015
c253954e
JB		 1016 static CORE_ADDR responds_selector = 0;
1017 static CORE_ADDR method_selector = 0;
a9fa03de 1018
c253954e 1019 CORE_ADDR selector = 0;
a9fa03de 1020
a9fa03de
AF		 1021 int struct_return = 0;
1022 int sub_no_side = 0;
1023
1024 static struct value *msg_send = NULL;
1025 static struct value *msg_send_stret = NULL;
1026 static int gnu_runtime = 0;
1027
1028 struct value *target = NULL;
1029 struct value *method = NULL;
1030 struct value *called_method = NULL;
1031
1032 struct type *selector_type = NULL;
d4dbb9c7 1033 struct type *long_type;
a9fa03de
AF		 1034
1035 struct value *ret = NULL;
1036 CORE_ADDR addr = 0;
1037
1038 selector = exp->elts[pc + 1].longconst;
1039 nargs = exp->elts[pc + 2].longconst;
1040 argvec = (struct value **) alloca (sizeof (struct value *)
1041 * (nargs + 5));
1042
1043 (*pos) += 3;
1044
d4dbb9c7
UW		 1045 long_type = builtin_type (exp->gdbarch)->builtin_long;
1046 selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1047
a9fa03de
AF		 1048 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1049 sub_no_side = EVAL_NORMAL;
1050 else
1051 sub_no_side = noside;
1052
1053 target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1054
1055 if (value_as_long (target) == 0)
d4dbb9c7 1056 return value_from_longest (long_type, 0);
a9fa03de
AF		 1057
1058 if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1059 gnu_runtime = 1;
1060
1061 /* Find the method dispatch (Apple runtime) or method lookup
1062 (GNU runtime) function for Objective-C. These will be used
1063 to lookup the symbol information for the method. If we
1064 can't find any symbol information, then we'll use these to
1065 call the method, otherwise we can call the method
1066 directly. The msg_send_stret function is used in the special
1067 case of a method that returns a structure (Apple runtime
1068 only). */
1069 if (gnu_runtime)
1070 {
d4dbb9c7 1071 struct type *type = selector_type;
c253954e
JB		 1072 type = lookup_function_type (type);
1073 type = lookup_pointer_type (type);
1074 type = lookup_function_type (type);
1075 type = lookup_pointer_type (type);
1076
3e3b026f
UW		 1077 msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1078 msg_send_stret
1079 = find_function_in_inferior ("objc_msg_lookup", NULL);
c253954e
JB		 1080
1081 msg_send = value_from_pointer (type, value_as_address (msg_send));
1082 msg_send_stret = value_from_pointer (type,
1083 value_as_address (msg_send_stret));
a9fa03de
AF		 1084 }
1085 else
1086 {
3e3b026f 1087 msg_send = find_function_in_inferior ("objc_msgSend", NULL);
a9fa03de 1088 /* Special dispatcher for methods returning structs */
3e3b026f
UW		 1089 msg_send_stret
1090 = find_function_in_inferior ("objc_msgSend_stret", NULL);
a9fa03de
AF		 1091 }
1092
1093 /* Verify the target object responds to this method. The
1094 standard top-level 'Object' class uses a different name for
1095 the verification method than the non-standard, but more
1096 often used, 'NSObject' class. Make sure we check for both. */
1097
1098 responds_selector = lookup_child_selector ("respondsToSelector:");
1099 if (responds_selector == 0)
1100 responds_selector = lookup_child_selector ("respondsTo:");
1101
1102 if (responds_selector == 0)
8a3fe4f8 1103 error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
a9fa03de
AF		 1104
1105 method_selector = lookup_child_selector ("methodForSelector:");
1106 if (method_selector == 0)
1107 method_selector = lookup_child_selector ("methodFor:");
1108
1109 if (method_selector == 0)
8a3fe4f8 1110 error (_("no 'methodFor:' or 'methodForSelector:' method"));
a9fa03de
AF		 1111
1112 /* Call the verification method, to make sure that the target
1113 class implements the desired method. */
1114
1115 argvec[0] = msg_send;
1116 argvec[1] = target;
d4dbb9c7
UW		 1117 argvec[2] = value_from_longest (long_type, responds_selector);
1118 argvec[3] = value_from_longest (long_type, selector);
a9fa03de
AF		 1119 argvec[4] = 0;
1120
1121 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1122 if (gnu_runtime)
1123 {
1124 /* Function objc_msg_lookup returns a pointer. */
1125 argvec[0] = ret;
1126 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1127 }
1128 if (value_as_long (ret) == 0)
8a3fe4f8 1129 error (_("Target does not respond to this message selector."));
a9fa03de
AF		 1130
1131 /* Call "methodForSelector:" method, to get the address of a
1132 function method that implements this selector for this
1133 class. If we can find a symbol at that address, then we
1134 know the return type, parameter types etc. (that's a good
1135 thing). */
1136
1137 argvec[0] = msg_send;
1138 argvec[1] = target;
d4dbb9c7
UW		 1139 argvec[2] = value_from_longest (long_type, method_selector);
1140 argvec[3] = value_from_longest (long_type, selector);
a9fa03de
AF		 1141 argvec[4] = 0;
1142
1143 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1144 if (gnu_runtime)
1145 {
1146 argvec[0] = ret;
1147 ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1148 }
1149
1150 /* ret should now be the selector. */
1151
1152 addr = value_as_long (ret);
1153 if (addr)
1154 {
1155 struct symbol *sym = NULL;
1156 /* Is it a high_level symbol? */
1157
1158 sym = find_pc_function (addr);
1159 if (sym != NULL)
1160 method = value_of_variable (sym, 0);
1161 }
1162
1163 /* If we found a method with symbol information, check to see
1164 if it returns a struct. Otherwise assume it doesn't. */
1165
1166 if (method)
1167 {
1168 struct block *b;
1169 CORE_ADDR funaddr;
c055b101 1170 struct type *val_type;
a9fa03de 1171
c055b101 1172 funaddr = find_function_addr (method, &val_type);
a9fa03de
AF		 1173
1174 b = block_for_pc (funaddr);
1175
c055b101 1176 CHECK_TYPEDEF (val_type);
a9fa03de 1177
c055b101
CV		 1178 if ((val_type == NULL)
1179 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
a9fa03de
AF		 1180 {
1181 if (expect_type != NULL)
c055b101 1182 val_type = expect_type;
a9fa03de
AF		 1183 }
1184
c055b101 1185 struct_return = using_struct_return (value_type (method), val_type);
a9fa03de
AF		 1186 }
1187 else if (expect_type != NULL)
1188 {
c055b101
CV		 1189 struct_return = using_struct_return (NULL,
1190 check_typedef (expect_type));
a9fa03de
AF		 1191 }
1192
1193 /* Found a function symbol. Now we will substitute its
1194 value in place of the message dispatcher (obj_msgSend),
1195 so that we call the method directly instead of thru
1196 the dispatcher. The main reason for doing this is that
1197 we can now evaluate the return value and parameter values
1198 according to their known data types, in case we need to
1199 do things like promotion, dereferencing, special handling
1200 of structs and doubles, etc.
1201
1202 We want to use the type signature of 'method', but still
1203 jump to objc_msgSend() or objc_msgSend_stret() to better
1204 mimic the behavior of the runtime. */
1205
1206 if (method)
1207 {
df407dfe 1208 if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
8a3fe4f8 1209 error (_("method address has symbol information with non-function type; skipping"));
a9fa03de
AF		 1210 if (struct_return)
1211 VALUE_ADDRESS (method) = value_as_address (msg_send_stret);
1212 else
1213 VALUE_ADDRESS (method) = value_as_address (msg_send);
1214 called_method = method;
1215 }
1216 else
1217 {
1218 if (struct_return)
1219 called_method = msg_send_stret;
1220 else
1221 called_method = msg_send;
1222 }
1223
1224 if (noside == EVAL_SKIP)
1225 goto nosideret;
1226
1227 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1228 {
1229 /* If the return type doesn't look like a function type,
1230 call an error. This can happen if somebody tries to
1231 turn a variable into a function call. This is here
1232 because people often want to call, eg, strcmp, which
1233 gdb doesn't know is a function. If gdb isn't asked for
1234 it's opinion (ie. through "whatis"), it won't offer
1235 it. */
1236
df407dfe 1237 struct type *type = value_type (called_method);
a9fa03de
AF		 1238 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1239 type = TYPE_TARGET_TYPE (type);
1240 type = TYPE_TARGET_TYPE (type);
1241
1242 if (type)
1243 {
1244 if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1245 return allocate_value (expect_type);
1246 else
1247 return allocate_value (type);
1248 }
1249 else
8a3fe4f8 1250 error (_("Expression of type other than \"method returning ...\" used as a method"));
a9fa03de
AF		 1251 }
1252
1253 /* Now depending on whether we found a symbol for the method,
1254 we will either call the runtime dispatcher or the method
1255 directly. */
1256
1257 argvec[0] = called_method;
1258 argvec[1] = target;
d4dbb9c7 1259 argvec[2] = value_from_longest (long_type, selector);
a9fa03de
AF		 1260 /* User-supplied arguments. */
1261 for (tem = 0; tem < nargs; tem++)
1262 argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1263 argvec[tem + 3] = 0;
1264
1265 if (gnu_runtime && (method != NULL))
1266 {
a9fa03de 1267 /* Function objc_msg_lookup returns a pointer. */
04624583
AC		 1268 deprecated_set_value_type (argvec[0],
1269 lookup_function_type (lookup_pointer_type (value_type (argvec[0]))));
c253954e 1270 argvec[0] = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
a9fa03de 1271 }
a9fa03de 1272
c253954e 1273 ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
a9fa03de
AF		 1274 return ret;
1275 }
1276 break;
1277
c906108c
SS		 1278 case OP_FUNCALL:
1279 (*pos) += 2;
1280 op = exp->elts[*pos].opcode;
1281 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1282 /* Allocate arg vector, including space for the function to be
c5aa993b 1283 called in argvec[0] and a terminating NULL */
f976f6d4 1284 argvec = (struct value **) alloca (sizeof (struct value *) * (nargs + 3));
c906108c
SS		 1285 if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1286 {
c906108c
SS		 1287 nargs++;
1288 /* First, evaluate the structure into arg2 */
1289 pc2 = (*pos)++;
1290
1291 if (noside == EVAL_SKIP)
1292 goto nosideret;
1293
1294 if (op == STRUCTOP_MEMBER)
1295 {
1296 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1297 }
1298 else
1299 {
1300 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1301 }
1302
1303 /* If the function is a virtual function, then the
1304 aggregate value (providing the structure) plays
1305 its part by providing the vtable. Otherwise,
1306 it is just along for the ride: call the function
1307 directly. */
1308
1309 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1310
0d5de010
DJ		 1311 if (TYPE_CODE (check_typedef (value_type (arg1)))
1312 != TYPE_CODE_METHODPTR)
1313 error (_("Non-pointer-to-member value used in pointer-to-member "
1314 "construct"));
c906108c 1315
0d5de010 1316 if (noside == EVAL_AVOID_SIDE_EFFECTS)
c906108c 1317 {
0d5de010
DJ		 1318 struct type *method_type = check_typedef (value_type (arg1));
1319 arg1 = value_zero (method_type, not_lval);
c906108c
SS		 1320 }
1321 else
0d5de010 1322 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
c906108c
SS		 1323
1324 /* Now, say which argument to start evaluating from */
1325 tem = 2;
1326 }
1327 else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1328 {
1329 /* Hair for method invocations */
1330 int tem2;
1331
1332 nargs++;
1333 /* First, evaluate the structure into arg2 */
1334 pc2 = (*pos)++;
1335 tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1336 *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1337 if (noside == EVAL_SKIP)
1338 goto nosideret;
1339
1340 if (op == STRUCTOP_STRUCT)
1341 {
1342 /* If v is a variable in a register, and the user types
c5aa993b
JM		 1343 v.method (), this will produce an error, because v has
1344 no address.
1345
1346 A possible way around this would be to allocate a
1347 copy of the variable on the stack, copy in the
1348 contents, call the function, and copy out the
1349 contents. I.e. convert this from call by reference
1350 to call by copy-return (or whatever it's called).
1351 However, this does not work because it is not the
1352 same: the method being called could stash a copy of
1353 the address, and then future uses through that address
1354 (after the method returns) would be expected to
1355 use the variable itself, not some copy of it. */
c906108c
SS		 1356 arg2 = evaluate_subexp_for_address (exp, pos, noside);
1357 }
1358 else
1359 {
1360 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1361 }
1362 /* Now, say which argument to start evaluating from */
1363 tem = 2;
1364 }
1365 else
1366 {
1367 /* Non-method function call */
1368 save_pos1 = *pos;
1369 argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1370 tem = 1;
df407dfe 1371 type = value_type (argvec[0]);
c906108c
SS		 1372 if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1373 type = TYPE_TARGET_TYPE (type);
1374 if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1375 {
1376 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1377 {
c5aa993b
JM		 1378 /* pai: FIXME This seems to be coercing arguments before
1379 * overload resolution has been done! */
1380 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type, tem - 1),
c906108c
SS		 1381 exp, pos, noside);
1382 }
1383 }
1384 }
1385
1386 /* Evaluate arguments */
1387 for (; tem <= nargs; tem++)
1388 {
1389 /* Ensure that array expressions are coerced into pointer objects. */
1390 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1391 }
1392
1393 /* signal end of arglist */
1394 argvec[tem] = 0;
1395
1396 if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1397 {
1398 int static_memfuncp;
c906108c 1399 char tstr[256];
c5aa993b
JM		 1400
1401 /* Method invocation : stuff "this" as first parameter */
9b013045 1402 argvec[1] = arg2;
c5aa993b
JM		 1403 /* Name of method from expression */
1404 strcpy (tstr, &exp->elts[pc2 + 2].string);
1405
1406 if (overload_resolution && (exp->language_defn->la_language == language_cplus))
1407 {
1408 /* Language is C++, do some overload resolution before evaluation */
61051030 1409 struct value *valp = NULL;
c5aa993b
JM		 1410
1411 /* Prepare list of argument types for overload resolution */
c2636352 1412 arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
c5aa993b 1413 for (ix = 1; ix <= nargs; ix++)
df407dfe 1414 arg_types[ix - 1] = value_type (argvec[ix]);
c5aa993b
JM		 1415
1416 (void) find_overload_match (arg_types, nargs, tstr,
1417 1 /* method */ , 0 /* strict match */ ,
7f8c9282 1418 &arg2 /* the object */ , NULL,
c5aa993b
JM		 1419 &valp, NULL, &static_memfuncp);
1420
1421
1422 argvec[1] = arg2; /* the ``this'' pointer */
1423 argvec[0] = valp; /* use the method found after overload resolution */
1424 }
1425 else
1426 /* Non-C++ case -- or no overload resolution */
1427 {
9b013045 1428 struct value *temp = arg2;
c5aa993b
JM		 1429 argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1430 &static_memfuncp,
1431 op == STRUCTOP_STRUCT
1432 ? "structure" : "structure pointer");
9b013045
PS		 1433 /* value_struct_elt updates temp with the correct value
1434 of the ``this'' pointer if necessary, so modify argvec[1] to
1435 reflect any ``this'' changes. */
df407dfe
AC		 1436 arg2 = value_from_longest (lookup_pointer_type(value_type (temp)),
1437 VALUE_ADDRESS (temp) + value_offset (temp)
13c3b5f5 1438 + value_embedded_offset (temp));
c5aa993b
JM		 1439 argvec[1] = arg2; /* the ``this'' pointer */
1440 }
c906108c
SS		 1441
1442 if (static_memfuncp)
1443 {
1444 argvec[1] = argvec[0];
1445 nargs--;
1446 argvec++;
1447 }
1448 }
1449 else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1450 {
1451 argvec[1] = arg2;
1452 argvec[0] = arg1;
1453 }
917317f4 1454 else if (op == OP_VAR_VALUE)
c5aa993b 1455 {
c906108c 1456 /* Non-member function being called */
917317f4
JM		 1457 /* fn: This can only be done for C++ functions. A C-style function
1458 in a C++ program, for instance, does not have the fields that
1459 are expected here */
c906108c 1460
c5aa993b
JM		 1461 if (overload_resolution && (exp->language_defn->la_language == language_cplus))
1462 {
1463 /* Language is C++, do some overload resolution before evaluation */
1464 struct symbol *symp;
1465
1466 /* Prepare list of argument types for overload resolution */
c2636352 1467 arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
c5aa993b 1468 for (ix = 1; ix <= nargs; ix++)
df407dfe 1469 arg_types[ix - 1] = value_type (argvec[ix]);
c5aa993b
JM		 1470
1471 (void) find_overload_match (arg_types, nargs, NULL /* no need for name */ ,
1472 0 /* not method */ , 0 /* strict match */ ,
917317f4 1473 NULL, exp->elts[save_pos1+2].symbol /* the function */ ,
c5aa993b
JM		 1474 NULL, &symp, NULL);
1475
1476 /* Now fix the expression being evaluated */
917317f4 1477 exp->elts[save_pos1+2].symbol = symp;
c5aa993b
JM		 1478 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1479 }
1480 else
1481 {
1482 /* Not C++, or no overload resolution allowed */
1483 /* nothing to be done; argvec already correctly set up */
1484 }
1485 }
917317f4
JM		 1486 else
1487 {
1488 /* It is probably a C-style function */
1489 /* nothing to be done; argvec already correctly set up */
1490 }
c906108c
SS		 1491
1492 do_call_it:
1493
1494 if (noside == EVAL_SKIP)
1495 goto nosideret;
0478d61c 1496 if (argvec[0] == NULL)
8a3fe4f8 1497 error (_("Cannot evaluate function -- may be inlined"));
c906108c
SS		 1498 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1499 {
1500 /* If the return type doesn't look like a function type, call an
1501 error. This can happen if somebody tries to turn a variable into
1502 a function call. This is here because people often want to
1503 call, eg, strcmp, which gdb doesn't know is a function. If
1504 gdb isn't asked for it's opinion (ie. through "whatis"),
1505 it won't offer it. */
1506
1507 struct type *ftype =
df407dfe 1508 TYPE_TARGET_TYPE (value_type (argvec[0]));
c906108c
SS		 1509
1510 if (ftype)
df407dfe 1511 return allocate_value (TYPE_TARGET_TYPE (value_type (argvec[0])));
c906108c 1512 else
8a3fe4f8 1513 error (_("Expression of type other than \"Function returning ...\" used as function"));
c906108c 1514 }
c906108c
SS		 1515 return call_function_by_hand (argvec[0], nargs, argvec + 1);
1516 /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve */
1517
c5aa993b 1518 case OP_F77_UNDETERMINED_ARGLIST:
c906108c
SS		 1519
1520 /* Remember that in F77, functions, substring ops and
1521 array subscript operations cannot be disambiguated
1522 at parse time. We have made all array subscript operations,
1523 substring operations as well as function calls come here
1524 and we now have to discover what the heck this thing actually was.
c5aa993b 1525 If it is a function, we process just as if we got an OP_FUNCALL. */
c906108c 1526
c5aa993b 1527 nargs = longest_to_int (exp->elts[pc + 1].longconst);
c906108c
SS		 1528 (*pos) += 2;
1529
c5aa993b 1530 /* First determine the type code we are dealing with. */
c906108c 1531 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 1532 type = check_typedef (value_type (arg1));
c906108c
SS		 1533 code = TYPE_CODE (type);
1534
df0ca547
WZ		 1535 if (code == TYPE_CODE_PTR)
1536 {
1537 /* Fortran always passes variable to subroutines as pointer.
1538 So we need to look into its target type to see if it is
1539 array, string or function. If it is, we need to switch
1540 to the target value the original one points to. */
1541 struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1542
1543 if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1544 || TYPE_CODE (target_type) == TYPE_CODE_STRING
1545 || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1546 {
1547 arg1 = value_ind (arg1);
1548 type = check_typedef (value_type (arg1));
1549 code = TYPE_CODE (type);
1550 }
1551 }
1552
c5aa993b 1553 switch (code)
c906108c
SS		 1554 {
1555 case TYPE_CODE_ARRAY:
0b4e1325
WZ		 1556 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1557 return value_f90_subarray (arg1, exp, pos, noside);
1558 else
1559 goto multi_f77_subscript;
c906108c
SS		 1560
1561 case TYPE_CODE_STRING:
0b4e1325
WZ		 1562 if (exp->elts[*pos].opcode == OP_F90_RANGE)
1563 return value_f90_subarray (arg1, exp, pos, noside);
1564 else
1565 {
1566 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1567 return value_subscript (arg1, arg2);
1568 }
c906108c
SS		 1569
1570 case TYPE_CODE_PTR:
1571 case TYPE_CODE_FUNC:
1572 /* It's a function call. */
1573 /* Allocate arg vector, including space for the function to be
1574 called in argvec[0] and a terminating NULL */
f976f6d4 1575 argvec = (struct value **) alloca (sizeof (struct value *) * (nargs + 2));
c906108c
SS		 1576 argvec[0] = arg1;
1577 tem = 1;
1578 for (; tem <= nargs; tem++)
1579 argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
c5aa993b 1580 argvec[tem] = 0; /* signal end of arglist */
c906108c
SS		 1581 goto do_call_it;
1582
1583 default:
8a3fe4f8 1584 error (_("Cannot perform substring on this type"));
c906108c
SS		 1585 }
1586
c906108c
SS		 1587 case OP_COMPLEX:
1588 /* We have a complex number, There should be 2 floating
c5aa993b 1589 point numbers that compose it */
c806c55a 1590 (*pos) += 2;
c906108c 1591 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
c5aa993b 1592 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
c906108c 1593
c806c55a 1594 return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
c906108c
SS		 1595
1596 case STRUCTOP_STRUCT:
1597 tem = longest_to_int (exp->elts[pc + 1].longconst);
1598 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1599 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1600 if (noside == EVAL_SKIP)
1601 goto nosideret;
1602 if (noside == EVAL_AVOID_SIDE_EFFECTS)
df407dfe 1603 return value_zero (lookup_struct_elt_type (value_type (arg1),
c906108c
SS		 1604 &exp->elts[pc + 2].string,
1605 0),
1606 lval_memory);
1607 else
1608 {
61051030 1609 struct value *temp = arg1;
c906108c
SS		 1610 return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
1611 NULL, "structure");
1612 }
1613
1614 case STRUCTOP_PTR:
1615 tem = longest_to_int (exp->elts[pc + 1].longconst);
1616 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1617 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1618 if (noside == EVAL_SKIP)
1619 goto nosideret;
070ad9f0
DB		 1620
1621 /* JYG: if print object is on we need to replace the base type
1622 with rtti type in order to continue on with successful
1623 lookup of member / method only available in the rtti type. */
1624 {
df407dfe 1625 struct type *type = value_type (arg1);
070ad9f0
DB		 1626 struct type *real_type;
1627 int full, top, using_enc;
79a45b7d
TT		 1628 struct value_print_options opts;
1629
1630 get_user_print_options (&opts);
1631 if (opts.objectprint && TYPE_TARGET_TYPE(type) &&
070ad9f0
DB		 1632 (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
1633 {
1634 real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
1635 if (real_type)
1636 {
1637 if (TYPE_CODE (type) == TYPE_CODE_PTR)
1638 real_type = lookup_pointer_type (real_type);
1639 else
1640 real_type = lookup_reference_type (real_type);
1641
1642 arg1 = value_cast (real_type, arg1);
1643 }
1644 }
1645 }
1646
c906108c 1647 if (noside == EVAL_AVOID_SIDE_EFFECTS)
df407dfe 1648 return value_zero (lookup_struct_elt_type (value_type (arg1),
c906108c
SS		 1649 &exp->elts[pc + 2].string,
1650 0),
1651 lval_memory);
1652 else
1653 {
61051030 1654 struct value *temp = arg1;
c906108c
SS		 1655 return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
1656 NULL, "structure pointer");
1657 }
1658
1659 case STRUCTOP_MEMBER:
0d5de010
DJ		 1660 case STRUCTOP_MPTR:
1661 if (op == STRUCTOP_MEMBER)
1662 arg1 = evaluate_subexp_for_address (exp, pos, noside);
1663 else
1664 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1665
c906108c
SS		 1666 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1667
0d5de010
DJ		 1668 if (noside == EVAL_SKIP)
1669 goto nosideret;
c5aa993b 1670
0d5de010
DJ		 1671 type = check_typedef (value_type (arg2));
1672 switch (TYPE_CODE (type))
1673 {
1674 case TYPE_CODE_METHODPTR:
0d5de010
DJ		 1675 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1676 return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1677 else
1678 {
1679 arg2 = cplus_method_ptr_to_value (&arg1, arg2);
1680 gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
1681 return value_ind (arg2);
1682 }
c906108c 1683
0d5de010
DJ		 1684 case TYPE_CODE_MEMBERPTR:
1685 /* Now, convert these values to an address. */
1686 arg1 = value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
1687 arg1);
c906108c 1688
0d5de010 1689 mem_offset = value_as_long (arg2);
c906108c 1690
0d5de010
DJ		 1691 arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1692 value_as_long (arg1) + mem_offset);
1693 return value_ind (arg3);
1694
1695 default:
1696 error (_("non-pointer-to-member value used in pointer-to-member construct"));
c5aa993b 1697 }
c906108c
SS		 1698
1699 case BINOP_CONCAT:
1700 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1701 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1702 if (noside == EVAL_SKIP)
1703 goto nosideret;
1704 if (binop_user_defined_p (op, arg1, arg2))
1705 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1706 else
1707 return value_concat (arg1, arg2);
1708
1709 case BINOP_ASSIGN:
1710 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 1711 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
c906108c 1712
c906108c
SS		 1713 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1714 return arg1;
1715 if (binop_user_defined_p (op, arg1, arg2))
1716 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1717 else
1718 return value_assign (arg1, arg2);
1719
1720 case BINOP_ASSIGN_MODIFY:
1721 (*pos) += 2;
1722 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 1723 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
c906108c
SS		 1724 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1725 return arg1;
1726 op = exp->elts[pc + 1].opcode;
1727 if (binop_user_defined_p (op, arg1, arg2))
1728 return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
89eef114
UW		 1729 else if (op == BINOP_ADD && ptrmath_type_p (value_type (arg1)))
1730 arg2 = value_ptradd (arg1, arg2);
1731 else if (op == BINOP_SUB && ptrmath_type_p (value_type (arg1)))
1732 arg2 = value_ptrsub (arg1, arg2);
c906108c 1733 else
f44316fa
UW		 1734 {
1735 struct value *tmp = arg1;
1736
1737 /* For shift and integer exponentiation operations,
1738 only promote the first argument. */
1739 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
1740 && is_integral_type (value_type (arg2)))
1741 unop_promote (exp->language_defn, exp->gdbarch, &tmp);
1742 else
1743 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
1744
1745 arg2 = value_binop (tmp, arg2, op);
1746 }
c906108c
SS		 1747 return value_assign (arg1, arg2);
1748
1749 case BINOP_ADD:
1750 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1751 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1752 if (noside == EVAL_SKIP)
1753 goto nosideret;
1754 if (binop_user_defined_p (op, arg1, arg2))
1755 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
89eef114
UW		 1756 else if (ptrmath_type_p (value_type (arg1)))
1757 return value_ptradd (arg1, arg2);
1758 else if (ptrmath_type_p (value_type (arg2)))
1759 return value_ptradd (arg2, arg1);
c906108c 1760 else
f44316fa
UW		 1761 {
1762 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
1763 return value_binop (arg1, arg2, BINOP_ADD);
1764 }
c906108c
SS		 1765
1766 case BINOP_SUB:
1767 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1768 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1769 if (noside == EVAL_SKIP)
1770 goto nosideret;
1771 if (binop_user_defined_p (op, arg1, arg2))
1772 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
89eef114
UW		 1773 else if (ptrmath_type_p (value_type (arg1)))
1774 {
1775 if (ptrmath_type_p (value_type (arg2)))
1776 {
1777 /* FIXME -- should be ptrdiff_t */
1778 type = builtin_type (exp->gdbarch)->builtin_long;
1779 return value_from_longest (type, value_ptrdiff (arg1, arg2));
1780 }
1781 else
1782 return value_ptrsub (arg1, arg2);
1783 }
c906108c 1784 else
f44316fa
UW		 1785 {
1786 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
1787 return value_binop (arg1, arg2, BINOP_SUB);
1788 }
c906108c 1789
bd49c137 1790 case BINOP_EXP:
c906108c
SS		 1791 case BINOP_MUL:
1792 case BINOP_DIV:
9b3442ee 1793 case BINOP_INTDIV:
c906108c
SS		 1794 case BINOP_REM:
1795 case BINOP_MOD:
1796 case BINOP_LSH:
1797 case BINOP_RSH:
1798 case BINOP_BITWISE_AND:
1799 case BINOP_BITWISE_IOR:
1800 case BINOP_BITWISE_XOR:
1801 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1802 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1803 if (noside == EVAL_SKIP)
1804 goto nosideret;
1805 if (binop_user_defined_p (op, arg1, arg2))
1806 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
c906108c 1807 else
301f0ecf
DE		 1808 {
1809 /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1810 fudge arg2 to avoid division-by-zero, the caller is
1811 (theoretically) only looking for the type of the result. */
1812 if (noside == EVAL_AVOID_SIDE_EFFECTS
1813 /* ??? Do we really want to test for BINOP_MOD here?
1814 The implementation of value_binop gives it a well-defined
1815 value. */
1816 && (op == BINOP_DIV
1817 || op == BINOP_INTDIV
1818 || op == BINOP_REM
1819 || op == BINOP_MOD)
1820 && value_logical_not (arg2))
1821 {
1822 struct value *v_one, *retval;
1823
1824 v_one = value_one (value_type (arg2), not_lval);
f44316fa 1825 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
301f0ecf
DE		 1826 retval = value_binop (arg1, v_one, op);
1827 return retval;
1828 }
1829 else
f44316fa
UW		 1830 {
1831 /* For shift and integer exponentiation operations,
1832 only promote the first argument. */
1833 if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
1834 && is_integral_type (value_type (arg2)))
1835 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
1836 else
1837 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
1838
1839 return value_binop (arg1, arg2, op);
1840 }
301f0ecf 1841 }
c906108c
SS		 1842
1843 case BINOP_RANGE:
1844 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1845 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1846 if (noside == EVAL_SKIP)
1847 goto nosideret;
8a3fe4f8 1848 error (_("':' operator used in invalid context"));
c906108c
SS		 1849
1850 case BINOP_SUBSCRIPT:
1851 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1852 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1853 if (noside == EVAL_SKIP)
1854 goto nosideret;
1855 if (binop_user_defined_p (op, arg1, arg2))
1856 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1857 else
c5aa993b 1858 {
c906108c
SS		 1859 /* If the user attempts to subscript something that is not an
1860 array or pointer type (like a plain int variable for example),
1861 then report this as an error. */
1862
994b9211 1863 arg1 = coerce_ref (arg1);
df407dfe 1864 type = check_typedef (value_type (arg1));
c906108c
SS		 1865 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
1866 && TYPE_CODE (type) != TYPE_CODE_PTR)
1867 {
1868 if (TYPE_NAME (type))
8a3fe4f8 1869 error (_("cannot subscript something of type `%s'"),
c906108c
SS		 1870 TYPE_NAME (type));
1871 else
8a3fe4f8 1872 error (_("cannot subscript requested type"));
c906108c
SS		 1873 }
1874
1875 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1876 return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
1877 else
1878 return value_subscript (arg1, arg2);
c5aa993b 1879 }
c906108c
SS		 1880
1881 case BINOP_IN:
1882 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1883 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1884 if (noside == EVAL_SKIP)
1885 goto nosideret;
fbb06eb1
UW		 1886 type = language_bool_type (exp->language_defn, exp->gdbarch);
1887 return value_from_longest (type, (LONGEST) value_in (arg1, arg2));
c5aa993b 1888
c906108c
SS		 1889 case MULTI_SUBSCRIPT:
1890 (*pos) += 2;
1891 nargs = longest_to_int (exp->elts[pc + 1].longconst);
1892 arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1893 while (nargs-- > 0)
1894 {
1895 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1896 /* FIXME: EVAL_SKIP handling may not be correct. */
1897 if (noside == EVAL_SKIP)
1898 {
1899 if (nargs > 0)
1900 {
1901 continue;
1902 }
1903 else
1904 {
1905 goto nosideret;
1906 }
1907 }
1908 /* FIXME: EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1909 if (noside == EVAL_AVOID_SIDE_EFFECTS)
1910 {
1911 /* If the user attempts to subscript something that has no target
c5aa993b
JM		 1912 type (like a plain int variable for example), then report this
1913 as an error. */
1914
df407dfe 1915 type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
c906108c
SS		 1916 if (type != NULL)
1917 {
1918 arg1 = value_zero (type, VALUE_LVAL (arg1));
1919 noside = EVAL_SKIP;
1920 continue;
1921 }
1922 else
1923 {
8a3fe4f8 1924 error (_("cannot subscript something of type `%s'"),
df407dfe 1925 TYPE_NAME (value_type (arg1)));
c906108c
SS		 1926 }
1927 }
c5aa993b 1928
c906108c
SS		 1929 if (binop_user_defined_p (op, arg1, arg2))
1930 {
1931 arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
1932 }
1933 else
1934 {
afc05acb
UW		 1935 arg1 = coerce_ref (arg1);
1936 type = check_typedef (value_type (arg1));
1937
1938 switch (TYPE_CODE (type))
1939 {
1940 case TYPE_CODE_PTR:
1941 case TYPE_CODE_ARRAY:
1942 case TYPE_CODE_STRING:
1943 arg1 = value_subscript (arg1, arg2);
1944 break;
1945
1946 case TYPE_CODE_BITSTRING:
fbb06eb1
UW		 1947 type = language_bool_type (exp->language_defn, exp->gdbarch);
1948 arg1 = value_bitstring_subscript (type, arg1, arg2);
afc05acb
UW		 1949 break;
1950
1951 default:
1952 if (TYPE_NAME (type))
1953 error (_("cannot subscript something of type `%s'"),
1954 TYPE_NAME (type));
1955 else
1956 error (_("cannot subscript requested type"));
1957 }
c906108c
SS		 1958 }
1959 }
1960 return (arg1);
1961
1962 multi_f77_subscript:
c5aa993b 1963 {
7ca2d3a3
DL		 1964 int subscript_array[MAX_FORTRAN_DIMS];
1965 int array_size_array[MAX_FORTRAN_DIMS];
c5aa993b
JM		 1966 int ndimensions = 1, i;
1967 struct type *tmp_type;
1968 int offset_item; /* The array offset where the item lives */
c906108c
SS		 1969
1970 if (nargs > MAX_FORTRAN_DIMS)
8a3fe4f8 1971 error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
c906108c 1972
df407dfe 1973 tmp_type = check_typedef (value_type (arg1));
c906108c
SS		 1974 ndimensions = calc_f77_array_dims (type);
1975
1976 if (nargs != ndimensions)
8a3fe4f8 1977 error (_("Wrong number of subscripts"));
c906108c
SS		 1978
1979 /* Now that we know we have a legal array subscript expression
c5aa993b 1980 let us actually find out where this element exists in the array. */
c906108c 1981
c5aa993b 1982 offset_item = 0;
7ca2d3a3
DL		 1983 /* Take array indices left to right */
1984 for (i = 0; i < nargs; i++)
c906108c 1985 {
c5aa993b 1986 /* Evaluate each subscript, It must be a legal integer in F77 */
c906108c
SS		 1987 arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1988
c5aa993b 1989 /* Fill in the subscript and array size arrays */
c906108c
SS		 1990
1991 subscript_array[i] = value_as_long (arg2);
7ca2d3a3 1992 }
c5aa993b 1993
7ca2d3a3
DL		 1994 /* Internal type of array is arranged right to left */
1995 for (i = 0; i < nargs; i++)
1996 {
d78df370
JK		 1997 upper = f77_get_upperbound (tmp_type);
1998 lower = f77_get_lowerbound (tmp_type);
c906108c 1999
7ca2d3a3 2000 array_size_array[nargs - i - 1] = upper - lower + 1;
c5aa993b
JM		 2001
2002 /* Zero-normalize subscripts so that offsetting will work. */
2003
7ca2d3a3 2004 subscript_array[nargs - i - 1] -= lower;
c906108c
SS		 2005
2006 /* If we are at the bottom of a multidimensional
2007 array type then keep a ptr to the last ARRAY
2008 type around for use when calling value_subscript()
2009 below. This is done because we pretend to value_subscript
2010 that we actually have a one-dimensional array
2011 of base element type that we apply a simple
c5aa993b 2012 offset to. */
c906108c 2013
7ca2d3a3 2014 if (i < nargs - 1)
c5aa993b 2015 tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
c906108c
SS		 2016 }
2017
2018 /* Now let us calculate the offset for this item */
2019
7ca2d3a3 2020 offset_item = subscript_array[ndimensions - 1];
c5aa993b 2021
7ca2d3a3 2022 for (i = ndimensions - 1; i > 0; --i)
c5aa993b 2023 offset_item =
7ca2d3a3 2024 array_size_array[i - 1] * offset_item + subscript_array[i - 1];
c906108c 2025
962d6d93
DL		 2026 /* Construct a value node with the value of the offset */
2027
6d84d3d8 2028 arg2 = value_from_longest (builtin_type_int32, offset_item);
962d6d93 2029
c906108c
SS		 2030 /* Let us now play a dirty trick: we will take arg1
2031 which is a value node pointing to the topmost level
2032 of the multidimensional array-set and pretend
2033 that it is actually a array of the final element
2034 type, this will ensure that value_subscript()
2035 returns the correct type value */
2036
04624583 2037 deprecated_set_value_type (arg1, tmp_type);
9eec4d1e 2038 return value_subscripted_rvalue (arg1, arg2, 0);
c906108c
SS		 2039 }
2040
2041 case BINOP_LOGICAL_AND:
2042 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2043 if (noside == EVAL_SKIP)
2044 {
2045 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2046 goto nosideret;
2047 }
c5aa993b 2048
c906108c
SS		 2049 oldpos = *pos;
2050 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2051 *pos = oldpos;
c5aa993b
JM		 2052
2053 if (binop_user_defined_p (op, arg1, arg2))
c906108c
SS		 2054 {
2055 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2056 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2057 }
2058 else
2059 {
2060 tem = value_logical_not (arg1);
2061 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2062 (tem ? EVAL_SKIP : noside));
fbb06eb1
UW		 2063 type = language_bool_type (exp->language_defn, exp->gdbarch);
2064 return value_from_longest (type,
c5aa993b 2065 (LONGEST) (!tem && !value_logical_not (arg2)));
c906108c
SS		 2066 }
2067
2068 case BINOP_LOGICAL_OR:
2069 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2070 if (noside == EVAL_SKIP)
2071 {
2072 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2073 goto nosideret;
2074 }
c5aa993b 2075
c906108c
SS		 2076 oldpos = *pos;
2077 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2078 *pos = oldpos;
c5aa993b
JM		 2079
2080 if (binop_user_defined_p (op, arg1, arg2))
c906108c
SS		 2081 {
2082 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2083 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2084 }
2085 else
2086 {
2087 tem = value_logical_not (arg1);
2088 arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2089 (!tem ? EVAL_SKIP : noside));
fbb06eb1
UW		 2090 type = language_bool_type (exp->language_defn, exp->gdbarch);
2091 return value_from_longest (type,
c5aa993b 2092 (LONGEST) (!tem || !value_logical_not (arg2)));
c906108c
SS		 2093 }
2094
2095 case BINOP_EQUAL:
2096 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 2097 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
c906108c
SS		 2098 if (noside == EVAL_SKIP)
2099 goto nosideret;
2100 if (binop_user_defined_p (op, arg1, arg2))
2101 {
2102 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2103 }
2104 else
2105 {
f44316fa 2106 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
c906108c 2107 tem = value_equal (arg1, arg2);
fbb06eb1
UW		 2108 type = language_bool_type (exp->language_defn, exp->gdbarch);
2109 return value_from_longest (type, (LONGEST) tem);
c906108c
SS		 2110 }
2111
2112 case BINOP_NOTEQUAL:
2113 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 2114 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
c906108c
SS		 2115 if (noside == EVAL_SKIP)
2116 goto nosideret;
2117 if (binop_user_defined_p (op, arg1, arg2))
2118 {
2119 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2120 }
2121 else
2122 {
f44316fa 2123 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
c906108c 2124 tem = value_equal (arg1, arg2);
fbb06eb1
UW		 2125 type = language_bool_type (exp->language_defn, exp->gdbarch);
2126 return value_from_longest (type, (LONGEST) ! tem);
c906108c
SS		 2127 }
2128
2129 case BINOP_LESS:
2130 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 2131 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
c906108c
SS		 2132 if (noside == EVAL_SKIP)
2133 goto nosideret;
2134 if (binop_user_defined_p (op, arg1, arg2))
2135 {
2136 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2137 }
2138 else
2139 {
f44316fa 2140 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
c906108c 2141 tem = value_less (arg1, arg2);
fbb06eb1
UW		 2142 type = language_bool_type (exp->language_defn, exp->gdbarch);
2143 return value_from_longest (type, (LONGEST) tem);
c906108c
SS		 2144 }
2145
2146 case BINOP_GTR:
2147 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 2148 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
c906108c
SS		 2149 if (noside == EVAL_SKIP)
2150 goto nosideret;
2151 if (binop_user_defined_p (op, arg1, arg2))
2152 {
2153 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2154 }
2155 else
2156 {
f44316fa 2157 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
c906108c 2158 tem = value_less (arg2, arg1);
fbb06eb1
UW		 2159 type = language_bool_type (exp->language_defn, exp->gdbarch);
2160 return value_from_longest (type, (LONGEST) tem);
c906108c
SS		 2161 }
2162
2163 case BINOP_GEQ:
2164 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 2165 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
c906108c
SS		 2166 if (noside == EVAL_SKIP)
2167 goto nosideret;
2168 if (binop_user_defined_p (op, arg1, arg2))
2169 {
2170 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2171 }
2172 else
2173 {
f44316fa 2174 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
c906108c 2175 tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
fbb06eb1
UW		 2176 type = language_bool_type (exp->language_defn, exp->gdbarch);
2177 return value_from_longest (type, (LONGEST) tem);
c906108c
SS		 2178 }
2179
2180 case BINOP_LEQ:
2181 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
df407dfe 2182 arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
c906108c
SS		 2183 if (noside == EVAL_SKIP)
2184 goto nosideret;
2185 if (binop_user_defined_p (op, arg1, arg2))
2186 {
2187 return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2188 }
c5aa993b 2189 else
c906108c 2190 {
f44316fa 2191 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
c906108c 2192 tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
fbb06eb1
UW		 2193 type = language_bool_type (exp->language_defn, exp->gdbarch);
2194 return value_from_longest (type, (LONGEST) tem);
c906108c
SS		 2195 }
2196
2197 case BINOP_REPEAT:
2198 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2199 arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2200 if (noside == EVAL_SKIP)
2201 goto nosideret;
df407dfe 2202 type = check_typedef (value_type (arg2));
c906108c 2203 if (TYPE_CODE (type) != TYPE_CODE_INT)
8a3fe4f8 2204 error (_("Non-integral right operand for \"@\" operator."));
c906108c
SS		 2205 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2206 {
df407dfe 2207 return allocate_repeat_value (value_type (arg1),
c5aa993b 2208 longest_to_int (value_as_long (arg2)));
c906108c
SS		 2209 }
2210 else
2211 return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2212
2213 case BINOP_COMMA:
2214 evaluate_subexp (NULL_TYPE, exp, pos, noside);
2215 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2216
36e9969c
NS		 2217 case UNOP_PLUS:
2218 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2219 if (noside == EVAL_SKIP)
2220 goto nosideret;
2221 if (unop_user_defined_p (op, arg1))
2222 return value_x_unop (arg1, op, noside);
2223 else
f44316fa
UW		 2224 {
2225 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2226 return value_pos (arg1);
2227 }
36e9969c 2228
c906108c
SS		 2229 case UNOP_NEG:
2230 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2231 if (noside == EVAL_SKIP)
2232 goto nosideret;
2233 if (unop_user_defined_p (op, arg1))
2234 return value_x_unop (arg1, op, noside);
2235 else
f44316fa
UW		 2236 {
2237 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2238 return value_neg (arg1);
2239 }
c906108c
SS		 2240
2241 case UNOP_COMPLEMENT:
2242 /* C++: check for and handle destructor names. */
2243 op = exp->elts[*pos].opcode;
2244
2245 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2246 if (noside == EVAL_SKIP)
2247 goto nosideret;
2248 if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2249 return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2250 else
f44316fa
UW		 2251 {
2252 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2253 return value_complement (arg1);
2254 }
c906108c
SS		 2255
2256 case UNOP_LOGICAL_NOT:
2257 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2258 if (noside == EVAL_SKIP)
2259 goto nosideret;
2260 if (unop_user_defined_p (op, arg1))
2261 return value_x_unop (arg1, op, noside);
2262 else
fbb06eb1
UW		 2263 {
2264 type = language_bool_type (exp->language_defn, exp->gdbarch);
2265 return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2266 }
c906108c
SS		 2267
2268 case UNOP_IND:
2269 if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
c5aa993b 2270 expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
c906108c 2271 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
0d5de010
DJ		 2272 type = check_typedef (value_type (arg1));
2273 if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2274 || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
8a3fe4f8 2275 error (_("Attempt to dereference pointer to member without an object"));
c906108c
SS		 2276 if (noside == EVAL_SKIP)
2277 goto nosideret;
2278 if (unop_user_defined_p (op, arg1))
2279 return value_x_unop (arg1, op, noside);
2280 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2281 {
df407dfe 2282 type = check_typedef (value_type (arg1));
c906108c
SS		 2283 if (TYPE_CODE (type) == TYPE_CODE_PTR
2284 || TYPE_CODE (type) == TYPE_CODE_REF
c5aa993b 2285 /* In C you can dereference an array to get the 1st elt. */
c906108c 2286 || TYPE_CODE (type) == TYPE_CODE_ARRAY
c5aa993b 2287 )
c906108c
SS		 2288 return value_zero (TYPE_TARGET_TYPE (type),
2289 lval_memory);
2290 else if (TYPE_CODE (type) == TYPE_CODE_INT)
2291 /* GDB allows dereferencing an int. */
22fe0fbb
UW		 2292 return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2293 lval_memory);
c906108c 2294 else
8a3fe4f8 2295 error (_("Attempt to take contents of a non-pointer value."));
c906108c 2296 }
22fe0fbb
UW		 2297
2298 /* Allow * on an integer so we can cast it to whatever we want.
2299 This returns an int, which seems like the most C-like thing to
2300 do. "long long" variables are rare enough that
2301 BUILTIN_TYPE_LONGEST would seem to be a mistake. */
2302 if (TYPE_CODE (type) == TYPE_CODE_INT)
2303 return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2304 (CORE_ADDR) value_as_address (arg1));
c906108c
SS		 2305 return value_ind (arg1);
2306
2307 case UNOP_ADDR:
2308 /* C++: check for and handle pointer to members. */
c5aa993b 2309
c906108c
SS		 2310 op = exp->elts[*pos].opcode;
2311
2312 if (noside == EVAL_SKIP)
2313 {
0d5de010 2314 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
c906108c
SS		 2315 goto nosideret;
2316 }
c5aa993b
JM		 2317 else
2318 {
61051030 2319 struct value *retvalp = evaluate_subexp_for_address (exp, pos, noside);
c5aa993b
JM		 2320 return retvalp;
2321 }
2322
c906108c
SS		 2323 case UNOP_SIZEOF:
2324 if (noside == EVAL_SKIP)
2325 {
2326 evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2327 goto nosideret;
2328 }
2329 return evaluate_subexp_for_sizeof (exp, pos);
2330
2331 case UNOP_CAST:
2332 (*pos) += 2;
2333 type = exp->elts[pc + 1].type;
2334 arg1 = evaluate_subexp (type, exp, pos, noside);
2335 if (noside == EVAL_SKIP)
2336 goto nosideret;
df407dfe 2337 if (type != value_type (arg1))
c906108c
SS		 2338 arg1 = value_cast (type, arg1);
2339 return arg1;
2340
2341 case UNOP_MEMVAL:
2342 (*pos) += 2;
2343 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2344 if (noside == EVAL_SKIP)
2345 goto nosideret;
2346 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2347 return value_zero (exp->elts[pc + 1].type, lval_memory);
2348 else
2349 return value_at_lazy (exp->elts[pc + 1].type,
00a4c844 2350 value_as_address (arg1));
c906108c 2351
9e35dae4
DJ		 2352 case UNOP_MEMVAL_TLS:
2353 (*pos) += 3;
2354 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2355 if (noside == EVAL_SKIP)
2356 goto nosideret;
2357 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2358 return value_zero (exp->elts[pc + 2].type, lval_memory);
2359 else
2360 {
2361 CORE_ADDR tls_addr;
2362 tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2363 value_as_address (arg1));
2364 return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
2365 }
2366
c906108c
SS		 2367 case UNOP_PREINCREMENT:
2368 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2369 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2370 return arg1;
2371 else if (unop_user_defined_p (op, arg1))
2372 {
2373 return value_x_unop (arg1, op, noside);
2374 }
2375 else
2376 {
89eef114
UW		 2377 arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
2378 if (ptrmath_type_p (value_type (arg1)))
2379 arg2 = value_ptradd (arg1, arg2);
2380 else
f44316fa
UW		 2381 {
2382 struct value *tmp = arg1;
2383 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2384 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2385 }
89eef114 2386
c906108c
SS		 2387 return value_assign (arg1, arg2);
2388 }
2389
2390 case UNOP_PREDECREMENT:
2391 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2392 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2393 return arg1;
2394 else if (unop_user_defined_p (op, arg1))
2395 {
2396 return value_x_unop (arg1, op, noside);
2397 }
2398 else
2399 {
89eef114
UW		 2400 arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
2401 if (ptrmath_type_p (value_type (arg1)))
2402 arg2 = value_ptrsub (arg1, arg2);
2403 else
f44316fa
UW		 2404 {
2405 struct value *tmp = arg1;
2406 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2407 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2408 }
89eef114 2409
c906108c
SS		 2410 return value_assign (arg1, arg2);
2411 }
2412
2413 case UNOP_POSTINCREMENT:
2414 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2415 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2416 return arg1;
2417 else if (unop_user_defined_p (op, arg1))
2418 {
2419 return value_x_unop (arg1, op, noside);
2420 }
2421 else
2422 {
89eef114
UW		 2423 arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
2424 if (ptrmath_type_p (value_type (arg1)))
2425 arg2 = value_ptradd (arg1, arg2);
2426 else
f44316fa
UW		 2427 {
2428 struct value *tmp = arg1;
2429 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2430 arg2 = value_binop (tmp, arg2, BINOP_ADD);
2431 }
89eef114 2432
c906108c
SS		 2433 value_assign (arg1, arg2);
2434 return arg1;
2435 }
2436
2437 case UNOP_POSTDECREMENT:
2438 arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2439 if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2440 return arg1;
2441 else if (unop_user_defined_p (op, arg1))
2442 {
2443 return value_x_unop (arg1, op, noside);
2444 }
2445 else
2446 {
89eef114
UW		 2447 arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
2448 if (ptrmath_type_p (value_type (arg1)))
2449 arg2 = value_ptrsub (arg1, arg2);
2450 else
f44316fa
UW		 2451 {
2452 struct value *tmp = arg1;
2453 binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2454 arg2 = value_binop (tmp, arg2, BINOP_SUB);
2455 }
89eef114 2456
c906108c
SS		 2457 value_assign (arg1, arg2);
2458 return arg1;
2459 }
c5aa993b 2460
c906108c
SS		 2461 case OP_THIS:
2462 (*pos) += 1;
2463 return value_of_this (1);
2464
a9fa03de
AF		 2465 case OP_OBJC_SELF:
2466 (*pos) += 1;
2467 return value_of_local ("self", 1);
2468
c906108c 2469 case OP_TYPE:
d843c49c
FF		 2470 /* The value is not supposed to be used. This is here to make it
2471 easier to accommodate expressions that contain types. */
2472 (*pos) += 2;
2473 if (noside == EVAL_SKIP)
2474 goto nosideret;
2475 else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2476 return allocate_value (exp->elts[pc + 1].type);
2477 else
2478 error (_("Attempt to use a type name as an expression"));
c906108c
SS		 2479
2480 default:
2481 /* Removing this case and compiling with gcc -Wall reveals that
c5aa993b 2482 a lot of cases are hitting this case. Some of these should
2df3850c
JM		 2483 probably be removed from expression.h; others are legitimate
2484 expressions which are (apparently) not fully implemented.
c906108c 2485
c5aa993b
JM		 2486 If there are any cases landing here which mean a user error,
2487 then they should be separate cases, with more descriptive
2488 error messages. */
c906108c 2489
8a3fe4f8
AC		 2490 error (_("\
2491GDB does not (yet) know how to evaluate that kind of expression"));
c906108c
SS		 2492 }
2493
c5aa993b 2494nosideret:
cb18ec49 2495 return value_from_longest (builtin_type_int8, (LONGEST) 1);
c906108c
SS		 2496}
2497\f
2498/* Evaluate a subexpression of EXP, at index *POS,
2499 and return the address of that subexpression.
2500 Advance *POS over the subexpression.
2501 If the subexpression isn't an lvalue, get an error.
2502 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2503 then only the type of the result need be correct. */
2504
61051030 2505static struct value *
aa1ee363 2506evaluate_subexp_for_address (struct expression *exp, int *pos,
fba45db2 2507 enum noside noside)
c906108c
SS		 2508{
2509 enum exp_opcode op;
52f0bd74 2510 int pc;
c906108c 2511 struct symbol *var;
ab5c9f60 2512 struct value *x;
0d5de010 2513 int tem;
c906108c
SS		 2514
2515 pc = (*pos);
2516 op = exp->elts[pc].opcode;
2517
2518 switch (op)
2519 {
2520 case UNOP_IND:
2521 (*pos)++;
ab5c9f60
DJ		 2522 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2523
2524 /* We can't optimize out "&*" if there's a user-defined operator*. */
2525 if (unop_user_defined_p (op, x))
2526 {
2527 x = value_x_unop (x, op, noside);
0d5de010 2528 goto default_case_after_eval;
ab5c9f60
DJ		 2529 }
2530
2531 return x;
c906108c
SS		 2532
2533 case UNOP_MEMVAL:
2534 (*pos) += 3;
2535 return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2536 evaluate_subexp (NULL_TYPE, exp, pos, noside));
2537
2538 case OP_VAR_VALUE:
2539 var = exp->elts[pc + 2].symbol;
2540
2541 /* C++: The "address" of a reference should yield the address
2542 * of the object pointed to. Let value_addr() deal with it. */
2543 if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
c5aa993b 2544 goto default_case;
c906108c
SS		 2545
2546 (*pos) += 4;
2547 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2548 {
2549 struct type *type =
c5aa993b 2550 lookup_pointer_type (SYMBOL_TYPE (var));
c906108c
SS		 2551 enum address_class sym_class = SYMBOL_CLASS (var);
2552
2553 if (sym_class == LOC_CONST
2554 || sym_class == LOC_CONST_BYTES
2a2d4dc3 2555 || sym_class == LOC_REGISTER)
8a3fe4f8 2556 error (_("Attempt to take address of register or constant."));
c906108c 2557
c5aa993b
JM		 2558 return
2559 value_zero (type, not_lval);
c906108c 2560 }
ceef53c1 2561 else if (symbol_read_needs_frame (var))
c906108c
SS		 2562 return
2563 locate_var_value
c5aa993b
JM		 2564 (var,
2565 block_innermost_frame (exp->elts[pc + 1].block));
ceef53c1
JB		 2566 else
2567 return locate_var_value (var, NULL);
c906108c 2568
0d5de010
DJ		 2569 case OP_SCOPE:
2570 tem = longest_to_int (exp->elts[pc + 2].longconst);
2571 (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2572 x = value_aggregate_elt (exp->elts[pc + 1].type,
2573 &exp->elts[pc + 3].string,
2574 1, noside);
2575 if (x == NULL)
2576 error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2577 return x;
2578
c906108c
SS		 2579 default:
2580 default_case:
ab5c9f60 2581 x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
0d5de010 2582 default_case_after_eval:
c906108c
SS		 2583 if (noside == EVAL_AVOID_SIDE_EFFECTS)
2584 {
0d5de010
DJ		 2585 struct type *type = check_typedef (value_type (x));
2586
63092375 2587 if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
df407dfe 2588 return value_zero (lookup_pointer_type (value_type (x)),
c906108c 2589 not_lval);
0d5de010
DJ		 2590 else if (TYPE_CODE (type) == TYPE_CODE_REF)
2591 return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2592 not_lval);
c906108c 2593 else
63092375 2594 error (_("Attempt to take address of value not located in memory."));
c906108c 2595 }
ab5c9f60 2596 return value_addr (x);
c906108c
SS		 2597 }
2598}
2599
2600/* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2601 When used in contexts where arrays will be coerced anyway, this is
2602 equivalent to `evaluate_subexp' but much faster because it avoids
2603 actually fetching array contents (perhaps obsolete now that we have
d69fe07e 2604 value_lazy()).
c906108c
SS		 2605
2606 Note that we currently only do the coercion for C expressions, where
2607 arrays are zero based and the coercion is correct. For other languages,
2608 with nonzero based arrays, coercion loses. Use CAST_IS_CONVERSION
2609 to decide if coercion is appropriate.
2610
c5aa993b 2611 */
c906108c 2612
61051030 2613struct value *
aa1ee363
AC		 2614evaluate_subexp_with_coercion (struct expression *exp,
2615 int *pos, enum noside noside)
c906108c 2616{
52f0bd74
AC		 2617 enum exp_opcode op;
2618 int pc;
61051030 2619 struct value *val;
c906108c
SS		 2620 struct symbol *var;
2621
2622 pc = (*pos);
2623 op = exp->elts[pc].opcode;
2624
2625 switch (op)
2626 {
2627 case OP_VAR_VALUE:
2628 var = exp->elts[pc + 2].symbol;
2629 if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var))) == TYPE_CODE_ARRAY
2630 && CAST_IS_CONVERSION)
2631 {
2632 (*pos) += 4;
2633 val =
2634 locate_var_value
c5aa993b 2635 (var, block_innermost_frame (exp->elts[pc + 1].block));
751a959b 2636 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var)))),
c906108c
SS		 2637 val);
2638 }
2639 /* FALLTHROUGH */
2640
2641 default:
2642 return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2643 }
2644}
2645
2646/* Evaluate a subexpression of EXP, at index *POS,
2647 and return a value for the size of that subexpression.
2648 Advance *POS over the subexpression. */
2649
61051030 2650static struct value *
aa1ee363 2651evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
c906108c 2652{
98b90dd8
UW		 2653 /* FIXME: This should be size_t. */
2654 struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
c906108c 2655 enum exp_opcode op;
52f0bd74 2656 int pc;
c906108c 2657 struct type *type;
61051030 2658 struct value *val;
c906108c
SS		 2659
2660 pc = (*pos);
2661 op = exp->elts[pc].opcode;
2662
2663 switch (op)
2664 {
2665 /* This case is handled specially
c5aa993b
JM		 2666 so that we avoid creating a value for the result type.
2667 If the result type is very big, it's desirable not to
2668 create a value unnecessarily. */
c906108c
SS		 2669 case UNOP_IND:
2670 (*pos)++;
2671 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
df407dfe 2672 type = check_typedef (value_type (val));
c906108c
SS		 2673 if (TYPE_CODE (type) != TYPE_CODE_PTR
2674 && TYPE_CODE (type) != TYPE_CODE_REF
2675 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
8a3fe4f8 2676 error (_("Attempt to take contents of a non-pointer value."));
c906108c 2677 type = check_typedef (TYPE_TARGET_TYPE (type));
98b90dd8 2678 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
c906108c
SS		 2679
2680 case UNOP_MEMVAL:
2681 (*pos) += 3;
2682 type = check_typedef (exp->elts[pc + 1].type);
98b90dd8 2683 return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
c906108c
SS		 2684
2685 case OP_VAR_VALUE:
2686 (*pos) += 4;
2687 type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
2688 return
98b90dd8 2689 value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
c906108c
SS		 2690
2691 default:
2692 val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
98b90dd8 2693 return value_from_longest (size_type,
df407dfe 2694 (LONGEST) TYPE_LENGTH (value_type (val)));
c906108c
SS		 2695 }
2696}
2697
2698/* Parse a type expression in the string [P..P+LENGTH). */
2699
2700struct type *
fba45db2 2701parse_and_eval_type (char *p, int length)
c906108c 2702{
c5aa993b
JM		 2703 char *tmp = (char *) alloca (length + 4);
2704 struct expression *expr;
2705 tmp[0] = '(';
2706 memcpy (tmp + 1, p, length);
2707 tmp[length + 1] = ')';
2708 tmp[length + 2] = '0';
2709 tmp[length + 3] = '\0';
2710 expr = parse_expression (tmp);
2711 if (expr->elts[0].opcode != UNOP_CAST)
8a3fe4f8 2712 error (_("Internal error in eval_type."));
c5aa993b 2713 return expr->elts[1].type;
c906108c
SS		 2714}
2715
2716int
fba45db2 2717calc_f77_array_dims (struct type *array_type)
c906108c
SS		 2718{
2719 int ndimen = 1;
2720 struct type *tmp_type;
2721
c5aa993b 2722 if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
8a3fe4f8 2723 error (_("Can't get dimensions for a non-array type"));
c5aa993b
JM		 2724
2725 tmp_type = array_type;
c906108c
SS		 2726
2727 while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
2728 {
2729 if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)
2730 ++ndimen;
2731 }
c5aa993b 2732 return ndimen;
c906108c 2733}
GDB Binutils - Deliverables
This page took 0.729189 seconds and 4 git commands to generate.