gdb/valops.c

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