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