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    Note: This function does *not* check the value of
2453    overload_resolution.  Caller must check it to see whether overload
2454    resolution is permitted.  */
2455
2456 int
2457 find_overload_match (struct value **args, int nargs,
2458                      const char *name, enum oload_search_type method,
2459                      struct value **objp, struct symbol *fsym,
2460                      struct value **valp, struct symbol **symp,
2461                      int *staticp, const int no_adl)
2462 {
2463   struct value *obj = (objp ? *objp : NULL);
2464   struct type *obj_type = obj ? value_type (obj) : NULL;
2465   /* Index of best overloaded function.  */
2466   int func_oload_champ = -1;
2467   int method_oload_champ = -1;
2468   int src_method_oload_champ = -1;
2469   int ext_method_oload_champ = -1;
2470   int src_and_ext_equal = 0;
2471
2472   /* The measure for the current best match.  */
2473   struct badness_vector *method_badness = NULL;
2474   struct badness_vector *func_badness = NULL;
2475   struct badness_vector *ext_method_badness = NULL;
2476   struct badness_vector *src_method_badness = NULL;
2477
2478   struct value *temp = obj;
2479   /* For methods, the list of overloaded methods.  */
2480   struct fn_field *fns_ptr = NULL;
2481   /* For non-methods, the list of overloaded function symbols.  */
2482   struct symbol **oload_syms = NULL;
2483   /* For xmethods, the VEC of xmethod workers.  */
2484   VEC (xmethod_worker_ptr) *xm_worker_vec = NULL;
2485   /* Number of overloaded instances being considered.  */
2486   int num_fns = 0;
2487   struct type *basetype = NULL;
2488   int boffset;
2489
2490   struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);
2491
2492   const char *obj_type_name = NULL;
2493   const char *func_name = NULL;
2494   enum oload_classification match_quality;
2495   enum oload_classification method_match_quality = INCOMPATIBLE;
2496   enum oload_classification src_method_match_quality = INCOMPATIBLE;
2497   enum oload_classification ext_method_match_quality = INCOMPATIBLE;
2498   enum oload_classification func_match_quality = INCOMPATIBLE;
2499
2500   /* Get the list of overloaded methods or functions.  */
2501   if (method == METHOD || method == BOTH)
2502     {
2503       gdb_assert (obj);
2504
2505       /* OBJ may be a pointer value rather than the object itself.  */
2506       obj = coerce_ref (obj);
2507       while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
2508         obj = coerce_ref (value_ind (obj));
2509       obj_type_name = TYPE_NAME (value_type (obj));
2510
2511       /* First check whether this is a data member, e.g. a pointer to
2512          a function.  */
2513       if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
2514         {
2515           *valp = search_struct_field (name, obj, 0,
2516                                        check_typedef (value_type (obj)), 0);
2517           if (*valp)
2518             {
2519               *staticp = 1;
2520               do_cleanups (all_cleanups);
2521               return 0;
2522             }
2523         }
2524
2525       /* Retrieve the list of methods with the name NAME.  */
2526       value_find_oload_method_list (&temp, name, 0, &fns_ptr, &num_fns,
2527                                     &xm_worker_vec, &basetype, &boffset);
2528       /* If this is a method only search, and no methods were found
2529          the search has faild.  */
2530       if (method == METHOD && (!fns_ptr || !num_fns) && !xm_worker_vec)
2531         error (_("Couldn't find method %s%s%s"),
2532                obj_type_name,
2533                (obj_type_name && *obj_type_name) ? "::" : "",
2534                name);
2535       /* If we are dealing with stub method types, they should have
2536          been resolved by find_method_list via
2537          value_find_oload_method_list above.  */
2538       if (fns_ptr)
2539         {
2540           gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
2541
2542           src_method_oload_champ = find_oload_champ (args, nargs,
2543                                                      num_fns, fns_ptr, NULL,
2544                                                      NULL, &src_method_badness);
2545
2546           src_method_match_quality = classify_oload_match
2547             (src_method_badness, nargs,
2548              oload_method_static_p (fns_ptr, src_method_oload_champ));
2549
2550           make_cleanup (xfree, src_method_badness);
2551         }
2552
2553       if (VEC_length (xmethod_worker_ptr, xm_worker_vec) > 0)
2554         {
2555           ext_method_oload_champ = find_oload_champ (args, nargs,
2556                                                      0, NULL, xm_worker_vec,
2557                                                      NULL, &ext_method_badness);
2558           ext_method_match_quality = classify_oload_match (ext_method_badness,
2559                                                            nargs, 0);
2560           make_cleanup (xfree, ext_method_badness);
2561           make_cleanup (free_xmethod_worker_vec, xm_worker_vec);
2562         }
2563
2564       if (src_method_oload_champ >= 0 && ext_method_oload_champ >= 0)
2565         {
2566           switch (compare_badness (ext_method_badness, src_method_badness))
2567             {
2568               case 0: /* Src method and xmethod are equally good.  */
2569                 src_and_ext_equal = 1;
2570                 /* If src method and xmethod are equally good, then
2571                    xmethod should be the winner.  Hence, fall through to the
2572                    case where a xmethod is better than the source
2573                    method, except when the xmethod match quality is
2574                    non-standard.  */
2575                 /* FALLTHROUGH */
2576               case 1: /* Src method and ext method are incompatible.  */
2577                 /* If ext method match is not standard, then let source method
2578                    win.  Otherwise, fallthrough to let xmethod win.  */
2579                 if (ext_method_match_quality != STANDARD)
2580                   {
2581                     method_oload_champ = src_method_oload_champ;
2582                     method_badness = src_method_badness;
2583                     ext_method_oload_champ = -1;
2584                     method_match_quality = src_method_match_quality;
2585                     break;
2586                   }
2587                 /* FALLTHROUGH */
2588               case 2: /* Ext method is champion.  */
2589                 method_oload_champ = ext_method_oload_champ;
2590                 method_badness = ext_method_badness;
2591                 src_method_oload_champ = -1;
2592                 method_match_quality = ext_method_match_quality;
2593                 break;
2594               case 3: /* Src method is champion.  */
2595                 method_oload_champ = src_method_oload_champ;
2596                 method_badness = src_method_badness;
2597                 ext_method_oload_champ = -1;
2598                 method_match_quality = src_method_match_quality;
2599                 break;
2600               default:
2601                 gdb_assert_not_reached ("Unexpected overload comparison "
2602                                         "result");
2603                 break;
2604             }
2605         }
2606       else if (src_method_oload_champ >= 0)
2607         {
2608           method_oload_champ = src_method_oload_champ;
2609           method_badness = src_method_badness;
2610           method_match_quality = src_method_match_quality;
2611         }
2612       else if (ext_method_oload_champ >= 0)
2613         {
2614           method_oload_champ = ext_method_oload_champ;
2615           method_badness = ext_method_badness;
2616           method_match_quality = ext_method_match_quality;
2617         }
2618     }
2619
2620   if (method == NON_METHOD || method == BOTH)
2621     {
2622       const char *qualified_name = NULL;
2623
2624       /* If the overload match is being search for both as a method
2625          and non member function, the first argument must now be
2626          dereferenced.  */
2627       if (method == BOTH)
2628         args[0] = value_ind (args[0]);
2629
2630       if (fsym)
2631         {
2632           qualified_name = SYMBOL_NATURAL_NAME (fsym);
2633
2634           /* If we have a function with a C++ name, try to extract just
2635              the function part.  Do not try this for non-functions (e.g.
2636              function pointers).  */
2637           if (qualified_name
2638               && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym)))
2639               == TYPE_CODE_FUNC)
2640             {
2641               char *temp;
2642
2643               temp = cp_func_name (qualified_name);
2644
2645               /* If cp_func_name did not remove anything, the name of the
2646                  symbol did not include scope or argument types - it was
2647                  probably a C-style function.  */
2648               if (temp)
2649                 {
2650                   make_cleanup (xfree, temp);
2651                   if (strcmp (temp, qualified_name) == 0)
2652                     func_name = NULL;
2653                   else
2654                     func_name = temp;
2655                 }
2656             }
2657         }
2658       else
2659         {
2660           func_name = name;
2661           qualified_name = name;
2662         }
2663
2664       /* If there was no C++ name, this must be a C-style function or
2665          not a function at all.  Just return the same symbol.  Do the
2666          same if cp_func_name fails for some reason.  */
2667       if (func_name == NULL)
2668         {
2669           *symp = fsym;
2670           do_cleanups (all_cleanups);
2671           return 0;
2672         }
2673
2674       func_oload_champ = find_oload_champ_namespace (args, nargs,
2675                                                      func_name,
2676                                                      qualified_name,
2677                                                      &oload_syms,
2678                                                      &func_badness,
2679                                                      no_adl);
2680
2681       if (func_oload_champ >= 0)
2682         func_match_quality = classify_oload_match (func_badness, nargs, 0);
2683
2684       make_cleanup (xfree, oload_syms);
2685       make_cleanup (xfree, func_badness);
2686     }
2687
2688   /* Did we find a match ?  */
2689   if (method_oload_champ == -1 && func_oload_champ == -1)
2690     throw_error (NOT_FOUND_ERROR,
2691                  _("No symbol \"%s\" in current context."),
2692                  name);
2693
2694   /* If we have found both a method match and a function
2695      match, find out which one is better, and calculate match
2696      quality.  */
2697   if (method_oload_champ >= 0 && func_oload_champ >= 0)
2698     {
2699       switch (compare_badness (func_badness, method_badness))
2700         {
2701           case 0: /* Top two contenders are equally good.  */
2702             /* FIXME: GDB does not support the general ambiguous case.
2703              All candidates should be collected and presented the
2704              user.  */
2705             error (_("Ambiguous overload resolution"));
2706             break;
2707           case 1: /* Incomparable top contenders.  */
2708             /* This is an error incompatible candidates
2709                should not have been proposed.  */
2710             error (_("Internal error: incompatible "
2711                      "overload candidates proposed"));
2712             break;
2713           case 2: /* Function champion.  */
2714             method_oload_champ = -1;
2715             match_quality = func_match_quality;
2716             break;
2717           case 3: /* Method champion.  */
2718             func_oload_champ = -1;
2719             match_quality = method_match_quality;
2720             break;
2721           default:
2722             error (_("Internal error: unexpected overload comparison result"));
2723             break;
2724         }
2725     }
2726   else
2727     {
2728       /* We have either a method match or a function match.  */
2729       if (method_oload_champ >= 0)
2730         match_quality = method_match_quality;
2731       else
2732         match_quality = func_match_quality;
2733     }
2734
2735   if (match_quality == INCOMPATIBLE)
2736     {
2737       if (method == METHOD)
2738         error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2739                obj_type_name,
2740                (obj_type_name && *obj_type_name) ? "::" : "",
2741                name);
2742       else
2743         error (_("Cannot resolve function %s to any overloaded instance"),
2744                func_name);
2745     }
2746   else if (match_quality == NON_STANDARD)
2747     {
2748       if (method == METHOD)
2749         warning (_("Using non-standard conversion to match "
2750                    "method %s%s%s to supplied arguments"),
2751                  obj_type_name,
2752                  (obj_type_name && *obj_type_name) ? "::" : "",
2753                  name);
2754       else
2755         warning (_("Using non-standard conversion to match "
2756                    "function %s to supplied arguments"),
2757                  func_name);
2758     }
2759
2760   if (staticp != NULL)
2761     *staticp = oload_method_static_p (fns_ptr, method_oload_champ);
2762
2763   if (method_oload_champ >= 0)
2764     {
2765       if (src_method_oload_champ >= 0)
2766         {
2767           if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ))
2768             *valp = value_virtual_fn_field (&temp, fns_ptr, method_oload_champ,
2769                                             basetype, boffset);
2770           else
2771             *valp = value_fn_field (&temp, fns_ptr, method_oload_champ,
2772                                     basetype, boffset);
2773         }
2774       else
2775         {
2776           *valp = value_of_xmethod (clone_xmethod_worker
2777             (VEC_index (xmethod_worker_ptr, xm_worker_vec,
2778                         ext_method_oload_champ)));
2779         }
2780     }
2781   else
2782     *symp = oload_syms[func_oload_champ];
2783
2784   if (objp)
2785     {
2786       struct type *temp_type = check_typedef (value_type (temp));
2787       struct type *objtype = check_typedef (obj_type);
2788
2789       if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
2790           && (TYPE_CODE (objtype) == TYPE_CODE_PTR
2791               || TYPE_CODE (objtype) == TYPE_CODE_REF))
2792         {
2793           temp = value_addr (temp);
2794         }
2795       *objp = temp;
2796     }
2797
2798   do_cleanups (all_cleanups);
2799
2800   switch (match_quality)
2801     {
2802     case INCOMPATIBLE:
2803       return 100;
2804     case NON_STANDARD:
2805       return 10;
2806     default:                            /* STANDARD */
2807       return 0;
2808     }
2809 }
2810
2811 /* Find the best overload match, searching for FUNC_NAME in namespaces
2812    contained in QUALIFIED_NAME until it either finds a good match or
2813    runs out of namespaces.  It stores the overloaded functions in
2814    *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV.  The
2815    calling function is responsible for freeing *OLOAD_SYMS and
2816    *OLOAD_CHAMP_BV.  If NO_ADL, argument dependent lookup is not
2817    performned.  */
2818
2819 static int
2820 find_oload_champ_namespace (struct value **args, int nargs,
2821                             const char *func_name,
2822                             const char *qualified_name,
2823                             struct symbol ***oload_syms,
2824                             struct badness_vector **oload_champ_bv,
2825                             const int no_adl)
2826 {
2827   int oload_champ;
2828
2829   find_oload_champ_namespace_loop (args, nargs,
2830                                    func_name,
2831                                    qualified_name, 0,
2832                                    oload_syms, oload_champ_bv,
2833                                    &oload_champ,
2834                                    no_adl);
2835
2836   return oload_champ;
2837 }
2838
2839 /* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2840    how deep we've looked for namespaces, and the champ is stored in
2841    OLOAD_CHAMP.  The return value is 1 if the champ is a good one, 0
2842    if it isn't.  Other arguments are the same as in
2843    find_oload_champ_namespace
2844
2845    It is the caller's responsibility to free *OLOAD_SYMS and
2846    *OLOAD_CHAMP_BV.  */
2847
2848 static int
2849 find_oload_champ_namespace_loop (struct value **args, int nargs,
2850                                  const char *func_name,
2851                                  const char *qualified_name,
2852                                  int namespace_len,
2853                                  struct symbol ***oload_syms,
2854                                  struct badness_vector **oload_champ_bv,
2855                                  int *oload_champ,
2856                                  const int no_adl)
2857 {
2858   int next_namespace_len = namespace_len;
2859   int searched_deeper = 0;
2860   int num_fns = 0;
2861   struct cleanup *old_cleanups;
2862   int new_oload_champ;
2863   struct symbol **new_oload_syms;
2864   struct badness_vector *new_oload_champ_bv;
2865   char *new_namespace;
2866
2867   if (next_namespace_len != 0)
2868     {
2869       gdb_assert (qualified_name[next_namespace_len] == ':');
2870       next_namespace_len +=  2;
2871     }
2872   next_namespace_len +=
2873     cp_find_first_component (qualified_name + next_namespace_len);
2874
2875   /* Initialize these to values that can safely be xfree'd.  */
2876   *oload_syms = NULL;
2877   *oload_champ_bv = NULL;
2878
2879   /* First, see if we have a deeper namespace we can search in.
2880      If we get a good match there, use it.  */
2881
2882   if (qualified_name[next_namespace_len] == ':')
2883     {
2884       searched_deeper = 1;
2885
2886       if (find_oload_champ_namespace_loop (args, nargs,
2887                                            func_name, qualified_name,
2888                                            next_namespace_len,
2889                                            oload_syms, oload_champ_bv,
2890                                            oload_champ, no_adl))
2891         {
2892           return 1;
2893         }
2894     };
2895
2896   /* If we reach here, either we're in the deepest namespace or we
2897      didn't find a good match in a deeper namespace.  But, in the
2898      latter case, we still have a bad match in a deeper namespace;
2899      note that we might not find any match at all in the current
2900      namespace.  (There's always a match in the deepest namespace,
2901      because this overload mechanism only gets called if there's a
2902      function symbol to start off with.)  */
2903
2904   old_cleanups = make_cleanup (xfree, *oload_syms);
2905   make_cleanup (xfree, *oload_champ_bv);
2906   new_namespace = alloca (namespace_len + 1);
2907   strncpy (new_namespace, qualified_name, namespace_len);
2908   new_namespace[namespace_len] = '\0';
2909   new_oload_syms = make_symbol_overload_list (func_name,
2910                                               new_namespace);
2911
2912   /* If we have reached the deepest level perform argument
2913      determined lookup.  */
2914   if (!searched_deeper && !no_adl)
2915     {
2916       int ix;
2917       struct type **arg_types;
2918
2919       /* Prepare list of argument types for overload resolution.  */
2920       arg_types = (struct type **)
2921         alloca (nargs * (sizeof (struct type *)));
2922       for (ix = 0; ix < nargs; ix++)
2923         arg_types[ix] = value_type (args[ix]);
2924       make_symbol_overload_list_adl (arg_types, nargs, func_name);
2925     }
2926
2927   while (new_oload_syms[num_fns])
2928     ++num_fns;
2929
2930   new_oload_champ = find_oload_champ (args, nargs, num_fns,
2931                                       NULL, NULL, new_oload_syms,
2932                                       &new_oload_champ_bv);
2933
2934   /* Case 1: We found a good match.  Free earlier matches (if any),
2935      and return it.  Case 2: We didn't find a good match, but we're
2936      not the deepest function.  Then go with the bad match that the
2937      deeper function found.  Case 3: We found a bad match, and we're
2938      the deepest function.  Then return what we found, even though
2939      it's a bad match.  */
2940
2941   if (new_oload_champ != -1
2942       && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2943     {
2944       *oload_syms = new_oload_syms;
2945       *oload_champ = new_oload_champ;
2946       *oload_champ_bv = new_oload_champ_bv;
2947       do_cleanups (old_cleanups);
2948       return 1;
2949     }
2950   else if (searched_deeper)
2951     {
2952       xfree (new_oload_syms);
2953       xfree (new_oload_champ_bv);
2954       discard_cleanups (old_cleanups);
2955       return 0;
2956     }
2957   else
2958     {
2959       *oload_syms = new_oload_syms;
2960       *oload_champ = new_oload_champ;
2961       *oload_champ_bv = new_oload_champ_bv;
2962       do_cleanups (old_cleanups);
2963       return 0;
2964     }
2965 }
2966
2967 /* Look for a function to take NARGS args of ARGS.  Find
2968    the best match from among the overloaded methods or functions
2969    given by FNS_PTR or OLOAD_SYMS or XM_WORKER_VEC, respectively.
2970    One, and only one of FNS_PTR, OLOAD_SYMS and XM_WORKER_VEC can be
2971    non-NULL.
2972
2973    If XM_WORKER_VEC is NULL, then the length of the arrays FNS_PTR
2974    or OLOAD_SYMS (whichever is non-NULL) is specified in NUM_FNS.
2975
2976    Return the index of the best match; store an indication of the
2977    quality of the match in OLOAD_CHAMP_BV.
2978
2979    It is the caller's responsibility to free *OLOAD_CHAMP_BV.  */
2980
2981 static int
2982 find_oload_champ (struct value **args, int nargs,
2983                   int num_fns, struct fn_field *fns_ptr,
2984                   VEC (xmethod_worker_ptr) *xm_worker_vec,
2985                   struct symbol **oload_syms,
2986                   struct badness_vector **oload_champ_bv)
2987 {
2988   int ix;
2989   int fn_count;
2990   int xm_worker_vec_n = VEC_length (xmethod_worker_ptr, xm_worker_vec);
2991   /* A measure of how good an overloaded instance is.  */
2992   struct badness_vector *bv;
2993   /* Index of best overloaded function.  */
2994   int oload_champ = -1;
2995   /* Current ambiguity state for overload resolution.  */
2996   int oload_ambiguous = 0;
2997   /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs.  */
2998
2999   /* A champion can be found among methods alone, or among functions
3000      alone, or in xmethods alone, but not in more than one of these
3001      groups.  */
3002   gdb_assert ((fns_ptr != NULL) + (oload_syms != NULL) + (xm_worker_vec != NULL)
3003               == 1);
3004
3005   *oload_champ_bv = NULL;
3006
3007   fn_count = (xm_worker_vec != NULL
3008               ? VEC_length (xmethod_worker_ptr, xm_worker_vec)
3009               : num_fns);
3010   /* Consider each candidate in turn.  */
3011   for (ix = 0; ix < fn_count; ix++)
3012     {
3013       int jj;
3014       int static_offset = 0;
3015       int nparms;
3016       struct type **parm_types;
3017       struct xmethod_worker *worker = NULL;
3018
3019       if (xm_worker_vec != NULL)
3020         {
3021           worker = VEC_index (xmethod_worker_ptr, xm_worker_vec, ix);
3022           parm_types = get_xmethod_arg_types (worker, &nparms);
3023         }
3024       else
3025         {
3026           if (fns_ptr != NULL)
3027             {
3028               nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
3029               static_offset = oload_method_static_p (fns_ptr, ix);
3030             }
3031           else
3032             nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
3033
3034           parm_types = (struct type **)
3035             xmalloc (nparms * (sizeof (struct type *)));
3036           for (jj = 0; jj < nparms; jj++)
3037             parm_types[jj] = (fns_ptr != NULL
3038                               ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
3039                               : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
3040                               jj));
3041         }
3042
3043       /* Compare parameter types to supplied argument types.  Skip
3044          THIS for static methods.  */
3045       bv = rank_function (parm_types, nparms,
3046                           args + static_offset,
3047                           nargs - static_offset);
3048
3049       if (!*oload_champ_bv)
3050         {
3051           *oload_champ_bv = bv;
3052           oload_champ = 0;
3053         }
3054       else /* See whether current candidate is better or worse than
3055               previous best.  */
3056         switch (compare_badness (bv, *oload_champ_bv))
3057           {
3058           case 0:               /* Top two contenders are equally good.  */
3059             oload_ambiguous = 1;
3060             break;
3061           case 1:               /* Incomparable top contenders.  */
3062             oload_ambiguous = 2;
3063             break;
3064           case 2:               /* New champion, record details.  */
3065             *oload_champ_bv = bv;
3066             oload_ambiguous = 0;
3067             oload_champ = ix;
3068             break;
3069           case 3:
3070           default:
3071             break;
3072           }
3073       xfree (parm_types);
3074       if (overload_debug)
3075         {
3076           if (fns_ptr != NULL)
3077             fprintf_filtered (gdb_stderr,
3078                               "Overloaded method instance %s, # of parms %d\n",
3079                               fns_ptr[ix].physname, nparms);
3080           else if (xm_worker_vec != NULL)
3081             fprintf_filtered (gdb_stderr,
3082                               "Xmethod worker, # of parms %d\n",
3083                               nparms);
3084           else
3085             fprintf_filtered (gdb_stderr,
3086                               "Overloaded function instance "
3087                               "%s # of parms %d\n",
3088                               SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
3089                               nparms);
3090           for (jj = 0; jj < nargs - static_offset; jj++)
3091             fprintf_filtered (gdb_stderr,
3092                               "...Badness @ %d : %d\n",
3093                               jj, bv->rank[jj].rank);
3094           fprintf_filtered (gdb_stderr, "Overload resolution "
3095                             "champion is %d, ambiguous? %d\n",
3096                             oload_champ, oload_ambiguous);
3097         }
3098     }
3099
3100   return oload_champ;
3101 }
3102
3103 /* Return 1 if we're looking at a static method, 0 if we're looking at
3104    a non-static method or a function that isn't a method.  */
3105
3106 static int
3107 oload_method_static_p (struct fn_field *fns_ptr, int index)
3108 {
3109   if (fns_ptr && index >= 0 && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
3110     return 1;
3111   else
3112     return 0;
3113 }
3114
3115 /* Check how good an overload match OLOAD_CHAMP_BV represents.  */
3116
3117 static enum oload_classification
3118 classify_oload_match (struct badness_vector *oload_champ_bv,
3119                       int nargs,
3120                       int static_offset)
3121 {
3122   int ix;
3123   enum oload_classification worst = STANDARD;
3124
3125   for (ix = 1; ix <= nargs - static_offset; ix++)
3126     {
3127       /* If this conversion is as bad as INCOMPATIBLE_TYPE_BADNESS
3128          or worse return INCOMPATIBLE.  */
3129       if (compare_ranks (oload_champ_bv->rank[ix],
3130                          INCOMPATIBLE_TYPE_BADNESS) <= 0)
3131         return INCOMPATIBLE;    /* Truly mismatched types.  */
3132       /* Otherwise If this conversion is as bad as
3133          NS_POINTER_CONVERSION_BADNESS or worse return NON_STANDARD.  */
3134       else if (compare_ranks (oload_champ_bv->rank[ix],
3135                               NS_POINTER_CONVERSION_BADNESS) <= 0)
3136         worst = NON_STANDARD;   /* Non-standard type conversions
3137                                    needed.  */
3138     }
3139
3140   /* If no INCOMPATIBLE classification was found, return the worst one
3141      that was found (if any).  */
3142   return worst;
3143 }
3144
3145 /* C++: return 1 is NAME is a legitimate name for the destructor of
3146    type TYPE.  If TYPE does not have a destructor, or if NAME is
3147    inappropriate for TYPE, an error is signaled.  Parameter TYPE should not yet
3148    have CHECK_TYPEDEF applied, this function will apply it itself.  */
3149
3150 int
3151 destructor_name_p (const char *name, struct type *type)
3152 {
3153   if (name[0] == '~')
3154     {
3155       const char *dname = type_name_no_tag_or_error (type);
3156       const char *cp = strchr (dname, '<');
3157       unsigned int len;
3158
3159       /* Do not compare the template part for template classes.  */
3160       if (cp == NULL)
3161         len = strlen (dname);
3162       else
3163         len = cp - dname;
3164       if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
3165         error (_("name of destructor must equal name of class"));
3166       else
3167         return 1;
3168     }
3169   return 0;
3170 }
3171
3172 /* Find an enum constant named NAME in TYPE.  TYPE must be an "enum
3173    class".  If the name is found, return a value representing it;
3174    otherwise throw an exception.  */
3175
3176 static struct value *
3177 enum_constant_from_type (struct type *type, const char *name)
3178 {
3179   int i;
3180   int name_len = strlen (name);
3181
3182   gdb_assert (TYPE_CODE (type) == TYPE_CODE_ENUM
3183               && TYPE_DECLARED_CLASS (type));
3184
3185   for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i)
3186     {
3187       const char *fname = TYPE_FIELD_NAME (type, i);
3188       int len;
3189
3190       if (TYPE_FIELD_LOC_KIND (type, i) != FIELD_LOC_KIND_ENUMVAL
3191           || fname == NULL)
3192         continue;
3193
3194       /* Look for the trailing "::NAME", since enum class constant
3195          names are qualified here.  */
3196       len = strlen (fname);
3197       if (len + 2 >= name_len
3198           && fname[len - name_len - 2] == ':'
3199           && fname[len - name_len - 1] == ':'
3200           && strcmp (&fname[len - name_len], name) == 0)
3201         return value_from_longest (type, TYPE_FIELD_ENUMVAL (type, i));
3202     }
3203
3204   error (_("no constant named \"%s\" in enum \"%s\""),
3205          name, TYPE_TAG_NAME (type));
3206 }
3207
3208 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3209    return the appropriate member (or the address of the member, if
3210    WANT_ADDRESS).  This function is used to resolve user expressions
3211    of the form "DOMAIN::NAME".  For more details on what happens, see
3212    the comment before value_struct_elt_for_reference.  */
3213
3214 struct value *
3215 value_aggregate_elt (struct type *curtype, const char *name,
3216                      struct type *expect_type, int want_address,
3217                      enum noside noside)
3218 {
3219   switch (TYPE_CODE (curtype))
3220     {
3221     case TYPE_CODE_STRUCT:
3222     case TYPE_CODE_UNION:
3223       return value_struct_elt_for_reference (curtype, 0, curtype,
3224                                              name, expect_type,
3225                                              want_address, noside);
3226     case TYPE_CODE_NAMESPACE:
3227       return value_namespace_elt (curtype, name,
3228                                   want_address, noside);
3229
3230     case TYPE_CODE_ENUM:
3231       return enum_constant_from_type (curtype, name);
3232
3233     default:
3234       internal_error (__FILE__, __LINE__,
3235                       _("non-aggregate type in value_aggregate_elt"));
3236     }
3237 }
3238
3239 /* Compares the two method/function types T1 and T2 for "equality"
3240    with respect to the methods' parameters.  If the types of the
3241    two parameter lists are the same, returns 1; 0 otherwise.  This
3242    comparison may ignore any artificial parameters in T1 if
3243    SKIP_ARTIFICIAL is non-zero.  This function will ALWAYS skip
3244    the first artificial parameter in T1, assumed to be a 'this' pointer.
3245
3246    The type T2 is expected to have come from make_params (in eval.c).  */
3247
3248 static int
3249 compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
3250 {
3251   int start = 0;
3252
3253   if (TYPE_NFIELDS (t1) > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0))
3254     ++start;
3255
3256   /* If skipping artificial fields, find the first real field
3257      in T1.  */
3258   if (skip_artificial)
3259     {
3260       while (start < TYPE_NFIELDS (t1)
3261              && TYPE_FIELD_ARTIFICIAL (t1, start))
3262         ++start;
3263     }
3264
3265   /* Now compare parameters.  */
3266
3267   /* Special case: a method taking void.  T1 will contain no
3268      non-artificial fields, and T2 will contain TYPE_CODE_VOID.  */
3269   if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
3270       && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
3271     return 1;
3272
3273   if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
3274     {
3275       int i;
3276
3277       for (i = 0; i < TYPE_NFIELDS (t2); ++i)
3278         {
3279           if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
3280                                             TYPE_FIELD_TYPE (t2, i), NULL),
3281                              EXACT_MATCH_BADNESS) != 0)
3282             return 0;
3283         }
3284
3285       return 1;
3286     }
3287
3288   return 0;
3289 }
3290
3291 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3292    return the address of this member as a "pointer to member" type.
3293    If INTYPE is non-null, then it will be the type of the member we
3294    are looking for.  This will help us resolve "pointers to member
3295    functions".  This function is used to resolve user expressions of
3296    the form "DOMAIN::NAME".  */
3297
3298 static struct value *
3299 value_struct_elt_for_reference (struct type *domain, int offset,
3300                                 struct type *curtype, const char *name,
3301                                 struct type *intype,
3302                                 int want_address,
3303                                 enum noside noside)
3304 {
3305   struct type *t = curtype;
3306   int i;
3307   struct value *v, *result;
3308
3309   if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3310       && TYPE_CODE (t) != TYPE_CODE_UNION)
3311     error (_("Internal error: non-aggregate type "
3312              "to value_struct_elt_for_reference"));
3313
3314   for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3315     {
3316       const char *t_field_name = TYPE_FIELD_NAME (t, i);
3317
3318       if (t_field_name && strcmp (t_field_name, name) == 0)
3319         {
3320           if (field_is_static (&TYPE_FIELD (t, i)))
3321             {
3322               v = value_static_field (t, i);
3323               if (want_address)
3324                 v = value_addr (v);
3325               return v;
3326             }
3327           if (TYPE_FIELD_PACKED (t, i))
3328             error (_("pointers to bitfield members not allowed"));
3329
3330           if (want_address)
3331             return value_from_longest
3332               (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
3333                offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3334           else if (noside != EVAL_NORMAL)
3335             return allocate_value (TYPE_FIELD_TYPE (t, i));
3336           else
3337             {
3338               /* Try to evaluate NAME as a qualified name with implicit
3339                  this pointer.  In this case, attempt to return the
3340                  equivalent to `this->*(&TYPE::NAME)'.  */
3341               v = value_of_this_silent (current_language);
3342               if (v != NULL)
3343                 {
3344                   struct value *ptr;
3345                   long mem_offset;
3346                   struct type *type, *tmp;
3347
3348                   ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
3349                   type = check_typedef (value_type (ptr));
3350                   gdb_assert (type != NULL
3351                               && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR);
3352                   tmp = lookup_pointer_type (TYPE_DOMAIN_TYPE (type));
3353                   v = value_cast_pointers (tmp, v, 1);
3354                   mem_offset = value_as_long (ptr);
3355                   tmp = lookup_pointer_type (TYPE_TARGET_TYPE (type));
3356                   result = value_from_pointer (tmp,
3357                                                value_as_long (v) + mem_offset);
3358                   return value_ind (result);
3359                 }
3360
3361               error (_("Cannot reference non-static field \"%s\""), name);
3362             }
3363         }
3364     }
3365
3366   /* C++: If it was not found as a data field, then try to return it
3367      as a pointer to a method.  */
3368
3369   /* Perform all necessary dereferencing.  */
3370   while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3371     intype = TYPE_TARGET_TYPE (intype);
3372
3373   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3374     {
3375       const char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3376       char dem_opname[64];
3377
3378       if (strncmp (t_field_name, "__", 2) == 0
3379           || strncmp (t_field_name, "op", 2) == 0
3380           || strncmp (t_field_name, "type", 4) == 0)
3381         {
3382           if (cplus_demangle_opname (t_field_name,
3383                                      dem_opname, DMGL_ANSI))
3384             t_field_name = dem_opname;
3385           else if (cplus_demangle_opname (t_field_name,
3386                                           dem_opname, 0))
3387             t_field_name = dem_opname;
3388         }
3389       if (t_field_name && strcmp (t_field_name, name) == 0)
3390         {
3391           int j;
3392           int len = TYPE_FN_FIELDLIST_LENGTH (t, i);
3393           struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3394
3395           check_stub_method_group (t, i);
3396
3397           if (intype)
3398             {
3399               for (j = 0; j < len; ++j)
3400                 {
3401                   if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
3402                       || compare_parameters (TYPE_FN_FIELD_TYPE (f, j),
3403                                              intype, 1))
3404                     break;
3405                 }
3406
3407               if (j == len)
3408                 error (_("no member function matches "
3409                          "that type instantiation"));
3410             }
3411           else
3412             {
3413               int ii;
3414
3415               j = -1;
3416               for (ii = 0; ii < len; ++ii)
3417                 {
3418                   /* Skip artificial methods.  This is necessary if,
3419                      for example, the user wants to "print
3420                      subclass::subclass" with only one user-defined
3421                      constructor.  There is no ambiguity in this case.
3422                      We are careful here to allow artificial methods
3423                      if they are the unique result.  */
3424                   if (TYPE_FN_FIELD_ARTIFICIAL (f, ii))
3425                     {
3426                       if (j == -1)
3427                         j = ii;
3428                       continue;
3429                     }
3430
3431                   /* Desired method is ambiguous if more than one
3432                      method is defined.  */
3433                   if (j != -1 && !TYPE_FN_FIELD_ARTIFICIAL (f, j))
3434                     error (_("non-unique member `%s' requires "
3435                              "type instantiation"), name);
3436
3437                   j = ii;
3438                 }
3439
3440               if (j == -1)
3441                 error (_("no matching member function"));
3442             }
3443
3444           if (TYPE_FN_FIELD_STATIC_P (f, j))
3445             {
3446               struct symbol *s =
3447                 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3448                                0, VAR_DOMAIN, 0);
3449
3450               if (s == NULL)
3451                 return NULL;
3452
3453               if (want_address)
3454                 return value_addr (read_var_value (s, 0));
3455               else
3456                 return read_var_value (s, 0);
3457             }
3458
3459           if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3460             {
3461               if (want_address)
3462                 {
3463                   result = allocate_value
3464                     (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3465                   cplus_make_method_ptr (value_type (result),
3466                                          value_contents_writeable (result),
3467                                          TYPE_FN_FIELD_VOFFSET (f, j), 1);
3468                 }
3469               else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3470                 return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
3471               else
3472                 error (_("Cannot reference virtual member function \"%s\""),
3473                        name);
3474             }
3475           else
3476             {
3477               struct symbol *s =
3478                 lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3479                                0, VAR_DOMAIN, 0);
3480
3481               if (s == NULL)
3482                 return NULL;
3483
3484               v = read_var_value (s, 0);
3485               if (!want_address)
3486                 result = v;
3487               else
3488                 {
3489                   result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3490                   cplus_make_method_ptr (value_type (result),
3491                                          value_contents_writeable (result),
3492                                          value_address (v), 0);
3493                 }
3494             }
3495           return result;
3496         }
3497     }
3498   for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3499     {
3500       struct value *v;
3501       int base_offset;
3502
3503       if (BASETYPE_VIA_VIRTUAL (t, i))
3504         base_offset = 0;
3505       else
3506         base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3507       v = value_struct_elt_for_reference (domain,
3508                                           offset + base_offset,
3509                                           TYPE_BASECLASS (t, i),
3510                                           name, intype,
3511                                           want_address, noside);
3512       if (v)
3513         return v;
3514     }
3515
3516   /* As a last chance, pretend that CURTYPE is a namespace, and look
3517      it up that way; this (frequently) works for types nested inside
3518      classes.  */
3519
3520   return value_maybe_namespace_elt (curtype, name,
3521                                     want_address, noside);
3522 }
3523
3524 /* C++: Return the member NAME of the namespace given by the type
3525    CURTYPE.  */
3526
3527 static struct value *
3528 value_namespace_elt (const struct type *curtype,
3529                      const char *name, int want_address,
3530                      enum noside noside)
3531 {
3532   struct value *retval = value_maybe_namespace_elt (curtype, name,
3533                                                     want_address,
3534                                                     noside);
3535
3536   if (retval == NULL)
3537     error (_("No symbol \"%s\" in namespace \"%s\"."),
3538            name, TYPE_TAG_NAME (curtype));
3539
3540   return retval;
3541 }
3542
3543 /* A helper function used by value_namespace_elt and
3544    value_struct_elt_for_reference.  It looks up NAME inside the
3545    context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3546    is a class and NAME refers to a type in CURTYPE itself (as opposed
3547    to, say, some base class of CURTYPE).  */
3548
3549 static struct value *
3550 value_maybe_namespace_elt (const struct type *curtype,
3551                            const char *name, int want_address,
3552                            enum noside noside)
3553 {
3554   const char *namespace_name = TYPE_TAG_NAME (curtype);
3555   struct symbol *sym;
3556   struct value *result;
3557
3558   sym = cp_lookup_symbol_namespace (namespace_name, name,
3559                                     get_selected_block (0), VAR_DOMAIN);
3560
3561   if (sym == NULL)
3562     {
3563       char *concatenated_name = alloca (strlen (namespace_name) + 2
3564                                         + strlen (name) + 1);
3565
3566       sprintf (concatenated_name, "%s::%s", namespace_name, name);
3567       sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN);
3568     }
3569
3570   if (sym == NULL)
3571     return NULL;
3572   else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
3573            && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
3574     result = allocate_value (SYMBOL_TYPE (sym));
3575   else
3576     result = value_of_variable (sym, get_selected_block (0));
3577
3578   if (result && want_address)
3579     result = value_addr (result);
3580
3581   return result;
3582 }
3583
3584 /* Given a pointer or a reference value V, find its real (RTTI) type.
3585
3586    Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3587    and refer to the values computed for the object pointed to.  */
3588
3589 struct type *
3590 value_rtti_indirect_type (struct value *v, int *full,
3591                           int *top, int *using_enc)
3592 {
3593   struct value *target;
3594   struct type *type, *real_type, *target_type;
3595
3596   type = value_type (v);
3597   type = check_typedef (type);
3598   if (TYPE_CODE (type) == TYPE_CODE_REF)
3599     target = coerce_ref (v);
3600   else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3601     target = value_ind (v);
3602   else
3603     return NULL;
3604
3605   real_type = value_rtti_type (target, full, top, using_enc);
3606
3607   if (real_type)
3608     {
3609       /* Copy qualifiers to the referenced object.  */
3610       target_type = value_type (target);
3611       real_type = make_cv_type (TYPE_CONST (target_type),
3612                                 TYPE_VOLATILE (target_type), real_type, NULL);
3613       if (TYPE_CODE (type) == TYPE_CODE_REF)
3614         real_type = lookup_reference_type (real_type);
3615       else if (TYPE_CODE (type) == TYPE_CODE_PTR)
3616         real_type = lookup_pointer_type (real_type);
3617       else
3618         internal_error (__FILE__, __LINE__, _("Unexpected value type."));
3619
3620       /* Copy qualifiers to the pointer/reference.  */
3621       real_type = make_cv_type (TYPE_CONST (type), TYPE_VOLATILE (type),
3622                                 real_type, NULL);
3623     }
3624
3625   return real_type;
3626 }
3627
3628 /* Given a value pointed to by ARGP, check its real run-time type, and
3629    if that is different from the enclosing type, create a new value
3630    using the real run-time type as the enclosing type (and of the same
3631    type as ARGP) and return it, with the embedded offset adjusted to
3632    be the correct offset to the enclosed object.  RTYPE is the type,
3633    and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3634    by value_rtti_type().  If these are available, they can be supplied
3635    and a second call to value_rtti_type() is avoided.  (Pass RTYPE ==
3636    NULL if they're not available.  */
3637
3638 struct value *
3639 value_full_object (struct value *argp,
3640                    struct type *rtype,
3641                    int xfull, int xtop,
3642                    int xusing_enc)
3643 {
3644   struct type *real_type;
3645   int full = 0;
3646   int top = -1;
3647   int using_enc = 0;
3648   struct value *new_val;
3649
3650   if (rtype)
3651     {
3652       real_type = rtype;
3653       full = xfull;
3654       top = xtop;
3655       using_enc = xusing_enc;
3656     }
3657   else
3658     real_type = value_rtti_type (argp, &full, &top, &using_enc);
3659
3660   /* If no RTTI data, or if object is already complete, do nothing.  */
3661   if (!real_type || real_type == value_enclosing_type (argp))
3662     return argp;
3663
3664   /* In a destructor we might see a real type that is a superclass of
3665      the object's type.  In this case it is better to leave the object
3666      as-is.  */
3667   if (full
3668       && TYPE_LENGTH (real_type) < TYPE_LENGTH (value_enclosing_type (argp)))
3669     return argp;
3670
3671   /* If we have the full object, but for some reason the enclosing
3672      type is wrong, set it.  */
3673   /* pai: FIXME -- sounds iffy */
3674   if (full)
3675     {
3676       argp = value_copy (argp);
3677       set_value_enclosing_type (argp, real_type);
3678       return argp;
3679     }
3680
3681   /* Check if object is in memory.  */
3682   if (VALUE_LVAL (argp) != lval_memory)
3683     {
3684       warning (_("Couldn't retrieve complete object of RTTI "
3685                  "type %s; object may be in register(s)."),
3686                TYPE_NAME (real_type));
3687
3688       return argp;
3689     }
3690
3691   /* All other cases -- retrieve the complete object.  */
3692   /* Go back by the computed top_offset from the beginning of the
3693      object, adjusting for the embedded offset of argp if that's what
3694      value_rtti_type used for its computation.  */
3695   new_val = value_at_lazy (real_type, value_address (argp) - top +
3696                            (using_enc ? 0 : value_embedded_offset (argp)));
3697   deprecated_set_value_type (new_val, value_type (argp));
3698   set_value_embedded_offset (new_val, (using_enc
3699                                        ? top + value_embedded_offset (argp)
3700                                        : top));
3701   return new_val;
3702 }
3703
3704
3705 /* Return the value of the local variable, if one exists.  Throw error
3706    otherwise, such as if the request is made in an inappropriate context.  */
3707
3708 struct value *
3709 value_of_this (const struct language_defn *lang)
3710 {
3711   struct symbol *sym;
3712   const struct block *b;
3713   struct frame_info *frame;
3714
3715   if (!lang->la_name_of_this)
3716     error (_("no `this' in current language"));
3717
3718   frame = get_selected_frame (_("no frame selected"));
3719
3720   b = get_frame_block (frame, NULL);
3721
3722   sym = lookup_language_this (lang, b);
3723   if (sym == NULL)
3724     error (_("current stack frame does not contain a variable named `%s'"),
3725            lang->la_name_of_this);
3726
3727   return read_var_value (sym, frame);
3728 }
3729
3730 /* Return the value of the local variable, if one exists.  Return NULL
3731    otherwise.  Never throw error.  */
3732
3733 struct value *
3734 value_of_this_silent (const struct language_defn *lang)
3735 {
3736   struct value *ret = NULL;
3737   volatile struct gdb_exception except;
3738
3739   TRY_CATCH (except, RETURN_MASK_ERROR)
3740     {
3741       ret = value_of_this (lang);
3742     }
3743
3744   return ret;
3745 }
3746
3747 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3748    elements long, starting at LOWBOUND.  The result has the same lower
3749    bound as the original ARRAY.  */
3750
3751 struct value *
3752 value_slice (struct value *array, int lowbound, int length)
3753 {
3754   struct type *slice_range_type, *slice_type, *range_type;
3755   LONGEST lowerbound, upperbound;
3756   struct value *slice;
3757   struct type *array_type;
3758
3759   array_type = check_typedef (value_type (array));
3760   if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3761       && TYPE_CODE (array_type) != TYPE_CODE_STRING)
3762     error (_("cannot take slice of non-array"));
3763
3764   range_type = TYPE_INDEX_TYPE (array_type);
3765   if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3766     error (_("slice from bad array or bitstring"));
3767
3768   if (lowbound < lowerbound || length < 0
3769       || lowbound + length - 1 > upperbound)
3770     error (_("slice out of range"));
3771
3772   /* FIXME-type-allocation: need a way to free this type when we are
3773      done with it.  */
3774   slice_range_type = create_static_range_type ((struct type *) NULL,
3775                                                TYPE_TARGET_TYPE (range_type),
3776                                                lowbound,
3777                                                lowbound + length - 1);
3778
3779   {
3780     struct type *element_type = TYPE_TARGET_TYPE (array_type);
3781     LONGEST offset
3782       = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3783
3784     slice_type = create_array_type ((struct type *) NULL,
3785                                     element_type,
3786                                     slice_range_type);
3787     TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3788
3789     if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
3790       slice = allocate_value_lazy (slice_type);
3791     else
3792       {
3793         slice = allocate_value (slice_type);
3794         value_contents_copy (slice, 0, array, offset,
3795                              TYPE_LENGTH (slice_type));
3796       }
3797
3798     set_value_component_location (slice, array);
3799     VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
3800     set_value_offset (slice, value_offset (array) + offset);
3801   }
3802
3803   return slice;
3804 }
3805
3806 /* Create a value for a FORTRAN complex number.  Currently most of the
3807    time values are coerced to COMPLEX*16 (i.e. a complex number
3808    composed of 2 doubles.  This really should be a smarter routine
3809    that figures out precision inteligently as opposed to assuming
3810    doubles.  FIXME: fmb  */
3811
3812 struct value *
3813 value_literal_complex (struct value *arg1,
3814                        struct value *arg2,
3815                        struct type *type)
3816 {
3817   struct value *val;
3818   struct type *real_type = TYPE_TARGET_TYPE (type);
3819
3820   val = allocate_value (type);
3821   arg1 = value_cast (real_type, arg1);
3822   arg2 = value_cast (real_type, arg2);
3823
3824   memcpy (value_contents_raw (val),
3825           value_contents (arg1), TYPE_LENGTH (real_type));
3826   memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
3827           value_contents (arg2), TYPE_LENGTH (real_type));
3828   return val;
3829 }
3830
3831 /* Cast a value into the appropriate complex data type.  */
3832
3833 static struct value *
3834 cast_into_complex (struct type *type, struct value *val)
3835 {
3836   struct type *real_type = TYPE_TARGET_TYPE (type);
3837
3838   if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
3839     {
3840       struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
3841       struct value *re_val = allocate_value (val_real_type);
3842       struct value *im_val = allocate_value (val_real_type);
3843
3844       memcpy (value_contents_raw (re_val),
3845               value_contents (val), TYPE_LENGTH (val_real_type));
3846       memcpy (value_contents_raw (im_val),
3847               value_contents (val) + TYPE_LENGTH (val_real_type),
3848               TYPE_LENGTH (val_real_type));
3849
3850       return value_literal_complex (re_val, im_val, type);
3851     }
3852   else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
3853            || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
3854     return value_literal_complex (val,
3855                                   value_zero (real_type, not_lval),
3856                                   type);
3857   else
3858     error (_("cannot cast non-number to complex"));
3859 }
3860
3861 void
3862 _initialize_valops (void)
3863 {
3864   add_setshow_boolean_cmd ("overload-resolution", class_support,
3865                            &overload_resolution, _("\
3866 Set overload resolution in evaluating C++ functions."), _("\
3867 Show overload resolution in evaluating C++ functions."),
3868                            NULL, NULL,
3869                            show_overload_resolution,
3870                            &setlist, &showlist);
3871   overload_resolution = 1;
3872 }