gdb/valops.c

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