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