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