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