gdb/valops.c

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