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