gdb/valops.c

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