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