gdb/valops.c

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