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