GDB (xrefs)
/tmp/gdb-7.10/gdb/valops.c
Go to the documentation of this file.
1 /* Perform non-arithmetic operations on values, 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 "frame.h"
25 #include "inferior.h"
26 #include "gdbcore.h"
27 #include "target.h"
28 #include "demangle.h"
29 #include "language.h"
30 #include "gdbcmd.h"
31 #include "regcache.h"
32 #include "cp-abi.h"
33 #include "block.h"
34 #include "infcall.h"
35 #include "dictionary.h"
36 #include "cp-support.h"
37 #include "dfp.h"
38 #include "tracepoint.h"
39 #include "observer.h"
40 #include "objfiles.h"
41 #include "extension.h"
42 
43 extern unsigned int overload_debug;
44 /* Local functions. */
45 
46 static int typecmp (int staticp, int varargs, int nargs,
47  struct field t1[], struct value *t2[]);
48 
49 static struct value *search_struct_field (const char *, struct value *,
50  struct type *, int);
51 
52 static struct value *search_struct_method (const char *, struct value **,
53  struct value **,
54  int, int *, struct type *);
55 
56 static int find_oload_champ_namespace (struct value **, int,
57  const char *, const char *,
58  struct symbol ***,
59  struct badness_vector **,
60  const int no_adl);
61 
62 static
63 int find_oload_champ_namespace_loop (struct value **, int,
64  const char *, const char *,
65  int, struct symbol ***,
66  struct badness_vector **, int *,
67  const int no_adl);
68 
69 static int find_oload_champ (struct value **, int, int,
70  struct fn_field *, VEC (xmethod_worker_ptr) *,
71  struct symbol **, struct badness_vector **);
72 
73 static int oload_method_static_p (struct fn_field *, int);
74 
76 
77 static enum
79  int, int);
80 
81 static struct value *value_struct_elt_for_reference (struct type *,
82  int, struct type *,
83  const char *,
84  struct type *,
85  int, enum noside);
86 
87 static struct value *value_namespace_elt (const struct type *,
88  const char *, int , enum noside);
89 
90 static struct value *value_maybe_namespace_elt (const struct type *,
91  const char *, int,
92  enum noside);
93 
95 
96 static struct value *cast_into_complex (struct type *, struct value *);
97 
98 static void find_method_list (struct value **, const char *,
99  int, struct type *, struct fn_field **, int *,
100  VEC (xmethod_worker_ptr) **,
101  struct type **, int *);
102 
103 void _initialize_valops (void);
104 
105 #if 0
106 /* Flag for whether we want to abandon failed expression evals by
107  default. */
108 
109 static int auto_abandon = 0;
110 #endif
111 
112 int overload_resolution = 0;
113 static void
114 show_overload_resolution (struct ui_file *file, int from_tty,
115  struct cmd_list_element *c,
116  const char *value)
117 {
118  fprintf_filtered (file, _("Overload resolution in evaluating "
119  "C++ functions is %s.\n"),
120  value);
121 }
122 
123 /* Find the address of function name NAME in the inferior. If OBJF_P
124  is non-NULL, *OBJF_P will be set to the OBJFILE where the function
125  is defined. */
126 
127 struct value *
128 find_function_in_inferior (const char *name, struct objfile **objf_p)
129 {
130  struct symbol *sym;
131 
132  sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
133  if (sym != NULL)
134  {
135  if (SYMBOL_CLASS (sym) != LOC_BLOCK)
136  {
137  error (_("\"%s\" exists in this program but is not a function."),
138  name);
139  }
140 
141  if (objf_p)
142  *objf_p = symbol_objfile (sym);
143 
144  return value_of_variable (sym, NULL);
145  }
146  else
147  {
148  struct bound_minimal_symbol msymbol =
150 
151  if (msymbol.minsym != NULL)
152  {
153  struct objfile *objfile = msymbol.objfile;
154  struct gdbarch *gdbarch = get_objfile_arch (objfile);
155 
156  struct type *type;
157  CORE_ADDR maddr;
158  type = lookup_pointer_type (builtin_type (gdbarch)->builtin_char);
159  type = lookup_function_type (type);
160  type = lookup_pointer_type (type);
161  maddr = BMSYMBOL_VALUE_ADDRESS (msymbol);
162 
163  if (objf_p)
164  *objf_p = objfile;
165 
166  return value_from_pointer (type, maddr);
167  }
168  else
169  {
171  error (_("evaluation of this expression "
172  "requires the target program to be active"));
173  else
174  error (_("evaluation of this expression requires the "
175  "program to have a function \"%s\"."),
176  name);
177  }
178  }
179 }
180 
181 /* Allocate NBYTES of space in the inferior using the inferior's
182  malloc and return a value that is a pointer to the allocated
183  space. */
184 
185 struct value *
187 {
188  struct objfile *objf;
189  struct value *val = find_function_in_inferior ("malloc", &objf);
190  struct gdbarch *gdbarch = get_objfile_arch (objf);
191  struct value *blocklen;
192 
193  blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
194  val = call_function_by_hand (val, 1, &blocklen);
195  if (value_logical_not (val))
196  {
198  error (_("No memory available to program now: "
199  "you need to start the target first"));
200  else
201  error (_("No memory available to program: call to malloc failed"));
202  }
203  return val;
204 }
205 
206 static CORE_ADDR
208 {
210 }
211 
212 /* Cast struct value VAL to type TYPE and return as a value.
213  Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
214  for this to work. Typedef to one of the codes is permitted.
215  Returns NULL if the cast is neither an upcast nor a downcast. */
216 
217 static struct value *
218 value_cast_structs (struct type *type, struct value *v2)
219 {
220  struct type *t1;
221  struct type *t2;
222  struct value *v;
223 
224  gdb_assert (type != NULL && v2 != NULL);
225 
226  t1 = check_typedef (type);
227  t2 = check_typedef (value_type (v2));
228 
229  /* Check preconditions. */
231  || TYPE_CODE (t1) == TYPE_CODE_UNION)
232  && !!"Precondition is that type is of STRUCT or UNION kind.");
234  || TYPE_CODE (t2) == TYPE_CODE_UNION)
235  && !!"Precondition is that value is of STRUCT or UNION kind");
236 
237  if (TYPE_NAME (t1) != NULL
238  && TYPE_NAME (t2) != NULL
239  && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2)))
240  return NULL;
241 
242  /* Upcasting: look in the type of the source to see if it contains the
243  type of the target as a superclass. If so, we'll need to
244  offset the pointer rather than just change its type. */
245  if (TYPE_NAME (t1) != NULL)
246  {
248  v2, t2, 1);
249  if (v)
250  return v;
251  }
252 
253  /* Downcasting: look in the type of the target to see if it contains the
254  type of the source as a superclass. If so, we'll need to
255  offset the pointer rather than just change its type. */
256  if (TYPE_NAME (t2) != NULL)
257  {
258  /* Try downcasting using the run-time type of the value. */
259  int full, top, using_enc;
260  struct type *real_type;
261 
262  real_type = value_rtti_type (v2, &full, &top, &using_enc);
263  if (real_type)
264  {
265  v = value_full_object (v2, real_type, full, top, using_enc);
266  v = value_at_lazy (real_type, value_address (v));
267  real_type = value_type (v);
268 
269  /* We might be trying to cast to the outermost enclosing
270  type, in which case search_struct_field won't work. */
271  if (TYPE_NAME (real_type) != NULL
272  && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1)))
273  return v;
274 
275  v = search_struct_field (type_name_no_tag (t2), v, real_type, 1);
276  if (v)
277  return v;
278  }
279 
280  /* Try downcasting using information from the destination type
281  T2. This wouldn't work properly for classes with virtual
282  bases, but those were handled above. */
284  value_zero (t1, not_lval), t1, 1);
285  if (v)
286  {
287  /* Downcasting is possible (t1 is superclass of v2). */
288  CORE_ADDR addr2 = value_address (v2);
289 
290  addr2 -= value_address (v) + value_embedded_offset (v);
291  return value_at (type, addr2);
292  }
293  }
294 
295  return NULL;
296 }
297 
298 /* Cast one pointer or reference type to another. Both TYPE and
299  the type of ARG2 should be pointer types, or else both should be
300  reference types. If SUBCLASS_CHECK is non-zero, this will force a
301  check to see whether TYPE is a superclass of ARG2's type. If
302  SUBCLASS_CHECK is zero, then the subclass check is done only when
303  ARG2 is itself non-zero. Returns the new pointer or reference. */
304 
305 struct value *
306 value_cast_pointers (struct type *type, struct value *arg2,
307  int subclass_check)
308 {
309  struct type *type1 = check_typedef (type);
310  struct type *type2 = check_typedef (value_type (arg2));
311  struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1));
312  struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
313 
314  if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
315  && TYPE_CODE (t2) == TYPE_CODE_STRUCT
316  && (subclass_check || !value_logical_not (arg2)))
317  {
318  struct value *v2;
319 
320  if (TYPE_CODE (type2) == TYPE_CODE_REF)
321  v2 = coerce_ref (arg2);
322  else
323  v2 = value_ind (arg2);
325  == TYPE_CODE_STRUCT && !!"Why did coercion fail?");
326  v2 = value_cast_structs (t1, v2);
327  /* At this point we have what we can have, un-dereference if needed. */
328  if (v2)
329  {
330  struct value *v = value_addr (v2);
331 
332  deprecated_set_value_type (v, type);
333  return v;
334  }
335  }
336 
337  /* No superclass found, just change the pointer type. */
338  arg2 = value_copy (arg2);
339  deprecated_set_value_type (arg2, type);
340  set_value_enclosing_type (arg2, type);
341  set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
342  return arg2;
343 }
344 
345 /* Cast value ARG2 to type TYPE and return as a value.
346  More general than a C cast: accepts any two types of the same length,
347  and if ARG2 is an lvalue it can be cast into anything at all. */
348 /* In C++, casts may change pointer or object representations. */
349 
350 struct value *
351 value_cast (struct type *type, struct value *arg2)
352 {
353  enum type_code code1;
354  enum type_code code2;
355  int scalar;
356  struct type *type2;
357 
358  int convert_to_boolean = 0;
359 
360  if (value_type (arg2) == type)
361  return arg2;
362 
363  code1 = TYPE_CODE (check_typedef (type));
364 
365  /* Check if we are casting struct reference to struct reference. */
366  if (code1 == TYPE_CODE_REF)
367  {
368  /* We dereference type; then we recurse and finally
369  we generate value of the given reference. Nothing wrong with
370  that. */
371  struct type *t1 = check_typedef (type);
372  struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
373  struct value *val = value_cast (dereftype, arg2);
374 
375  return value_ref (val);
376  }
377 
378  code2 = TYPE_CODE (check_typedef (value_type (arg2)));
379 
380  if (code2 == TYPE_CODE_REF)
381  /* We deref the value and then do the cast. */
382  return value_cast (type, coerce_ref (arg2));
383 
384  CHECK_TYPEDEF (type);
385  code1 = TYPE_CODE (type);
386  arg2 = coerce_ref (arg2);
387  type2 = check_typedef (value_type (arg2));
388 
389  /* You can't cast to a reference type. See value_cast_pointers
390  instead. */
391  gdb_assert (code1 != TYPE_CODE_REF);
392 
393  /* A cast to an undetermined-length array_type, such as
394  (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
395  where N is sizeof(OBJECT)/sizeof(TYPE). */
396  if (code1 == TYPE_CODE_ARRAY)
397  {
398  struct type *element_type = TYPE_TARGET_TYPE (type);
399  unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
400 
401  if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
402  {
403  struct type *range_type = TYPE_INDEX_TYPE (type);
404  int val_length = TYPE_LENGTH (type2);
405  LONGEST low_bound, high_bound, new_length;
406 
407  if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
408  low_bound = 0, high_bound = 0;
409  new_length = val_length / element_length;
410  if (val_length % element_length != 0)
411  warning (_("array element type size does not "
412  "divide object size in cast"));
413  /* FIXME-type-allocation: need a way to free this type when
414  we are done with it. */
415  range_type = create_static_range_type ((struct type *) NULL,
416  TYPE_TARGET_TYPE (range_type),
417  low_bound,
418  new_length + low_bound - 1);
420  create_array_type ((struct type *) NULL,
421  element_type,
422  range_type));
423  return arg2;
424  }
425  }
426 
428  && TYPE_CODE (type2) == TYPE_CODE_ARRAY
429  && !TYPE_VECTOR (type2))
430  arg2 = value_coerce_array (arg2);
431 
432  if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
433  arg2 = value_coerce_function (arg2);
434 
435  type2 = check_typedef (value_type (arg2));
436  code2 = TYPE_CODE (type2);
437 
438  if (code1 == TYPE_CODE_COMPLEX)
439  return cast_into_complex (type, arg2);
440  if (code1 == TYPE_CODE_BOOL)
441  {
442  code1 = TYPE_CODE_INT;
443  convert_to_boolean = 1;
444  }
445  if (code1 == TYPE_CODE_CHAR)
446  code1 = TYPE_CODE_INT;
447  if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
448  code2 = TYPE_CODE_INT;
449 
450  scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
451  || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
452  || code2 == TYPE_CODE_RANGE);
453 
454  if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
455  && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
456  && TYPE_NAME (type) != 0)
457  {
458  struct value *v = value_cast_structs (type, arg2);
459 
460  if (v)
461  return v;
462  }
463 
464  if (code1 == TYPE_CODE_FLT && scalar)
465  return value_from_double (type, value_as_double (arg2));
466  else if (code1 == TYPE_CODE_DECFLOAT && scalar)
467  {
468  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
469  int dec_len = TYPE_LENGTH (type);
470  gdb_byte dec[16];
471 
472  if (code2 == TYPE_CODE_FLT)
473  decimal_from_floating (arg2, dec, dec_len, byte_order);
474  else if (code2 == TYPE_CODE_DECFLOAT)
475  decimal_convert (value_contents (arg2), TYPE_LENGTH (type2),
476  byte_order, dec, dec_len, byte_order);
477  else
478  /* The only option left is an integral type. */
479  decimal_from_integral (arg2, dec, dec_len, byte_order);
480 
481  return value_from_decfloat (type, dec);
482  }
483  else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
484  || code1 == TYPE_CODE_RANGE)
485  && (scalar || code2 == TYPE_CODE_PTR
486  || code2 == TYPE_CODE_MEMBERPTR))
487  {
488  LONGEST longest;
489 
490  /* When we cast pointers to integers, we mustn't use
491  gdbarch_pointer_to_address to find the address the pointer
492  represents, as value_as_long would. GDB should evaluate
493  expressions just as the compiler would --- and the compiler
494  sees a cast as a simple reinterpretation of the pointer's
495  bits. */
496  if (code2 == TYPE_CODE_PTR)
497  longest = extract_unsigned_integer
498  (value_contents (arg2), TYPE_LENGTH (type2),
500  else
501  longest = value_as_long (arg2);
502  return value_from_longest (type, convert_to_boolean ?
503  (LONGEST) (longest ? 1 : 0) : longest);
504  }
505  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT
506  || code2 == TYPE_CODE_ENUM
507  || code2 == TYPE_CODE_RANGE))
508  {
509  /* TYPE_LENGTH (type) is the length of a pointer, but we really
510  want the length of an address! -- we are really dealing with
511  addresses (i.e., gdb representations) not pointers (i.e.,
512  target representations) here.
513 
514  This allows things like "print *(int *)0x01000234" to work
515  without printing a misleading message -- which would
516  otherwise occur when dealing with a target having two byte
517  pointers and four byte addresses. */
518 
519  int addr_bit = gdbarch_addr_bit (get_type_arch (type2));
520  LONGEST longest = value_as_long (arg2);
521 
522  if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
523  {
524  if (longest >= ((LONGEST) 1 << addr_bit)
525  || longest <= -((LONGEST) 1 << addr_bit))
526  warning (_("value truncated"));
527  }
528  return value_from_longest (type, longest);
529  }
530  else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
531  && value_as_long (arg2) == 0)
532  {
533  struct value *result = allocate_value (type);
534 
535  cplus_make_method_ptr (type, value_contents_writeable (result), 0, 0);
536  return result;
537  }
538  else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
539  && value_as_long (arg2) == 0)
540  {
541  /* The Itanium C++ ABI represents NULL pointers to members as
542  minus one, instead of biasing the normal case. */
543  return value_from_longest (type, -1);
544  }
545  else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type)
546  && code2 == TYPE_CODE_ARRAY && TYPE_VECTOR (type2)
547  && TYPE_LENGTH (type) != TYPE_LENGTH (type2))
548  error (_("Cannot convert between vector values of different sizes"));
549  else if (code1 == TYPE_CODE_ARRAY && TYPE_VECTOR (type) && scalar
550  && TYPE_LENGTH (type) != TYPE_LENGTH (type2))
551  error (_("can only cast scalar to vector of same size"));
552  else if (code1 == TYPE_CODE_VOID)
553  {
554  return value_zero (type, not_lval);
555  }
556  else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
557  {
558  if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
559  return value_cast_pointers (type, arg2, 0);
560 
561  arg2 = value_copy (arg2);
562  deprecated_set_value_type (arg2, type);
563  set_value_enclosing_type (arg2, type);
564  set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
565  return arg2;
566  }
567  else if (VALUE_LVAL (arg2) == lval_memory)
568  return value_at_lazy (type, value_address (arg2));
569  else
570  {
571  error (_("Invalid cast."));
572  return 0;
573  }
574 }
575 
576 /* The C++ reinterpret_cast operator. */
577 
578 struct value *
579 value_reinterpret_cast (struct type *type, struct value *arg)
580 {
581  struct value *result;
582  struct type *real_type = check_typedef (type);
583  struct type *arg_type, *dest_type;
584  int is_ref = 0;
585  enum type_code dest_code, arg_code;
586 
587  /* Do reference, function, and array conversion. */
588  arg = coerce_array (arg);
589 
590  /* Attempt to preserve the type the user asked for. */
591  dest_type = type;
592 
593  /* If we are casting to a reference type, transform
594  reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V). */
595  if (TYPE_CODE (real_type) == TYPE_CODE_REF)
596  {
597  is_ref = 1;
598  arg = value_addr (arg);
599  dest_type = lookup_pointer_type (TYPE_TARGET_TYPE (dest_type));
600  real_type = lookup_pointer_type (real_type);
601  }
602 
603  arg_type = value_type (arg);
604 
605  dest_code = TYPE_CODE (real_type);
606  arg_code = TYPE_CODE (arg_type);
607 
608  /* We can convert pointer types, or any pointer type to int, or int
609  type to pointer. */
610  if ((dest_code == TYPE_CODE_PTR && arg_code == TYPE_CODE_INT)
611  || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_PTR)
612  || (dest_code == TYPE_CODE_METHODPTR && arg_code == TYPE_CODE_INT)
613  || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_METHODPTR)
614  || (dest_code == TYPE_CODE_MEMBERPTR && arg_code == TYPE_CODE_INT)
615  || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_MEMBERPTR)
616  || (dest_code == arg_code
617  && (dest_code == TYPE_CODE_PTR
618  || dest_code == TYPE_CODE_METHODPTR
619  || dest_code == TYPE_CODE_MEMBERPTR)))
620  result = value_cast (dest_type, arg);
621  else
622  error (_("Invalid reinterpret_cast"));
623 
624  if (is_ref)
625  result = value_cast (type, value_ref (value_ind (result)));
626 
627  return result;
628 }
629 
630 /* A helper for value_dynamic_cast. This implements the first of two
631  runtime checks: we iterate over all the base classes of the value's
632  class which are equal to the desired class; if only one of these
633  holds the value, then it is the answer. */
634 
635 static int
636 dynamic_cast_check_1 (struct type *desired_type,
637  const gdb_byte *valaddr,
638  int embedded_offset,
639  CORE_ADDR address,
640  struct value *val,
641  struct type *search_type,
642  CORE_ADDR arg_addr,
643  struct type *arg_type,
644  struct value **result)
645 {
646  int i, result_count = 0;
647 
648  for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
649  {
650  int offset = baseclass_offset (search_type, i, valaddr, embedded_offset,
651  address, val);
652 
653  if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
654  {
655  if (address + embedded_offset + offset >= arg_addr
656  && address + embedded_offset + offset < arg_addr + TYPE_LENGTH (arg_type))
657  {
658  ++result_count;
659  if (!*result)
660  *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
661  address + embedded_offset + offset);
662  }
663  }
664  else
665  result_count += dynamic_cast_check_1 (desired_type,
666  valaddr,
667  embedded_offset + offset,
668  address, val,
669  TYPE_BASECLASS (search_type, i),
670  arg_addr,
671  arg_type,
672  result);
673  }
674 
675  return result_count;
676 }
677 
678 /* A helper for value_dynamic_cast. This implements the second of two
679  runtime checks: we look for a unique public sibling class of the
680  argument's declared class. */
681 
682 static int
683 dynamic_cast_check_2 (struct type *desired_type,
684  const gdb_byte *valaddr,
685  int embedded_offset,
686  CORE_ADDR address,
687  struct value *val,
688  struct type *search_type,
689  struct value **result)
690 {
691  int i, result_count = 0;
692 
693  for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
694  {
695  int offset;
696 
697  if (! BASETYPE_VIA_PUBLIC (search_type, i))
698  continue;
699 
700  offset = baseclass_offset (search_type, i, valaddr, embedded_offset,
701  address, val);
702  if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
703  {
704  ++result_count;
705  if (*result == NULL)
706  *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
707  address + embedded_offset + offset);
708  }
709  else
710  result_count += dynamic_cast_check_2 (desired_type,
711  valaddr,
712  embedded_offset + offset,
713  address, val,
714  TYPE_BASECLASS (search_type, i),
715  result);
716  }
717 
718  return result_count;
719 }
720 
721 /* The C++ dynamic_cast operator. */
722 
723 struct value *
724 value_dynamic_cast (struct type *type, struct value *arg)
725 {
726  int full, top, using_enc;
727  struct type *resolved_type = check_typedef (type);
728  struct type *arg_type = check_typedef (value_type (arg));
729  struct type *class_type, *rtti_type;
730  struct value *result, *tem, *original_arg = arg;
731  CORE_ADDR addr;
732  int is_ref = TYPE_CODE (resolved_type) == TYPE_CODE_REF;
733 
734  if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR
735  && TYPE_CODE (resolved_type) != TYPE_CODE_REF)
736  error (_("Argument to dynamic_cast must be a pointer or reference type"));
737  if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID
738  && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_STRUCT)
739  error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
740 
741  class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type));
742  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
743  {
744  if (TYPE_CODE (arg_type) != TYPE_CODE_PTR
745  && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT
746  && value_as_long (arg) == 0))
747  error (_("Argument to dynamic_cast does not have pointer type"));
748  if (TYPE_CODE (arg_type) == TYPE_CODE_PTR)
749  {
750  arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
751  if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
752  error (_("Argument to dynamic_cast does "
753  "not have pointer to class type"));
754  }
755 
756  /* Handle NULL pointers. */
757  if (value_as_long (arg) == 0)
758  return value_zero (type, not_lval);
759 
760  arg = value_ind (arg);
761  }
762  else
763  {
764  if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
765  error (_("Argument to dynamic_cast does not have class type"));
766  }
767 
768  /* If the classes are the same, just return the argument. */
769  if (class_types_same_p (class_type, arg_type))
770  return value_cast (type, arg);
771 
772  /* If the target type is a unique base class of the argument's
773  declared type, just cast it. */
774  if (is_ancestor (class_type, arg_type))
775  {
776  if (is_unique_ancestor (class_type, arg))
777  return value_cast (type, original_arg);
778  error (_("Ambiguous dynamic_cast"));
779  }
780 
781  rtti_type = value_rtti_type (arg, &full, &top, &using_enc);
782  if (! rtti_type)
783  error (_("Couldn't determine value's most derived type for dynamic_cast"));
784 
785  /* Compute the most derived object's address. */
786  addr = value_address (arg);
787  if (full)
788  {
789  /* Done. */
790  }
791  else if (using_enc)
792  addr += top;
793  else
794  addr += top + value_embedded_offset (arg);
795 
796  /* dynamic_cast<void *> means to return a pointer to the
797  most-derived object. */
798  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR
799  && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID)
800  return value_at_lazy (type, addr);
801 
802  tem = value_at (type, addr);
803  type = value_type (tem);
804 
805  /* The first dynamic check specified in 5.2.7. */
806  if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type)))
807  {
808  if (class_types_same_p (rtti_type, TYPE_TARGET_TYPE (resolved_type)))
809  return tem;
810  result = NULL;
811  if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type),
813  value_embedded_offset (tem),
814  value_address (tem), tem,
815  rtti_type, addr,
816  arg_type,
817  &result) == 1)
818  return value_cast (type,
819  is_ref ? value_ref (result) : value_addr (result));
820  }
821 
822  /* The second dynamic check specified in 5.2.7. */
823  result = NULL;
824  if (is_public_ancestor (arg_type, rtti_type)
825  && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type),
827  value_embedded_offset (tem),
828  value_address (tem), tem,
829  rtti_type, &result) == 1)
830  return value_cast (type,
831  is_ref ? value_ref (result) : value_addr (result));
832 
833  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
834  return value_zero (type, not_lval);
835 
836  error (_("dynamic_cast failed"));
837 }
838 
839 /* Create a value of type TYPE that is zero, and return it. */
840 
841 struct value *
842 value_zero (struct type *type, enum lval_type lv)
843 {
844  struct value *val = allocate_value (type);
845 
846  VALUE_LVAL (val) = (lv == lval_computed ? not_lval : lv);
847  return val;
848 }
849 
850 /* Create a not_lval value of numeric type TYPE that is one, and return it. */
851 
852 struct value *
853 value_one (struct type *type)
854 {
855  struct type *type1 = check_typedef (type);
856  struct value *val;
857 
858  if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
859  {
860  enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
861  gdb_byte v[16];
862 
863  decimal_from_string (v, TYPE_LENGTH (type), byte_order, "1");
864  val = value_from_decfloat (type, v);
865  }
866  else if (TYPE_CODE (type1) == TYPE_CODE_FLT)
867  {
868  val = value_from_double (type, (DOUBLEST) 1);
869  }
870  else if (is_integral_type (type1))
871  {
872  val = value_from_longest (type, (LONGEST) 1);
873  }
874  else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
875  {
876  struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1));
877  int i;
878  LONGEST low_bound, high_bound;
879  struct value *tmp;
880 
881  if (!get_array_bounds (type1, &low_bound, &high_bound))
882  error (_("Could not determine the vector bounds"));
883 
884  val = allocate_value (type);
885  for (i = 0; i < high_bound - low_bound + 1; i++)
886  {
887  tmp = value_one (eltype);
888  memcpy (value_contents_writeable (val) + i * TYPE_LENGTH (eltype),
889  value_contents_all (tmp), TYPE_LENGTH (eltype));
890  }
891  }
892  else
893  {
894  error (_("Not a numeric type."));
895  }
896 
897  /* value_one result is never used for assignments to. */
898  gdb_assert (VALUE_LVAL (val) == not_lval);
899 
900  return val;
901 }
902 
903 /* Helper function for value_at, value_at_lazy, and value_at_lazy_stack.
904  The type of the created value may differ from the passed type TYPE.
905  Make sure to retrieve the returned values's new type after this call
906  e.g. in case the type is a variable length array. */
907 
908 static struct value *
909 get_value_at (struct type *type, CORE_ADDR addr, int lazy)
910 {
911  struct value *val;
912 
913  if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
914  error (_("Attempt to dereference a generic pointer."));
915 
916  val = value_from_contents_and_address (type, NULL, addr);
917 
918  if (!lazy)
919  value_fetch_lazy (val);
920 
921  return val;
922 }
923 
924 /* Return a value with type TYPE located at ADDR.
925 
926  Call value_at only if the data needs to be fetched immediately;
927  if we can be 'lazy' and defer the fetch, perhaps indefinately, call
928  value_at_lazy instead. value_at_lazy simply records the address of
929  the data and sets the lazy-evaluation-required flag. The lazy flag
930  is tested in the value_contents macro, which is used if and when
931  the contents are actually required. The type of the created value
932  may differ from the passed type TYPE. Make sure to retrieve the
933  returned values's new type after this call e.g. in case the type
934  is a variable length array.
935 
936  Note: value_at does *NOT* handle embedded offsets; perform such
937  adjustments before or after calling it. */
938 
939 struct value *
940 value_at (struct type *type, CORE_ADDR addr)
941 {
942  return get_value_at (type, addr, 0);
943 }
944 
945 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).
946  The type of the created value may differ from the passed type TYPE.
947  Make sure to retrieve the returned values's new type after this call
948  e.g. in case the type is a variable length array. */
949 
950 struct value *
951 value_at_lazy (struct type *type, CORE_ADDR addr)
952 {
953  return get_value_at (type, addr, 1);
954 }
955 
956 void
958  int stack, CORE_ADDR memaddr,
959  gdb_byte *buffer, size_t length)
960 {
961  ULONGEST xfered = 0;
962 
963  while (xfered < length)
964  {
966  ULONGEST xfered_len;
967 
969  TARGET_OBJECT_MEMORY, NULL,
970  buffer + xfered, NULL,
971  memaddr + xfered, length - xfered,
972  &xfered_len);
973 
974  if (status == TARGET_XFER_OK)
975  /* nothing */;
976  else if (status == TARGET_XFER_UNAVAILABLE)
977  mark_value_bytes_unavailable (val, embedded_offset + xfered,
978  xfered_len);
979  else if (status == TARGET_XFER_EOF)
980  memory_error (TARGET_XFER_E_IO, memaddr + xfered);
981  else
982  memory_error (status, memaddr + xfered);
983 
984  xfered += xfered_len;
985  QUIT;
986  }
987 }
988 
989 /* Store the contents of FROMVAL into the location of TOVAL.
990  Return a new value with the location of TOVAL and contents of FROMVAL. */
991 
992 struct value *
993 value_assign (struct value *toval, struct value *fromval)
994 {
995  struct type *type;
996  struct value *val;
997  struct frame_id old_frame;
998 
999  if (!deprecated_value_modifiable (toval))
1000  error (_("Left operand of assignment is not a modifiable lvalue."));
1001 
1002  toval = coerce_ref (toval);
1003 
1004  type = value_type (toval);
1005  if (VALUE_LVAL (toval) != lval_internalvar)
1006  fromval = value_cast (type, fromval);
1007  else
1008  {
1009  /* Coerce arrays and functions to pointers, except for arrays
1010  which only live in GDB's storage. */
1011  if (!value_must_coerce_to_target (fromval))
1012  fromval = coerce_array (fromval);
1013  }
1014 
1015  CHECK_TYPEDEF (type);
1016 
1017  /* Since modifying a register can trash the frame chain, and
1018  modifying memory can trash the frame cache, we save the old frame
1019  and then restore the new frame afterwards. */
1021 
1022  switch (VALUE_LVAL (toval))
1023  {
1024  case lval_internalvar:
1025  set_internalvar (VALUE_INTERNALVAR (toval), fromval);
1026  return value_of_internalvar (get_type_arch (type),
1027  VALUE_INTERNALVAR (toval));
1028 
1030  {
1031  int offset = value_offset (toval);
1032 
1033  /* Are we dealing with a bitfield?
1034 
1035  It is important to mention that `value_parent (toval)' is
1036  non-NULL iff `value_bitsize (toval)' is non-zero. */
1037  if (value_bitsize (toval))
1038  {
1039  /* VALUE_INTERNALVAR below refers to the parent value, while
1040  the offset is relative to this parent value. */
1041  gdb_assert (value_parent (value_parent (toval)) == NULL);
1042  offset += value_offset (value_parent (toval));
1043  }
1044 
1046  offset,
1047  value_bitpos (toval),
1048  value_bitsize (toval),
1049  fromval);
1050  }
1051  break;
1052 
1053  case lval_memory:
1054  {
1055  const gdb_byte *dest_buffer;
1056  CORE_ADDR changed_addr;
1057  int changed_len;
1058  gdb_byte buffer[sizeof (LONGEST)];
1059 
1060  if (value_bitsize (toval))
1061  {
1062  struct value *parent = value_parent (toval);
1063 
1064  changed_addr = value_address (parent) + value_offset (toval);
1065  changed_len = (value_bitpos (toval)
1066  + value_bitsize (toval)
1067  + HOST_CHAR_BIT - 1)
1068  / HOST_CHAR_BIT;
1069 
1070  /* If we can read-modify-write exactly the size of the
1071  containing type (e.g. short or int) then do so. This
1072  is safer for volatile bitfields mapped to hardware
1073  registers. */
1074  if (changed_len < TYPE_LENGTH (type)
1075  && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)
1076  && ((LONGEST) changed_addr % TYPE_LENGTH (type)) == 0)
1077  changed_len = TYPE_LENGTH (type);
1078 
1079  if (changed_len > (int) sizeof (LONGEST))
1080  error (_("Can't handle bitfields which "
1081  "don't fit in a %d bit word."),
1082  (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1083 
1084  read_memory (changed_addr, buffer, changed_len);
1085  modify_field (type, buffer, value_as_long (fromval),
1086  value_bitpos (toval), value_bitsize (toval));
1087  dest_buffer = buffer;
1088  }
1089  else
1090  {
1091  changed_addr = value_address (toval);
1092  changed_len = TYPE_LENGTH (type);
1093  dest_buffer = value_contents (fromval);
1094  }
1095 
1096  write_memory_with_notification (changed_addr, dest_buffer, changed_len);
1097  }
1098  break;
1099 
1100  case lval_register:
1101  {
1102  struct frame_info *frame;
1103  struct gdbarch *gdbarch;
1104  int value_reg;
1105 
1106  /* Figure out which frame this is in currently. */
1107  frame = frame_find_by_id (VALUE_FRAME_ID (toval));
1108  value_reg = VALUE_REGNUM (toval);
1109 
1110  if (!frame)
1111  error (_("Value being assigned to is no longer active."));
1112 
1113  gdbarch = get_frame_arch (frame);
1114 
1115  if (value_bitsize (toval))
1116  {
1117  struct value *parent = value_parent (toval);
1118  int offset = value_offset (parent) + value_offset (toval);
1119  int changed_len;
1120  gdb_byte buffer[sizeof (LONGEST)];
1121  int optim, unavail;
1122 
1123  changed_len = (value_bitpos (toval)
1124  + value_bitsize (toval)
1125  + HOST_CHAR_BIT - 1)
1126  / HOST_CHAR_BIT;
1127 
1128  if (changed_len > (int) sizeof (LONGEST))
1129  error (_("Can't handle bitfields which "
1130  "don't fit in a %d bit word."),
1131  (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1132 
1133  if (!get_frame_register_bytes (frame, value_reg, offset,
1134  changed_len, buffer,
1135  &optim, &unavail))
1136  {
1137  if (optim)
1139  _("value has been optimized out"));
1140  if (unavail)
1142  _("value is not available"));
1143  }
1144 
1145  modify_field (type, buffer, value_as_long (fromval),
1146  value_bitpos (toval), value_bitsize (toval));
1147 
1148  put_frame_register_bytes (frame, value_reg, offset,
1149  changed_len, buffer);
1150  }
1151  else
1152  {
1153  if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval),
1154  type))
1155  {
1156  /* If TOVAL is a special machine register requiring
1157  conversion of program values to a special raw
1158  format. */
1159  gdbarch_value_to_register (gdbarch, frame,
1160  VALUE_REGNUM (toval), type,
1161  value_contents (fromval));
1162  }
1163  else
1164  {
1165  put_frame_register_bytes (frame, value_reg,
1166  value_offset (toval),
1167  TYPE_LENGTH (type),
1168  value_contents (fromval));
1169  }
1170  }
1171 
1172  observer_notify_register_changed (frame, value_reg);
1175  break;
1176  }
1177 
1178  case lval_computed:
1179  {
1180  const struct lval_funcs *funcs = value_computed_funcs (toval);
1181 
1182  if (funcs->write != NULL)
1183  {
1184  funcs->write (toval, fromval);
1185  break;
1186  }
1187  }
1188  /* Fall through. */
1189 
1190  default:
1191  error (_("Left operand of assignment is not an lvalue."));
1192  }
1193 
1194  /* Assigning to the stack pointer, frame pointer, and other
1195  (architecture and calling convention specific) registers may
1196  cause the frame cache and regcache to be out of date. Assigning to memory
1197  also can. We just do this on all assignments to registers or
1198  memory, for simplicity's sake; I doubt the slowdown matters. */
1199  switch (VALUE_LVAL (toval))
1200  {
1201  case lval_memory:
1202  case lval_register:
1203  case lval_computed:
1204 
1206 
1207  /* Having destroyed the frame cache, restore the selected
1208  frame. */
1209 
1210  /* FIXME: cagney/2002-11-02: There has to be a better way of
1211  doing this. Instead of constantly saving/restoring the
1212  frame. Why not create a get_selected_frame() function that,
1213  having saved the selected frame's ID can automatically
1214  re-find the previously selected frame automatically. */
1215 
1216  {
1217  struct frame_info *fi = frame_find_by_id (old_frame);
1218 
1219  if (fi != NULL)
1220  select_frame (fi);
1221  }
1222 
1223  break;
1224  default:
1225  break;
1226  }
1227 
1228  /* If the field does not entirely fill a LONGEST, then zero the sign
1229  bits. If the field is signed, and is negative, then sign
1230  extend. */
1231  if ((value_bitsize (toval) > 0)
1232  && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
1233  {
1234  LONGEST fieldval = value_as_long (fromval);
1235  LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
1236 
1237  fieldval &= valmask;
1238  if (!TYPE_UNSIGNED (type)
1239  && (fieldval & (valmask ^ (valmask >> 1))))
1240  fieldval |= ~valmask;
1241 
1242  fromval = value_from_longest (type, fieldval);
1243  }
1244 
1245  /* The return value is a copy of TOVAL so it shares its location
1246  information, but its contents are updated from FROMVAL. This
1247  implies the returned value is not lazy, even if TOVAL was. */
1248  val = value_copy (toval);
1249  set_value_lazy (val, 0);
1250  memcpy (value_contents_raw (val), value_contents (fromval),
1251  TYPE_LENGTH (type));
1252 
1253  /* We copy over the enclosing type and pointed-to offset from FROMVAL
1254  in the case of pointer types. For object types, the enclosing type
1255  and embedded offset must *not* be copied: the target object refered
1256  to by TOVAL retains its original dynamic type after assignment. */
1257  if (TYPE_CODE (type) == TYPE_CODE_PTR)
1258  {
1261  }
1262 
1263  return val;
1264 }
1265 
1266 /* Extend a value VAL to COUNT repetitions of its type. */
1267 
1268 struct value *
1269 value_repeat (struct value *arg1, int count)
1270 {
1271  struct value *val;
1272 
1273  if (VALUE_LVAL (arg1) != lval_memory)
1274  error (_("Only values in memory can be extended with '@'."));
1275  if (count < 1)
1276  error (_("Invalid number %d of repetitions."), count);
1277 
1278  val = allocate_repeat_value (value_enclosing_type (arg1), count);
1279 
1280  VALUE_LVAL (val) = lval_memory;
1281  set_value_address (val, value_address (arg1));
1282 
1283  read_value_memory (val, 0, value_stack (val), value_address (val),
1284  value_contents_all_raw (val),
1286 
1287  return val;
1288 }
1289 
1290 struct value *
1291 value_of_variable (struct symbol *var, const struct block *b)
1292 {
1293  struct frame_info *frame;
1294 
1295  if (!symbol_read_needs_frame (var))
1296  frame = NULL;
1297  else if (!b)
1298  frame = get_selected_frame (_("No frame selected."));
1299  else
1300  {
1301  frame = block_innermost_frame (b);
1302  if (!frame)
1303  {
1304  if (BLOCK_FUNCTION (b) && !block_inlined_p (b)
1306  error (_("No frame is currently executing in block %s."),
1308  else
1309  error (_("No frame is currently executing in specified block"));
1310  }
1311  }
1312 
1313  return read_var_value (var, frame);
1314 }
1315 
1316 struct value *
1317 address_of_variable (struct symbol *var, const struct block *b)
1318 {
1319  struct type *type = SYMBOL_TYPE (var);
1320  struct value *val;
1321 
1322  /* Evaluate it first; if the result is a memory address, we're fine.
1323  Lazy evaluation pays off here. */
1324 
1325  val = value_of_variable (var, b);
1326  type = value_type (val);
1327 
1328  if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
1329  || TYPE_CODE (type) == TYPE_CODE_FUNC)
1330  {
1331  CORE_ADDR addr = value_address (val);
1332 
1333  return value_from_pointer (lookup_pointer_type (type), addr);
1334  }
1335 
1336  /* Not a memory address; check what the problem was. */
1337  switch (VALUE_LVAL (val))
1338  {
1339  case lval_register:
1340  {
1341  struct frame_info *frame;
1342  const char *regname;
1343 
1344  frame = frame_find_by_id (VALUE_FRAME_ID (val));
1345  gdb_assert (frame);
1346 
1347  regname = gdbarch_register_name (get_frame_arch (frame),
1348  VALUE_REGNUM (val));
1349  gdb_assert (regname && *regname);
1350 
1351  error (_("Address requested for identifier "
1352  "\"%s\" which is in register $%s"),
1353  SYMBOL_PRINT_NAME (var), regname);
1354  break;
1355  }
1356 
1357  default:
1358  error (_("Can't take address of \"%s\" which isn't an lvalue."),
1359  SYMBOL_PRINT_NAME (var));
1360  break;
1361  }
1362 
1363  return val;
1364 }
1365 
1366 /* Return one if VAL does not live in target memory, but should in order
1367  to operate on it. Otherwise return zero. */
1368 
1369 int
1371 {
1372  struct type *valtype;
1373 
1374  /* The only lval kinds which do not live in target memory. */
1375  if (VALUE_LVAL (val) != not_lval
1376  && VALUE_LVAL (val) != lval_internalvar
1377  && VALUE_LVAL (val) != lval_xcallable)
1378  return 0;
1379 
1380  valtype = check_typedef (value_type (val));
1381 
1382  switch (TYPE_CODE (valtype))
1383  {
1384  case TYPE_CODE_ARRAY:
1385  return TYPE_VECTOR (valtype) ? 0 : 1;
1386  case TYPE_CODE_STRING:
1387  return 1;
1388  default:
1389  return 0;
1390  }
1391 }
1392 
1393 /* Make sure that VAL lives in target memory if it's supposed to. For
1394  instance, strings are constructed as character arrays in GDB's
1395  storage, and this function copies them to the target. */
1396 
1397 struct value *
1399 {
1400  LONGEST length;
1401  CORE_ADDR addr;
1402 
1403  if (!value_must_coerce_to_target (val))
1404  return val;
1405 
1406  length = TYPE_LENGTH (check_typedef (value_type (val)));
1407  addr = allocate_space_in_inferior (length);
1408  write_memory (addr, value_contents (val), length);
1409  return value_at_lazy (value_type (val), addr);
1410 }
1411 
1412 /* Given a value which is an array, return a value which is a pointer
1413  to its first element, regardless of whether or not the array has a
1414  nonzero lower bound.
1415 
1416  FIXME: A previous comment here indicated that this routine should
1417  be substracting the array's lower bound. It's not clear to me that
1418  this is correct. Given an array subscripting operation, it would
1419  certainly work to do the adjustment here, essentially computing:
1420 
1421  (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1422 
1423  However I believe a more appropriate and logical place to account
1424  for the lower bound is to do so in value_subscript, essentially
1425  computing:
1426 
1427  (&array[0] + ((index - lowerbound) * sizeof array[0]))
1428 
1429  As further evidence consider what would happen with operations
1430  other than array subscripting, where the caller would get back a
1431  value that had an address somewhere before the actual first element
1432  of the array, and the information about the lower bound would be
1433  lost because of the coercion to pointer type. */
1434 
1435 struct value *
1437 {
1438  struct type *type = check_typedef (value_type (arg1));
1439 
1440  /* If the user tries to do something requiring a pointer with an
1441  array that has not yet been pushed to the target, then this would
1442  be a good time to do so. */
1443  arg1 = value_coerce_to_target (arg1);
1444 
1445  if (VALUE_LVAL (arg1) != lval_memory)
1446  error (_("Attempt to take address of value not located in memory."));
1447 
1449  value_address (arg1));
1450 }
1451 
1452 /* Given a value which is a function, return a value which is a pointer
1453  to it. */
1454 
1455 struct value *
1457 {
1458  struct value *retval;
1459 
1460  if (VALUE_LVAL (arg1) != lval_memory)
1461  error (_("Attempt to take address of value not located in memory."));
1462 
1464  value_address (arg1));
1465  return retval;
1466 }
1467 
1468 /* Return a pointer value for the object for which ARG1 is the
1469  contents. */
1470 
1471 struct value *
1472 value_addr (struct value *arg1)
1473 {
1474  struct value *arg2;
1475  struct type *type = check_typedef (value_type (arg1));
1476 
1477  if (TYPE_CODE (type) == TYPE_CODE_REF)
1478  {
1479  /* Copy the value, but change the type from (T&) to (T*). We
1480  keep the same location information, which is efficient, and
1481  allows &(&X) to get the location containing the reference. */
1482  arg2 = value_copy (arg1);
1485  return arg2;
1486  }
1487  if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1488  return value_coerce_function (arg1);
1489 
1490  /* If this is an array that has not yet been pushed to the target,
1491  then this would be a good time to force it to memory. */
1492  arg1 = value_coerce_to_target (arg1);
1493 
1494  if (VALUE_LVAL (arg1) != lval_memory)
1495  error (_("Attempt to take address of value not located in memory."));
1496 
1497  /* Get target memory address. */
1499  (value_address (arg1)
1500  + value_embedded_offset (arg1)));
1501 
1502  /* This may be a pointer to a base subobject; so remember the
1503  full derived object's type ... */
1506  /* ... and also the relative position of the subobject in the full
1507  object. */
1509  return arg2;
1510 }
1511 
1512 /* Return a reference value for the object for which ARG1 is the
1513  contents. */
1514 
1515 struct value *
1516 value_ref (struct value *arg1)
1517 {
1518  struct value *arg2;
1519  struct type *type = check_typedef (value_type (arg1));
1520 
1521  if (TYPE_CODE (type) == TYPE_CODE_REF)
1522  return arg1;
1523 
1524  arg2 = value_addr (arg1);
1526  return arg2;
1527 }
1528 
1529 /* Given a value of a pointer type, apply the C unary * operator to
1530  it. */
1531 
1532 struct value *
1533 value_ind (struct value *arg1)
1534 {
1535  struct type *base_type;
1536  struct value *arg2;
1537 
1538  arg1 = coerce_array (arg1);
1539 
1540  base_type = check_typedef (value_type (arg1));
1541 
1542  if (VALUE_LVAL (arg1) == lval_computed)
1543  {
1544  const struct lval_funcs *funcs = value_computed_funcs (arg1);
1545 
1546  if (funcs->indirect)
1547  {
1548  struct value *result = funcs->indirect (arg1);
1549 
1550  if (result)
1551  return result;
1552  }
1553  }
1554 
1555  if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
1556  {
1557  struct type *enc_type;
1558 
1559  /* We may be pointing to something embedded in a larger object.
1560  Get the real type of the enclosing object. */
1561  enc_type = check_typedef (value_enclosing_type (arg1));
1562  enc_type = TYPE_TARGET_TYPE (enc_type);
1563 
1564  if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
1565  || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
1566  /* For functions, go through find_function_addr, which knows
1567  how to handle function descriptors. */
1568  arg2 = value_at_lazy (enc_type,
1569  find_function_addr (arg1, NULL));
1570  else
1571  /* Retrieve the enclosing object pointed to. */
1572  arg2 = value_at_lazy (enc_type,
1573  (value_as_address (arg1)
1574  - value_pointed_to_offset (arg1)));
1575 
1576  enc_type = value_type (arg2);
1577  return readjust_indirect_value_type (arg2, enc_type, base_type, arg1);
1578  }
1579 
1580  error (_("Attempt to take contents of a non-pointer value."));
1581  return 0; /* For lint -- never reached. */
1582 }
1583 
1584 /* Create a value for an array by allocating space in GDB, copying the
1585  data into that space, and then setting up an array value.
1586 
1587  The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1588  is populated from the values passed in ELEMVEC.
1589 
1590  The element type of the array is inherited from the type of the
1591  first element, and all elements must have the same size (though we
1592  don't currently enforce any restriction on their types). */
1593 
1594 struct value *
1595 value_array (int lowbound, int highbound, struct value **elemvec)
1596 {
1597  int nelem;
1598  int idx;
1599  unsigned int typelength;
1600  struct value *val;
1601  struct type *arraytype;
1602 
1603  /* Validate that the bounds are reasonable and that each of the
1604  elements have the same size. */
1605 
1606  nelem = highbound - lowbound + 1;
1607  if (nelem <= 0)
1608  {
1609  error (_("bad array bounds (%d, %d)"), lowbound, highbound);
1610  }
1611  typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
1612  for (idx = 1; idx < nelem; idx++)
1613  {
1614  if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
1615  {
1616  error (_("array elements must all be the same size"));
1617  }
1618  }
1619 
1620  arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]),
1621  lowbound, highbound);
1622 
1624  {
1625  val = allocate_value (arraytype);
1626  for (idx = 0; idx < nelem; idx++)
1627  value_contents_copy (val, idx * typelength, elemvec[idx], 0,
1628  typelength);
1629  return val;
1630  }
1631 
1632  /* Allocate space to store the array, and then initialize it by
1633  copying in each element. */
1634 
1635  val = allocate_value (arraytype);
1636  for (idx = 0; idx < nelem; idx++)
1637  value_contents_copy (val, idx * typelength, elemvec[idx], 0, typelength);
1638  return val;
1639 }
1640 
1641 struct value *
1642 value_cstring (char *ptr, ssize_t len, struct type *char_type)
1643 {
1644  struct value *val;
1645  int lowbound = current_language->string_lower_bound;
1646  ssize_t highbound = len / TYPE_LENGTH (char_type);
1647  struct type *stringtype
1648  = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
1649 
1650  val = allocate_value (stringtype);
1651  memcpy (value_contents_raw (val), ptr, len);
1652  return val;
1653 }
1654 
1655 /* Create a value for a string constant by allocating space in the
1656  inferior, copying the data into that space, and returning the
1657  address with type TYPE_CODE_STRING. PTR points to the string
1658  constant data; LEN is number of characters.
1659 
1660  Note that string types are like array of char types with a lower
1661  bound of zero and an upper bound of LEN - 1. Also note that the
1662  string may contain embedded null bytes. */
1663 
1664 struct value *
1665 value_string (char *ptr, ssize_t len, struct type *char_type)
1666 {
1667  struct value *val;
1668  int lowbound = current_language->string_lower_bound;
1669  ssize_t highbound = len / TYPE_LENGTH (char_type);
1670  struct type *stringtype
1671  = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
1672 
1673  val = allocate_value (stringtype);
1674  memcpy (value_contents_raw (val), ptr, len);
1675  return val;
1676 }
1677 
1678 
1679 /* See if we can pass arguments in T2 to a function which takes
1680  arguments of types T1. T1 is a list of NARGS arguments, and T2 is
1681  a NULL-terminated vector. If some arguments need coercion of some
1682  sort, then the coerced values are written into T2. Return value is
1683  0 if the arguments could be matched, or the position at which they
1684  differ if not.
1685 
1686  STATICP is nonzero if the T1 argument list came from a static
1687  member function. T2 will still include the ``this'' pointer, but
1688  it will be skipped.
1689 
1690  For non-static member functions, we ignore the first argument,
1691  which is the type of the instance variable. This is because we
1692  want to handle calls with objects from derived classes. This is
1693  not entirely correct: we should actually check to make sure that a
1694  requested operation is type secure, shouldn't we? FIXME. */
1695 
1696 static int
1697 typecmp (int staticp, int varargs, int nargs,
1698  struct field t1[], struct value *t2[])
1699 {
1700  int i;
1701 
1702  if (t2 == 0)
1703  internal_error (__FILE__, __LINE__,
1704  _("typecmp: no argument list"));
1705 
1706  /* Skip ``this'' argument if applicable. T2 will always include
1707  THIS. */
1708  if (staticp)
1709  t2 ++;
1710 
1711  for (i = 0;
1712  (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1713  i++)
1714  {
1715  struct type *tt1, *tt2;
1716 
1717  if (!t2[i])
1718  return i + 1;
1719 
1720  tt1 = check_typedef (t1[i].type);
1721  tt2 = check_typedef (value_type (t2[i]));
1722 
1723  if (TYPE_CODE (tt1) == TYPE_CODE_REF
1724  /* We should be doing hairy argument matching, as below. */
1726  == TYPE_CODE (tt2)))
1727  {
1728  if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1729  t2[i] = value_coerce_array (t2[i]);
1730  else
1731  t2[i] = value_ref (t2[i]);
1732  continue;
1733  }
1734 
1735  /* djb - 20000715 - Until the new type structure is in the
1736  place, and we can attempt things like implicit conversions,
1737  we need to do this so you can take something like a map<const
1738  char *>, and properly access map["hello"], because the
1739  argument to [] will be a reference to a pointer to a char,
1740  and the argument will be a pointer to a char. */
1741  while (TYPE_CODE(tt1) == TYPE_CODE_REF
1742  || TYPE_CODE (tt1) == TYPE_CODE_PTR)
1743  {
1744  tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1745  }
1746  while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
1747  || TYPE_CODE(tt2) == TYPE_CODE_PTR
1748  || TYPE_CODE(tt2) == TYPE_CODE_REF)
1749  {
1750  tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1751  }
1752  if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1753  continue;
1754  /* Array to pointer is a `trivial conversion' according to the
1755  ARM. */
1756 
1757  /* We should be doing much hairier argument matching (see
1758  section 13.2 of the ARM), but as a quick kludge, just check
1759  for the same type code. */
1760  if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
1761  return i + 1;
1762  }
1763  if (varargs || t2[i] == NULL)
1764  return 0;
1765  return i + 1;
1766 }
1767 
1768 /* Helper class for do_search_struct_field that updates *RESULT_PTR
1769  and *LAST_BOFFSET, and possibly throws an exception if the field
1770  search has yielded ambiguous results. */
1771 
1772 static void
1773 update_search_result (struct value **result_ptr, struct value *v,
1774  int *last_boffset, int boffset,
1775  const char *name, struct type *type)
1776 {
1777  if (v != NULL)
1778  {
1779  if (*result_ptr != NULL
1780  /* The result is not ambiguous if all the classes that are
1781  found occupy the same space. */
1782  && *last_boffset != boffset)
1783  error (_("base class '%s' is ambiguous in type '%s'"),
1784  name, TYPE_SAFE_NAME (type));
1785  *result_ptr = v;
1786  *last_boffset = boffset;
1787  }
1788 }
1789 
1790 /* A helper for search_struct_field. This does all the work; most
1791  arguments are as passed to search_struct_field. The result is
1792  stored in *RESULT_PTR, which must be initialized to NULL.
1793  OUTERMOST_TYPE is the type of the initial type passed to
1794  search_struct_field; this is used for error reporting when the
1795  lookup is ambiguous. */
1796 
1797 static void
1798 do_search_struct_field (const char *name, struct value *arg1, int offset,
1799  struct type *type, int looking_for_baseclass,
1800  struct value **result_ptr,
1801  int *last_boffset,
1802  struct type *outermost_type)
1803 {
1804  int i;
1805  int nbases;
1806 
1807  CHECK_TYPEDEF (type);
1808  nbases = TYPE_N_BASECLASSES (type);
1809 
1810  if (!looking_for_baseclass)
1811  for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1812  {
1813  const char *t_field_name = TYPE_FIELD_NAME (type, i);
1814 
1815  if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1816  {
1817  struct value *v;
1818 
1819  if (field_is_static (&TYPE_FIELD (type, i)))
1820  v = value_static_field (type, i);
1821  else
1822  v = value_primitive_field (arg1, offset, i, type);
1823  *result_ptr = v;
1824  return;
1825  }
1826 
1827  if (t_field_name
1828  && t_field_name[0] == '\0')
1829  {
1830  struct type *field_type = TYPE_FIELD_TYPE (type, i);
1831 
1832  if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1833  || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1834  {
1835  /* Look for a match through the fields of an anonymous
1836  union, or anonymous struct. C++ provides anonymous
1837  unions.
1838 
1839  In the GNU Chill (now deleted from GDB)
1840  implementation of variant record types, each
1841  <alternative field> has an (anonymous) union type,
1842  each member of the union represents a <variant
1843  alternative>. Each <variant alternative> is
1844  represented as a struct, with a member for each
1845  <variant field>. */
1846 
1847  struct value *v = NULL;
1848  int new_offset = offset;
1849 
1850  /* This is pretty gross. In G++, the offset in an
1851  anonymous union is relative to the beginning of the
1852  enclosing struct. In the GNU Chill (now deleted
1853  from GDB) implementation of variant records, the
1854  bitpos is zero in an anonymous union field, so we
1855  have to add the offset of the union here. */
1856  if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1857  || (TYPE_NFIELDS (field_type) > 0
1858  && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1859  new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1860 
1861  do_search_struct_field (name, arg1, new_offset,
1862  field_type,
1863  looking_for_baseclass, &v,
1864  last_boffset,
1865  outermost_type);
1866  if (v)
1867  {
1868  *result_ptr = v;
1869  return;
1870  }
1871  }
1872  }
1873  }
1874 
1875  for (i = 0; i < nbases; i++)
1876  {
1877  struct value *v = NULL;
1878  struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1879  /* If we are looking for baseclasses, this is what we get when
1880  we hit them. But it could happen that the base part's member
1881  name is not yet filled in. */
1882  int found_baseclass = (looking_for_baseclass
1883  && TYPE_BASECLASS_NAME (type, i) != NULL
1884  && (strcmp_iw (name,
1885  TYPE_BASECLASS_NAME (type,
1886  i)) == 0));
1887  int boffset = value_embedded_offset (arg1) + offset;
1888 
1889  if (BASETYPE_VIA_VIRTUAL (type, i))
1890  {
1891  struct value *v2;
1892 
1893  boffset = baseclass_offset (type, i,
1895  value_embedded_offset (arg1) + offset,
1896  value_address (arg1),
1897  arg1);
1898 
1899  /* The virtual base class pointer might have been clobbered
1900  by the user program. Make sure that it still points to a
1901  valid memory location. */
1902 
1903  boffset += value_embedded_offset (arg1) + offset;
1904  if (boffset < 0
1905  || boffset >= TYPE_LENGTH (value_enclosing_type (arg1)))
1906  {
1907  CORE_ADDR base_addr;
1908 
1909  base_addr = value_address (arg1) + boffset;
1910  v2 = value_at_lazy (basetype, base_addr);
1911  if (target_read_memory (base_addr,
1912  value_contents_raw (v2),
1913  TYPE_LENGTH (value_type (v2))) != 0)
1914  error (_("virtual baseclass botch"));
1915  }
1916  else
1917  {
1918  v2 = value_copy (arg1);
1919  deprecated_set_value_type (v2, basetype);
1920  set_value_embedded_offset (v2, boffset);
1921  }
1922 
1923  if (found_baseclass)
1924  v = v2;
1925  else
1926  {
1927  do_search_struct_field (name, v2, 0,
1928  TYPE_BASECLASS (type, i),
1929  looking_for_baseclass,
1930  result_ptr, last_boffset,
1931  outermost_type);
1932  }
1933  }
1934  else if (found_baseclass)
1935  v = value_primitive_field (arg1, offset, i, type);
1936  else
1937  {
1938  do_search_struct_field (name, arg1,
1939  offset + TYPE_BASECLASS_BITPOS (type,
1940  i) / 8,
1941  basetype, looking_for_baseclass,
1942  result_ptr, last_boffset,
1943  outermost_type);
1944  }
1945 
1946  update_search_result (result_ptr, v, last_boffset,
1947  boffset, name, outermost_type);
1948  }
1949 }
1950 
1951 /* Helper function used by value_struct_elt to recurse through
1952  baseclasses. Look for a field NAME in ARG1. Search in it assuming
1953  it has (class) type TYPE. If found, return value, else return NULL.
1954 
1955  If LOOKING_FOR_BASECLASS, then instead of looking for struct
1956  fields, look for a baseclass named NAME. */
1957 
1958 static struct value *
1959 search_struct_field (const char *name, struct value *arg1,
1960  struct type *type, int looking_for_baseclass)
1961 {
1962  struct value *result = NULL;
1963  int boffset = 0;
1964 
1965  do_search_struct_field (name, arg1, 0, type, looking_for_baseclass,
1966  &result, &boffset, type);
1967  return result;
1968 }
1969 
1970 /* Helper function used by value_struct_elt to recurse through
1971  baseclasses. Look for a field NAME in ARG1. Adjust the address of
1972  ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1973  TYPE.
1974 
1975  If found, return value, else if name matched and args not return
1976  (value) -1, else return NULL. */
1977 
1978 static struct value *
1979 search_struct_method (const char *name, struct value **arg1p,
1980  struct value **args, int offset,
1981  int *static_memfuncp, struct type *type)
1982 {
1983  int i;
1984  struct value *v;
1985  int name_matched = 0;
1986  char dem_opname[64];
1987 
1988  CHECK_TYPEDEF (type);
1989  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1990  {
1991  const char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1992 
1993  /* FIXME! May need to check for ARM demangling here. */
1994  if (startswith (t_field_name, "__") ||
1995  startswith (t_field_name, "op") ||
1996  startswith (t_field_name, "type"))
1997  {
1998  if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
1999  t_field_name = dem_opname;
2000  else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2001  t_field_name = dem_opname;
2002  }
2003  if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2004  {
2005  int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2006  struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2007 
2008  name_matched = 1;
2009  check_stub_method_group (type, i);
2010  if (j > 0 && args == 0)
2011  error (_("cannot resolve overloaded method "
2012  "`%s': no arguments supplied"), name);
2013  else if (j == 0 && args == 0)
2014  {
2015  v = value_fn_field (arg1p, f, j, type, offset);
2016  if (v != NULL)
2017  return v;
2018  }
2019  else
2020  while (j >= 0)
2021  {
2022  if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2025  TYPE_FN_FIELD_ARGS (f, j), args))
2026  {
2027  if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2028  return value_virtual_fn_field (arg1p, f, j,
2029  type, offset);
2030  if (TYPE_FN_FIELD_STATIC_P (f, j)
2031  && static_memfuncp)
2032  *static_memfuncp = 1;
2033  v = value_fn_field (arg1p, f, j, type, offset);
2034  if (v != NULL)
2035  return v;
2036  }
2037  j--;
2038  }
2039  }
2040  }
2041 
2042  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2043  {
2044  int base_offset;
2045  int this_offset;
2046 
2047  if (BASETYPE_VIA_VIRTUAL (type, i))
2048  {
2049  struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2050  struct value *base_val;
2051  const gdb_byte *base_valaddr;
2052 
2053  /* The virtual base class pointer might have been
2054  clobbered by the user program. Make sure that it
2055  still points to a valid memory location. */
2056 
2057  if (offset < 0 || offset >= TYPE_LENGTH (type))
2058  {
2059  gdb_byte *tmp;
2060  struct cleanup *back_to;
2061  CORE_ADDR address;
2062 
2063  tmp = xmalloc (TYPE_LENGTH (baseclass));
2064  back_to = make_cleanup (xfree, tmp);
2065  address = value_address (*arg1p);
2066 
2067  if (target_read_memory (address + offset,
2068  tmp, TYPE_LENGTH (baseclass)) != 0)
2069  error (_("virtual baseclass botch"));
2070 
2071  base_val = value_from_contents_and_address (baseclass,
2072  tmp,
2073  address + offset);
2074  base_valaddr = value_contents_for_printing (base_val);
2075  this_offset = 0;
2076  do_cleanups (back_to);
2077  }
2078  else
2079  {
2080  base_val = *arg1p;
2081  base_valaddr = value_contents_for_printing (*arg1p);
2082  this_offset = offset;
2083  }
2084 
2085  base_offset = baseclass_offset (type, i, base_valaddr,
2086  this_offset, value_address (base_val),
2087  base_val);
2088  }
2089  else
2090  {
2091  base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2092  }
2093  v = search_struct_method (name, arg1p, args, base_offset + offset,
2094  static_memfuncp, TYPE_BASECLASS (type, i));
2095  if (v == (struct value *) - 1)
2096  {
2097  name_matched = 1;
2098  }
2099  else if (v)
2100  {
2101  /* FIXME-bothner: Why is this commented out? Why is it here? */
2102  /* *arg1p = arg1_tmp; */
2103  return v;
2104  }
2105  }
2106  if (name_matched)
2107  return (struct value *) - 1;
2108  else
2109  return NULL;
2110 }
2111 
2112 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2113  extract the component named NAME from the ultimate target
2114  structure/union and return it as a value with its appropriate type.
2115  ERR is used in the error message if *ARGP's type is wrong.
2116 
2117  C++: ARGS is a list of argument types to aid in the selection of
2118  an appropriate method. Also, handle derived types.
2119 
2120  STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2121  where the truthvalue of whether the function that was resolved was
2122  a static member function or not is stored.
2123 
2124  ERR is an error message to be printed in case the field is not
2125  found. */
2126 
2127 struct value *
2128 value_struct_elt (struct value **argp, struct value **args,
2129  const char *name, int *static_memfuncp, const char *err)
2130 {
2131  struct type *t;
2132  struct value *v;
2133 
2134  *argp = coerce_array (*argp);
2135 
2136  t = check_typedef (value_type (*argp));
2137 
2138  /* Follow pointers until we get to a non-pointer. */
2139 
2140  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2141  {
2142  *argp = value_ind (*argp);
2143  /* Don't coerce fn pointer to fn and then back again! */
2144  if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2145  *argp = coerce_array (*argp);
2146  t = check_typedef (value_type (*argp));
2147  }
2148 
2149  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2150  && TYPE_CODE (t) != TYPE_CODE_UNION)
2151  error (_("Attempt to extract a component of a value that is not a %s."),
2152  err);
2153 
2154  /* Assume it's not, unless we see that it is. */
2155  if (static_memfuncp)
2156  *static_memfuncp = 0;
2157 
2158  if (!args)
2159  {
2160  /* if there are no arguments ...do this... */
2161 
2162  /* Try as a field first, because if we succeed, there is less
2163  work to be done. */
2164  v = search_struct_field (name, *argp, t, 0);
2165  if (v)
2166  return v;
2167 
2168  /* C++: If it was not found as a data field, then try to
2169  return it as a pointer to a method. */
2170  v = search_struct_method (name, argp, args, 0,
2171  static_memfuncp, t);
2172 
2173  if (v == (struct value *) - 1)
2174  error (_("Cannot take address of method %s."), name);
2175  else if (v == 0)
2176  {
2177  if (TYPE_NFN_FIELDS (t))
2178  error (_("There is no member or method named %s."), name);
2179  else
2180  error (_("There is no member named %s."), name);
2181  }
2182  return v;
2183  }
2184 
2185  v = search_struct_method (name, argp, args, 0,
2186  static_memfuncp, t);
2187 
2188  if (v == (struct value *) - 1)
2189  {
2190  error (_("One of the arguments you tried to pass to %s could not "
2191  "be converted to what the function wants."), name);
2192  }
2193  else if (v == 0)
2194  {
2195  /* See if user tried to invoke data as function. If so, hand it
2196  back. If it's not callable (i.e., a pointer to function),
2197  gdb should give an error. */
2198  v = search_struct_field (name, *argp, t, 0);
2199  /* If we found an ordinary field, then it is not a method call.
2200  So, treat it as if it were a static member function. */
2201  if (v && static_memfuncp)
2202  *static_memfuncp = 1;
2203  }
2204 
2205  if (!v)
2207  _("Structure has no component named %s."), name);
2208  return v;
2209 }
2210 
2211 /* Given *ARGP, a value of type structure or union, or a pointer/reference
2212  to a structure or union, extract and return its component (field) of
2213  type FTYPE at the specified BITPOS.
2214  Throw an exception on error. */
2215 
2216 struct value *
2217 value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype,
2218  const char *err)
2219 {
2220  struct type *t;
2221  struct value *v;
2222  int i;
2223  int nbases;
2224 
2225  *argp = coerce_array (*argp);
2226 
2227  t = check_typedef (value_type (*argp));
2228 
2229  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2230  {
2231  *argp = value_ind (*argp);
2232  if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2233  *argp = coerce_array (*argp);
2234  t = check_typedef (value_type (*argp));
2235  }
2236 
2237  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2238  && TYPE_CODE (t) != TYPE_CODE_UNION)
2239  error (_("Attempt to extract a component of a value that is not a %s."),
2240  err);
2241 
2242  for (i = TYPE_N_BASECLASSES (t); i < TYPE_NFIELDS (t); i++)
2243  {
2244  if (!field_is_static (&TYPE_FIELD (t, i))
2245  && bitpos == TYPE_FIELD_BITPOS (t, i)
2246  && types_equal (ftype, TYPE_FIELD_TYPE (t, i)))
2247  return value_primitive_field (*argp, 0, i, t);
2248  }
2249 
2250  error (_("No field with matching bitpos and type."));
2251 
2252  /* Never hit. */
2253  return NULL;
2254 }
2255 
2256 /* Search through the methods of an object (and its bases) to find a
2257  specified method. Return the pointer to the fn_field list FN_LIST of
2258  overloaded instances defined in the source language. If available
2259  and matching, a vector of matching xmethods defined in extension
2260  languages are also returned in XM_WORKER_VEC
2261 
2262  Helper function for value_find_oload_list.
2263  ARGP is a pointer to a pointer to a value (the object).
2264  METHOD is a string containing the method name.
2265  OFFSET is the offset within the value.
2266  TYPE is the assumed type of the object.
2267  FN_LIST is the pointer to matching overloaded instances defined in
2268  source language. Since this is a recursive function, *FN_LIST
2269  should be set to NULL when calling this function.
2270  NUM_FNS is the number of overloaded instances. *NUM_FNS should be set to
2271  0 when calling this function.
2272  XM_WORKER_VEC is the vector of matching xmethod workers. *XM_WORKER_VEC
2273  should also be set to NULL when calling this function.
2274  BASETYPE is set to the actual type of the subobject where the
2275  method is found.
2276  BOFFSET is the offset of the base subobject where the method is found. */
2277 
2278 static void
2279 find_method_list (struct value **argp, const char *method,
2280  int offset, struct type *type,
2281  struct fn_field **fn_list, int *num_fns,
2282  VEC (xmethod_worker_ptr) **xm_worker_vec,
2283  struct type **basetype, int *boffset)
2284 {
2285  int i;
2286  struct fn_field *f = NULL;
2287  VEC (xmethod_worker_ptr) *worker_vec = NULL, *new_vec = NULL;
2288 
2289  gdb_assert (fn_list != NULL && xm_worker_vec != NULL);
2290  CHECK_TYPEDEF (type);
2291 
2292  /* First check in object itself.
2293  This function is called recursively to search through base classes.
2294  If there is a source method match found at some stage, then we need not
2295  look for source methods in consequent recursive calls. */
2296  if ((*fn_list) == NULL)
2297  {
2298  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2299  {
2300  /* pai: FIXME What about operators and type conversions? */
2301  const char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2302 
2303  if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2304  {
2305  int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2306  f = TYPE_FN_FIELDLIST1 (type, i);
2307  *fn_list = f;
2308 
2309  *num_fns = len;
2310  *basetype = type;
2311  *boffset = offset;
2312 
2313  /* Resolve any stub methods. */
2314  check_stub_method_group (type, i);
2315 
2316  break;
2317  }
2318  }
2319  }
2320 
2321  /* Unlike source methods, xmethods can be accumulated over successive
2322  recursive calls. In other words, an xmethod named 'm' in a class
2323  will not hide an xmethod named 'm' in its base class(es). We want
2324  it to be this way because xmethods are after all convenience functions
2325  and hence there is no point restricting them with something like method
2326  hiding. Moreover, if hiding is done for xmethods as well, then we will
2327  have to provide a mechanism to un-hide (like the 'using' construct). */
2328  worker_vec = get_matching_xmethod_workers (type, method);
2329  new_vec = VEC_merge (xmethod_worker_ptr, *xm_worker_vec, worker_vec);
2330 
2331  VEC_free (xmethod_worker_ptr, *xm_worker_vec);
2332  VEC_free (xmethod_worker_ptr, worker_vec);
2333  *xm_worker_vec = new_vec;
2334 
2335  /* If source methods are not found in current class, look for them in the
2336  base classes. We also have to go through the base classes to gather
2337  extension methods. */
2338  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2339  {
2340  int base_offset;
2341 
2342  if (BASETYPE_VIA_VIRTUAL (type, i))
2343  {
2344  base_offset = baseclass_offset (type, i,
2346  value_offset (*argp) + offset,
2347  value_address (*argp), *argp);
2348  }
2349  else /* Non-virtual base, simply use bit position from debug
2350  info. */
2351  {
2352  base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2353  }
2354 
2355  find_method_list (argp, method, base_offset + offset,
2356  TYPE_BASECLASS (type, i), fn_list, num_fns,
2357  xm_worker_vec, basetype, boffset);
2358  }
2359 }
2360 
2361 /* Return the list of overloaded methods of a specified name. The methods
2362  could be those GDB finds in the binary, or xmethod. Methods found in
2363  the binary are returned in FN_LIST, and xmethods are returned in
2364  XM_WORKER_VEC.
2365 
2366  ARGP is a pointer to a pointer to a value (the object).
2367  METHOD is the method name.
2368  OFFSET is the offset within the value contents.
2369  FN_LIST is the pointer to matching overloaded instances defined in
2370  source language.
2371  NUM_FNS is the number of overloaded instances.
2372  XM_WORKER_VEC is the vector of matching xmethod workers defined in
2373  extension languages.
2374  BASETYPE is set to the type of the base subobject that defines the
2375  method.
2376  BOFFSET is the offset of the base subobject which defines the method. */
2377 
2378 static void
2379 value_find_oload_method_list (struct value **argp, const char *method,
2380  int offset, struct fn_field **fn_list,
2381  int *num_fns,
2382  VEC (xmethod_worker_ptr) **xm_worker_vec,
2383  struct type **basetype, int *boffset)
2384 {
2385  struct type *t;
2386 
2387  t = check_typedef (value_type (*argp));
2388 
2389  /* Code snarfed from value_struct_elt. */
2390  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2391  {
2392  *argp = value_ind (*argp);
2393  /* Don't coerce fn pointer to fn and then back again! */
2394  if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
2395  *argp = coerce_array (*argp);
2396  t = check_typedef (value_type (*argp));
2397  }
2398 
2399  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2400  && TYPE_CODE (t) != TYPE_CODE_UNION)
2401  error (_("Attempt to extract a component of a "
2402  "value that is not a struct or union"));
2403 
2404  gdb_assert (fn_list != NULL && xm_worker_vec != NULL);
2405 
2406  /* Clear the lists. */
2407  *fn_list = NULL;
2408  *num_fns = 0;
2409  *xm_worker_vec = NULL;
2410 
2411  find_method_list (argp, method, 0, t, fn_list, num_fns, xm_worker_vec,
2412  basetype, boffset);
2413 }
2414 
2415 /* Given an array of arguments (ARGS) (which includes an
2416  entry for "this" in the case of C++ methods), the number of
2417  arguments NARGS, the NAME of a function, and whether it's a method or
2418  not (METHOD), find the best function that matches on the argument types
2419  according to the overload resolution rules.
2420 
2421  METHOD can be one of three values:
2422  NON_METHOD for non-member functions.
2423  METHOD: for member functions.
2424  BOTH: used for overload resolution of operators where the
2425  candidates are expected to be either member or non member
2426  functions. In this case the first argument ARGTYPES
2427  (representing 'this') is expected to be a reference to the
2428  target object, and will be dereferenced when attempting the
2429  non-member search.
2430 
2431  In the case of class methods, the parameter OBJ is an object value
2432  in which to search for overloaded methods.
2433 
2434  In the case of non-method functions, the parameter FSYM is a symbol
2435  corresponding to one of the overloaded functions.
2436 
2437  Return value is an integer: 0 -> good match, 10 -> debugger applied
2438  non-standard coercions, 100 -> incompatible.
2439 
2440  If a method is being searched for, VALP will hold the value.
2441  If a non-method is being searched for, SYMP will hold the symbol
2442  for it.
2443 
2444  If a method is being searched for, and it is a static method,
2445  then STATICP will point to a non-zero value.
2446 
2447  If NO_ADL argument dependent lookup is disabled. This is used to prevent
2448  ADL overload candidates when performing overload resolution for a fully
2449  qualified name.
2450 
2451  If NOSIDE is EVAL_AVOID_SIDE_EFFECTS, then OBJP's memory cannot be
2452  read while picking the best overload match (it may be all zeroes and thus
2453  not have a vtable pointer), in which case skip virtual function lookup.
2454  This is ok as typically EVAL_AVOID_SIDE_EFFECTS is only used to determine
2455  the result type.
2456 
2457  Note: This function does *not* check the value of
2458  overload_resolution. Caller must check it to see whether overload
2459  resolution is permitted. */
2460 
2461 int
2462 find_overload_match (struct value **args, int nargs,
2463  const char *name, enum oload_search_type method,
2464  struct value **objp, struct symbol *fsym,
2465  struct value **valp, struct symbol **symp,
2466  int *staticp, const int no_adl,
2467  const enum noside noside)
2468 {
2469  struct value *obj = (objp ? *objp : NULL);
2470  struct type *obj_type = obj ? value_type (obj) : NULL;
2471  /* Index of best overloaded function. */
2472  int func_oload_champ = -1;
2473  int method_oload_champ = -1;
2474  int src_method_oload_champ = -1;
2475  int ext_method_oload_champ = -1;
2476  int src_and_ext_equal = 0;
2477 
2478  /* The measure for the current best match. */
2479  struct badness_vector *method_badness = NULL;
2480  struct badness_vector *func_badness = NULL;
2481  struct badness_vector *ext_method_badness = NULL;
2482  struct badness_vector *src_method_badness = NULL;
2483 
2484  struct value *temp = obj;
2485  /* For methods, the list of overloaded methods. */
2486  struct fn_field *fns_ptr = NULL;
2487  /* For non-methods, the list of overloaded function symbols. */
2488  struct symbol **oload_syms = NULL;
2489  /* For xmethods, the VEC of xmethod workers. */
2490  VEC (xmethod_worker_ptr) *xm_worker_vec = NULL;
2491  /* Number of overloaded instances being considered. */
2492  int num_fns = 0;
2493  struct type *basetype = NULL;
2494  int boffset;
2495 
2496  struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);
2497 
2498  const char *obj_type_name = NULL;
2499  const char *func_name = NULL;
2500  enum oload_classification match_quality;
2501  enum oload_classification method_match_quality = INCOMPATIBLE;
2502  enum oload_classification src_method_match_quality = INCOMPATIBLE;
2503  enum oload_classification ext_method_match_quality = INCOMPATIBLE;
2504  enum oload_classification func_match_quality = INCOMPATIBLE;
2505 
2506  /* Get the list of overloaded methods or functions. */
2507  if (method == METHOD || method == BOTH)
2508  {
2509  gdb_assert (obj);
2510 
2511  /* OBJ may be a pointer value rather than the object itself. */
2512  obj = coerce_ref (obj);
2513  while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
2514  obj = coerce_ref (value_ind (obj));
2515  obj_type_name = TYPE_NAME (value_type (obj));
2516 
2517  /* First check whether this is a data member, e.g. a pointer to
2518  a function. */
2519  if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
2520  {
2521  *valp = search_struct_field (name, obj,
2522  check_typedef (value_type (obj)), 0);
2523  if (*valp)
2524  {
2525  *staticp = 1;
2526  do_cleanups (all_cleanups);
2527  return 0;
2528  }
2529  }
2530 
2531  /* Retrieve the list of methods with the name NAME. */
2532  value_find_oload_method_list (&temp, name, 0, &fns_ptr, &num_fns,
2533  &xm_worker_vec, &basetype, &boffset);
2534  /* If this is a method only search, and no methods were found
2535  the search has faild. */
2536  if (method == METHOD && (!fns_ptr || !num_fns) && !xm_worker_vec)
2537  error (_("Couldn't find method %s%s%s"),
2538  obj_type_name,
2539  (obj_type_name && *obj_type_name) ? "::" : "",
2540  name);
2541  /* If we are dealing with stub method types, they should have
2542  been resolved by find_method_list via
2543  value_find_oload_method_list above. */
2544  if (fns_ptr)
2545  {
2546  gdb_assert (TYPE_SELF_TYPE (fns_ptr[0].type) != NULL);
2547 
2548  src_method_oload_champ = find_oload_champ (args, nargs,
2549  num_fns, fns_ptr, NULL,
2550  NULL, &src_method_badness);
2551 
2552  src_method_match_quality = classify_oload_match
2553  (src_method_badness, nargs,
2554  oload_method_static_p (fns_ptr, src_method_oload_champ));
2555 
2556  make_cleanup (xfree, src_method_badness);
2557  }
2558 
2559  if (VEC_length (xmethod_worker_ptr, xm_worker_vec) > 0)
2560  {
2561  ext_method_oload_champ = find_oload_champ (args, nargs,
2562  0, NULL, xm_worker_vec,
2563  NULL, &ext_method_badness);
2564  ext_method_match_quality = classify_oload_match (ext_method_badness,
2565  nargs, 0);
2566  make_cleanup (xfree, ext_method_badness);
2567  make_cleanup (free_xmethod_worker_vec, xm_worker_vec);
2568  }
2569 
2570  if (src_method_oload_champ >= 0 && ext_method_oload_champ >= 0)
2571  {
2572  switch (compare_badness (ext_method_badness, src_method_badness))
2573  {
2574  case 0: /* Src method and xmethod are equally good. */
2575  src_and_ext_equal = 1;
2576  /* If src method and xmethod are equally good, then
2577  xmethod should be the winner. Hence, fall through to the
2578  case where a xmethod is better than the source
2579  method, except when the xmethod match quality is
2580  non-standard. */
2581  /* FALLTHROUGH */
2582  case 1: /* Src method and ext method are incompatible. */
2583  /* If ext method match is not standard, then let source method
2584  win. Otherwise, fallthrough to let xmethod win. */
2585  if (ext_method_match_quality != STANDARD)
2586  {
2587  method_oload_champ = src_method_oload_champ;
2588  method_badness = src_method_badness;
2589  ext_method_oload_champ = -1;
2590  method_match_quality = src_method_match_quality;
2591  break;
2592  }
2593  /* FALLTHROUGH */
2594  case 2: /* Ext method is champion. */
2595  method_oload_champ = ext_method_oload_champ;
2596  method_badness = ext_method_badness;
2597  src_method_oload_champ = -1;
2598  method_match_quality = ext_method_match_quality;
2599  break;
2600  case 3: /* Src method is champion. */
2601  method_oload_champ = src_method_oload_champ;
2602  method_badness = src_method_badness;
2603  ext_method_oload_champ = -1;
2604  method_match_quality = src_method_match_quality;
2605  break;
2606  default:
2607  gdb_assert_not_reached ("Unexpected overload comparison "
2608  "result");
2609  break;
2610  }
2611  }
2612  else if (src_method_oload_champ >= 0)
2613  {
2614  method_oload_champ = src_method_oload_champ;
2615  method_badness = src_method_badness;
2616  method_match_quality = src_method_match_quality;
2617  }
2618  else if (ext_method_oload_champ >= 0)
2619  {
2620  method_oload_champ = ext_method_oload_champ;
2621  method_badness = ext_method_badness;
2622  method_match_quality = ext_method_match_quality;
2623  }
2624  }
2625 
2626  if (method == NON_METHOD || method == BOTH)
2627  {
2628  const char *qualified_name = NULL;
2629 
2630  /* If the overload match is being search for both as a method
2631  and non member function, the first argument must now be
2632  dereferenced. */
2633  if (method == BOTH)
2634  args[0] = value_ind (args[0]);
2635 
2636  if (fsym)
2637  {
2638  qualified_name = SYMBOL_NATURAL_NAME (fsym);
2639 
2640  /* If we have a function with a C++ name, try to extract just
2641  the function part. Do not try this for non-functions (e.g.
2642  function pointers). */
2643  if (qualified_name
2644  && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym)))
2645  == TYPE_CODE_FUNC)
2646  {
2647  char *temp;
2648 
2649  temp = cp_func_name (qualified_name);
2650 
2651  /* If cp_func_name did not remove anything, the name of the
2652  symbol did not include scope or argument types - it was
2653  probably a C-style function. */
2654  if (temp)
2655  {
2656  make_cleanup (xfree, temp);
2657  if (strcmp (temp, qualified_name) == 0)
2658  func_name = NULL;
2659  else
2660  func_name = temp;
2661  }
2662  }
2663  }
2664  else
2665  {
2666  func_name = name;
2667  qualified_name = name;
2668  }
2669 
2670  /* If there was no C++ name, this must be a C-style function or
2671  not a function at all. Just return the same symbol. Do the
2672  same if cp_func_name fails for some reason. */
2673  if (func_name == NULL)
2674  {
2675  *symp = fsym;
2676  do_cleanups (all_cleanups);
2677  return 0;
2678  }
2679 
2680  func_oload_champ = find_oload_champ_namespace (args, nargs,
2681  func_name,
2682  qualified_name,
2683  &oload_syms,
2684  &func_badness,
2685  no_adl);
2686 
2687  if (func_oload_champ >= 0)
2688  func_match_quality = classify_oload_match (func_badness, nargs, 0);
2689 
2690  make_cleanup (xfree, oload_syms);
2691  make_cleanup (xfree, func_badness);
2692  }
2693 
2694  /* Did we find a match ? */
2695  if (method_oload_champ == -1 && func_oload_champ == -1)
2697  _("No symbol \"%s\" in current context."),
2698  name);
2699 
2700  /* If we have found both a method match and a function
2701  match, find out which one is better, and calculate match
2702  quality. */
2703  if (method_oload_champ >= 0 && func_oload_champ >= 0)
2704  {
2705  switch (compare_badness (func_badness, method_badness))
2706  {
2707  case 0: /* Top two contenders are equally good. */
2708  /* FIXME: GDB does not support the general ambiguous case.
2709  All candidates should be collected and presented the
2710  user. */
2711  error (_("Ambiguous overload resolution"));
2712  break;
2713  case 1: /* Incomparable top contenders. */
2714  /* This is an error incompatible candidates
2715  should not have been proposed. */
2716  error (_("Internal error: incompatible "
2717  "overload candidates proposed"));
2718  break;
2719  case 2: /* Function champion. */
2720  method_oload_champ = -1;
2721  match_quality = func_match_quality;
2722  break;
2723  case 3: /* Method champion. */
2724  func_oload_champ = -1;
2725  match_quality = method_match_quality;
2726  break;
2727  default:
2728  error (_("Internal error: unexpected overload comparison result"));
2729  break;
2730  }
2731  }
2732  else
2733  {
2734  /* We have either a method match or a function match. */
2735  if (method_oload_champ >= 0)
2736  match_quality = method_match_quality;
2737  else
2738  match_quality = func_match_quality;
2739  }
2740 
2741  if (match_quality == INCOMPATIBLE)
2742  {
2743  if (method == METHOD)
2744  error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2745  obj_type_name,
2746  (obj_type_name && *obj_type_name) ? "::" : "",
2747  name);
2748  else
2749  error (_("Cannot resolve function %s to any overloaded instance"),
2750  func_name);
2751  }
2752  else if (match_quality == NON_STANDARD)
2753  {
2754  if (method == METHOD)
2755  warning (_("Using non-standard conversion to match "
2756  "method %s%s%s to supplied arguments"),
2757  obj_type_name,
2758  (obj_type_name && *obj_type_name) ? "::" : "",
2759  name);
2760  else
2761  warning (_("Using non-standard conversion to match "
2762  "function %s to supplied arguments"),
2763  func_name);
2764  }
2765 
2766  if (staticp != NULL)
2767  *staticp = oload_method_static_p (fns_ptr, method_oload_champ);
2768 
2769  if (method_oload_champ >= 0)
2770  {
2771  if (src_method_oload_champ >= 0)
2772  {
2773  if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ)
2774  && noside != EVAL_AVOID_SIDE_EFFECTS)
2775  {
2776  *valp = value_virtual_fn_field (&temp, fns_ptr,
2777  method_oload_champ, basetype,
2778  boffset);
2779  }
2780  else
2781  *valp = value_fn_field (&temp, fns_ptr, method_oload_champ,
2782  basetype, boffset);
2783  }
2784  else
2785  {
2787  (VEC_index (xmethod_worker_ptr, xm_worker_vec,
2788  ext_method_oload_champ)));
2789  }
2790  }
2791  else
2792  *symp = oload_syms[func_oload_champ];
2793 
2794  if (objp)
2795  {
2796  struct type *temp_type = check_typedef (value_type (temp));
2797  struct type *objtype = check_typedef (obj_type);
2798 
2799  if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
2800  && (TYPE_CODE (objtype) == TYPE_CODE_PTR
2801  || TYPE_CODE (objtype) == TYPE_CODE_REF))
2802  {
2803  temp = value_addr (temp);
2804  }
2805  *objp = temp;
2806  }
2807 
2808  do_cleanups (all_cleanups);
2809 
2810  switch (match_quality)
2811  {
2812  case INCOMPATIBLE:
2813  return 100;
2814  case NON_STANDARD:
2815  return 10;
2816  default: /* STANDARD */
2817  return 0;
2818  }
2819 }
2820 
2821 /* Find the best overload match, searching for FUNC_NAME in namespaces
2822  contained in QUALIFIED_NAME until it either finds a good match or
2823  runs out of namespaces. It stores the overloaded functions in
2824  *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV. The
2825  calling function is responsible for freeing *OLOAD_SYMS and
2826  *OLOAD_CHAMP_BV. If NO_ADL, argument dependent lookup is not
2827  performned. */
2828 
2829 static int
2830 find_oload_champ_namespace (struct value **args, int nargs,
2831  const char *func_name,
2832  const char *qualified_name,
2833  struct symbol ***oload_syms,
2834  struct badness_vector **oload_champ_bv,
2835  const int no_adl)
2836 {
2837  int oload_champ;
2838 
2839  find_oload_champ_namespace_loop (args, nargs,
2840  func_name,
2841  qualified_name, 0,
2842  oload_syms, oload_champ_bv,
2843  &oload_champ,
2844  no_adl);
2845 
2846  return oload_champ;
2847 }
2848 
2849 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2850  how deep we've looked for namespaces, and the champ is stored in
2851  OLOAD_CHAMP. The return value is 1 if the champ is a good one, 0
2852  if it isn't. Other arguments are the same as in
2853  find_oload_champ_namespace
2854 
2855  It is the caller's responsibility to free *OLOAD_SYMS and
2856  *OLOAD_CHAMP_BV. */
2857 
2858 static int
2859 find_oload_champ_namespace_loop (struct value **args, int nargs,
2860  const char *func_name,
2861  const char *qualified_name,
2862  int namespace_len,
2863  struct symbol ***oload_syms,
2864  struct badness_vector **oload_champ_bv,
2865  int *oload_champ,
2866  const int no_adl)
2867 {
2868  int next_namespace_len = namespace_len;
2869  int searched_deeper = 0;
2870  int num_fns = 0;
2871  struct cleanup *old_cleanups;
2872  int new_oload_champ;
2873  struct symbol **new_oload_syms;
2874  struct badness_vector *new_oload_champ_bv;
2875  char *new_namespace;
2876 
2877  if (next_namespace_len != 0)
2878  {
2879  gdb_assert (qualified_name[next_namespace_len] == ':');
2880  next_namespace_len += 2;
2881  }
2882  next_namespace_len +=
2883  cp_find_first_component (qualified_name + next_namespace_len);
2884 
2885  /* Initialize these to values that can safely be xfree'd. */
2886  *oload_syms = NULL;
2887  *oload_champ_bv = NULL;
2888 
2889  /* First, see if we have a deeper namespace we can search in.
2890  If we get a good match there, use it. */
2891 
2892  if (qualified_name[next_namespace_len] == ':')
2893  {
2894  searched_deeper = 1;
2895 
2896  if (find_oload_champ_namespace_loop (args, nargs,
2897  func_name, qualified_name,
2898  next_namespace_len,
2899  oload_syms, oload_champ_bv,
2900  oload_champ, no_adl))
2901  {
2902  return 1;
2903  }
2904  };
2905 
2906  /* If we reach here, either we're in the deepest namespace or we
2907  didn't find a good match in a deeper namespace. But, in the
2908  latter case, we still have a bad match in a deeper namespace;
2909  note that we might not find any match at all in the current
2910  namespace. (There's always a match in the deepest namespace,
2911  because this overload mechanism only gets called if there's a
2912  function symbol to start off with.) */
2913 
2914  old_cleanups = make_cleanup (xfree, *oload_syms);
2915  make_cleanup (xfree, *oload_champ_bv);
2916  new_namespace = alloca (namespace_len + 1);
2917  strncpy (new_namespace, qualified_name, namespace_len);
2918  new_namespace[namespace_len] = '\0';
2919  new_oload_syms = make_symbol_overload_list (func_name,
2920  new_namespace);
2921 
2922  /* If we have reached the deepest level perform argument
2923  determined lookup. */
2924  if (!searched_deeper && !no_adl)
2925  {
2926  int ix;
2927  struct type **arg_types;
2928 
2929  /* Prepare list of argument types for overload resolution. */
2930  arg_types = (struct type **)
2931  alloca (nargs * (sizeof (struct type *)));
2932  for (ix = 0; ix < nargs; ix++)
2933  arg_types[ix] = value_type (args[ix]);
2934  make_symbol_overload_list_adl (arg_types, nargs, func_name);
2935  }
2936 
2937  while (new_oload_syms[num_fns])
2938  ++num_fns;
2939 
2940  new_oload_champ = find_oload_champ (args, nargs, num_fns,
2941  NULL, NULL, new_oload_syms,
2942  &new_oload_champ_bv);
2943 
2944  /* Case 1: We found a good match. Free earlier matches (if any),
2945  and return it. Case 2: We didn't find a good match, but we're
2946  not the deepest function. Then go with the bad match that the
2947  deeper function found. Case 3: We found a bad match, and we're
2948  the deepest function. Then return what we found, even though
2949  it's a bad match. */
2950 
2951  if (new_oload_champ != -1
2952  && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2953  {
2954  *oload_syms = new_oload_syms;
2955  *oload_champ = new_oload_champ;
2956  *oload_champ_bv = new_oload_champ_bv;
2957  do_cleanups (old_cleanups);
2958  return 1;
2959  }
2960  else if (searched_deeper)
2961  {
2962  xfree (new_oload_syms);
2963  xfree (new_oload_champ_bv);
2964  discard_cleanups (old_cleanups);
2965  return 0;
2966  }
2967  else
2968  {
2969  *oload_syms = new_oload_syms;
2970  *oload_champ = new_oload_champ;
2971  *oload_champ_bv = new_oload_champ_bv;
2972  do_cleanups (old_cleanups);
2973  return 0;
2974  }
2975 }
2976 
2977 /* Look for a function to take NARGS args of ARGS. Find
2978  the best match from among the overloaded methods or functions
2979  given by FNS_PTR or OLOAD_SYMS or XM_WORKER_VEC, respectively.
2980  One, and only one of FNS_PTR, OLOAD_SYMS and XM_WORKER_VEC can be
2981  non-NULL.
2982 
2983  If XM_WORKER_VEC is NULL, then the length of the arrays FNS_PTR
2984  or OLOAD_SYMS (whichever is non-NULL) is specified in NUM_FNS.
2985 
2986  Return the index of the best match; store an indication of the
2987  quality of the match in OLOAD_CHAMP_BV.
2988 
2989  It is the caller's responsibility to free *OLOAD_CHAMP_BV. */
2990 
2991 static int
2992 find_oload_champ (struct value **args, int nargs,
2993  int num_fns, struct fn_field *fns_ptr,
2994  VEC (xmethod_worker_ptr) *xm_worker_vec,
2995  struct symbol **oload_syms,
2996  struct badness_vector **oload_champ_bv)
2997 {
2998  int ix;
2999  int fn_count;
3000  int xm_worker_vec_n = VEC_length (xmethod_worker_ptr, xm_worker_vec);
3001  /* A measure of how good an overloaded instance is. */
3002  struct badness_vector *bv;
3003  /* Index of best overloaded function. */
3004  int oload_champ = -1;
3005  /* Current ambiguity state for overload resolution. */
3006  int oload_ambiguous = 0;
3007  /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs. */
3008 
3009  /* A champion can be found among methods alone, or among functions
3010  alone, or in xmethods alone, but not in more than one of these
3011  groups. */
3012  gdb_assert ((fns_ptr != NULL) + (oload_syms != NULL) + (xm_worker_vec != NULL)
3013  == 1);
3014 
3015  *oload_champ_bv = NULL;
3016 
3017  fn_count = (xm_worker_vec != NULL
3018  ? VEC_length (xmethod_worker_ptr, xm_worker_vec)
3019  : num_fns);
3020  /* Consider each candidate in turn. */
3021  for (ix = 0; ix < fn_count; ix++)
3022  {
3023  int jj;
3024  int static_offset = 0;
3025  int nparms;
3026  struct type **parm_types;
3027  struct xmethod_worker *worker = NULL;
3028 
3029  if (xm_worker_vec != NULL)
3030  {
3031  worker = VEC_index (xmethod_worker_ptr, xm_worker_vec, ix);
3032  parm_types = get_xmethod_arg_types (worker, &nparms);
3033  }
3034  else
3035  {
3036  if (fns_ptr != NULL)
3037  {
3038  nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
3039  static_offset = oload_method_static_p (fns_ptr, ix);
3040  }
3041  else
3042  nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
3043 
3044  parm_types = (struct type **)
3045  xmalloc (nparms * (sizeof (struct type *)));
3046  for (jj = 0; jj < nparms; jj++)
3047  parm_types[jj] = (fns_ptr != NULL
3048  ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
3049  : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
3050  jj));
3051  }
3052 
3053  /* Compare parameter types to supplied argument types. Skip
3054  THIS for static methods. */
3055  bv = rank_function (parm_types, nparms,
3056  args + static_offset,
3057  nargs - static_offset);
3058 
3059  if (!*oload_champ_bv)
3060  {
3061  *oload_champ_bv = bv;
3062  oload_champ = 0;
3063  }
3064  else /* See whether current candidate is better or worse than
3065  previous best. */
3066  switch (compare_badness (bv, *oload_champ_bv))
3067  {
3068  case 0: /* Top two contenders are equally good. */
3069  oload_ambiguous = 1;
3070  break;
3071  case 1: /* Incomparable top contenders. */
3072  oload_ambiguous = 2;
3073  break;
3074  case 2: /* New champion, record details. */
3075  *oload_champ_bv = bv;
3076  oload_ambiguous = 0;
3077  oload_champ = ix;
3078  break;
3079  case 3:
3080  default:
3081  break;
3082  }
3083  xfree (parm_types);
3084  if (overload_debug)
3085  {
3086  if (fns_ptr != NULL)
3088  "Overloaded method instance %s, # of parms %d\n",
3089  fns_ptr[ix].physname, nparms);
3090  else if (xm_worker_vec != NULL)
3092  "Xmethod worker, # of parms %d\n",
3093  nparms);
3094  else
3096  "Overloaded function instance "
3097  "%s # of parms %d\n",
3098  SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
3099  nparms);
3100  for (jj = 0; jj < nargs - static_offset; jj++)
3102  "...Badness @ %d : %d\n",
3103  jj, bv->rank[jj].rank);
3104  fprintf_filtered (gdb_stderr, "Overload resolution "
3105  "champion is %d, ambiguous? %d\n",
3106  oload_champ, oload_ambiguous);
3107  }
3108  }
3109 
3110  return oload_champ;
3111 }
3112 
3113 /* Return 1 if we're looking at a static method, 0 if we're looking at
3114  a non-static method or a function that isn't a method. */
3115 
3116 static int
3117 oload_method_static_p (struct fn_field *fns_ptr, int index)
3118 {
3119  if (fns_ptr && index >= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
3120  return 1;
3121  else
3122  return 0;
3123 }
3124 
3125 /* Check how good an overload match OLOAD_CHAMP_BV represents. */
3126 
3127 static enum oload_classification
3128 classify_oload_match (struct badness_vector *oload_champ_bv,
3129  int nargs,
3130  int static_offset)
3131 {
3132  int ix;
3133  enum oload_classification worst = STANDARD;
3134 
3135  for (ix = 1; ix <= nargs - static_offset; ix++)
3136  {
3137  /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3138  or worse return INCOMPATIBLE. */
3139  if (compare_ranks (oload_champ_bv->rank[ix],
3141  return INCOMPATIBLE; /* Truly mismatched types. */
3142  /* Otherwise If this conversion is as bad as
3143  NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD. */
3144  else if (compare_ranks (oload_champ_bv->rank[ix],
3146  worst = NON_STANDARD; /* Non-standard type conversions
3147  needed. */
3148  }
3149 
3150  /* If no INCOMPATIBLE classification was found, return the worst one
3151  that was found (if any). */
3152  return worst;
3153 }
3154 
3155 /* C++: return 1 is NAME is a legitimate name for the destructor of
3156  type TYPE. If TYPE does not have a destructor, or if NAME is
3157  inappropriate for TYPE, an error is signaled. Parameter TYPE should not yet
3158  have CHECK_TYPEDEF applied, this function will apply it itself. */
3159 
3160 int
3161 destructor_name_p (const char *name, struct type *type)
3162 {
3163  if (name[0] == '~')
3164  {
3165  const char *dname = type_name_no_tag_or_error (type);
3166  const char *cp = strchr (dname, '<');
3167  unsigned int len;
3168 
3169  /* Do not compare the template part for template classes. */
3170  if (cp == NULL)
3171  len = strlen (dname);
3172  else
3173  len = cp - dname;
3174  if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
3175  error (_("name of destructor must equal name of class"));
3176  else
3177  return 1;
3178  }
3179  return 0;
3180 }
3181 
3182 /* Find an enum constant named NAME in TYPE. TYPE must be an "enum
3183  class". If the name is found, return a value representing it;
3184  otherwise throw an exception. */
3185 
3186 static struct value *
3187 enum_constant_from_type (struct type *type, const char *name)
3188 {
3189  int i;
3190  int name_len = strlen (name);
3191 
3193  && TYPE_DECLARED_CLASS (type));
3194 
3195  for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i)
3196  {
3197  const char *fname = TYPE_FIELD_NAME (type, i);
3198  int len;
3199 
3201  || fname == NULL)
3202  continue;
3203 
3204  /* Look for the trailing "::NAME", since enum class constant
3205  names are qualified here. */
3206  len = strlen (fname);
3207  if (len + 2 >= name_len
3208  && fname[len - name_len - 2] == ':'
3209  && fname[len - name_len - 1] == ':'
3210  && strcmp (&fname[len - name_len], name) == 0)
3211  return value_from_longest (type, TYPE_FIELD_ENUMVAL (type, i));
3212  }
3213 
3214  error (_("no constant named \"%s\" in enum \"%s\""),
3215  name, TYPE_TAG_NAME (type));
3216 }
3217 
3218 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3219  return the appropriate member (or the address of the member, if
3220  WANT_ADDRESS). This function is used to resolve user expressions
3221  of the form "DOMAIN::NAME". For more details on what happens, see
3222  the comment before value_struct_elt_for_reference. */
3223 
3224 struct value *
3225 value_aggregate_elt (struct type *curtype, const char *name,
3226  struct type *expect_type, int want_address,
3227  enum noside noside)
3228 {
3229  switch (TYPE_CODE (curtype))
3230  {
3231  case TYPE_CODE_STRUCT:
3232  case TYPE_CODE_UNION:
3233  return value_struct_elt_for_reference (curtype, 0, curtype,
3234  name, expect_type,
3235  want_address, noside);
3236  case TYPE_CODE_NAMESPACE:
3237  return value_namespace_elt (curtype, name,
3238  want_address, noside);
3239 
3240  case TYPE_CODE_ENUM:
3241  return enum_constant_from_type (curtype, name);
3242 
3243  default:
3244  internal_error (__FILE__, __LINE__,
3245  _("non-aggregate type in value_aggregate_elt"));
3246  }
3247 }
3248 
3249 /* Compares the two method/function types T1 and T2 for "equality"
3250  with respect to the methods' parameters. If the types of the
3251  two parameter lists are the same, returns 1; 0 otherwise. This
3252  comparison may ignore any artificial parameters in T1 if
3253  SKIP_ARTIFICIAL is non-zero. This function will ALWAYS skip
3254  the first artificial parameter in T1, assumed to be a 'this' pointer.
3255 
3256  The type T2 is expected to have come from make_params (in eval.c). */
3257 
3258 static int
3259 compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
3260 {
3261  int start = 0;
3262 
3263  if (TYPE_NFIELDS (t1) > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0))
3264  ++start;
3265 
3266  /* If skipping artificial fields, find the first real field
3267  in T1. */
3268  if (skip_artificial)
3269  {
3270  while (start < TYPE_NFIELDS (t1)
3271  && TYPE_FIELD_ARTIFICIAL (t1, start))
3272  ++start;
3273  }
3274 
3275  /* Now compare parameters. */
3276 
3277  /* Special case: a method taking void. T1 will contain no
3278  non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
3279  if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
3280  && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
3281  return 1;
3282 
3283  if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
3284  {
3285  int i;
3286 
3287  for (i = 0; i < TYPE_NFIELDS (t2); ++i)
3288  {
3289  if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
3290  TYPE_FIELD_TYPE (t2, i), NULL),
3291  EXACT_MATCH_BADNESS) != 0)
3292  return 0;
3293  }
3294 
3295  return 1;
3296  }
3297 
3298  return 0;
3299 }
3300 
3301 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3302  return the address of this member as a "pointer to member" type.
3303  If INTYPE is non-null, then it will be the type of the member we
3304  are looking for. This will help us resolve "pointers to member
3305  functions". This function is used to resolve user expressions of
3306  the form "DOMAIN::NAME". */
3307 
3308 static struct value *
3309 value_struct_elt_for_reference (struct type *domain, int offset,
3310  struct type *curtype, const char *name,
3311  struct type *intype,
3312  int want_address,
3313  enum noside noside)
3314 {
3315  struct type *t = curtype;
3316  int i;
3317  struct value *v, *result;
3318 
3319  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3320  && TYPE_CODE (t) != TYPE_CODE_UNION)
3321  error (_("Internal error: non-aggregate type "
3322  "to value_struct_elt_for_reference"));
3323 
3324  for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3325  {
3326  const char *t_field_name = TYPE_FIELD_NAME (t, i);
3327 
3328  if (t_field_name && strcmp (t_field_name, name) == 0)
3329  {
3330  if (field_is_static (&TYPE_FIELD (t, i)))
3331  {
3332  v = value_static_field (t, i);
3333  if (want_address)
3334  v = value_addr (v);
3335  return v;
3336  }
3337  if (TYPE_FIELD_PACKED (t, i))
3338  error (_("pointers to bitfield members not allowed"));
3339 
3340  if (want_address)
3341  return value_from_longest
3342  (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
3343  offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3344  else if (noside != EVAL_NORMAL)
3345  return allocate_value (TYPE_FIELD_TYPE (t, i));
3346  else
3347  {
3348  /* Try to evaluate NAME as a qualified name with implicit
3349  this pointer. In this case, attempt to return the
3350  equivalent to `this->*(&TYPE::NAME)'. */
3352  if (v != NULL)
3353  {
3354  struct value *ptr;
3355  long mem_offset;
3356  struct type *type, *tmp;
3357 
3358  ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
3359  type = check_typedef (value_type (ptr));
3360  gdb_assert (type != NULL
3361  && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR);
3362  tmp = lookup_pointer_type (TYPE_SELF_TYPE (type));
3363  v = value_cast_pointers (tmp, v, 1);
3364  mem_offset = value_as_long (ptr);
3365  tmp = lookup_pointer_type (TYPE_TARGET_TYPE (type));
3366  result = value_from_pointer (tmp,
3367  value_as_long (v) + mem_offset);
3368  return value_ind (result);
3369  }
3370 
3371  error (_("Cannot reference non-static field \"%s\""), name);
3372  }
3373  }
3374  }
3375 
3376  /* C++: If it was not found as a data field, then try to return it
3377  as a pointer to a method. */
3378 
3379  /* Perform all necessary dereferencing. */
3380  while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3381  intype = TYPE_TARGET_TYPE (intype);
3382 
3383  for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3384  {
3385  const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3386  char dem_opname[64];
3387 
3388  if (startswith (t_field_name, "__")
3389  || startswith (t_field_name, "op")
3390  || startswith (t_field_name, "type"))
3391  {
3392  if (cplus_demangle_opname (t_field_name,
3393  dem_opname, DMGL_ANSI))
3394  t_field_name = dem_opname;
3395  else if (cplus_demangle_opname (t_field_name,
3396  dem_opname, 0))
3397  t_field_name = dem_opname;
3398  }
3399  if (t_field_name && strcmp (t_field_name, name) == 0)
3400  {
3401  int j;
3402  int len = TYPE_FN_FIELDLIST_LENGTH (t, i);
3403  struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3404 
3405  check_stub_method_group (t, i);
3406 
3407  if (intype)
3408  {
3409  for (j = 0; j < len; ++j)
3410  {
3411  if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
3413  intype, 1))
3414  break;
3415  }
3416 
3417  if (j == len)
3418  error (_("no member function matches "
3419  "that type instantiation"));
3420  }
3421  else
3422  {
3423  int ii;
3424 
3425  j = -1;
3426  for (ii = 0; ii < len; ++ii)
3427  {
3428  /* Skip artificial methods. This is necessary if,
3429  for example, the user wants to "print
3430  subclass::subclass" with only one user-defined
3431  constructor. There is no ambiguity in this case.
3432  We are careful here to allow artificial methods
3433  if they are the unique result. */
3434  if (TYPE_FN_FIELD_ARTIFICIAL (f, ii))
3435  {
3436  if (j == -1)
3437  j = ii;
3438  continue;
3439  }
3440 
3441  /* Desired method is ambiguous if more than one
3442  method is defined. */
3443  if (j != -1 && !TYPE_FN_FIELD_ARTIFICIAL (f, j))
3444  error (_("non-unique member `%s' requires "
3445  "type instantiation"), name);
3446 
3447  j = ii;
3448  }
3449 
3450  if (j == -1)
3451  error (_("no matching member function"));
3452  }
3453 
3454  if (TYPE_FN_FIELD_STATIC_P (f, j))
3455  {
3456  struct symbol *s =
3458  0, VAR_DOMAIN, 0);
3459 
3460  if (s == NULL)
3461  return NULL;
3462 
3463  if (want_address)
3464  return value_addr (read_var_value (s, 0));
3465  else
3466  return read_var_value (s, 0);
3467  }
3468 
3469  if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3470  {
3471  if (want_address)
3472  {
3473  result = allocate_value
3476  value_contents_writeable (result),
3477  TYPE_FN_FIELD_VOFFSET (f, j), 1);
3478  }
3479  else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3480  return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
3481  else
3482  error (_("Cannot reference virtual member function \"%s\""),
3483  name);
3484  }
3485  else
3486  {
3487  struct symbol *s =
3489  0, VAR_DOMAIN, 0);
3490 
3491  if (s == NULL)
3492  return NULL;
3493 
3494  v = read_var_value (s, 0);
3495  if (!want_address)
3496  result = v;
3497  else
3498  {
3501  value_contents_writeable (result),
3502  value_address (v), 0);
3503  }
3504  }
3505  return result;
3506  }
3507  }
3508  for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3509  {
3510  struct value *v;
3511  int base_offset;
3512 
3513  if (BASETYPE_VIA_VIRTUAL (t, i))
3514  base_offset = 0;
3515  else
3516  base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3517  v = value_struct_elt_for_reference (domain,
3518  offset + base_offset,
3519  TYPE_BASECLASS (t, i),
3520  name, intype,
3521  want_address, noside);
3522  if (v)
3523  return v;
3524  }
3525 
3526  /* As a last chance, pretend that CURTYPE is a namespace, and look
3527  it up that way; this (frequently) works for types nested inside
3528  classes. */
3529 
3530  return value_maybe_namespace_elt (curtype, name,
3531  want_address, noside);
3532 }
3533 
3534 /* C++: Return the member NAME of the namespace given by the type
3535  CURTYPE. */
3536 
3537 static struct value *
3538 value_namespace_elt (const struct type *curtype,
3539  const char *name, int want_address,
3540  enum noside noside)
3541 {
3542  struct value *retval = value_maybe_namespace_elt (curtype, name,
3543  want_address,
3544  noside);
3545 
3546  if (retval == NULL)
3547  error (_("No symbol \"%s\" in namespace \"%s\"."),
3548  name, TYPE_TAG_NAME (curtype));
3549 
3550  return retval;
3551 }
3552 
3553 /* A helper function used by value_namespace_elt and
3554  value_struct_elt_for_reference. It looks up NAME inside the
3555  context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3556  is a class and NAME refers to a type in CURTYPE itself (as opposed
3557  to, say, some base class of CURTYPE). */
3558 
3559 static struct value *
3560 value_maybe_namespace_elt (const struct type *curtype,
3561  const char *name, int want_address,
3562  enum noside noside)
3563 {
3564  const char *namespace_name = TYPE_TAG_NAME (curtype);
3565  struct symbol *sym;
3566  struct value *result;
3567 
3568  sym = cp_lookup_symbol_namespace (namespace_name, name,
3570 
3571  if (sym == NULL)
3572  return NULL;
3573  else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
3574  && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
3575  result = allocate_value (SYMBOL_TYPE (sym));
3576  else
3577  result = value_of_variable (sym, get_selected_block (0));
3578 
3579  if (want_address)
3580  result = value_addr (result);
3581 
3582  return result;
3583 }
3584 
3585 /* Given a pointer or a reference value V, find its real (RTTI) type.
3586 
3587  Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3588  and refer to the values computed for the object pointed to. */
3589 
3590 struct type *
3591 value_rtti_indirect_type (struct value *v, int *full,
3592  int *top, int *using_enc)
3593 {
3594  struct value *target = NULL;
3595  struct type *type, *real_type, *target_type;
3596 
3597  type = value_type (v);
3598  type = check_typedef (type);
3599  if (TYPE_CODE (type) == TYPE_CODE_REF)
3600  target = coerce_ref (v);
3601  else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3602  {
3603 
3604  TRY
3605  {
3606  target = value_ind (v);
3607  }
3608  CATCH (except, RETURN_MASK_ERROR)
3609  {
3610  if (except.error == MEMORY_ERROR)
3611  {
3612  /* value_ind threw a memory error. The pointer is NULL or
3613  contains an uninitialized value: we can't determine any
3614  type. */
3615  return NULL;
3616  }
3617  throw_exception (except);
3618  }
3619  END_CATCH
3620  }
3621  else
3622  return NULL;
3623 
3624  real_type = value_rtti_type (target, full, top, using_enc);
3625 
3626  if (real_type)
3627  {
3628  /* Copy qualifiers to the referenced object. */
3629  target_type = value_type (target);
3630  real_type = make_cv_type (TYPE_CONST (target_type),
3631  TYPE_VOLATILE (target_type), real_type, NULL);
3632  if (TYPE_CODE (type) == TYPE_CODE_REF)
3633  real_type = lookup_reference_type (real_type);
3634  else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3635  real_type = lookup_pointer_type (real_type);
3636  else
3637  internal_error (__FILE__, __LINE__, _("Unexpected value type."));
3638 
3639  /* Copy qualifiers to the pointer/reference. */
3640  real_type = make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type),
3641  real_type, NULL);
3642  }
3643 
3644  return real_type;
3645 }
3646 
3647 /* Given a value pointed to by ARGP, check its real run-time type, and
3648  if that is different from the enclosing type, create a new value
3649  using the real run-time type as the enclosing type (and of the same
3650  type as ARGP) and return it, with the embedded offset adjusted to
3651  be the correct offset to the enclosed object. RTYPE is the type,
3652  and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3653  by value_rtti_type(). If these are available, they can be supplied
3654  and a second call to value_rtti_type() is avoided. (Pass RTYPE ==
3655  NULL if they're not available. */
3656 
3657 struct value *
3658 value_full_object (struct value *argp,
3659  struct type *rtype,
3660  int xfull, int xtop,
3661  int xusing_enc)
3662 {
3663  struct type *real_type;
3664  int full = 0;
3665  int top = -1;
3666  int using_enc = 0;
3667  struct value *new_val;
3668 
3669  if (rtype)
3670  {
3671  real_type = rtype;
3672  full = xfull;
3673  top = xtop;
3674  using_enc = xusing_enc;
3675  }
3676  else
3677  real_type = value_rtti_type (argp, &full, &top, &using_enc);
3678 
3679  /* If no RTTI data, or if object is already complete, do nothing. */
3680  if (!real_type || real_type == value_enclosing_type (argp))
3681  return argp;
3682 
3683  /* In a destructor we might see a real type that is a superclass of
3684  the object's type. In this case it is better to leave the object
3685  as-is. */
3686  if (full
3687  && TYPE_LENGTH (real_type) < TYPE_LENGTH (value_enclosing_type (argp)))
3688  return argp;
3689 
3690  /* If we have the full object, but for some reason the enclosing
3691  type is wrong, set it. */
3692  /* pai: FIXME -- sounds iffy */
3693  if (full)
3694  {
3695  argp = value_copy (argp);
3696  set_value_enclosing_type (argp, real_type);
3697  return argp;
3698  }
3699 
3700  /* Check if object is in memory. */
3701  if (VALUE_LVAL (argp) != lval_memory)
3702  {
3703  warning (_("Couldn't retrieve complete object of RTTI "
3704  "type %s; object may be in register(s)."),
3705  TYPE_NAME (real_type));
3706 
3707  return argp;
3708  }
3709 
3710  /* All other cases -- retrieve the complete object. */
3711  /* Go back by the computed top_offset from the beginning of the
3712  object, adjusting for the embedded offset of argp if that's what
3713  value_rtti_type used for its computation. */
3714  new_val = value_at_lazy (real_type, value_address (argp) - top +
3715  (using_enc ? 0 : value_embedded_offset (argp)));
3716  deprecated_set_value_type (new_val, value_type (argp));
3717  set_value_embedded_offset (new_val, (using_enc
3718  ? top + value_embedded_offset (argp)
3719  : top));
3720  return new_val;
3721 }
3722 
3723 
3724 /* Return the value of the local variable, if one exists. Throw error
3725  otherwise, such as if the request is made in an inappropriate context. */
3726 
3727 struct value *
3728 value_of_this (const struct language_defn *lang)
3729 {
3730  struct symbol *sym;
3731  const struct block *b;
3732  struct frame_info *frame;
3733 
3734  if (!lang->la_name_of_this)
3735  error (_("no `this' in current language"));
3736 
3737  frame = get_selected_frame (_("no frame selected"));
3738 
3739  b = get_frame_block (frame, NULL);
3740 
3741  sym = lookup_language_this (lang, b);
3742  if (sym == NULL)
3743  error (_("current stack frame does not contain a variable named `%s'"),
3744  lang->la_name_of_this);
3745 
3746  return read_var_value (sym, frame);
3747 }
3748 
3749 /* Return the value of the local variable, if one exists. Return NULL
3750  otherwise. Never throw error. */
3751 
3752 struct value *
3754 {
3755  struct value *ret = NULL;
3756 
3757  TRY
3758  {
3759  ret = value_of_this (lang);
3760  }
3761  CATCH (except, RETURN_MASK_ERROR)
3762  {
3763  }
3764  END_CATCH
3765 
3766  return ret;
3767 }
3768 
3769 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3770  elements long, starting at LOWBOUND. The result has the same lower
3771  bound as the original ARRAY. */
3772 
3773 struct value *
3774 value_slice (struct value *array, int lowbound, int length)
3775 {
3776  struct type *slice_range_type, *slice_type, *range_type;
3777  LONGEST lowerbound, upperbound;
3778  struct value *slice;
3779  struct type *array_type;
3780 
3781  array_type = check_typedef (value_type (array));
3782  if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3783  && TYPE_CODE (array_type) != TYPE_CODE_STRING)
3784  error (_("cannot take slice of non-array"));
3785 
3786  range_type = TYPE_INDEX_TYPE (array_type);
3787  if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3788  error (_("slice from bad array or bitstring"));
3789 
3790  if (lowbound < lowerbound || length < 0
3791  || lowbound + length - 1 > upperbound)
3792  error (_("slice out of range"));
3793 
3794  /* FIXME-type-allocation: need a way to free this type when we are
3795  done with it. */
3796  slice_range_type = create_static_range_type ((struct type *) NULL,
3797  TYPE_TARGET_TYPE (range_type),
3798  lowbound,
3799  lowbound + length - 1);
3800 
3801  {
3802  struct type *element_type = TYPE_TARGET_TYPE (array_type);
3803  LONGEST offset
3804  = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3805 
3806  slice_type = create_array_type ((struct type *) NULL,
3807  element_type,
3808  slice_range_type);
3809  TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3810 
3811  if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
3812  slice = allocate_value_lazy (slice_type);
3813  else
3814  {
3815  slice = allocate_value (slice_type);
3816  value_contents_copy (slice, 0, array, offset,
3817  TYPE_LENGTH (slice_type));
3818  }
3819 
3820  set_value_component_location (slice, array);
3821  VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
3822  set_value_offset (slice, value_offset (array) + offset);
3823  }
3824 
3825  return slice;
3826 }
3827 
3828 /* Create a value for a FORTRAN complex number. Currently most of the
3829  time values are coerced to COMPLEX*16 (i.e. a complex number
3830  composed of 2 doubles. This really should be a smarter routine
3831  that figures out precision inteligently as opposed to assuming
3832  doubles. FIXME: fmb */
3833 
3834 struct value *
3836  struct value *arg2,
3837  struct type *type)
3838 {
3839  struct value *val;
3840  struct type *real_type = TYPE_TARGET_TYPE (type);
3841 
3842  val = allocate_value (type);
3843  arg1 = value_cast (real_type, arg1);
3844  arg2 = value_cast (real_type, arg2);
3845 
3846  memcpy (value_contents_raw (val),
3847  value_contents (arg1), TYPE_LENGTH (real_type));
3848  memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
3849  value_contents (arg2), TYPE_LENGTH (real_type));
3850  return val;
3851 }
3852 
3853 /* Cast a value into the appropriate complex data type. */
3854 
3855 static struct value *
3856 cast_into_complex (struct type *type, struct value *val)
3857 {
3858  struct type *real_type = TYPE_TARGET_TYPE (type);
3859 
3860  if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
3861  {
3862  struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
3863  struct value *re_val = allocate_value (val_real_type);
3864  struct value *im_val = allocate_value (val_real_type);
3865 
3866  memcpy (value_contents_raw (re_val),
3867  value_contents (val), TYPE_LENGTH (val_real_type));
3868  memcpy (value_contents_raw (im_val),
3869  value_contents (val) + TYPE_LENGTH (val_real_type),
3870  TYPE_LENGTH (val_real_type));
3871 
3872  return value_literal_complex (re_val, im_val, type);
3873  }
3874  else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
3875  || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
3876  return value_literal_complex (val,
3877  value_zero (real_type, not_lval),
3878  type);
3879  else
3880  error (_("cannot cast non-number to complex"));
3881 }
3882 
3883 void
3885 {
3886  add_setshow_boolean_cmd ("overload-resolution", class_support,
3887  &overload_resolution, _("\
3888 Set overload resolution in evaluating C++ functions."), _("\
3889 Show overload resolution in evaluating C++ functions."),
3890  NULL, NULL,
3892  &setlist, &showlist);
3893  overload_resolution = 1;
3894 }
const struct rank INCOMPATIBLE_TYPE_BADNESS
Definition: gdbtypes.c:47
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:733
struct value * value_virtual_fn_field(struct value **arg1p, struct fn_field *f, int j, struct type *type, int offset)
Definition: cp-abi.c:97
struct value * value_zero(struct type *type, enum lval_type lv)
Definition: valops.c:842
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
#define VEC_merge(T, V1, V2)
Definition: vec.h:213
struct value * value_array(int lowbound, int highbound, struct value **elemvec)
Definition: valops.c:1595
type_code
Definition: gdbtypes.h:85
static struct value * value_namespace_elt(const struct type *, const char *, int, enum noside)
Definition: valops.c:3538
char string_lower_bound
Definition: language.h:294
struct type * lookup_string_range_type(struct type *string_char_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1164
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1128
struct value * call_function_by_hand(struct value *function, int nargs, struct value **args)
Definition: infcall.c:488
int decimal_from_string(gdb_byte *decbytes, int len, enum bfd_endian byte_order, const char *string)
Definition: dfp.c:174
static struct value * cast_into_complex(struct type *, struct value *)
Definition: valops.c:3856
struct value * value_addr(struct value *arg1)
Definition: valops.c:1472
struct value * value_primitive_field(struct value *arg1, int offset, int fieldno, struct type *arg_type)
Definition: value.c:2990
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
#define VALUE_FRAME_ID(val)
Definition: value.h:436
void(* deprecated_register_changed_hook)(int regno)
Definition: top.c:227
static int typecmp(int staticp, int varargs, int nargs, struct field t1[], struct value *t2[])
Definition: valops.c:1697
struct type * create_static_range_type(struct type *result_type, struct type *index_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:867
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
const struct rank NS_POINTER_CONVERSION_BADNESS
Definition: gdbtypes.c:62
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
oload_search_type
Definition: value.h:751
struct value * value_from_contents_and_address(struct type *type, const gdb_byte *valaddr, CORE_ADDR address)
Definition: value.c:3529
bfd_vma CORE_ADDR
Definition: common-types.h:41
noside
Definition: expression.h:122
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1327
unsigned int overload_debug
Definition: gdbtypes.c:122
void value_contents_copy(struct value *dst, int dst_offset, struct value *src, int src_offset, int length)
Definition: value.c:1295
struct value * value_struct_elt_bitpos(struct value **argp, int bitpos, struct type *ftype, const char *err)
Definition: valops.c:2217
void xfree(void *)
Definition: common-utils.c:97
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
int value_offset(const struct value *value)
Definition: value.c:1032
struct value * value_ref(struct value *arg1)
Definition: valops.c:1516
int strcmp_iw(const char *string1, const char *string2)
Definition: utils.c:2511
#define TYPE_NFN_FIELDS(thistype)
Definition: gdbtypes.h:1307
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
const char * type_name_no_tag_or_error(struct type *type)
Definition: gdbtypes.c:1380
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
void warning(const char *fmt,...)
Definition: errors.c:26
void observer_notify_register_changed(struct frame_info *frame, int regnum)
struct type * create_array_type(struct type *result_type, struct type *element_type, struct type *range_type)
Definition: gdbtypes.c:1119
Definition: value.h:751
struct value * value_coerce_array(struct value *arg1)
Definition: valops.c:1436
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
unsigned int lazy
Definition: value.c:195
struct value * address_of_variable(struct symbol *var, const struct block *b)
Definition: valops.c:1317
struct value * value_of_this_silent(const struct language_defn *lang)
Definition: valops.c:3753
#define TYPE_FIELD_ARTIFICIAL(thistype, n)
Definition: gdbtypes.h:1376
void decimal_convert(const gdb_byte *from, int len_from, enum bfd_endian byte_order_from, gdb_byte *to, int len_to, enum bfd_endian byte_order_to)
Definition: dfp.c:371
int value_bitpos(const struct value *value)
Definition: value.c:1043
struct value * value_at(struct type *type, CORE_ADDR addr)
Definition: valops.c:940
char * cp_func_name(const char *full_name)
Definition: cp-support.c:855
#define TYPE_VOLATILE(t)
Definition: gdbtypes.h:350
void put_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, const gdb_byte *myaddr)
Definition: frame.c:1351
struct value * allocate_value_lazy(struct type *type)
Definition: value.c:913
void select_frame(struct frame_info *fi)
Definition: frame.c:1574
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
#define BASETYPE_VIA_VIRTUAL(thistype, index)
Definition: gdbtypes.h:1335
#define VALUE_INTERNALVAR(val)
Definition: value.h:431
struct value * value_coerce_function(struct value *arg1)
Definition: valops.c:1456
struct value * coerce_ref(struct value *arg)
Definition: value.c:3688
#define TYPE_FN_FIELD_STATIC_P(thisfn, n)
Definition: gdbtypes.h:1442
struct value * read_var_value(struct symbol *var, struct frame_info *frame)
Definition: findvar.c:613
struct rank * rank
Definition: gdbtypes.h:1045
void set_value_lazy(struct value *value, int val)
Definition: value.c:1311
struct value * value_ind(struct value *arg1)
Definition: valops.c:1533
struct value * value_copy(struct value *arg)
Definition: value.c:1667
short rank
Definition: gdbtypes.h:1027
void mark_value_bytes_unavailable(struct value *value, int offset, int length)
Definition: value.c:593
struct value * value_of_this(const struct language_defn *lang)
Definition: valops.c:3728
static int find_oload_champ_namespace(struct value **, int, const char *, const char *, struct symbol ***, struct badness_vector **, const int no_adl)
Definition: valops.c:2830
#define VEC(T)
Definition: vec.h:398
int is_public_ancestor(struct type *base, struct type *dclass)
Definition: gdbtypes.c:2847
#define _(String)
Definition: gdb_locale.h:40
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1173
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
struct value * value_parent(struct value *value)
Definition: value.c:1065
lval_type
Definition: defs.h:350
#define TYPE_FN_FIELD_ARGS(thisfn, n)
Definition: gdbtypes.h:1425
#define TYPE_FIELD_ENUMVAL(thistype, n)
Definition: gdbtypes.h:1372
#define END_CATCH
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
#define VALUE_LVAL(val)
Definition: value.h:411
struct value * allocate_value(struct type *type)
Definition: value.c:962
static struct value * enum_constant_from_type(struct type *type, const char *name)
Definition: valops.c:3187
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:6231
static void do_search_struct_field(const char *name, struct value *arg1, int offset, struct type *type, int looking_for_baseclass, struct value **result_ptr, int *last_boffset, struct type *outermost_type)
Definition: valops.c:1798
static int oload_method_static_p(struct fn_field *, int)
Definition: valops.c:3117
int gdbarch_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
Definition: gdbarch.c:2413
static struct value * search_struct_field(const char *, struct value *, struct type *, int)
Definition: valops.c:1959
void decimal_from_floating(struct value *from, gdb_byte *to, int len, enum bfd_endian byte_order)
Definition: dfp.c:241
static int compare_parameters(struct type *t1, struct type *t2, int skip_artificial)
Definition: valops.c:3259
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
const struct rank EXACT_MATCH_BADNESS
Definition: gdbtypes.c:49
void deprecated_set_value_type(struct value *value, struct type *type)
Definition: value.c:1026
Definition: value.h:751
struct symbol ** make_symbol_overload_list_adl(struct type **arg_types, int nargs, const char *func_name)
Definition: cp-support.c:1322
void set_value_address(struct value *value, CORE_ADDR addr)
Definition: value.c:1463
struct cleanup * all_cleanups(void)
Definition: cleanups.c:166
void null_cleanup(void *arg)
Definition: cleanups.c:295
#define TRY
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
Definition: corefile.c:217
int bitpos
Definition: value.c:250
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
struct value * value_struct_elt(struct value **argp, struct value **args, const char *name, int *static_memfuncp, const char *err)
Definition: valops.c:2128
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition: gdbtypes.h:1423
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:473
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define TYPE_FN_FIELD_VIRTUAL_P(thisfn, n)
Definition: gdbtypes.h:1441
struct frame_info * block_innermost_frame(const struct block *block)
Definition: blockframe.c:332
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
#define CATCH(EXCEPTION, MASK)
struct type * lookup_memberptr_type(struct type *type, struct type *domain)
Definition: gdbtypes.c:780
struct value * value_from_decfloat(struct type *type, const gdb_byte *dec)
Definition: value.c:3580
struct target_ops current_target
#define TYPE_FN_FIELD_ARTIFICIAL(thisfn, n)
Definition: gdbtypes.h:1435
int value_lazy(struct value *value)
Definition: value.c:1305
int field_is_static(struct field *f)
Definition: gdbtypes.c:3797
struct symbol * lookup_language_this(const struct language_defn *lang, const struct block *block)
Definition: symtab.c:1979
struct value * value_static_field(struct type *type, int fieldno)
Definition: value.c:2926
struct symbol ** make_symbol_overload_list(const char *func_name, const char *the_namespace)
Definition: cp-support.c:1186
int compare_badness(struct badness_vector *a, struct badness_vector *b)
Definition: gdbtypes.c:2965
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
#define SYMBOL_DEMANGLED_NAME(symbol)
Definition: symtab.h:245
void cplus_make_method_ptr(struct type *type, gdb_byte *contents, CORE_ADDR value, int is_virtual)
Definition: cp-abi.c:147
int value_bitsize(const struct value *value)
Definition: value.c:1054
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t err
Definition: gnu-nat.c:1816
struct value * find_function_in_inferior(const char *name, struct objfile **objf_p)
Definition: valops.c:128
unsigned int cp_find_first_component(const char *name)
Definition: cp-support.c:964
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
Definition: blockframe.c:55
struct value * value_cast_pointers(struct type *type, struct value *arg2, int subclass_check)
Definition: valops.c:306
void(* write)(struct value *toval, struct value *fromval)
Definition: value.h:230
void set_value_enclosing_type(struct value *val, struct type *new_encl_type)
Definition: value.c:2975
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
int symbol_read_needs_frame(struct symbol *sym)
Definition: findvar.c:343
int is_ancestor(struct type *base, struct type *dclass)
Definition: gdbtypes.c:2838
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
const gdb_byte * value_contents_all(struct value *value)
Definition: value.c:1188
#define TYPE_VECTOR(t)
Definition: gdbtypes.h:287
double DOUBLEST
Definition: doublest.h:24
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
int is_integral_type(struct type *t)
Definition: gdbtypes.c:2690
struct type * value_enclosing_type(struct value *value)
Definition: value.c:1098
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define VEC_length(T, V)
Definition: vec.h:124
void set_internalvar(struct internalvar *var, struct value *val)
Definition: value.c:2295
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct frame_info * deprecated_safe_get_selected_frame(void)
Definition: frame.c:1564
target_xfer_status
Definition: target.h:219
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
struct value * value_coerce_to_target(struct value *val)
Definition: valops.c:1398
static struct value * search_struct_method(const char *, struct value **, struct value **, int, int *, struct type *)
Definition: valops.c:1979
struct value * value_of_xmethod(struct xmethod_worker *worker)
Definition: value.c:2608
#define VALUE_REGNUM(val)
Definition: value.h:440
#define VEC_index(T, V, I)
Definition: vec.h:151
struct value * parent
Definition: value.c:262
struct gdbarch * get_type_arch(const struct type *type)
Definition: gdbtypes.c:232
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
static const char * type
Definition: language.c:103
#define gdb_assert(expr)
Definition: gdb_assert.h:33
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3464
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
void set_value_offset(struct value *value, int offset)
Definition: value.c:1037
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
Definition: valops.c:951
void free_xmethod_worker_vec(void *vec)
Definition: extension.c:1020
struct value * value_cast(struct type *type, struct value *arg2)
Definition: valops.c:351
struct type * value_rtti_indirect_type(struct value *v, int *full, int *top, int *using_enc)
Definition: valops.c:3591
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
#define target_has_execution
Definition: target.h:1726
gdb_byte * value_contents_all_raw(struct value *value)
Definition: value.c:1091
int class_types_same_p(const struct type *a, const struct type *b)
Definition: gdbtypes.c:2778
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1326
char c_style_arrays
Definition: language.h:291
#define TYPE_FIELD_PACKED(thistype, n)
Definition: gdbtypes.h:1378
int deprecated_value_modifiable(struct value *value)
Definition: value.c:1490
struct value * value_dynamic_cast(struct type *type, struct value *arg)
Definition: valops.c:724
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:244
#define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype)
Definition: gdbtypes.h:1282
struct badness_vector * rank_function(struct type **parms, int nparms, struct value **args, int nargs)
Definition: gdbtypes.c:3009
static struct value * value_cast_structs(struct type *type, struct value *v2)
Definition: valops.c:218
struct value * value_from_double(struct type *type, DOUBLEST num)
Definition: value.c:3563
static struct value * value_struct_elt_for_reference(struct type *, int, struct type *, const char *, struct type *, int, enum noside)
Definition: valops.c:3309
void * xmalloc(YYSIZE_T)
int baseclass_offset(struct type *type, int index, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, const struct value *val)
Definition: cp-abi.c:68
static const char * namespace_name(struct die_info *die, int *is_anonymous, struct dwarf2_cu *)
Definition: dwarf2read.c:14156
struct value * value_full_object(struct value *argp, struct type *rtype, int xfull, int xtop, int xusing_enc)
Definition: valops.c:3658
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 destructor_name_p(const char *name, struct type *type)
Definition: valops.c:3161
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
static void show_overload_resolution(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: valops.c:114
int value_must_coerce_to_target(struct value *val)
Definition: valops.c:1370
struct value * value_fn_field(struct value **arg1p, struct fn_field *f, int j, struct type *type, int offset)
Definition: value.c:3115
struct value *(* indirect)(struct value *value)
Definition: value.h:235
static int find_oload_champ(struct value **, int, int, struct fn_field *, VEC(xmethod_worker_ptr)*, struct symbol **, struct badness_vector **)
Definition: valops.c:2992
#define TYPE_FN_FIELD_VOFFSET(thisfn, n)
Definition: gdbtypes.h:1440
void throw_exception(struct gdb_exception exception)
oload_classification
Definition: valops.c:75
static int dynamic_cast_check_1(struct type *desired_type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct value *val, struct type *search_type, CORE_ADDR arg_addr, struct type *arg_type, struct value **result)
Definition: valops.c:636
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
int block_inlined_p(const struct block *bl)
Definition: block.c:126
int types_equal(struct type *a, struct type *b)
Definition: gdbtypes.c:3085
#define TYPE_FN_FIELD_TYPE(thisfn, n)
Definition: gdbtypes.h:1424
void set_internalvar_component(struct internalvar *var, int offset, int bitpos, int bitsize, struct value *newval)
Definition: value.c:2270
struct value * allocate_repeat_value(struct type *type, int count)
Definition: value.c:975
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition: value.c:3490
xmethod_worker_vec * get_matching_xmethod_workers(struct type *, const char *)
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:651
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
static void update_search_result(struct value **result_ptr, struct value *v, int *last_boffset, int boffset, const char *name, struct type *type)
Definition: valops.c:1773
void observer_notify_target_changed(struct target_ops *target)
void set_value_embedded_offset(struct value *value, int val)
Definition: value.c:1394
#define TYPE_VARARGS(t)
Definition: gdbtypes.h:282
const struct language_defn * current_language
Definition: language.c:85
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
void value_fetch_lazy(struct value *val)
Definition: value.c:3793
void set_value_pointed_to_offset(struct value *value, int val)
Definition: value.c:1406
void gdbarch_value_to_register(struct gdbarch *gdbarch, struct frame_info *frame, int regnum, struct type *type, const gdb_byte *buf)
Definition: gdbarch.c:2447
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
struct rank rank_one_type(struct type *parm, struct type *arg, struct value *value)
Definition: gdbtypes.c:3377
#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
void read_value_memory(struct value *val, int embedded_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length)
Definition: valops.c:957
#define TYPE_BASECLASS_NAME(thistype, index)
Definition: gdbtypes.h:1328
int value_pointed_to_offset(struct value *value)
Definition: value.c:1400
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
struct value * value_of_variable(struct symbol *var, const struct block *b)
Definition: valops.c:1291
struct ui_file * gdb_stderr
Definition: main.c:72
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type)
Definition: infcall.c:247
struct minimal_symbol * minsym
Definition: minsyms.h:32
void decimal_from_integral(struct value *from, gdb_byte *to, int len, enum bfd_endian byte_order)
Definition: dfp.c:209
struct value * value_repeat(struct value *arg1, int count)
Definition: valops.c:1269
static CORE_ADDR allocate_space_in_inferior(int)
Definition: valops.c:207
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
int offset
Definition: agent.c:65
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition: minsyms.c:335
unsigned int stack
Definition: value.c:202
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
Definition: buffer.h:23
static enum oload_classification classify_oload_match(struct badness_vector *, int, int)
Definition: valops.c:3128
#define VEC_free(T, V)
Definition: vec.h:180
struct value * value_cstring(char *ptr, ssize_t len, struct type *char_type)
Definition: valops.c:1642
struct value * value_one(struct type *type)
Definition: valops.c:853
struct type * value_rtti_type(struct value *v, int *full, int *top, int *using_enc)
Definition: cp-abi.c:108
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
int value_logical_not(struct value *arg1)
Definition: valarith.c:1513
void check_stub_method_group(struct type *type, int method_id)
Definition: gdbtypes.c:2538
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
static struct value * get_value_at(struct type *type, CORE_ADDR addr, int lazy)
Definition: valops.c:909
const struct block * get_selected_block(CORE_ADDR *addr_in_block)
Definition: stack.c:2230
int get_frame_register_bytes(struct frame_info *frame, int regnum, CORE_ADDR offset, int len, gdb_byte *myaddr, int *optimizedp, int *unavailablep)
Definition: frame.c:1274
void _initialize_valops(void)
Definition: valops.c:3884
#define SYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:231
unsigned long long ULONGEST
Definition: common-types.h:53
#define BASETYPE_VIA_PUBLIC(thistype, index)
Definition: gdbtypes.h:1330
target_xfer_partial_ftype target_xfer_partial
int value_embedded_offset(struct value *value)
Definition: value.c:1388
struct value * value_allocate_space_in_inferior(int len)
Definition: valops.c:186
struct value * value_slice(struct value *array, int lowbound, int length)
Definition: valops.c:3774
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 type ** get_xmethod_arg_types(struct xmethod_worker *worker, int *nargs)
Definition: extension.c:948
CORE_ADDR value_as_address(struct value *val)
Definition: value.c:2679
static void value_find_oload_method_list(struct value **argp, const char *method, int offset, struct fn_field **fn_list, int *num_fns, VEC(xmethod_worker_ptr)**xm_worker_vec, struct type **basetype, int *boffset)
Definition: valops.c:2379
int is_unique_ancestor(struct type *base, struct value *val)
Definition: gdbtypes.c:2907
struct value * readjust_indirect_value_type(struct value *value, struct type *enc_type, struct type *original_type, struct value *original_value)
Definition: value.c:3672
struct type * lookup_methodptr_type(struct type *to_type)
Definition: gdbtypes.c:792
gdb_byte * value_contents_raw(struct value *value)
Definition: value.c:1084
static struct value * value_maybe_namespace_elt(const struct type *, const char *, int, enum noside)
Definition: valops.c:3560
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition: gdbtypes.h:1412
const char * type_name_no_tag(const struct type *type)
Definition: gdbtypes.c:1361
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
#define TYPE_BASECLASS_BITPOS(thistype, index)
Definition: gdbtypes.h:1329
struct objfile * objfile
Definition: minsyms.h:37
#define HOST_CHAR_BIT
Definition: host-defs.h:40
struct value * value_literal_complex(struct value *arg1, struct value *arg2, struct type *type)
Definition: valops.c:3835
#define TYPE_FN_FIELDLIST_LENGTH(thistype, n)
Definition: gdbtypes.h:1413
int value_stack(struct value *value)
Definition: value.c:1317
int compare_ranks(struct rank a, struct rank b)
Definition: gdbtypes.c:2937
char * la_name_of_this
Definition: language.h:264
void write_memory_with_notification(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:402
struct xmethod_worker * clone_xmethod_worker(struct xmethod_worker *worker)
Definition: extension.c:884
static int dynamic_cast_check_2(struct type *desired_type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct value *val, struct type *search_type, struct value **result)
Definition: valops.c:683
#define QUIT
Definition: defs.h:160
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:389
#define TYPE_FIELD_LOC_KIND(thistype, n)
Definition: gdbtypes.h:1370
#define TYPE_DECLARED_CLASS(t)
Definition: gdbtypes.h:334
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
Definition: defs.h:353
static int find_oload_champ_namespace_loop(struct value **, int, const char *, const char *, int, struct symbol ***, struct badness_vector **, int *, const int no_adl)
Definition: valops.c:2859
int get_array_bounds(struct type *type, LONGEST *low_bound, LONGEST *high_bound)
Definition: gdbtypes.c:978
#define TYPE_CONST(t)
Definition: gdbtypes.h:345
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
DOUBLEST value_as_double(struct value *val)
Definition: value.c:2664
int embedded_offset
Definition: value.c:312
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
#define TYPE_FN_FIELDLIST1(thistype, n)
Definition: gdbtypes.h:1411
void throw_error(enum errors error, const char *fmt,...)
long long LONGEST
Definition: common-types.h:52
struct target_ops * beneath
Definition: target.h:431
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
void set_value_component_location(struct value *component, const struct value *whole)
Definition: value.c:1761
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:482
#define TYPE_SAFE_NAME(type)
Definition: gdbtypes.h:1466
static void find_method_list(struct value **, const char *, int, struct type *, struct fn_field **, int *, VEC(xmethod_worker_ptr)**, struct type **, int *)
Definition: valops.c:2279
const ULONGEST const LONGEST len
Definition: target.h:309
const struct lval_funcs * value_computed_funcs(const struct value *v)
Definition: value.c:1412