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