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