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