contrib/gdb/gdb/valops.c

   1 /* Perform non-arithmetic operations on values, for GDB.
   2    Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "value.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29 #include "demangle.h"
  30 #include "language.h"
  31 #include "gdbcmd.h"
  32
  33 #include <errno.h>
  34 #include "gdb_string.h"
  35
  36 /* Default to coercing float to double in function calls only when there is
  37    no prototype.  Otherwise on targets where the debug information is incorrect
  38    for either the prototype or non-prototype case, we can force it by defining
  39    COERCE_FLOAT_TO_DOUBLE in the target configuration file. */
  40
  41 #ifndef COERCE_FLOAT_TO_DOUBLE
  42 #define COERCE_FLOAT_TO_DOUBLE (param_type == NULL)
  43 #endif
  44
  45 /* Flag indicating HP compilers were used; needed to correctly handle some
  46    value operations with HP aCC code/runtime. */
  47 extern int hp_som_som_object_present;
  48
  49
  50 /* Local functions.  */
  51
  52 static int typecmp PARAMS ((int staticp, struct type *t1[], value_ptr t2[]));
  53
  54 #ifdef CALL_DUMMY
  55 static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
  56 static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *, int));
  57 #endif
  58
  59
  60 #ifndef PUSH_ARGUMENTS
  61 static CORE_ADDR value_push PARAMS ((CORE_ADDR, value_ptr));
  62 #endif
  63
  64 static value_ptr search_struct_field PARAMS ((char *, value_ptr, int,
  65                                               struct type *, int));
  66
  67 static value_ptr search_struct_field_aux PARAMS ((char *, value_ptr, int,
  68                                                   struct type *, int, int *, char *,
  69                                                   struct type **));
  70
  71 static value_ptr search_struct_method PARAMS ((char *, value_ptr *,
  72                                                value_ptr *,
  73                                                int, int *, struct type *));
  74
  75 static int check_field_in PARAMS ((struct type *, const char *));
  76
  77 static CORE_ADDR allocate_space_in_inferior PARAMS ((int));
  78
  79 static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
  80
  81 void _initialize_valops PARAMS ((void));
  82
  83 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
  84
  85 /* Flag for whether we want to abandon failed expression evals by default.  */
  86
  87 #if 0
  88 static int auto_abandon = 0;
  89 #endif
  90
  91 int overload_resolution = 0;
  92
  93
  94 \f
  95 /* Find the address of function name NAME in the inferior.  */
  96
  97 value_ptr
  98 find_function_in_inferior (name)
  99      char *name;
 100 {
 101   register struct symbol *sym;
 102   sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
 103   if (sym != NULL)
 104     {
 105       if (SYMBOL_CLASS (sym) != LOC_BLOCK)
 106         {
 107           error ("\"%s\" exists in this program but is not a function.",
 108                  name);
 109         }
 110       return value_of_variable (sym, NULL);
 111     }
 112   else
 113     {
 114       struct minimal_symbol *msymbol = lookup_minimal_symbol(name, NULL, NULL);
 115       if (msymbol != NULL)
 116         {
 117           struct type *type;
 118           LONGEST maddr;
 119           type = lookup_pointer_type (builtin_type_char);
 120           type = lookup_function_type (type);
 121           type = lookup_pointer_type (type);
 122           maddr = (LONGEST) SYMBOL_VALUE_ADDRESS (msymbol);
 123           return value_from_longest (type, maddr);
 124         }
 125       else
 126         {
 127           if (!target_has_execution)
 128             error ("evaluation of this expression requires the target program to be active");
 129           else
 130             error ("evaluation of this expression requires the program to have a function \"%s\".", name);
 131         }
 132     }
 133 }
 134
 135 /* Allocate NBYTES of space in the inferior using the inferior's malloc
 136    and return a value that is a pointer to the allocated space. */
 137
 138 value_ptr
 139 value_allocate_space_in_inferior (len)
 140      int len;
 141 {
 142   value_ptr blocklen;
 143   register value_ptr val = find_function_in_inferior ("malloc");
 144
 145   blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
 146   val = call_function_by_hand (val, 1, &blocklen);
 147   if (value_logical_not (val))
 148     {
 149       if (!target_has_execution)
 150         error ("No memory available to program now: you need to start the target first");
 151       else
 152         error ("No memory available to program: call to malloc failed");
 153     }
 154   return val;
 155 }
 156
 157 static CORE_ADDR
 158 allocate_space_in_inferior (len)
 159      int len;
 160 {
 161   return value_as_long (value_allocate_space_in_inferior (len));
 162 }
 163
 164 /* Cast value ARG2 to type TYPE and return as a value.
 165    More general than a C cast: accepts any two types of the same length,
 166    and if ARG2 is an lvalue it can be cast into anything at all.  */
 167 /* In C++, casts may change pointer or object representations.  */
 168
 169 value_ptr
 170 value_cast (type, arg2)
 171      struct type *type;
 172      register value_ptr arg2;
 173 {
 174   register enum type_code code1;
 175   register enum type_code code2;
 176   register int scalar;
 177   struct type *type2;
 178
 179   int convert_to_boolean = 0;
 180
 181   if (VALUE_TYPE (arg2) == type)
 182     return arg2;
 183
 184   CHECK_TYPEDEF (type);
 185   code1 = TYPE_CODE (type);
 186   COERCE_REF(arg2);
 187   type2 = check_typedef (VALUE_TYPE (arg2));
 188
 189   /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
 190      is treated like a cast to (TYPE [N])OBJECT,
 191      where N is sizeof(OBJECT)/sizeof(TYPE). */
 192   if (code1 == TYPE_CODE_ARRAY)
 193     {
 194       struct type *element_type = TYPE_TARGET_TYPE (type);
 195       unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
 196       if (element_length > 0
 197           && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
 198         {
 199           struct type *range_type = TYPE_INDEX_TYPE (type);
 200           int val_length = TYPE_LENGTH (type2);
 201           LONGEST low_bound, high_bound, new_length;
 202           if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
 203             low_bound = 0, high_bound = 0;
 204           new_length = val_length / element_length;
 205           if (val_length % element_length != 0)
 206             warning("array element type size does not divide object size in cast");
 207           /* FIXME-type-allocation: need a way to free this type when we are
 208              done with it.  */
 209           range_type = create_range_type ((struct type *) NULL,
 210                                           TYPE_TARGET_TYPE (range_type),
 211                                           low_bound,
 212                                           new_length + low_bound - 1);
 213           VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
 214                                                  element_type, range_type);
 215           return arg2;
 216         }
 217     }
 218
 219   if (current_language->c_style_arrays
 220       && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
 221     arg2 = value_coerce_array (arg2);
 222
 223   if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
 224     arg2 = value_coerce_function (arg2);
 225
 226   type2 = check_typedef (VALUE_TYPE (arg2));
 227   COERCE_VARYING_ARRAY (arg2, type2);
 228   code2 = TYPE_CODE (type2);
 229
 230   if (code1 == TYPE_CODE_COMPLEX)
 231     return cast_into_complex (type, arg2);
 232   if (code1 == TYPE_CODE_BOOL)
 233     {
 234       code1 = TYPE_CODE_INT;
 235       convert_to_boolean = 1;
 236     }
 237   if (code1 == TYPE_CODE_CHAR)
 238     code1 = TYPE_CODE_INT;
 239   if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
 240     code2 = TYPE_CODE_INT;
 241
 242   scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
 243             || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
 244
 245   if (   code1 == TYPE_CODE_STRUCT
 246       && code2 == TYPE_CODE_STRUCT
 247       && TYPE_NAME (type) != 0)
 248     {
 249       /* Look in the type of the source to see if it contains the
 250          type of the target as a superclass.  If so, we'll need to
 251          offset the object in addition to changing its type.  */
 252       value_ptr v = search_struct_field (type_name_no_tag (type),
 253                                          arg2, 0, type2, 1);
 254       if (v)
 255         {
 256           VALUE_TYPE (v) = type;
 257           return v;
 258         }
 259     }
 260   if (code1 == TYPE_CODE_FLT && scalar)
 261     return value_from_double (type, value_as_double (arg2));
 262   else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
 263             || code1 == TYPE_CODE_RANGE)
 264            && (scalar || code2 == TYPE_CODE_PTR))
 265     {
 266       LONGEST longest;
 267
 268       if (hp_som_som_object_present &&  /* if target compiled by HP aCC */
 269           (code2 == TYPE_CODE_PTR))
 270         {
 271           unsigned int * ptr;
 272           value_ptr retvalp;
 273
 274           switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
 275             {
 276               /* With HP aCC, pointers to data members have a bias */
 277               case TYPE_CODE_MEMBER:
 278                 retvalp = value_from_longest (type, value_as_long (arg2));
 279                 ptr = (unsigned int *) VALUE_CONTENTS (retvalp); /* force evaluation */
 280                 *ptr &= ~0x20000000; /* zap 29th bit to remove bias */
 281                 return retvalp;
 282
 283               /* While pointers to methods don't really point to a function */
 284               case TYPE_CODE_METHOD:
 285                 error ("Pointers to methods not supported with HP aCC");
 286
 287               default:
 288                 break; /* fall out and go to normal handling */
 289             }
 290         }
 291       longest = value_as_long (arg2);
 292       return value_from_longest (type, convert_to_boolean ? (LONGEST) (longest ? 1 : 0) : longest);
 293     }
 294   else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
 295     {
 296       if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
 297         {
 298           struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
 299           struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
 300           if (   TYPE_CODE (t1) == TYPE_CODE_STRUCT
 301               && TYPE_CODE (t2) == TYPE_CODE_STRUCT
 302               && !value_logical_not (arg2))
 303             {
 304               value_ptr v;
 305
 306               /* Look in the type of the source to see if it contains the
 307                  type of the target as a superclass.  If so, we'll need to
 308                  offset the pointer rather than just change its type.  */
 309               if (TYPE_NAME (t1) != NULL)
 310                 {
 311                   v = search_struct_field (type_name_no_tag (t1),
 312                                            value_ind (arg2), 0, t2, 1);
 313                   if (v)
 314                     {
 315                       v = value_addr (v);
 316                       VALUE_TYPE (v) = type;
 317                       return v;
 318                     }
 319                 }
 320
 321               /* Look in the type of the target to see if it contains the
 322                  type of the source as a superclass.  If so, we'll need to
 323                  offset the pointer rather than just change its type.
 324                  FIXME: This fails silently with virtual inheritance.  */
 325               if (TYPE_NAME (t2) != NULL)
 326                 {
 327                   v = search_struct_field (type_name_no_tag (t2),
 328                                            value_zero (t1, not_lval), 0, t1, 1);
 329                   if (v)
 330                     {
 331                       value_ptr v2 = value_ind (arg2);
 332                       VALUE_ADDRESS (v2) -= VALUE_ADDRESS (v)
 333                                             + VALUE_OFFSET (v);
 334                       v2 = value_addr (v2);
 335                       VALUE_TYPE (v2) = type;
 336                       return v2;
 337                     }
 338                 }
 339             }
 340           /* No superclass found, just fall through to change ptr type.  */
 341         }
 342       VALUE_TYPE (arg2) = type;
 343       VALUE_ENCLOSING_TYPE (arg2) = type;  /* pai: chk_val */
 344       VALUE_POINTED_TO_OFFSET (arg2) = 0;  /* pai: chk_val */
 345       return arg2;
 346     }
 347   else if (chill_varying_type (type))
 348     {
 349       struct type *range1, *range2, *eltype1, *eltype2;
 350       value_ptr val;
 351       int count1, count2;
 352       LONGEST low_bound, high_bound;
 353       char *valaddr, *valaddr_data;
 354       /* For lint warning about eltype2 possibly uninitialized: */
 355       eltype2 = NULL;
 356       if (code2 == TYPE_CODE_BITSTRING)
 357         error ("not implemented: converting bitstring to varying type");
 358       if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING)
 359           || (eltype1 = check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1))),
 360               eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)),
 361               (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
 362                /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
 363         error ("Invalid conversion to varying type");
 364       range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0);
 365       range2 = TYPE_FIELD_TYPE (type2, 0);
 366       if (get_discrete_bounds (range1, &low_bound, &high_bound) < 0)
 367         count1 = -1;
 368       else
 369         count1 = high_bound - low_bound + 1;
 370       if (get_discrete_bounds (range2, &low_bound, &high_bound) < 0)
 371         count1 = -1, count2 = 0;  /* To force error before */
 372       else
 373         count2 = high_bound - low_bound + 1;
 374       if (count2 > count1)
 375         error ("target varying type is too small");
 376       val = allocate_value (type);
 377       valaddr = VALUE_CONTENTS_RAW (val);
 378       valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
 379       /* Set val's __var_length field to count2. */
 380       store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)),
 381                             count2);
 382       /* Set the __var_data field to count2 elements copied from arg2. */
 383       memcpy (valaddr_data, VALUE_CONTENTS (arg2),
 384               count2 * TYPE_LENGTH (eltype2));
 385       /* Zero the rest of the __var_data field of val. */
 386       memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0',
 387               (count1 - count2) * TYPE_LENGTH (eltype2));
 388       return val;
 389     }
 390   else if (VALUE_LVAL (arg2) == lval_memory)
 391     {
 392       return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2),
 393                             VALUE_BFD_SECTION (arg2));
 394     }
 395   else if (code1 == TYPE_CODE_VOID)
 396     {
 397       return value_zero (builtin_type_void, not_lval);
 398     }
 399   else
 400     {
 401       error ("Invalid cast.");
 402       return 0;
 403     }
 404 }
 405
 406 /* Create a value of type TYPE that is zero, and return it.  */
 407
 408 value_ptr
 409 value_zero (type, lv)
 410      struct type *type;
 411      enum lval_type lv;
 412 {
 413   register value_ptr val = allocate_value (type);
 414
 415   memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
 416   VALUE_LVAL (val) = lv;
 417
 418   return val;
 419 }
 420
 421 /* Return a value with type TYPE located at ADDR.
 422
 423    Call value_at only if the data needs to be fetched immediately;
 424    if we can be 'lazy' and defer the fetch, perhaps indefinately, call
 425    value_at_lazy instead.  value_at_lazy simply records the address of
 426    the data and sets the lazy-evaluation-required flag.  The lazy flag
 427    is tested in the VALUE_CONTENTS macro, which is used if and when
 428    the contents are actually required.
 429
 430    Note: value_at does *NOT* handle embedded offsets; perform such
 431    adjustments before or after calling it. */
 432
 433 value_ptr
 434 value_at (type, addr, sect)
 435      struct type *type;
 436      CORE_ADDR addr;
 437      asection *sect;
 438 {
 439   register value_ptr val;
 440
 441   if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
 442     error ("Attempt to dereference a generic pointer.");
 443
 444   val = allocate_value (type);
 445
 446 #ifdef GDB_TARGET_IS_D10V
 447   if (TYPE_CODE (type) == TYPE_CODE_PTR
 448       && TYPE_TARGET_TYPE (type)
 449       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
 450     {
 451       /* pointer to function */
 452       unsigned long num;
 453       unsigned short snum;
 454       snum = read_memory_unsigned_integer (addr, 2);
 455       num = D10V_MAKE_IADDR(snum);
 456       store_address ( VALUE_CONTENTS_RAW (val), 4, num);
 457     }
 458   else if (TYPE_CODE(type) == TYPE_CODE_PTR)
 459     {
 460       /* pointer to data */
 461       unsigned long num;
 462       unsigned short snum;
 463       snum = read_memory_unsigned_integer (addr, 2);
 464       num = D10V_MAKE_DADDR(snum);
 465       store_address ( VALUE_CONTENTS_RAW (val), 4, num);
 466     }
 467   else
 468 #endif
 469     read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type), sect);
 470
 471   VALUE_LVAL (val) = lval_memory;
 472   VALUE_ADDRESS (val) = addr;
 473   VALUE_BFD_SECTION (val) = sect;
 474
 475   return val;
 476 }
 477
 478 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
 479
 480 value_ptr
 481 value_at_lazy (type, addr, sect)
 482      struct type *type;
 483      CORE_ADDR addr;
 484      asection *sect;
 485 {
 486   register value_ptr val;
 487
 488   if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
 489     error ("Attempt to dereference a generic pointer.");
 490
 491   val = allocate_value (type);
 492
 493   VALUE_LVAL (val) = lval_memory;
 494   VALUE_ADDRESS (val) = addr;
 495   VALUE_LAZY (val) = 1;
 496   VALUE_BFD_SECTION (val) = sect;
 497
 498   return val;
 499 }
 500
 501 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
 502    if the current data for a variable needs to be loaded into
 503    VALUE_CONTENTS(VAL).  Fetches the data from the user's process, and
 504    clears the lazy flag to indicate that the data in the buffer is valid.
 505
 506    If the value is zero-length, we avoid calling read_memory, which would
 507    abort.  We mark the value as fetched anyway -- all 0 bytes of it.
 508
 509    This function returns a value because it is used in the VALUE_CONTENTS
 510    macro as part of an expression, where a void would not work.  The
 511    value is ignored.  */
 512
 513 int
 514 value_fetch_lazy (val)
 515      register value_ptr val;
 516 {
 517   CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
 518   int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
 519
 520 #ifdef GDB_TARGET_IS_D10V
 521   struct type *type = VALUE_TYPE(val);
 522   if (TYPE_CODE (type) == TYPE_CODE_PTR
 523       && TYPE_TARGET_TYPE (type)
 524       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
 525     {
 526       /* pointer to function */
 527       unsigned long num;
 528       unsigned short snum;
 529       snum = read_memory_unsigned_integer (addr, 2);
 530       num = D10V_MAKE_IADDR(snum);
 531       store_address ( VALUE_CONTENTS_RAW (val), 4, num);
 532     }
 533   else if (TYPE_CODE(type) == TYPE_CODE_PTR)
 534     {
 535       /* pointer to data */
 536       unsigned long num;
 537       unsigned short snum;
 538       snum = read_memory_unsigned_integer (addr, 2);
 539       num = D10V_MAKE_DADDR(snum);
 540       store_address ( VALUE_CONTENTS_RAW (val), 4, num);
 541     }
 542   else
 543 #endif
 544
 545   if (length)
 546     read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), length,
 547                          VALUE_BFD_SECTION (val));
 548   VALUE_LAZY (val) = 0;
 549   return 0;
 550 }
 551
 552
 553 /* Store the contents of FROMVAL into the location of TOVAL.
 554    Return a new value with the location of TOVAL and contents of FROMVAL.  */
 555
 556 value_ptr
 557 value_assign (toval, fromval)
 558      register value_ptr toval, fromval;
 559 {
 560   register struct type *type;
 561   register value_ptr val;
 562   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 563   int use_buffer = 0;
 564
 565   if (!toval->modifiable)
 566     error ("Left operand of assignment is not a modifiable lvalue.");
 567
 568   COERCE_REF (toval);
 569
 570   type = VALUE_TYPE (toval);
 571   if (VALUE_LVAL (toval) != lval_internalvar)
 572     fromval = value_cast (type, fromval);
 573   else
 574     COERCE_ARRAY (fromval);
 575   CHECK_TYPEDEF (type);
 576
 577   /* If TOVAL is a special machine register requiring conversion
 578      of program values to a special raw format,
 579      convert FROMVAL's contents now, with result in `raw_buffer',
 580      and set USE_BUFFER to the number of bytes to write.  */
 581
 582 #ifdef REGISTER_CONVERTIBLE
 583   if (VALUE_REGNO (toval) >= 0
 584       && REGISTER_CONVERTIBLE (VALUE_REGNO (toval)))
 585     {
 586       int regno = VALUE_REGNO (toval);
 587       if (REGISTER_CONVERTIBLE (regno))
 588         {
 589           struct type *fromtype = check_typedef (VALUE_TYPE (fromval));
 590           REGISTER_CONVERT_TO_RAW (fromtype, regno,
 591                                    VALUE_CONTENTS (fromval), raw_buffer);
 592           use_buffer = REGISTER_RAW_SIZE (regno);
 593         }
 594     }
 595 #endif
 596
 597   switch (VALUE_LVAL (toval))
 598     {
 599     case lval_internalvar:
 600       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
 601       val = value_copy (VALUE_INTERNALVAR (toval)->value);
 602       VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval);
 603       VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
 604       VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
 605       return val;
 606
 607     case lval_internalvar_component:
 608       set_internalvar_component (VALUE_INTERNALVAR (toval),
 609                                  VALUE_OFFSET (toval),
 610                                  VALUE_BITPOS (toval),
 611                                  VALUE_BITSIZE (toval),
 612                                  fromval);
 613       break;
 614
 615     case lval_memory:
 616       {
 617         char *dest_buffer;
 618         CORE_ADDR changed_addr;
 619         int changed_len;
 620
 621         if (VALUE_BITSIZE (toval))
 622           {
 623             char buffer[sizeof (LONGEST)];
 624             /* We assume that the argument to read_memory is in units of
 625                host chars.  FIXME:  Is that correct?  */
 626             changed_len = (VALUE_BITPOS (toval)
 627                      + VALUE_BITSIZE (toval)
 628                      + HOST_CHAR_BIT - 1)
 629                     / HOST_CHAR_BIT;
 630
 631             if (changed_len > (int) sizeof (LONGEST))
 632               error ("Can't handle bitfields which don't fit in a %d bit word.",
 633                      sizeof (LONGEST) * HOST_CHAR_BIT);
 634
 635             read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 636                          buffer, changed_len);
 637             modify_field (buffer, value_as_long (fromval),
 638                           VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 639             changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
 640             dest_buffer = buffer;
 641           }
 642         else if (use_buffer)
 643           {
 644             changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
 645             changed_len = use_buffer;
 646             dest_buffer = raw_buffer;
 647           }
 648         else
 649           {
 650             changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
 651             changed_len = TYPE_LENGTH (type);
 652             dest_buffer = VALUE_CONTENTS (fromval);
 653           }
 654
 655         write_memory (changed_addr, dest_buffer, changed_len);
 656         if (memory_changed_hook)
 657           memory_changed_hook (changed_addr, changed_len);
 658       }
 659       break;
 660
 661     case lval_register:
 662       if (VALUE_BITSIZE (toval))
 663         {
 664           char buffer[sizeof (LONGEST)];
 665           int len = REGISTER_RAW_SIZE (VALUE_REGNO (toval));
 666
 667           if (len > (int) sizeof (LONGEST))
 668             error ("Can't handle bitfields in registers larger than %d bits.",
 669                    sizeof (LONGEST) * HOST_CHAR_BIT);
 670
 671           if (VALUE_BITPOS (toval) + VALUE_BITSIZE (toval)
 672               > len * HOST_CHAR_BIT)
 673             /* Getting this right would involve being very careful about
 674                byte order.  */
 675             error ("\
 676 Can't handle bitfield which doesn't fit in a single register.");
 677
 678           read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 679                                buffer, len);
 680           modify_field (buffer, value_as_long (fromval),
 681                         VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 682           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 683                                 buffer, len);
 684         }
 685       else if (use_buffer)
 686         write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 687                               raw_buffer, use_buffer);
 688       else
 689         {
 690           /* Do any conversion necessary when storing this type to more
 691              than one register.  */
 692 #ifdef REGISTER_CONVERT_FROM_TYPE
 693           memcpy (raw_buffer, VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
 694           REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval), type, raw_buffer);
 695           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 696                                 raw_buffer, TYPE_LENGTH (type));
 697 #else
 698           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 699                                 VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
 700 #endif
 701         }
 702       /* Assigning to the stack pointer, frame pointer, and other
 703          (architecture and calling convention specific) registers may
 704          cause the frame cache to be out of date.  We just do this
 705          on all assignments to registers for simplicity; I doubt the slowdown
 706          matters.  */
 707       reinit_frame_cache ();
 708       break;
 709
 710     case lval_reg_frame_relative:
 711       {
 712         /* value is stored in a series of registers in the frame
 713            specified by the structure.  Copy that value out, modify
 714            it, and copy it back in.  */
 715         int amount_to_copy = (VALUE_BITSIZE (toval) ? 1 : TYPE_LENGTH (type));
 716         int reg_size = REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval));
 717         int byte_offset = VALUE_OFFSET (toval) % reg_size;
 718         int reg_offset = VALUE_OFFSET (toval) / reg_size;
 719         int amount_copied;
 720
 721         /* Make the buffer large enough in all cases.  */
 722         char *buffer = (char *) alloca (amount_to_copy
 723                                         + sizeof (LONGEST)
 724                                         + MAX_REGISTER_RAW_SIZE);
 725
 726         int regno;
 727         struct frame_info *frame;
 728
 729         /* Figure out which frame this is in currently.  */
 730         for (frame = get_current_frame ();
 731              frame && FRAME_FP (frame) != VALUE_FRAME (toval);
 732              frame = get_prev_frame (frame))
 733           ;
 734
 735         if (!frame)
 736           error ("Value being assigned to is no longer active.");
 737
 738         amount_to_copy += (reg_size - amount_to_copy % reg_size);
 739
 740         /* Copy it out.  */
 741         for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
 742               amount_copied = 0);
 743              amount_copied < amount_to_copy;
 744              amount_copied += reg_size, regno++)
 745           {
 746             get_saved_register (buffer + amount_copied,
 747                                 (int *)NULL, (CORE_ADDR *)NULL,
 748                                 frame, regno, (enum lval_type *)NULL);
 749           }
 750
 751         /* Modify what needs to be modified.  */
 752         if (VALUE_BITSIZE (toval))
 753           modify_field (buffer + byte_offset,
 754                         value_as_long (fromval),
 755                         VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 756         else if (use_buffer)
 757           memcpy (buffer + byte_offset, raw_buffer, use_buffer);
 758         else
 759           memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
 760                   TYPE_LENGTH (type));
 761
 762         /* Copy it back.  */
 763         for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
 764               amount_copied = 0);
 765              amount_copied < amount_to_copy;
 766              amount_copied += reg_size, regno++)
 767           {
 768             enum lval_type lval;
 769             CORE_ADDR addr;
 770             int optim;
 771
 772             /* Just find out where to put it.  */
 773             get_saved_register ((char *)NULL,
 774                                 &optim, &addr, frame, regno, &lval);
 775
 776             if (optim)
 777               error ("Attempt to assign to a value that was optimized out.");
 778             if (lval == lval_memory)
 779               write_memory (addr, buffer + amount_copied, reg_size);
 780             else if (lval == lval_register)
 781               write_register_bytes (addr, buffer + amount_copied, reg_size);
 782             else
 783               error ("Attempt to assign to an unmodifiable value.");
 784           }
 785
 786         if (register_changed_hook)
 787           register_changed_hook (-1);
 788       }
 789       break;
 790
 791
 792     default:
 793       error ("Left operand of assignment is not an lvalue.");
 794     }
 795
 796   /* If the field does not entirely fill a LONGEST, then zero the sign bits.
 797      If the field is signed, and is negative, then sign extend. */
 798   if ((VALUE_BITSIZE (toval) > 0)
 799       && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST)))
 800     {
 801       LONGEST fieldval = value_as_long (fromval);
 802       LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
 803
 804       fieldval &= valmask;
 805       if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
 806         fieldval |= ~valmask;
 807
 808       fromval = value_from_longest (type, fieldval);
 809     }
 810
 811   val = value_copy (toval);
 812   memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
 813           TYPE_LENGTH (type));
 814   VALUE_TYPE (val) = type;
 815   VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval);
 816   VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
 817   VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
 818
 819   return val;
 820 }
 821
 822 /* Extend a value VAL to COUNT repetitions of its type.  */
 823
 824 value_ptr
 825 value_repeat (arg1, count)
 826      value_ptr arg1;
 827      int count;
 828 {
 829   register value_ptr val;
 830
 831   if (VALUE_LVAL (arg1) != lval_memory)
 832     error ("Only values in memory can be extended with '@'.");
 833   if (count < 1)
 834     error ("Invalid number %d of repetitions.", count);
 835
 836   val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count);
 837
 838   read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
 839                VALUE_CONTENTS_ALL_RAW (val),
 840                TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)));
 841   VALUE_LVAL (val) = lval_memory;
 842   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
 843
 844   return val;
 845 }
 846
 847 value_ptr
 848 value_of_variable (var, b)
 849      struct symbol *var;
 850      struct block *b;
 851 {
 852   value_ptr val;
 853   struct frame_info *frame = NULL;
 854
 855   if (!b)
 856     frame = NULL;               /* Use selected frame.  */
 857   else if (symbol_read_needs_frame (var))
 858     {
 859       frame = block_innermost_frame (b);
 860       if (!frame)
 861         {
 862           if (BLOCK_FUNCTION (b)
 863               && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)))
 864             error ("No frame is currently executing in block %s.",
 865                    SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)));
 866           else
 867             error ("No frame is currently executing in specified block");
 868         }
 869     }
 870
 871   val = read_var_value (var, frame);
 872   if (!val)
 873     error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 874
 875   return val;
 876 }
 877
 878 /* Given a value which is an array, return a value which is a pointer to its
 879    first element, regardless of whether or not the array has a nonzero lower
 880    bound.
 881
 882    FIXME:  A previous comment here indicated that this routine should be
 883    substracting the array's lower bound.  It's not clear to me that this
 884    is correct.  Given an array subscripting operation, it would certainly
 885    work to do the adjustment here, essentially computing:
 886
 887    (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
 888
 889    However I believe a more appropriate and logical place to account for
 890    the lower bound is to do so in value_subscript, essentially computing:
 891
 892    (&array[0] + ((index - lowerbound) * sizeof array[0]))
 893
 894    As further evidence consider what would happen with operations other
 895    than array subscripting, where the caller would get back a value that
 896    had an address somewhere before the actual first element of the array,
 897    and the information about the lower bound would be lost because of
 898    the coercion to pointer type.
 899    */
 900
 901 value_ptr
 902 value_coerce_array (arg1)
 903      value_ptr arg1;
 904 {
 905   register struct type *type = check_typedef (VALUE_TYPE (arg1));
 906
 907   if (VALUE_LVAL (arg1) != lval_memory)
 908     error ("Attempt to take address of value not located in memory.");
 909
 910   return value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
 911                        (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 912 }
 913
 914 /* Given a value which is a function, return a value which is a pointer
 915    to it.  */
 916
 917 value_ptr
 918 value_coerce_function (arg1)
 919      value_ptr arg1;
 920 {
 921   value_ptr retval;
 922
 923   if (VALUE_LVAL (arg1) != lval_memory)
 924     error ("Attempt to take address of value not located in memory.");
 925
 926   retval = value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
 927                                (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 928   VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1);
 929   return retval;
 930 }
 931
 932 /* Return a pointer value for the object for which ARG1 is the contents.  */
 933
 934 value_ptr
 935 value_addr (arg1)
 936      value_ptr arg1;
 937 {
 938   value_ptr arg2;
 939
 940   struct type *type = check_typedef (VALUE_TYPE (arg1));
 941   if (TYPE_CODE (type) == TYPE_CODE_REF)
 942     {
 943       /* Copy the value, but change the type from (T&) to (T*).
 944          We keep the same location information, which is efficient,
 945          and allows &(&X) to get the location containing the reference. */
 946       arg2 = value_copy (arg1);
 947       VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
 948       return arg2;
 949     }
 950   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
 951     return value_coerce_function (arg1);
 952
 953   if (VALUE_LVAL (arg1) != lval_memory)
 954     error ("Attempt to take address of value not located in memory.");
 955
 956   /* Get target memory address */
 957   arg2 = value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
 958                                (LONGEST) (VALUE_ADDRESS (arg1)
 959                                           + VALUE_OFFSET (arg1)
 960                                           + VALUE_EMBEDDED_OFFSET (arg1)));
 961
 962   /* This may be a pointer to a base subobject; so remember the
 963      full derived object's type ... */
 964   VALUE_ENCLOSING_TYPE (arg2) = lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1));
 965   /* ... and also the relative position of the subobject in the full object */
 966   VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
 967   VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1);
 968   return arg2;
 969 }
 970
 971 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 972
 973 value_ptr
 974 value_ind (arg1)
 975      value_ptr arg1;
 976 {
 977   struct type *base_type;
 978   value_ptr arg2;
 979   value_ptr real_val;
 980
 981   COERCE_ARRAY (arg1);
 982
 983   base_type = check_typedef (VALUE_TYPE (arg1));
 984
 985   if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
 986     error ("not implemented: member types in value_ind");
 987
 988   /* Allow * on an integer so we can cast it to whatever we want.
 989      This returns an int, which seems like the most C-like thing
 990      to do.  "long long" variables are rare enough that
 991      BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
 992   if (TYPE_CODE (base_type) == TYPE_CODE_INT)
 993     return value_at (builtin_type_int,
 994                      (CORE_ADDR) value_as_long (arg1),
 995                      VALUE_BFD_SECTION (arg1));
 996   else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
 997     {
 998       struct type *enc_type;
 999       /* We may be pointing to something embedded in a larger object */
1000       /* Get the real type of the enclosing object */
1001       enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1));
1002       enc_type = TYPE_TARGET_TYPE (enc_type);
1003       /* Retrieve the enclosing object pointed to */
1004       arg2 =  value_at_lazy (enc_type,
1005                              value_as_pointer (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
1006                              VALUE_BFD_SECTION (arg1));
1007       /* Re-adjust type */
1008       VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
1009       /* Add embedding info */
1010       VALUE_ENCLOSING_TYPE (arg2) = enc_type;
1011       VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
1012
1013       /* We may be pointing to an object of some derived type */
1014       arg2 = value_full_object (arg2, NULL, 0, 0, 0);
1015       return arg2;
1016     }
1017
1018   error ("Attempt to take contents of a non-pointer value.");
1019   return 0;  /* For lint -- never reached */
1020 }
1021 \f
1022 /* Pushing small parts of stack frames.  */
1023
1024 /* Push one word (the size of object that a register holds).  */
1025
1026 CORE_ADDR
1027 push_word (sp, word)
1028      CORE_ADDR sp;
1029      ULONGEST word;
1030 {
1031   register int len = REGISTER_SIZE;
1032   char buffer[MAX_REGISTER_RAW_SIZE];
1033
1034   store_unsigned_integer (buffer, len, word);
1035   if (INNER_THAN (1, 2))
1036     {
1037       /* stack grows downward */
1038       sp -= len;
1039       write_memory (sp, buffer, len);
1040     }
1041   else
1042     {
1043       /* stack grows upward */
1044       write_memory (sp, buffer, len);
1045       sp += len;
1046     }
1047
1048   return sp;
1049 }
1050
1051 /* Push LEN bytes with data at BUFFER.  */
1052
1053 CORE_ADDR
1054 push_bytes (sp, buffer, len)
1055      CORE_ADDR sp;
1056      char *buffer;
1057      int len;
1058 {
1059   if (INNER_THAN (1, 2))
1060     {
1061       /* stack grows downward */
1062       sp -= len;
1063       write_memory (sp, buffer, len);
1064     }
1065   else
1066     {
1067       /* stack grows upward */
1068       write_memory (sp, buffer, len);
1069       sp += len;
1070     }
1071
1072   return sp;
1073 }
1074
1075 /* Push onto the stack the specified value VALUE.  */
1076
1077 #ifndef PUSH_ARGUMENTS
1078
1079 static CORE_ADDR
1080 value_push (sp, arg)
1081      register CORE_ADDR sp;
1082      value_ptr arg;
1083 {
1084   register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
1085
1086   if (INNER_THAN (1, 2))
1087     {
1088       /* stack grows downward */
1089       sp -= len;
1090       write_memory (sp, VALUE_CONTENTS_ALL (arg), len);
1091     }
1092   else
1093     {
1094       /* stack grows upward */
1095       write_memory (sp, VALUE_CONTENTS_ALL (arg), len);
1096       sp += len;
1097     }
1098
1099   return sp;
1100 }
1101
1102 #endif  /* !PUSH_ARGUMENTS */
1103
1104 #ifdef CALL_DUMMY
1105 /* Perform the standard coercions that are specified
1106    for arguments to be passed to C functions.
1107
1108    If PARAM_TYPE is non-NULL, it is the expected parameter type.
1109    IS_PROTOTYPED is non-zero if the function declaration is prototyped.  */
1110
1111 static value_ptr
1112 value_arg_coerce (arg, param_type, is_prototyped)
1113      value_ptr arg;
1114      struct type *param_type;
1115      int is_prototyped;
1116 {
1117   register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
1118   register struct type *type
1119     = param_type ? check_typedef (param_type) : arg_type;
1120
1121   switch (TYPE_CODE (type))
1122     {
1123     case TYPE_CODE_REF:
1124       if (TYPE_CODE (arg_type) != TYPE_CODE_REF)
1125         {
1126           arg = value_addr (arg);
1127           VALUE_TYPE (arg) = param_type;
1128           return arg;
1129         }
1130       break;
1131     case TYPE_CODE_INT:
1132     case TYPE_CODE_CHAR:
1133     case TYPE_CODE_BOOL:
1134     case TYPE_CODE_ENUM:
1135       /* If we don't have a prototype, coerce to integer type if necessary.  */
1136       if (!is_prototyped)
1137         {
1138           if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1139             type = builtin_type_int;
1140         }
1141       /* Currently all target ABIs require at least the width of an integer
1142          type for an argument.  We may have to conditionalize the following
1143          type coercion for future targets.  */
1144       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1145         type = builtin_type_int;
1146       break;
1147     case TYPE_CODE_FLT:
1148       /* FIXME: We should always convert floats to doubles in the
1149          non-prototyped case.  As many debugging formats include
1150          no information about prototyping, we have to live with
1151          COERCE_FLOAT_TO_DOUBLE for now.  */
1152       if (!is_prototyped && COERCE_FLOAT_TO_DOUBLE)
1153         {
1154           if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
1155             type = builtin_type_double;
1156           else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
1157             type = builtin_type_long_double;
1158         }
1159       break;
1160     case TYPE_CODE_FUNC:
1161       type = lookup_pointer_type (type);
1162       break;
1163     case TYPE_CODE_ARRAY:
1164       if (current_language->c_style_arrays)
1165         type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1166       break;
1167     case TYPE_CODE_UNDEF:
1168     case TYPE_CODE_PTR:
1169     case TYPE_CODE_STRUCT:
1170     case TYPE_CODE_UNION:
1171     case TYPE_CODE_VOID:
1172     case TYPE_CODE_SET:
1173     case TYPE_CODE_RANGE:
1174     case TYPE_CODE_STRING:
1175     case TYPE_CODE_BITSTRING:
1176     case TYPE_CODE_ERROR:
1177     case TYPE_CODE_MEMBER:
1178     case TYPE_CODE_METHOD:
1179     case TYPE_CODE_COMPLEX:
1180     default:
1181       break;
1182     }
1183
1184   return value_cast (type, arg);
1185 }
1186
1187 /* Determine a function's address and its return type from its value.
1188    Calls error() if the function is not valid for calling.  */
1189
1190 static CORE_ADDR
1191 find_function_addr (function, retval_type)
1192      value_ptr function;
1193      struct type **retval_type;
1194 {
1195   register struct type *ftype = check_typedef (VALUE_TYPE (function));
1196   register enum type_code code = TYPE_CODE (ftype);
1197   struct type *value_type;
1198   CORE_ADDR funaddr;
1199
1200   /* If it's a member function, just look at the function
1201      part of it.  */
1202
1203   /* Determine address to call.  */
1204   if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
1205     {
1206       funaddr = VALUE_ADDRESS (function);
1207       value_type = TYPE_TARGET_TYPE (ftype);
1208     }
1209   else if (code == TYPE_CODE_PTR)
1210     {
1211       funaddr = value_as_pointer (function);
1212       ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
1213       if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
1214           || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
1215         {
1216 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1217           /* FIXME: This is a workaround for the unusual function
1218              pointer representation on the RS/6000, see comment
1219              in config/rs6000/tm-rs6000.h  */
1220           funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
1221 #endif
1222           value_type = TYPE_TARGET_TYPE (ftype);
1223         }
1224       else
1225         value_type = builtin_type_int;
1226     }
1227   else if (code == TYPE_CODE_INT)
1228     {
1229       /* Handle the case of functions lacking debugging info.
1230          Their values are characters since their addresses are char */
1231       if (TYPE_LENGTH (ftype) == 1)
1232         funaddr = value_as_pointer (value_addr (function));
1233       else
1234         /* Handle integer used as address of a function.  */
1235         funaddr = (CORE_ADDR) value_as_long (function);
1236
1237       value_type = builtin_type_int;
1238     }
1239   else
1240     error ("Invalid data type for function to be called.");
1241
1242   *retval_type = value_type;
1243   return funaddr;
1244 }
1245
1246 /* All this stuff with a dummy frame may seem unnecessarily complicated
1247    (why not just save registers in GDB?).  The purpose of pushing a dummy
1248    frame which looks just like a real frame is so that if you call a
1249    function and then hit a breakpoint (get a signal, etc), "backtrace"
1250    will look right.  Whether the backtrace needs to actually show the
1251    stack at the time the inferior function was called is debatable, but
1252    it certainly needs to not display garbage.  So if you are contemplating
1253    making dummy frames be different from normal frames, consider that.  */
1254
1255 /* Perform a function call in the inferior.
1256    ARGS is a vector of values of arguments (NARGS of them).
1257    FUNCTION is a value, the function to be called.
1258    Returns a value representing what the function returned.
1259    May fail to return, if a breakpoint or signal is hit
1260    during the execution of the function.
1261
1262    ARGS is modified to contain coerced values. */
1263
1264 value_ptr
1265 call_function_by_hand (function, nargs, args)
1266      value_ptr function;
1267      int nargs;
1268      value_ptr *args;
1269 {
1270   register CORE_ADDR sp;
1271   register int i;
1272   CORE_ADDR start_sp;
1273   /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1274      is in host byte order.  Before calling FIX_CALL_DUMMY, we byteswap it
1275      and remove any extra bytes which might exist because ULONGEST is
1276      bigger than REGISTER_SIZE.
1277
1278      NOTE: This is pretty wierd, as the call dummy is actually a
1279            sequence of instructions.  But CISC machines will have
1280            to pack the instructions into REGISTER_SIZE units (and
1281            so will RISC machines for which INSTRUCTION_SIZE is not
1282            REGISTER_SIZE). */
1283
1284   static ULONGEST dummy[] = CALL_DUMMY;
1285   char dummy1[REGISTER_SIZE * sizeof dummy / sizeof (ULONGEST)];
1286   CORE_ADDR old_sp;
1287   struct type *value_type;
1288   unsigned char struct_return;
1289   CORE_ADDR struct_addr = 0;
1290   struct inferior_status inf_status;
1291   struct cleanup *old_chain;
1292   CORE_ADDR funaddr;
1293   int using_gcc;        /* Set to version of gcc in use, or zero if not gcc */
1294   CORE_ADDR real_pc;
1295   struct type *param_type = NULL;
1296   struct type *ftype = check_typedef (SYMBOL_TYPE (function));
1297
1298   if (!target_has_execution)
1299     noprocess();
1300
1301   save_inferior_status (&inf_status, 1);
1302   old_chain = make_cleanup ((make_cleanup_func) restore_inferior_status,
1303                             &inf_status);
1304
1305   /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1306      (and POP_FRAME for restoring them).  (At least on most machines)
1307      they are saved on the stack in the inferior.  */
1308   PUSH_DUMMY_FRAME;
1309
1310   old_sp = sp = read_sp ();
1311
1312   if (INNER_THAN (1, 2))
1313     {
1314       /* Stack grows down */
1315       sp -= sizeof dummy1;
1316       start_sp = sp;
1317     }
1318   else
1319     {
1320       /* Stack grows up */
1321       start_sp = sp;
1322       sp += sizeof dummy1;
1323     }
1324
1325   funaddr = find_function_addr (function, &value_type);
1326   CHECK_TYPEDEF (value_type);
1327
1328   {
1329     struct block *b = block_for_pc (funaddr);
1330     /* If compiled without -g, assume GCC 2.  */
1331     using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
1332   }
1333
1334   /* Are we returning a value using a structure return or a normal
1335      value return? */
1336
1337   struct_return = using_struct_return (function, funaddr, value_type,
1338                                        using_gcc);
1339
1340   /* Create a call sequence customized for this function
1341      and the number of arguments for it.  */
1342   for (i = 0; i < (int) (sizeof (dummy) / sizeof (dummy[0])); i++)
1343     store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
1344                             REGISTER_SIZE,
1345                             (ULONGEST)dummy[i]);
1346
1347 #ifdef GDB_TARGET_IS_HPPA
1348   real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1349                             value_type, using_gcc);
1350 #else
1351   FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1352                   value_type, using_gcc);
1353   real_pc = start_sp;
1354 #endif
1355
1356 #if CALL_DUMMY_LOCATION == ON_STACK
1357   write_memory (start_sp, (char *)dummy1, sizeof dummy1);
1358 #endif /* On stack.  */
1359
1360 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1361   /* Convex Unix prohibits executing in the stack segment. */
1362   /* Hope there is empty room at the top of the text segment. */
1363   {
1364     extern CORE_ADDR text_end;
1365     static checked = 0;
1366     if (!checked)
1367       for (start_sp = text_end - sizeof dummy1; start_sp < text_end; ++start_sp)
1368         if (read_memory_integer (start_sp, 1) != 0)
1369           error ("text segment full -- no place to put call");
1370     checked = 1;
1371     sp = old_sp;
1372     real_pc = text_end - sizeof dummy1;
1373     write_memory (real_pc, (char *)dummy1, sizeof dummy1);
1374   }
1375 #endif /* Before text_end.  */
1376
1377 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1378   {
1379     extern CORE_ADDR text_end;
1380     int errcode;
1381     sp = old_sp;
1382     real_pc = text_end;
1383     errcode = target_write_memory (real_pc, (char *)dummy1, sizeof dummy1);
1384     if (errcode != 0)
1385       error ("Cannot write text segment -- call_function failed");
1386   }
1387 #endif /* After text_end.  */
1388
1389 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1390   real_pc = funaddr;
1391 #endif /* At entry point.  */
1392
1393 #ifdef lint
1394   sp = old_sp;          /* It really is used, for some ifdef's... */
1395 #endif
1396
1397   if (nargs < TYPE_NFIELDS (ftype))
1398     error ("too few arguments in function call");
1399
1400   for (i = nargs - 1; i >= 0; i--)
1401     {
1402       /* If we're off the end of the known arguments, do the standard
1403          promotions.  FIXME: if we had a prototype, this should only
1404          be allowed if ... were present.  */
1405       if (i >= TYPE_NFIELDS (ftype))
1406         args[i] = value_arg_coerce (args[i], NULL, 0);
1407
1408       else
1409         {
1410           int is_prototyped = TYPE_FLAGS (ftype) & TYPE_FLAG_PROTOTYPED;
1411           param_type = TYPE_FIELD_TYPE (ftype, i);
1412
1413           args[i] = value_arg_coerce (args[i], param_type, is_prototyped);
1414         }
1415
1416       /*elz: this code is to handle the case in which the function to be called
1417         has a pointer to function as parameter and the corresponding actual argument
1418         is the address of a function and not a pointer to function variable.
1419         In aCC compiled code, the calls through pointers to functions (in the body
1420         of the function called by hand) are made via $$dyncall_external which
1421         requires some registers setting, this is taken care of if we call
1422         via a function pointer variable, but not via a function address.
1423         In cc this is not a problem. */
1424
1425       if (using_gcc == 0)
1426         if (param_type)
1427           /* if this parameter is a pointer to function*/
1428           if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
1429             if (TYPE_CODE (param_type->target_type) == TYPE_CODE_FUNC)
1430               /* elz: FIXME here should go the test about the compiler used
1431                     to compile the target. We want to issue the error
1432                     message only if the compiler used was HP's aCC.
1433                     If we used HP's cc, then there is no problem and no need
1434                     to return at this point */
1435               if (using_gcc == 0) /* && compiler == aCC*/
1436                 /* go see if the actual parameter is a variable of type
1437                 pointer to function or just a function */
1438                 if (args[i]->lval == not_lval)
1439                   {
1440                     char *arg_name;
1441                     if (find_pc_partial_function((CORE_ADDR)args[i]->aligner.contents[0], &arg_name, NULL, NULL))
1442                       error("\
1443 You cannot use function <%s> as argument. \n\
1444 You must use a pointer to function type variable. Command ignored.", arg_name);
1445                   }
1446     }
1447
1448 #if defined (REG_STRUCT_HAS_ADDR)
1449   {
1450     /* This is a machine like the sparc, where we may need to pass a pointer
1451        to the structure, not the structure itself.  */
1452     for (i = nargs - 1; i >= 0; i--)
1453       {
1454         struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
1455         if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
1456              || TYPE_CODE (arg_type) == TYPE_CODE_UNION
1457              || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
1458              || TYPE_CODE (arg_type) == TYPE_CODE_STRING
1459              || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
1460              || TYPE_CODE (arg_type) == TYPE_CODE_SET
1461              || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
1462                  && TYPE_LENGTH (arg_type) > 8)
1463              )
1464           && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
1465           {
1466             CORE_ADDR addr;
1467             int len; /*  = TYPE_LENGTH (arg_type); */
1468             int aligned_len;
1469             arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
1470             len = TYPE_LENGTH (arg_type);
1471
1472 #ifdef STACK_ALIGN
1473   /* MVS 11/22/96: I think at least some of this stack_align code is
1474      really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1475      a target-defined manner.  */
1476             aligned_len = STACK_ALIGN (len);
1477 #else
1478             aligned_len = len;
1479 #endif
1480             if (INNER_THAN (1, 2))
1481               {
1482                 /* stack grows downward */
1483                 sp -= aligned_len;
1484               }
1485             else
1486               {
1487                 /* The stack grows up, so the address of the thing we push
1488                    is the stack pointer before we push it.  */
1489                 addr = sp;
1490               }
1491             /* Push the structure.  */
1492             write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
1493             if (INNER_THAN (1, 2))
1494               {
1495                 /* The stack grows down, so the address of the thing we push
1496                    is the stack pointer after we push it.  */
1497                 addr = sp;
1498               }
1499             else
1500               {
1501                 /* stack grows upward */
1502                 sp += aligned_len;
1503               }
1504             /* The value we're going to pass is the address of the thing
1505                we just pushed.  */
1506             /*args[i] = value_from_longest (lookup_pointer_type (value_type),
1507                                           (LONGEST) addr);*/
1508             args[i] = value_from_longest (lookup_pointer_type (arg_type),
1509                                           (LONGEST) addr);
1510           }
1511       }
1512   }
1513 #endif /* REG_STRUCT_HAS_ADDR.  */
1514
1515   /* Reserve space for the return structure to be written on the
1516      stack, if necessary */
1517
1518   if (struct_return)
1519     {
1520       int len = TYPE_LENGTH (value_type);
1521 #ifdef STACK_ALIGN
1522   /* MVS 11/22/96: I think at least some of this stack_align code is
1523      really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1524      a target-defined manner.  */
1525       len = STACK_ALIGN (len);
1526 #endif
1527       if (INNER_THAN (1, 2))
1528         {
1529           /* stack grows downward */
1530           sp -= len;
1531           struct_addr = sp;
1532         }
1533       else
1534         {
1535           /* stack grows upward */
1536           struct_addr = sp;
1537           sp += len;
1538         }
1539     }
1540
1541 /* elz: on HPPA no need for this extra alignment, maybe it is needed
1542    on other architectures. This is because all the alignment is taken care
1543    of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in
1544    hppa_push_arguments*/
1545 #ifndef NO_EXTRA_ALIGNMENT_NEEDED
1546
1547 #if defined(STACK_ALIGN)
1548   /* MVS 11/22/96: I think at least some of this stack_align code is
1549      really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1550      a target-defined manner.  */
1551   if (INNER_THAN (1, 2))
1552     {
1553       /* If stack grows down, we must leave a hole at the top. */
1554       int len = 0;
1555
1556       for (i = nargs - 1; i >= 0; i--)
1557         len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
1558 #ifdef CALL_DUMMY_STACK_ADJUST
1559       len += CALL_DUMMY_STACK_ADJUST;
1560 #endif
1561       sp -= STACK_ALIGN (len) - len;
1562     }
1563 #endif /* STACK_ALIGN */
1564 #endif /* NO_EXTRA_ALIGNMENT_NEEDED */
1565
1566 #ifdef PUSH_ARGUMENTS
1567   PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr);
1568 #else /* !PUSH_ARGUMENTS */
1569   for (i = nargs - 1; i >= 0; i--)
1570     sp = value_push (sp, args[i]);
1571 #endif /* !PUSH_ARGUMENTS */
1572
1573 #ifdef PUSH_RETURN_ADDRESS      /* for targets that use no CALL_DUMMY */
1574   /* There are a number of targets now which actually don't write any
1575      CALL_DUMMY instructions into the target, but instead just save the
1576      machine state, push the arguments, and jump directly to the callee
1577      function.  Since this doesn't actually involve executing a JSR/BSR
1578      instruction, the return address must be set up by hand, either by
1579      pushing onto the stack or copying into a return-address register
1580      as appropriate.  Formerly this has been done in PUSH_ARGUMENTS,
1581      but that's overloading its functionality a bit, so I'm making it
1582      explicit to do it here.  */
1583   sp = PUSH_RETURN_ADDRESS(real_pc, sp);
1584 #endif  /* PUSH_RETURN_ADDRESS */
1585
1586 #if defined(STACK_ALIGN)
1587   if (! INNER_THAN (1, 2))
1588     {
1589       /* If stack grows up, we must leave a hole at the bottom, note
1590          that sp already has been advanced for the arguments!  */
1591 #ifdef CALL_DUMMY_STACK_ADJUST
1592       sp += CALL_DUMMY_STACK_ADJUST;
1593 #endif
1594       sp = STACK_ALIGN (sp);
1595     }
1596 #endif /* STACK_ALIGN */
1597
1598 /* XXX This seems wrong.  For stacks that grow down we shouldn't do
1599    anything here!  */
1600   /* MVS 11/22/96: I think at least some of this stack_align code is
1601      really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1602      a target-defined manner.  */
1603 #ifdef CALL_DUMMY_STACK_ADJUST
1604   if (INNER_THAN (1, 2))
1605     {
1606       /* stack grows downward */
1607       sp -= CALL_DUMMY_STACK_ADJUST;
1608     }
1609 #endif /* CALL_DUMMY_STACK_ADJUST */
1610
1611   /* Store the address at which the structure is supposed to be
1612      written.  Note that this (and the code which reserved the space
1613      above) assumes that gcc was used to compile this function.  Since
1614      it doesn't cost us anything but space and if the function is pcc
1615      it will ignore this value, we will make that assumption.
1616
1617      Also note that on some machines (like the sparc) pcc uses a
1618      convention like gcc's.  */
1619
1620   if (struct_return)
1621     STORE_STRUCT_RETURN (struct_addr, sp);
1622
1623   /* Write the stack pointer.  This is here because the statements above
1624      might fool with it.  On SPARC, this write also stores the register
1625      window into the right place in the new stack frame, which otherwise
1626      wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
1627   write_sp (sp);
1628
1629   {
1630     char retbuf[REGISTER_BYTES];
1631     char *name;
1632     struct symbol *symbol;
1633
1634     name = NULL;
1635     symbol = find_pc_function (funaddr);
1636     if (symbol)
1637       {
1638         name = SYMBOL_SOURCE_NAME (symbol);
1639       }
1640     else
1641       {
1642         /* Try the minimal symbols.  */
1643         struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
1644
1645         if (msymbol)
1646           {
1647             name = SYMBOL_SOURCE_NAME (msymbol);
1648           }
1649       }
1650     if (name == NULL)
1651       {
1652         char format[80];
1653         sprintf (format, "at %s", local_hex_format ());
1654         name = alloca (80);
1655         /* FIXME-32x64: assumes funaddr fits in a long.  */
1656         sprintf (name, format, (unsigned long) funaddr);
1657       }
1658
1659     /* Execute the stack dummy routine, calling FUNCTION.
1660        When it is done, discard the empty frame
1661        after storing the contents of all regs into retbuf.  */
1662     if (run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf))
1663       {
1664         /* We stopped somewhere besides the call dummy.  */
1665
1666         /* If we did the cleanups, we would print a spurious error message
1667            (Unable to restore previously selected frame), would write the
1668            registers from the inf_status (which is wrong), and would do other
1669            wrong things (like set stop_bpstat to the wrong thing).  */
1670         discard_cleanups (old_chain);
1671         /* Prevent memory leak.  */
1672         bpstat_clear (&inf_status.stop_bpstat);
1673
1674         /* The following error message used to say "The expression
1675            which contained the function call has been discarded."  It
1676            is a hard concept to explain in a few words.  Ideally, GDB
1677            would be able to resume evaluation of the expression when
1678            the function finally is done executing.  Perhaps someday
1679            this will be implemented (it would not be easy).  */
1680
1681         /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1682            a C++ name with arguments and stuff.  */
1683         error ("\
1684 The program being debugged stopped while in a function called from GDB.\n\
1685 When the function (%s) is done executing, GDB will silently\n\
1686 stop (instead of continuing to evaluate the expression containing\n\
1687 the function call).", name);
1688       }
1689
1690     do_cleanups (old_chain);
1691
1692     /* Figure out the value returned by the function.  */
1693 /* elz: I defined this new macro for the hppa architecture only.
1694    this gives us a way to get the value returned by the function from the stack,
1695    at the same address we told the function to put it.
1696    We cannot assume on the pa that r28 still contains the address of the returned
1697    structure. Usually this will be overwritten by the callee.
1698    I don't know about other architectures, so I defined this macro
1699 */
1700
1701 #ifdef VALUE_RETURNED_FROM_STACK
1702     if (struct_return)
1703       return (value_ptr) VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
1704 #endif
1705
1706     return value_being_returned (value_type, retbuf, struct_return);
1707   }
1708 }
1709 #else /* no CALL_DUMMY.  */
1710 value_ptr
1711 call_function_by_hand (function, nargs, args)
1712      value_ptr function;
1713      int nargs;
1714      value_ptr *args;
1715 {
1716   error ("Cannot invoke functions on this machine.");
1717 }
1718 #endif /* no CALL_DUMMY.  */
1719
1720 \f
1721 /* Create a value for an array by allocating space in the inferior, copying
1722    the data into that space, and then setting up an array value.
1723
1724    The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1725    populated from the values passed in ELEMVEC.
1726
1727    The element type of the array is inherited from the type of the
1728    first element, and all elements must have the same size (though we
1729    don't currently enforce any restriction on their types). */
1730
1731 value_ptr
1732 value_array (lowbound, highbound, elemvec)
1733      int lowbound;
1734      int highbound;
1735      value_ptr *elemvec;
1736 {
1737   int nelem;
1738   int idx;
1739   unsigned int typelength;
1740   value_ptr val;
1741   struct type *rangetype;
1742   struct type *arraytype;
1743   CORE_ADDR addr;
1744
1745   /* Validate that the bounds are reasonable and that each of the elements
1746      have the same size. */
1747
1748   nelem = highbound - lowbound + 1;
1749   if (nelem <= 0)
1750     {
1751       error ("bad array bounds (%d, %d)", lowbound, highbound);
1752     }
1753   typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
1754   for (idx = 1; idx < nelem; idx++)
1755     {
1756       if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
1757         {
1758           error ("array elements must all be the same size");
1759         }
1760     }
1761
1762   rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1763                                  lowbound, highbound);
1764   arraytype = create_array_type ((struct type *) NULL,
1765                                  VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
1766
1767   if (!current_language->c_style_arrays)
1768     {
1769       val = allocate_value (arraytype);
1770       for (idx = 0; idx < nelem; idx++)
1771         {
1772           memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
1773                   VALUE_CONTENTS_ALL (elemvec[idx]),
1774                   typelength);
1775         }
1776       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
1777       return val;
1778     }
1779
1780   /* Allocate space to store the array in the inferior, and then initialize
1781      it by copying in each element.  FIXME:  Is it worth it to create a
1782      local buffer in which to collect each value and then write all the
1783      bytes in one operation? */
1784
1785   addr = allocate_space_in_inferior (nelem * typelength);
1786   for (idx = 0; idx < nelem; idx++)
1787     {
1788       write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
1789                     typelength);
1790     }
1791
1792   /* Create the array type and set up an array value to be evaluated lazily. */
1793
1794   val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
1795   return (val);
1796 }
1797
1798 /* Create a value for a string constant by allocating space in the inferior,
1799    copying the data into that space, and returning the address with type
1800    TYPE_CODE_STRING.  PTR points to the string constant data; LEN is number
1801    of characters.
1802    Note that string types are like array of char types with a lower bound of
1803    zero and an upper bound of LEN - 1.  Also note that the string may contain
1804    embedded null bytes. */
1805
1806 value_ptr
1807 value_string (ptr, len)
1808      char *ptr;
1809      int len;
1810 {
1811   value_ptr val;
1812   int lowbound = current_language->string_lower_bound;
1813   struct type *rangetype = create_range_type ((struct type *) NULL,
1814                                               builtin_type_int,
1815                                               lowbound, len + lowbound - 1);
1816   struct type *stringtype
1817     = create_string_type ((struct type *) NULL, rangetype);
1818   CORE_ADDR addr;
1819
1820   if (current_language->c_style_arrays == 0)
1821     {
1822       val = allocate_value (stringtype);
1823       memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1824       return val;
1825     }
1826
1827
1828   /* Allocate space to store the string in the inferior, and then
1829      copy LEN bytes from PTR in gdb to that address in the inferior. */
1830
1831   addr = allocate_space_in_inferior (len);
1832   write_memory (addr, ptr, len);
1833
1834   val = value_at_lazy (stringtype, addr, NULL);
1835   return (val);
1836 }
1837
1838 value_ptr
1839 value_bitstring (ptr, len)
1840      char *ptr;
1841      int len;
1842 {
1843   value_ptr val;
1844   struct type *domain_type = create_range_type (NULL, builtin_type_int,
1845                                                 0, len - 1);
1846   struct type *type = create_set_type ((struct type*) NULL, domain_type);
1847   TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1848   val = allocate_value (type);
1849   memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
1850   return val;
1851 }
1852 \f
1853 /* See if we can pass arguments in T2 to a function which takes arguments
1854    of types T1.  Both t1 and t2 are NULL-terminated vectors.  If some
1855    arguments need coercion of some sort, then the coerced values are written
1856    into T2.  Return value is 0 if the arguments could be matched, or the
1857    position at which they differ if not.
1858
1859    STATICP is nonzero if the T1 argument list came from a
1860    static member function.
1861
1862    For non-static member functions, we ignore the first argument,
1863    which is the type of the instance variable.  This is because we want
1864    to handle calls with objects from derived classes.  This is not
1865    entirely correct: we should actually check to make sure that a
1866    requested operation is type secure, shouldn't we?  FIXME.  */
1867
1868 static int
1869 typecmp (staticp, t1, t2)
1870      int staticp;
1871      struct type *t1[];
1872      value_ptr t2[];
1873 {
1874   int i;
1875
1876   if (t2 == 0)
1877     return 1;
1878   if (staticp && t1 == 0)
1879     return t2[1] != 0;
1880   if (t1 == 0)
1881     return 1;
1882   if (TYPE_CODE (t1[0]) == TYPE_CODE_VOID) return 0;
1883   if (t1[!staticp] == 0) return 0;
1884   for (i = !staticp; t1[i] && TYPE_CODE (t1[i]) != TYPE_CODE_VOID; i++)
1885     {
1886     struct type *tt1, *tt2;
1887       if (! t2[i])
1888         return i+1;
1889       tt1 = check_typedef (t1[i]);
1890       tt2 = check_typedef (VALUE_TYPE(t2[i]));
1891       if (TYPE_CODE (tt1) == TYPE_CODE_REF
1892           /* We should be doing hairy argument matching, as below.  */
1893           && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1894         {
1895           if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1896             t2[i] = value_coerce_array (t2[i]);
1897           else
1898             t2[i] = value_addr (t2[i]);
1899           continue;
1900         }
1901
1902       while (TYPE_CODE (tt1) == TYPE_CODE_PTR
1903           && (   TYPE_CODE (tt2) == TYPE_CODE_ARRAY
1904               || TYPE_CODE (tt2) == TYPE_CODE_PTR))
1905         {
1906            tt1 = check_typedef (TYPE_TARGET_TYPE(tt1));
1907            tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1908         }
1909       if (TYPE_CODE(tt1) == TYPE_CODE(tt2)) continue;
1910       /* Array to pointer is a `trivial conversion' according to the ARM.  */
1911
1912       /* We should be doing much hairier argument matching (see section 13.2
1913          of the ARM), but as a quick kludge, just check for the same type
1914          code.  */
1915       if (TYPE_CODE (t1[i]) != TYPE_CODE (VALUE_TYPE (t2[i])))
1916         return i+1;
1917     }
1918   if (!t1[i]) return 0;
1919   return t2[i] ? i+1 : 0;
1920 }
1921
1922 /* Helper function used by value_struct_elt to recurse through baseclasses.
1923    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1924    and search in it assuming it has (class) type TYPE.
1925    If found, return value, else return NULL.
1926
1927    If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1928    look for a baseclass named NAME.  */
1929
1930 static value_ptr
1931 search_struct_field (name, arg1, offset, type, looking_for_baseclass)
1932      char *name;
1933      register value_ptr arg1;
1934      int offset;
1935      register struct type *type;
1936      int looking_for_baseclass;
1937 {
1938   int i;
1939   int nbases = TYPE_N_BASECLASSES (type);
1940
1941   CHECK_TYPEDEF (type);
1942
1943   if (! looking_for_baseclass)
1944     for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1945       {
1946         char *t_field_name = TYPE_FIELD_NAME (type, i);
1947
1948         if (t_field_name && STREQ (t_field_name, name))
1949           {
1950             value_ptr v;
1951             if (TYPE_FIELD_STATIC (type, i))
1952               v = value_static_field (type, i);
1953             else
1954               v = value_primitive_field (arg1, offset, i, type);
1955             if (v == 0)
1956               error("there is no field named %s", name);
1957             return v;
1958           }
1959
1960         if (t_field_name
1961             && (t_field_name[0] == '\0'
1962                 || (TYPE_CODE (type) == TYPE_CODE_UNION
1963                     && STREQ (t_field_name, "else"))))
1964           {
1965             struct type *field_type = TYPE_FIELD_TYPE (type, i);
1966             if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1967                 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1968               {
1969                 /* Look for a match through the fields of an anonymous union,
1970                    or anonymous struct.  C++ provides anonymous unions.
1971
1972                    In the GNU Chill implementation of variant record types,
1973                    each <alternative field> has an (anonymous) union type,
1974                    each member of the union represents a <variant alternative>.
1975                    Each <variant alternative> is represented as a struct,
1976                    with a member for each <variant field>.  */
1977
1978                 value_ptr v;
1979                 int new_offset = offset;
1980
1981                 /* This is pretty gross.  In G++, the offset in an anonymous
1982                    union is relative to the beginning of the enclosing struct.
1983                    In the GNU Chill implementation of variant records,
1984                    the bitpos is zero in an anonymous union field, so we
1985                    have to add the offset of the union here. */
1986                 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1987                     || (TYPE_NFIELDS (field_type) > 0
1988                         && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1989                   new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1990
1991                 v = search_struct_field (name, arg1, new_offset, field_type,
1992                                          looking_for_baseclass);
1993                 if (v)
1994                   return v;
1995               }
1996           }
1997       }
1998
1999   for (i = 0;  i < nbases;  i++)
2000     {
2001       value_ptr v;
2002       struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
2003       /* If we are looking for baseclasses, this is what we get when we
2004          hit them.  But it could happen that the base part's member name
2005          is not yet filled in.  */
2006       int found_baseclass = (looking_for_baseclass
2007                              && TYPE_BASECLASS_NAME (type, i) != NULL
2008                              && STREQ (name, TYPE_BASECLASS_NAME (type, i)));
2009
2010       if (BASETYPE_VIA_VIRTUAL (type, i))
2011         {
2012           int boffset;
2013           value_ptr v2 = allocate_value (basetype);
2014
2015           boffset = baseclass_offset (type, i,
2016                                       VALUE_CONTENTS (arg1) + offset,
2017                                       VALUE_ADDRESS (arg1)
2018                                         + VALUE_OFFSET (arg1) + offset);
2019           if (boffset == -1)
2020             error ("virtual baseclass botch");
2021
2022           /* The virtual base class pointer might have been clobbered by the
2023              user program. Make sure that it still points to a valid memory
2024              location.  */
2025
2026           boffset += offset;
2027           if (boffset < 0 || boffset >= TYPE_LENGTH (type))
2028             {
2029               CORE_ADDR base_addr;
2030
2031               base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
2032               if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
2033                                       TYPE_LENGTH (basetype)) != 0)
2034                 error ("virtual baseclass botch");
2035               VALUE_LVAL (v2) = lval_memory;
2036               VALUE_ADDRESS (v2) = base_addr;
2037             }
2038           else
2039             {
2040               VALUE_LVAL (v2) = VALUE_LVAL (arg1);
2041               VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
2042               VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
2043               if (VALUE_LAZY (arg1))
2044                 VALUE_LAZY (v2) = 1;
2045               else
2046                 memcpy (VALUE_CONTENTS_RAW (v2),
2047                         VALUE_CONTENTS_RAW (arg1) + boffset,
2048                         TYPE_LENGTH (basetype));
2049             }
2050
2051           if (found_baseclass)
2052             return v2;
2053           v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
2054                                    looking_for_baseclass);
2055         }
2056       else if (found_baseclass)
2057         v = value_primitive_field (arg1, offset, i, type);
2058       else
2059         v = search_struct_field (name, arg1,
2060                                  offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
2061                                  basetype, looking_for_baseclass);
2062       if (v) return v;
2063     }
2064   return NULL;
2065 }
2066
2067
2068 /* Return the offset (in bytes) of the virtual base of type BASETYPE
2069  * in an object pointed to by VALADDR (on the host), assumed to be of
2070  * type TYPE.  OFFSET is number of bytes beyond start of ARG to start
2071  * looking (in case VALADDR is the contents of an enclosing object).
2072  *
2073  * This routine recurses on the primary base of the derived class because
2074  * the virtual base entries of the primary base appear before the other
2075  * virtual base entries.
2076  *
2077  * If the virtual base is not found, a negative integer is returned.
2078  * The magnitude of the negative integer is the number of entries in
2079  * the virtual table to skip over (entries corresponding to various
2080  * ancestral classes in the chain of primary bases).
2081  *
2082  * Important: This assumes the HP / Taligent C++ runtime
2083  * conventions. Use baseclass_offset() instead to deal with g++
2084  * conventions.  */
2085
2086 void
2087 find_rt_vbase_offset(type, basetype, valaddr, offset, boffset_p, skip_p)
2088   struct type * type;
2089   struct type * basetype;
2090   char * valaddr;
2091   int offset;
2092   int * boffset_p;
2093   int * skip_p;
2094 {
2095   int boffset;           /* offset of virtual base */
2096   int index;             /* displacement to use in virtual table */
2097   int skip;
2098
2099   value_ptr vp;
2100   CORE_ADDR vtbl;      /* the virtual table pointer */
2101   struct type * pbc;   /* the primary base class */
2102
2103   /* Look for the virtual base recursively in the primary base, first.
2104    * This is because the derived class object and its primary base
2105    * subobject share the primary virtual table.  */
2106
2107   boffset = 0;
2108   pbc = TYPE_PRIMARY_BASE(type);
2109   if (pbc)
2110     {
2111       find_rt_vbase_offset (pbc, basetype, valaddr, offset, &boffset, &skip);
2112       if (skip < 0)
2113         {
2114           *boffset_p = boffset;
2115           *skip_p = -1;
2116           return;
2117         }
2118     }
2119   else
2120     skip = 0;
2121
2122
2123   /* Find the index of the virtual base according to HP/Taligent
2124      runtime spec. (Depth-first, left-to-right.)  */
2125   index = virtual_base_index_skip_primaries (basetype, type);
2126
2127   if (index < 0) {
2128     *skip_p = skip + virtual_base_list_length_skip_primaries (type);
2129     *boffset_p = 0;
2130     return;
2131   }
2132
2133   /* pai: FIXME -- 32x64 possible problem */
2134   /* First word (4 bytes) in object layout is the vtable pointer */
2135   vtbl = * (CORE_ADDR *) (valaddr + offset);
2136
2137   /* Before the constructor is invoked, things are usually zero'd out. */
2138   if (vtbl == 0)
2139     error ("Couldn't find virtual table -- object may not be constructed yet.");
2140
2141
2142   /* Find virtual base's offset -- jump over entries for primary base
2143    * ancestors, then use the index computed above.  But also adjust by
2144    * HP_ACC_VBASE_START for the vtable slots before the start of the
2145    * virtual base entries.  Offset is negative -- virtual base entries
2146    * appear _before_ the address point of the virtual table. */
2147
2148   /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2149      & use long type */
2150
2151   /* epstein : FIXME -- added param for overlay section. May not be correct */
2152    vp = value_at (builtin_type_int, vtbl + 4 * (- skip - index - HP_ACC_VBASE_START), NULL);
2153   boffset = value_as_long (vp);
2154   *skip_p = -1;
2155   *boffset_p = boffset;
2156   return;
2157 }
2158
2159
2160 /* Helper function used by value_struct_elt to recurse through baseclasses.
2161    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2162    and search in it assuming it has (class) type TYPE.
2163    If found, return value, else if name matched and args not return (value)-1,
2164    else return NULL. */
2165
2166 static value_ptr
2167 search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
2168      char *name;
2169      register value_ptr *arg1p, *args;
2170      int offset, *static_memfuncp;
2171      register struct type *type;
2172 {
2173   int i;
2174   value_ptr v;
2175   int name_matched = 0;
2176   char dem_opname[64];
2177
2178   CHECK_TYPEDEF (type);
2179   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2180     {
2181       char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2182       /* FIXME!  May need to check for ARM demangling here */
2183       if (strncmp(t_field_name, "__", 2)==0 ||
2184         strncmp(t_field_name, "op", 2)==0 ||
2185         strncmp(t_field_name, "type", 4)==0 )
2186         {
2187           if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
2188             t_field_name = dem_opname;
2189           else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
2190             t_field_name = dem_opname;
2191         }
2192       if (t_field_name && STREQ (t_field_name, name))
2193         {
2194           int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2195           struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2196           name_matched = 1;
2197
2198           if (j > 0 && args == 0)
2199             error ("cannot resolve overloaded method `%s': no arguments supplied", name);
2200           while (j >= 0)
2201             {
2202               if (TYPE_FN_FIELD_STUB (f, j))
2203                 check_stub_method (type, i, j);
2204               if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2205                             TYPE_FN_FIELD_ARGS (f, j), args))
2206                 {
2207                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2208                     return value_virtual_fn_field (arg1p, f, j, type, offset);
2209                   if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
2210                     *static_memfuncp = 1;
2211                   v = value_fn_field (arg1p, f, j, type, offset);
2212                   if (v != NULL) return v;
2213                 }
2214               j--;
2215             }
2216         }
2217     }
2218
2219   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2220     {
2221       int base_offset;
2222
2223       if (BASETYPE_VIA_VIRTUAL (type, i))
2224         {
2225          if (TYPE_HAS_VTABLE (type))
2226             {
2227               /* HP aCC compiled type, search for virtual base offset
2228                  according to HP/Taligent runtime spec.  */
2229               int skip;
2230               find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2231                                     VALUE_CONTENTS_ALL (*arg1p),
2232                                     offset + VALUE_EMBEDDED_OFFSET (*arg1p),
2233                                     &base_offset, &skip);
2234               if (skip >= 0)
2235                 error ("Virtual base class offset not found in vtable");
2236             }
2237          else
2238            {
2239              struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2240              char *base_valaddr;
2241
2242              /* The virtual base class pointer might have been clobbered by the
2243                 user program. Make sure that it still points to a valid memory
2244                 location.  */
2245
2246              if (offset < 0 || offset >= TYPE_LENGTH (type))
2247                {
2248                  base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
2249                  if (target_read_memory (VALUE_ADDRESS (*arg1p)
2250                                          + VALUE_OFFSET (*arg1p) + offset,
2251                                          base_valaddr,
2252                                          TYPE_LENGTH (baseclass)) != 0)
2253                    error ("virtual baseclass botch");
2254                }
2255             else
2256                base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
2257
2258             base_offset =
2259                baseclass_offset (type, i, base_valaddr,
2260                                  VALUE_ADDRESS (*arg1p)
2261                                    + VALUE_OFFSET (*arg1p) + offset);
2262             if (base_offset == -1)
2263                error ("virtual baseclass botch");
2264            }
2265         }
2266       else
2267         {
2268           base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2269         }
2270       v = search_struct_method (name, arg1p, args, base_offset + offset,
2271                                 static_memfuncp, TYPE_BASECLASS (type, i));
2272       if (v == (value_ptr) -1)
2273         {
2274           name_matched = 1;
2275         }
2276       else if (v)
2277         {
2278 /* FIXME-bothner:  Why is this commented out?  Why is it here?  */
2279 /*        *arg1p = arg1_tmp;*/
2280           return v;
2281         }
2282     }
2283   if (name_matched) return (value_ptr) -1;
2284   else return NULL;
2285 }
2286
2287 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2288    extract the component named NAME from the ultimate target structure/union
2289    and return it as a value with its appropriate type.
2290    ERR is used in the error message if *ARGP's type is wrong.
2291
2292    C++: ARGS is a list of argument types to aid in the selection of
2293    an appropriate method. Also, handle derived types.
2294
2295    STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2296    where the truthvalue of whether the function that was resolved was
2297    a static member function or not is stored.
2298
2299    ERR is an error message to be printed in case the field is not found.  */
2300
2301 value_ptr
2302 value_struct_elt (argp, args, name, static_memfuncp, err)
2303      register value_ptr *argp, *args;
2304      char *name;
2305      int *static_memfuncp;
2306      char *err;
2307 {
2308   register struct type *t;
2309   value_ptr v;
2310
2311   COERCE_ARRAY (*argp);
2312
2313   t = check_typedef (VALUE_TYPE (*argp));
2314
2315   /* Follow pointers until we get to a non-pointer.  */
2316
2317   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2318     {
2319       *argp = value_ind (*argp);
2320       /* Don't coerce fn pointer to fn and then back again!  */
2321       if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2322         COERCE_ARRAY (*argp);
2323       t = check_typedef (VALUE_TYPE (*argp));
2324     }
2325
2326   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2327     error ("not implemented: member type in value_struct_elt");
2328
2329   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
2330       && TYPE_CODE (t) != TYPE_CODE_UNION)
2331     error ("Attempt to extract a component of a value that is not a %s.", err);
2332
2333   /* Assume it's not, unless we see that it is.  */
2334   if (static_memfuncp)
2335     *static_memfuncp =0;
2336
2337   if (!args)
2338     {
2339       /* if there are no arguments ...do this...  */
2340
2341       /* Try as a field first, because if we succeed, there
2342          is less work to be done.  */
2343       v = search_struct_field (name, *argp, 0, t, 0);
2344       if (v)
2345         return v;
2346
2347       /* C++: If it was not found as a data field, then try to
2348          return it as a pointer to a method.  */
2349
2350       if (destructor_name_p (name, t))
2351         error ("Cannot get value of destructor");
2352
2353       v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2354
2355       if (v == (value_ptr) -1)
2356         error ("Cannot take address of a method");
2357       else if (v == 0)
2358         {
2359           if (TYPE_NFN_FIELDS (t))
2360             error ("There is no member or method named %s.", name);
2361           else
2362             error ("There is no member named %s.", name);
2363         }
2364       return v;
2365     }
2366
2367   if (destructor_name_p (name, t))
2368     {
2369       if (!args[1])
2370         {
2371           /* Destructors are a special case.  */
2372           int m_index, f_index;
2373
2374           v = NULL;
2375           if (get_destructor_fn_field (t, &m_index, &f_index))
2376             {
2377               v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, m_index),
2378                                   f_index, NULL, 0);
2379             }
2380           if (v == NULL)
2381             error ("could not find destructor function named %s.", name);
2382           else
2383             return v;
2384         }
2385       else
2386         {
2387           error ("destructor should not have any argument");
2388         }
2389     }
2390   else
2391     v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2392
2393   if (v == (value_ptr) -1)
2394     {
2395         error("Argument list of %s mismatch with component in the structure.", name);
2396     }
2397   else if (v == 0)
2398     {
2399       /* See if user tried to invoke data as function.  If so,
2400          hand it back.  If it's not callable (i.e., a pointer to function),
2401          gdb should give an error.  */
2402       v = search_struct_field (name, *argp, 0, t, 0);
2403     }
2404
2405   if (!v)
2406     error ("Structure has no component named %s.", name);
2407   return v;
2408 }
2409
2410 /* Search through the methods of an object (and its bases)
2411  * to find a specified method. Return the pointer to the
2412  * fn_field list of overloaded instances.
2413  * Helper function for value_find_oload_list.
2414  * ARGP is a pointer to a pointer to a value (the object)
2415  * METHOD is a string containing the method name
2416  * OFFSET is the offset within the value
2417  * STATIC_MEMFUNCP is set if the method is static
2418  * TYPE is the assumed type of the object
2419  * NUM_FNS is the number of overloaded instances
2420  * BASETYPE is set to the actual type of the subobject where the method is found
2421  * BOFFSET is the offset of the base subobject where the method is found */
2422
2423 struct fn_field *
2424 find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset)
2425   value_ptr *argp;
2426   char * method;
2427   int offset;
2428   int * static_memfuncp;
2429   struct type * type;
2430   int * num_fns;
2431   struct type ** basetype;
2432   int * boffset;
2433 {
2434   int i;
2435   struct fn_field * f;
2436   CHECK_TYPEDEF (type);
2437
2438   *num_fns = 0;
2439
2440   /* First check in object itself */
2441   for (i = TYPE_NFN_FIELDS (type) -1; i >= 0; i--)
2442     {
2443       /* pai: FIXME What about operators and type conversions? */
2444       char * fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2445       if (fn_field_name && STREQ (fn_field_name, method))
2446         {
2447           *num_fns = TYPE_FN_FIELDLIST_LENGTH (type, i);
2448           *basetype = type;
2449           *boffset = offset;
2450           return TYPE_FN_FIELDLIST1 (type, i);
2451         }
2452     }
2453
2454   /* Not found in object, check in base subobjects */
2455   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2456     {
2457       int base_offset;
2458       if (BASETYPE_VIA_VIRTUAL (type, i))
2459         {
2460           if (TYPE_HAS_VTABLE (type))
2461             {
2462               /* HP aCC compiled type, search for virtual base offset
2463                * according to HP/Taligent runtime spec.  */
2464               int skip;
2465               find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2466                                     VALUE_CONTENTS_ALL (*argp),
2467                                     offset + VALUE_EMBEDDED_OFFSET (*argp),
2468                                     &base_offset, &skip);
2469               if (skip >= 0)
2470                 error ("Virtual base class offset not found in vtable");
2471             }
2472           else
2473             {
2474               /* probably g++ runtime model */
2475               base_offset = VALUE_OFFSET (*argp) + offset;
2476               base_offset =
2477                 baseclass_offset (type, i,
2478                                   VALUE_CONTENTS (*argp) + base_offset,
2479                                   VALUE_ADDRESS (*argp) + base_offset);
2480               if (base_offset == -1)
2481                 error ("virtual baseclass botch");
2482             }
2483         }
2484       else /* non-virtual base, simply use bit position from debug info */
2485         {
2486           base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2487         }
2488       f = find_method_list (argp, method, base_offset + offset,
2489                             static_memfuncp, TYPE_BASECLASS (type, i), num_fns, basetype, boffset);
2490       if (f)
2491         return f;
2492     }
2493   return NULL;
2494 }
2495
2496 /* Return the list of overloaded methods of a specified name.
2497  * ARGP is a pointer to a pointer to a value (the object)
2498  * METHOD is the method name
2499  * OFFSET is the offset within the value contents
2500  * STATIC_MEMFUNCP is set if the method is static
2501  * NUM_FNS is the number of overloaded instances
2502  * BASETYPE is set to the type of the base subobject that defines the method
2503  * BOFFSET is the offset of the base subobject which defines the method */
2504
2505 struct fn_field *
2506 value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, basetype, boffset)
2507   value_ptr *argp;
2508   char * method;
2509   int offset;
2510   int * static_memfuncp;
2511   int * num_fns;
2512   struct type ** basetype;
2513   int * boffset;
2514 {
2515   struct type * t;
2516   value_ptr v;
2517
2518   t = check_typedef (VALUE_TYPE (*argp));
2519
2520   /* code snarfed from value_struct_elt */
2521   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2522     {
2523       *argp = value_ind (*argp);
2524       /* Don't coerce fn pointer to fn and then back again!  */
2525       if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2526         COERCE_ARRAY (*argp);
2527       t = check_typedef (VALUE_TYPE (*argp));
2528     }
2529
2530   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2531     error ("Not implemented: member type in value_find_oload_lis");
2532
2533   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
2534          && TYPE_CODE (t) != TYPE_CODE_UNION)
2535     error ("Attempt to extract a component of a value that is not a struct or union");
2536
2537   /* Assume it's not static, unless we see that it is.  */
2538   if (static_memfuncp)
2539     *static_memfuncp =0;
2540
2541   return find_method_list (argp, method, 0, static_memfuncp, t, num_fns, basetype, boffset);
2542
2543 }
2544
2545 /* Given an array of argument types (ARGTYPES) (which includes an
2546    entry for "this" in the case of C++ methods), the number of
2547    arguments NARGS, the NAME of a function whether it's a method or
2548    not (METHOD), and the degree of laxness (LAX) in conforming to
2549    overload resolution rules in ANSI C++, find the best function that
2550    matches on the argument types according to the overload resolution
2551    rules.
2552
2553    In the case of class methods, the parameter OBJ is an object value
2554    in which to search for overloaded methods.
2555
2556    In the case of non-method functions, the parameter FSYM is a symbol
2557    corresponding to one of the overloaded functions.
2558
2559    Return value is an integer: 0 -> good match, 10 -> debugger applied
2560    non-standard coercions, 100 -> incompatible.
2561
2562    If a method is being searched for, VALP will hold the value.
2563    If a non-method is being searched for, SYMP will hold the symbol for it.
2564
2565    If a method is being searched for, and it is a static method,
2566    then STATICP will point to a non-zero value.
2567
2568    Note: This function does *not* check the value of
2569    overload_resolution.  Caller must check it to see whether overload
2570    resolution is permitted.
2571    */
2572
2573 int
2574 find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, staticp)
2575   struct type ** arg_types;
2576   int nargs;
2577   char * name;
2578   int method;
2579   int lax;
2580   value_ptr obj;
2581   struct symbol * fsym;
2582   value_ptr * valp;
2583   struct symbol ** symp;
2584   int * staticp;
2585 {
2586   int nparms;
2587   struct type ** parm_types;
2588   int champ_nparms = 0;
2589
2590   short oload_champ = -1;          /* Index of best overloaded function */
2591   short oload_ambiguous = 0;       /* Current ambiguity state for overload resolution */
2592                                    /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2593   short oload_ambig_champ = -1;    /* 2nd contender for best match */
2594   short oload_non_standard = 0;    /* did we have to use non-standard conversions? */
2595   short oload_incompatible = 0;    /* are args supplied incompatible with any function? */
2596
2597   struct badness_vector * bv;      /* A measure of how good an overloaded instance is */
2598   struct badness_vector * oload_champ_bv = NULL; /* The measure for the current best match */
2599
2600   value_ptr temp = obj;
2601   struct fn_field * fns_ptr = NULL;   /* For methods, the list of overloaded methods */
2602   struct symbol ** oload_syms = NULL; /* For non-methods, the list of overloaded function symbols */
2603   int num_fns = 0;                    /* Number of overloaded instances being considered */
2604   struct type * basetype = NULL;
2605   int boffset;
2606   register int jj;
2607   register int ix;
2608
2609   char * obj_type_name = NULL;
2610   char * func_name = NULL;
2611
2612   /* Get the list of overloaded methods or functions */
2613   if (method)
2614     {
2615       obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
2616       /* Hack: evaluate_subexp_standard often passes in a pointer
2617          value rather than the object itself, so try again */
2618       if ((!obj_type_name || !*obj_type_name) &&
2619           (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
2620         obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
2621
2622       fns_ptr = value_find_oload_method_list (&temp, name, 0,
2623                                               staticp,
2624                                               &num_fns,
2625                                               &basetype, &boffset);
2626       if (!fns_ptr || !num_fns)
2627         error ("Couldn't find method %s%s%s",
2628                obj_type_name,
2629                (obj_type_name && *obj_type_name) ? "::" : "",
2630                name);
2631     }
2632   else
2633     {
2634       int i = -1;
2635       func_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_NO_OPTS);
2636
2637       oload_syms = make_symbol_overload_list (fsym);
2638       while (oload_syms[++i])
2639         num_fns++;
2640       if (!num_fns)
2641         error ("Couldn't find function %s", func_name);
2642     }
2643
2644   oload_champ_bv = NULL;
2645
2646   /* Consider each candidate in turn */
2647   for (ix = 0; ix < num_fns; ix++)
2648     {
2649       int jj;
2650
2651       /* Number of parameters for current candidate */
2652       nparms = method ? TYPE_NFIELDS (fns_ptr[ix].type)
2653                       : TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
2654
2655       /* Prepare array of parameter types */
2656       parm_types = (struct type **) xmalloc (nparms * (sizeof (struct type *)));
2657       for (jj = 0; jj < nparms; jj++)
2658         parm_types[jj] = method ? TYPE_FIELD_TYPE (fns_ptr[ix].type, jj)
2659                                 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj);
2660
2661       /* Compare parameter types to supplied argument types */
2662       bv = rank_function (parm_types, nparms, arg_types, nargs);
2663
2664       if (!oload_champ_bv)
2665         {
2666           oload_champ_bv = bv;
2667           oload_champ = 0;
2668           champ_nparms = nparms;
2669         }
2670       else
2671         /* See whether current candidate is better or worse than previous best */
2672         switch (compare_badness (bv, oload_champ_bv))
2673           {
2674             case 0:
2675               oload_ambiguous = 1;    /* top two contenders are equally good */
2676               oload_ambig_champ = ix;
2677               break;
2678             case 1:
2679               oload_ambiguous = 2;    /* incomparable top contenders */
2680               oload_ambig_champ = ix;
2681               break;
2682             case 2:
2683               oload_champ_bv = bv;    /* new champion, record details */
2684               oload_ambiguous = 0;
2685               oload_champ = ix;
2686               oload_ambig_champ = -1;
2687               champ_nparms = nparms;
2688               break;
2689             case 3:
2690             default:
2691               break;
2692           }
2693       free (parm_types);
2694 #ifdef DEBUG_OLOAD
2695       if (method)
2696         printf("Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
2697       else
2698         printf("Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME(oload_syms[ix]),nparms);
2699       for (jj = 0; jj <= nargs; jj++)
2700         printf("...Badness @ %d : %d\n", jj, bv->rank[jj]);
2701       printf("Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
2702 #endif
2703     } /* end loop over all candidates */
2704
2705   if (oload_ambiguous)
2706     {
2707       if (method)
2708         error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2709                obj_type_name,
2710                (obj_type_name && *obj_type_name) ? "::" : "",
2711                name);
2712       else
2713         error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2714                func_name);
2715     }
2716
2717   /* Check how bad the best match is */
2718   for (ix = 1; ix <= nargs; ix++)
2719     {
2720       switch (oload_champ_bv->rank[ix])
2721         {
2722           case 10:
2723             oload_non_standard = 1;  /* non-standard type conversions needed */
2724             break;
2725           case 100:
2726             oload_incompatible = 1;  /* truly mismatched types */
2727             break;
2728         }
2729     }
2730   if (oload_incompatible)
2731     {
2732       if (method)
2733         error ("Cannot resolve method %s%s%s to any overloaded instance",
2734                obj_type_name,
2735                (obj_type_name && *obj_type_name) ? "::" : "",
2736                name);
2737       else
2738         error ("Cannot resolve function %s to any overloaded instance",
2739                func_name);
2740     }
2741   else if (oload_non_standard)
2742     {
2743       if (method)
2744         warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2745                  obj_type_name,
2746                  (obj_type_name && *obj_type_name) ? "::" : "",
2747                  name);
2748       else
2749         warning ("Using non-standard conversion to match function %s to supplied arguments",
2750                  func_name);
2751     }
2752
2753   if (method)
2754     {
2755       if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
2756         *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2757       else
2758         *valp = value_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2759     }
2760   else
2761     {
2762       *symp = oload_syms[oload_champ];
2763       free (func_name);
2764     }
2765
2766   return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
2767 }
2768
2769 /* C++: return 1 is NAME is a legitimate name for the destructor
2770    of type TYPE.  If TYPE does not have a destructor, or
2771    if NAME is inappropriate for TYPE, an error is signaled.  */
2772 int
2773 destructor_name_p (name, type)
2774      const char *name;
2775      const struct type *type;
2776 {
2777   /* destructors are a special case.  */
2778
2779   if (name[0] == '~')
2780     {
2781       char *dname = type_name_no_tag (type);
2782       char *cp = strchr (dname, '<');
2783       unsigned int len;
2784
2785       /* Do not compare the template part for template classes.  */
2786       if (cp == NULL)
2787         len = strlen (dname);
2788       else
2789         len = cp - dname;
2790       if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
2791         error ("name of destructor must equal name of class");
2792       else
2793         return 1;
2794     }
2795   return 0;
2796 }
2797
2798 /* Helper function for check_field: Given TYPE, a structure/union,
2799    return 1 if the component named NAME from the ultimate
2800    target structure/union is defined, otherwise, return 0. */
2801
2802 static int
2803 check_field_in (type, name)
2804      register struct type *type;
2805      const char *name;
2806 {
2807   register int i;
2808
2809   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2810     {
2811       char *t_field_name = TYPE_FIELD_NAME (type, i);
2812       if (t_field_name && STREQ (t_field_name, name))
2813         return 1;
2814     }
2815
2816   /* C++: If it was not found as a data field, then try to
2817      return it as a pointer to a method.  */
2818
2819   /* Destructors are a special case.  */
2820   if (destructor_name_p (name, type))
2821     {
2822       int m_index, f_index;
2823
2824       return get_destructor_fn_field (type, &m_index, &f_index);
2825     }
2826
2827   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2828     {
2829       if (STREQ (TYPE_FN_FIELDLIST_NAME (type, i), name))
2830         return 1;
2831     }
2832
2833   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2834     if (check_field_in (TYPE_BASECLASS (type, i), name))
2835       return 1;
2836
2837   return 0;
2838 }
2839
2840
2841 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2842    return 1 if the component named NAME from the ultimate
2843    target structure/union is defined, otherwise, return 0.  */
2844
2845 int
2846 check_field (arg1, name)
2847      register value_ptr arg1;
2848      const char *name;
2849 {
2850   register struct type *t;
2851
2852   COERCE_ARRAY (arg1);
2853
2854   t = VALUE_TYPE (arg1);
2855
2856   /* Follow pointers until we get to a non-pointer.  */
2857
2858   for (;;)
2859     {
2860       CHECK_TYPEDEF (t);
2861       if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF)
2862         break;
2863       t = TYPE_TARGET_TYPE (t);
2864     }
2865
2866   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2867     error ("not implemented: member type in check_field");
2868
2869   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
2870       && TYPE_CODE (t) != TYPE_CODE_UNION)
2871     error ("Internal error: `this' is not an aggregate");
2872
2873   return check_field_in (t, name);
2874 }
2875
2876 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2877    return the address of this member as a "pointer to member"
2878    type.  If INTYPE is non-null, then it will be the type
2879    of the member we are looking for.  This will help us resolve
2880    "pointers to member functions".  This function is used
2881    to resolve user expressions of the form "DOMAIN::NAME".  */
2882
2883 value_ptr
2884 value_struct_elt_for_reference (domain, offset, curtype, name, intype)
2885      struct type *domain, *curtype, *intype;
2886      int offset;
2887      char *name;
2888 {
2889   register struct type *t = curtype;
2890   register int i;
2891   value_ptr v;
2892
2893   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
2894       && TYPE_CODE (t) != TYPE_CODE_UNION)
2895     error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2896
2897   for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
2898     {
2899       char *t_field_name = TYPE_FIELD_NAME (t, i);
2900
2901       if (t_field_name && STREQ (t_field_name, name))
2902         {
2903           if (TYPE_FIELD_STATIC (t, i))
2904             {
2905               v = value_static_field (t, i);
2906               if (v == NULL)
2907                 error ("Internal error: could not find static variable %s",
2908                        name);
2909               return v;
2910             }
2911           if (TYPE_FIELD_PACKED (t, i))
2912             error ("pointers to bitfield members not allowed");
2913
2914           return value_from_longest
2915             (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
2916                                                         domain)),
2917              offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
2918         }
2919     }
2920
2921   /* C++: If it was not found as a data field, then try to
2922      return it as a pointer to a method.  */
2923
2924   /* Destructors are a special case.  */
2925   if (destructor_name_p (name, t))
2926     {
2927       error ("member pointers to destructors not implemented yet");
2928     }
2929
2930   /* Perform all necessary dereferencing.  */
2931   while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
2932     intype = TYPE_TARGET_TYPE (intype);
2933
2934   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
2935     {
2936       char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
2937       char dem_opname[64];
2938
2939       if (strncmp(t_field_name, "__", 2)==0 ||
2940         strncmp(t_field_name, "op", 2)==0 ||
2941         strncmp(t_field_name, "type", 4)==0 )
2942         {
2943           if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
2944             t_field_name = dem_opname;
2945           else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
2946             t_field_name = dem_opname;
2947         }
2948       if (t_field_name && STREQ (t_field_name, name))
2949         {
2950           int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
2951           struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
2952
2953           if (intype == 0 && j > 1)
2954             error ("non-unique member `%s' requires type instantiation", name);
2955           if (intype)
2956             {
2957               while (j--)
2958                 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
2959                   break;
2960               if (j < 0)
2961                 error ("no member function matches that type instantiation");
2962             }
2963           else
2964             j = 0;
2965
2966           if (TYPE_FN_FIELD_STUB (f, j))
2967             check_stub_method (t, i, j);
2968           if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2969             {
2970               return value_from_longest
2971                 (lookup_reference_type
2972                  (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
2973                                       domain)),
2974                  (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
2975             }
2976           else
2977             {
2978               struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
2979                                                 0, VAR_NAMESPACE, 0, NULL);
2980               if (s == NULL)
2981                 {
2982                   v = 0;
2983                 }
2984               else
2985                 {
2986                   v = read_var_value (s, 0);
2987 #if 0
2988                   VALUE_TYPE (v) = lookup_reference_type
2989                     (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
2990                                          domain));
2991 #endif
2992                 }
2993               return v;
2994             }
2995         }
2996     }
2997   for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
2998     {
2999       value_ptr v;
3000       int base_offset;
3001
3002       if (BASETYPE_VIA_VIRTUAL (t, i))
3003         base_offset = 0;
3004       else
3005         base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3006       v = value_struct_elt_for_reference (domain,
3007                                           offset + base_offset,
3008                                           TYPE_BASECLASS (t, i),
3009                                           name,
3010                                           intype);
3011       if (v)
3012         return v;
3013     }
3014   return 0;
3015 }
3016
3017
3018 /* Find the real run-time type of a value using RTTI.
3019  * V is a pointer to the value.
3020  * A pointer to the struct type entry of the run-time type
3021  * is returneed.
3022  * FULL is a flag that is set only if the value V includes
3023  * the entire contents of an object of the RTTI type.
3024  * TOP is the offset to the top of the enclosing object of
3025  * the real run-time type.  This offset may be for the embedded
3026  * object, or for the enclosing object of V.
3027  * USING_ENC is the flag that distinguishes the two cases.
3028  * If it is 1, then the offset is for the enclosing object,
3029  * otherwise for the embedded object.
3030  *
3031  * This currently works only for RTTI information generated
3032  * by the HP ANSI C++ compiler (aCC).  g++ today (1997-06-10)
3033  * does not appear to support RTTI. This function returns a
3034  * NULL value for objects in the g++ runtime model. */
3035
3036 struct type *
3037 value_rtti_type (v, full, top, using_enc)
3038   value_ptr v;
3039   int * full;
3040   int * top;
3041   int * using_enc;
3042 {
3043   struct type * known_type;
3044   struct type * rtti_type;
3045   CORE_ADDR coreptr;
3046   value_ptr vp;
3047   int using_enclosing = 0;
3048   long top_offset = 0;
3049   char rtti_type_name[256];
3050
3051   if (full)
3052     *full = 0;
3053   if (top)
3054     *top = -1;
3055   if (using_enc)
3056     *using_enc = 0;
3057
3058   /* Get declared type */
3059   known_type = VALUE_TYPE (v);
3060   CHECK_TYPEDEF (known_type);
3061   /* RTTI works only or class objects */
3062   if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
3063     return NULL;
3064
3065   /* If neither the declared type nor the enclosing type of the
3066    * value structure has a HP ANSI C++ style virtual table,
3067    * we can't do anything. */
3068   if (!TYPE_HAS_VTABLE (known_type))
3069     {
3070       known_type = VALUE_ENCLOSING_TYPE (v);
3071       CHECK_TYPEDEF (known_type);
3072       if ((TYPE_CODE (known_type) != TYPE_CODE_CLASS) ||
3073           !TYPE_HAS_VTABLE (known_type))
3074         return NULL; /* No RTTI, or not HP-compiled types */
3075       CHECK_TYPEDEF (known_type);
3076       using_enclosing = 1;
3077     }
3078
3079   if (using_enclosing && using_enc)
3080     *using_enc = 1;
3081
3082   /* First get the virtual table address */
3083   coreptr = * (CORE_ADDR *) ((VALUE_CONTENTS_ALL (v))
3084                              + VALUE_OFFSET (v)
3085                              + (using_enclosing ? 0 : VALUE_EMBEDDED_OFFSET (v)));
3086   if (coreptr == 0)
3087     return NULL; /* return silently -- maybe called on gdb-generated value */
3088
3089   /* Fetch the top offset of the object */
3090   /* FIXME possible 32x64 problem with pointer size & arithmetic */
3091   vp = value_at (builtin_type_int,
3092                  coreptr + 4 * HP_ACC_TOP_OFFSET_OFFSET,
3093                  VALUE_BFD_SECTION (v));
3094   top_offset = value_as_long (vp);
3095   if (top)
3096     *top = top_offset;
3097
3098   /* Fetch the typeinfo pointer */
3099   /* FIXME possible 32x64 problem with pointer size & arithmetic */
3100   vp = value_at (builtin_type_int, coreptr + 4 * HP_ACC_TYPEINFO_OFFSET, VALUE_BFD_SECTION (v));
3101   /* Indirect through the typeinfo pointer and retrieve the pointer
3102    * to the string name */
3103   coreptr = * (CORE_ADDR *) (VALUE_CONTENTS (vp));
3104   if (!coreptr)
3105     error ("Retrieved null typeinfo pointer in trying to determine run-time type");
3106   vp = value_at (builtin_type_int, coreptr + 4, VALUE_BFD_SECTION (v));  /* 4 -> offset of name field */
3107                                                   /* FIXME possible 32x64 problem */
3108
3109   coreptr = * (CORE_ADDR *) (VALUE_CONTENTS (vp));
3110
3111   read_memory_string (coreptr, rtti_type_name, 256);
3112
3113   if (strlen (rtti_type_name) == 0)
3114     error ("Retrieved null type name from typeinfo");
3115
3116   /* search for type */
3117   rtti_type = lookup_typename (rtti_type_name, (struct block *) 0, 1);
3118
3119   if (!rtti_type)
3120     error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name);
3121   CHECK_TYPEDEF (rtti_type);
3122
3123 #if 0 /* debugging*/
3124   printf("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1);
3125 #endif
3126
3127   /* Check whether we have the entire object */
3128   if (full /* Non-null pointer passed */
3129
3130       &&
3131            /* Either we checked on the whole object in hand and found the
3132               top offset to be zero */
3133       (((top_offset == 0) &&
3134        using_enclosing &&
3135        TYPE_LENGTH (known_type) == TYPE_LENGTH (rtti_type))
3136       ||
3137            /* Or we checked on the embedded object and top offset was the
3138               same as the embedded offset */
3139       ((top_offset == VALUE_EMBEDDED_OFFSET (v)) &&
3140        !using_enclosing &&
3141        TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type))))
3142
3143     *full = 1;
3144
3145   return rtti_type;
3146 }
3147
3148 /* Given a pointer value V, find the real (RTTI) type
3149    of the object it points to.
3150    Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3151    and refer to the values computed for the object pointed to. */
3152
3153 struct type *
3154 value_rtti_target_type (v, full, top, using_enc)
3155   value_ptr v;
3156   int * full;
3157   int * top;
3158   int * using_enc;
3159 {
3160   value_ptr target;
3161
3162   target = value_ind (v);
3163
3164   return value_rtti_type (target, full, top, using_enc);
3165 }
3166
3167 /* Given a value pointed to by ARGP, check its real run-time type, and
3168    if that is different from the enclosing type, create a new value
3169    using the real run-time type as the enclosing type (and of the same
3170    type as ARGP) and return it, with the embedded offset adjusted to
3171    be the correct offset to the enclosed object
3172    RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3173    parameters, computed by value_rtti_type(). If these are available,
3174    they can be supplied and a second call to value_rtti_type() is avoided.
3175    (Pass RTYPE == NULL if they're not available */
3176
3177 value_ptr
3178 value_full_object (argp, rtype, xfull, xtop, xusing_enc)
3179   value_ptr argp;
3180   struct type * rtype;
3181   int xfull;
3182   int xtop;
3183   int xusing_enc;
3184
3185 {
3186   struct type * real_type;
3187   int full = 0;
3188   int top = -1;
3189   int using_enc = 0;
3190   value_ptr new_val;
3191
3192   if (rtype)
3193     {
3194       real_type = rtype;
3195       full = xfull;
3196       top = xtop;
3197       using_enc = xusing_enc;
3198     }
3199   else
3200     real_type = value_rtti_type (argp, &full, &top, &using_enc);
3201
3202   /* If no RTTI data, or if object is already complete, do nothing */
3203   if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
3204     return argp;
3205
3206   /* If we have the full object, but for some reason the enclosing
3207      type is wrong, set it */ /* pai: FIXME -- sounds iffy */
3208   if (full)
3209     {
3210       VALUE_ENCLOSING_TYPE (argp) = real_type;
3211       return argp;
3212     }
3213
3214   /* Check if object is in memory */
3215   if (VALUE_LVAL (argp) != lval_memory)
3216     {
3217       warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
3218
3219       return argp;
3220     }
3221
3222   /* All other cases -- retrieve the complete object */
3223   /* Go back by the computed top_offset from the beginning of the object,
3224      adjusting for the embedded offset of argp if that's what value_rtti_type
3225      used for its computation. */
3226   new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
3227                            (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
3228                            VALUE_BFD_SECTION (argp));
3229   VALUE_TYPE (new_val) = VALUE_TYPE (argp);
3230   VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
3231   return new_val;
3232 }
3233
3234
3235
3236
3237 /* C++: return the value of the class instance variable, if one exists.
3238    Flag COMPLAIN signals an error if the request is made in an
3239    inappropriate context.  */
3240
3241 value_ptr
3242 value_of_this (complain)
3243      int complain;
3244 {
3245   struct symbol *func, *sym;
3246   struct block *b;
3247   int i;
3248   static const char funny_this[] = "this";
3249   value_ptr this;
3250
3251   if (selected_frame == 0)
3252     {
3253       if (complain)
3254         error ("no frame selected");
3255       else return 0;
3256     }
3257
3258   func = get_frame_function (selected_frame);
3259   if (!func)
3260     {
3261       if (complain)
3262         error ("no `this' in nameless context");
3263       else return 0;
3264     }
3265
3266   b = SYMBOL_BLOCK_VALUE (func);
3267   i = BLOCK_NSYMS (b);
3268   if (i <= 0)
3269     {
3270       if (complain)
3271         error ("no args, no `this'");
3272       else return 0;
3273     }
3274
3275   /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3276      symbol instead of the LOC_ARG one (if both exist).  */
3277   sym = lookup_block_symbol (b, funny_this, VAR_NAMESPACE);
3278   if (sym == NULL)
3279     {
3280       if (complain)
3281         error ("current stack frame not in method");
3282       else
3283         return NULL;
3284     }
3285
3286   this = read_var_value (sym, selected_frame);
3287   if (this == 0 && complain)
3288     error ("`this' argument at unknown address");
3289   return this;
3290 }
3291
3292 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3293    long, starting at LOWBOUND.  The result has the same lower bound as
3294    the original ARRAY.  */
3295
3296 value_ptr
3297 value_slice (array, lowbound, length)
3298      value_ptr array;
3299      int lowbound, length;
3300 {
3301   struct type *slice_range_type, *slice_type, *range_type;
3302   LONGEST lowerbound, upperbound, offset;
3303   value_ptr slice;
3304   struct type *array_type;
3305   array_type = check_typedef (VALUE_TYPE (array));
3306   COERCE_VARYING_ARRAY (array, array_type);
3307   if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3308       && TYPE_CODE (array_type) != TYPE_CODE_STRING
3309       && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
3310     error ("cannot take slice of non-array");
3311   range_type = TYPE_INDEX_TYPE (array_type);
3312   if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3313     error ("slice from bad array or bitstring");
3314   if (lowbound < lowerbound || length < 0
3315       || lowbound + length - 1 > upperbound
3316       /* Chill allows zero-length strings but not arrays. */
3317       || (current_language->la_language == language_chill
3318           && length == 0 && TYPE_CODE (array_type) == TYPE_CODE_ARRAY))
3319     error ("slice out of range");
3320   /* FIXME-type-allocation: need a way to free this type when we are
3321      done with it.  */
3322   slice_range_type = create_range_type ((struct type*) NULL,
3323                                         TYPE_TARGET_TYPE (range_type),
3324                                         lowbound, lowbound + length - 1);
3325   if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
3326     {
3327       int i;
3328       slice_type = create_set_type ((struct type*) NULL, slice_range_type);
3329       TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
3330       slice = value_zero (slice_type, not_lval);
3331       for (i = 0; i < length; i++)
3332         {
3333           int element = value_bit_index (array_type,
3334                                          VALUE_CONTENTS (array),
3335                                          lowbound + i);
3336           if (element < 0)
3337             error ("internal error accessing bitstring");
3338           else if (element > 0)
3339             {
3340               int j = i % TARGET_CHAR_BIT;
3341               if (BITS_BIG_ENDIAN)
3342                 j = TARGET_CHAR_BIT - 1 - j;
3343               VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
3344             }
3345         }
3346       /* We should set the address, bitssize, and bitspos, so the clice
3347          can be used on the LHS, but that may require extensions to
3348          value_assign.  For now, just leave as a non_lval.  FIXME.  */
3349     }
3350   else
3351     {
3352       struct type *element_type = TYPE_TARGET_TYPE (array_type);
3353       offset
3354         = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3355       slice_type = create_array_type ((struct type*) NULL, element_type,
3356                                       slice_range_type);
3357       TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3358       slice = allocate_value (slice_type);
3359       if (VALUE_LAZY (array))
3360         VALUE_LAZY (slice) = 1;
3361       else
3362         memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
3363                 TYPE_LENGTH (slice_type));
3364       if (VALUE_LVAL (array) == lval_internalvar)
3365         VALUE_LVAL (slice) = lval_internalvar_component;
3366       else
3367         VALUE_LVAL (slice) = VALUE_LVAL (array);
3368       VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
3369       VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
3370     }
3371   return slice;
3372 }
3373
3374 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
3375    value as a fixed-length array. */
3376
3377 value_ptr
3378 varying_to_slice (varray)
3379      value_ptr varray;
3380 {
3381   struct type *vtype = check_typedef (VALUE_TYPE (varray));
3382   LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
3383                                 VALUE_CONTENTS (varray)
3384                                 + TYPE_FIELD_BITPOS (vtype, 0) / 8);
3385   return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
3386 }
3387
3388 /* Create a value for a FORTRAN complex number.  Currently most of
3389    the time values are coerced to COMPLEX*16 (i.e. a complex number
3390    composed of 2 doubles.  This really should be a smarter routine
3391    that figures out precision inteligently as opposed to assuming
3392    doubles. FIXME: fmb */
3393
3394 value_ptr
3395 value_literal_complex (arg1, arg2, type)
3396      value_ptr arg1;
3397      value_ptr arg2;
3398      struct type *type;
3399 {
3400   register value_ptr val;
3401   struct type *real_type = TYPE_TARGET_TYPE (type);
3402
3403   val = allocate_value (type);
3404   arg1 = value_cast (real_type, arg1);
3405   arg2 = value_cast (real_type, arg2);
3406
3407   memcpy (VALUE_CONTENTS_RAW (val),
3408           VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
3409   memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
3410           VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
3411   return val;
3412 }
3413
3414 /* Cast a value into the appropriate complex data type. */
3415
3416 static value_ptr
3417 cast_into_complex (type, val)
3418      struct type *type;
3419      register value_ptr val;
3420 {
3421   struct type *real_type = TYPE_TARGET_TYPE (type);
3422   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
3423     {
3424       struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
3425       value_ptr re_val = allocate_value (val_real_type);
3426       value_ptr im_val = allocate_value (val_real_type);
3427
3428       memcpy (VALUE_CONTENTS_RAW (re_val),
3429               VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
3430       memcpy (VALUE_CONTENTS_RAW (im_val),
3431               VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
3432                TYPE_LENGTH (val_real_type));
3433
3434       return value_literal_complex (re_val, im_val, type);
3435     }
3436   else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
3437            || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
3438     return value_literal_complex (val, value_zero (real_type, not_lval), type);
3439   else
3440     error ("cannot cast non-number to complex");
3441 }
3442
3443 void
3444 _initialize_valops ()
3445 {
3446 #if 0
3447   add_show_from_set
3448     (add_set_cmd ("abandon", class_support, var_boolean, (char *)&auto_abandon,
3449                   "Set automatic abandonment of expressions upon failure.",
3450                   &setlist),
3451      &showlist);
3452 #endif
3453
3454   add_show_from_set
3455     (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *)&overload_resolution,
3456                   "Set overload resolution in evaluating C++ functions.",
3457                   &setlist),
3458      &showlist);
3459   overload_resolution = 1;
3460
3461 }