gdb/valops.c

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