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