gdb/valops.c

   1 /* Perform non-arithmetic operations on values, for GDB.
   2    Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "value.h"
  25 #include "frame.h"
  26 #include "inferior.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29 #include "demangle.h"
  30 #include "language.h"
  31 #include "gdbcmd.h"
  32
  33 #include <errno.h>
  34 #include "gdb_string.h"
  35
  36 /* Default to coercing float to double in function calls only when there is
  37    no prototype.  Otherwise on targets where the debug information is incorrect
  38    for either the prototype or non-prototype case, we can force it by defining
  39    COERCE_FLOAT_TO_DOUBLE in the target configuration file. */
  40
  41 #ifndef COERCE_FLOAT_TO_DOUBLE
  42 #define COERCE_FLOAT_TO_DOUBLE (param_type == NULL)
  43 #endif
  44
  45 /* Flag indicating HP compilers were used; needed to correctly handle some
  46    value operations with HP aCC code/runtime. */
  47 extern int hp_som_som_object_present;
  48
  49
  50 /* Local functions.  */
  51
  52 static int typecmp PARAMS ((int staticp, struct type *t1[], value_ptr t2[]));
  53
  54 static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
  55 static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *, int));
  56
  57
  58 static CORE_ADDR value_push PARAMS ((CORE_ADDR, value_ptr));
  59
  60 static value_ptr search_struct_field PARAMS ((char *, value_ptr, int,
  61                                               struct type *, int));
  62
  63 static value_ptr search_struct_field_aux PARAMS ((char *, value_ptr, int,
  64                                                   struct type *, int, int *, char *,
  65                                                   struct type **));
  66
  67 static value_ptr search_struct_method PARAMS ((char *, value_ptr *,
  68                                                value_ptr *,
  69                                                int, int *, struct type *));
  70
  71 static int check_field_in PARAMS ((struct type *, const char *));
  72
  73 static CORE_ADDR allocate_space_in_inferior PARAMS ((int));
  74
  75 static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
  76
  77 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));
  78
  79 void _initialize_valops PARAMS ((void));
  80
  81 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
  82
  83 /* Flag for whether we want to abandon failed expression evals by default.  */
  84
  85 #if 0
  86 static int auto_abandon = 0;
  87 #endif
  88
  89 int overload_resolution = 0;
  90
  91
  92 \f
  93 /* Find the address of function name NAME in the inferior.  */
  94
  95 value_ptr
  96 find_function_in_inferior (name)
  97      char *name;
  98 {
  99   register struct symbol *sym;
 100   sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
 101   if (sym != NULL)
 102     {
 103       if (SYMBOL_CLASS (sym) != LOC_BLOCK)
 104         {
 105           error ("\"%s\" exists in this program but is not a function.",
 106                  name);
 107         }
 108       return value_of_variable (sym, NULL);
 109     }
 110   else
 111     {
 112       struct minimal_symbol *msymbol = lookup_minimal_symbol(name, NULL, NULL);
 113       if (msymbol != NULL)
 114         {
 115           struct type *type;
 116           LONGEST maddr;
 117           type = lookup_pointer_type (builtin_type_char);
 118           type = lookup_function_type (type);
 119           type = lookup_pointer_type (type);
 120           maddr = (LONGEST) SYMBOL_VALUE_ADDRESS (msymbol);
 121           return value_from_longest (type, maddr);
 122         }
 123       else
 124         {
 125           if (!target_has_execution)
 126             error ("evaluation of this expression requires the target program to be active");
 127           else
 128             error ("evaluation of this expression requires the program to have a function \"%s\".", name);
 129         }
 130     }
 131 }
 132
 133 /* Allocate NBYTES of space in the inferior using the inferior's malloc
 134    and return a value that is a pointer to the allocated space. */
 135
 136 value_ptr
 137 value_allocate_space_in_inferior (len)
 138      int len;
 139 {
 140   value_ptr blocklen;
 141   register value_ptr val = find_function_in_inferior ("malloc");
 142
 143   blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
 144   val = call_function_by_hand (val, 1, &blocklen);
 145   if (value_logical_not (val))
 146     {
 147       if (!target_has_execution)
 148         error ("No memory available to program now: you need to start the target first");
 149       else
 150         error ("No memory available to program: call to malloc failed");
 151     }
 152   return val;
 153 }
 154
 155 static CORE_ADDR
 156 allocate_space_in_inferior (len)
 157      int len;
 158 {
 159   return value_as_long (value_allocate_space_in_inferior (len));
 160 }
 161
 162 /* Cast value ARG2 to type TYPE and return as a value.
 163    More general than a C cast: accepts any two types of the same length,
 164    and if ARG2 is an lvalue it can be cast into anything at all.  */
 165 /* In C++, casts may change pointer or object representations.  */
 166
 167 value_ptr
 168 value_cast (type, arg2)
 169      struct type *type;
 170      register value_ptr arg2;
 171 {
 172   register enum type_code code1;
 173   register enum type_code code2;
 174   register int scalar;
 175   struct type *type2;
 176
 177   int convert_to_boolean = 0;
 178
 179   if (VALUE_TYPE (arg2) == type)
 180     return arg2;
 181
 182   CHECK_TYPEDEF (type);
 183   code1 = TYPE_CODE (type);
 184   COERCE_REF(arg2);
 185   type2 = check_typedef (VALUE_TYPE (arg2));
 186
 187   /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
 188      is treated like a cast to (TYPE [N])OBJECT,
 189      where N is sizeof(OBJECT)/sizeof(TYPE). */
 190   if (code1 == TYPE_CODE_ARRAY)
 191     {
 192       struct type *element_type = TYPE_TARGET_TYPE (type);
 193       unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
 194       if (element_length > 0
 195           && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
 196         {
 197           struct type *range_type = TYPE_INDEX_TYPE (type);
 198           int val_length = TYPE_LENGTH (type2);
 199           LONGEST low_bound, high_bound, new_length;
 200           if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
 201             low_bound = 0, high_bound = 0;
 202           new_length = val_length / element_length;
 203           if (val_length % element_length != 0)
 204             warning("array element type size does not divide object size in cast");
 205           /* FIXME-type-allocation: need a way to free this type when we are
 206              done with it.  */
 207           range_type = create_range_type ((struct type *) NULL,
 208                                           TYPE_TARGET_TYPE (range_type),
 209                                           low_bound,
 210                                           new_length + low_bound - 1);
 211           VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
 212                                                  element_type, range_type);
 213           return arg2;
 214         }
 215     }
 216
 217   if (current_language->c_style_arrays
 218       && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
 219     arg2 = value_coerce_array (arg2);
 220
 221   if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
 222     arg2 = value_coerce_function (arg2);
 223
 224   type2 = check_typedef (VALUE_TYPE (arg2));
 225   COERCE_VARYING_ARRAY (arg2, type2);
 226   code2 = TYPE_CODE (type2);
 227
 228   if (code1 == TYPE_CODE_COMPLEX)
 229     return cast_into_complex (type, arg2);
 230   if (code1 == TYPE_CODE_BOOL)
 231     {
 232       code1 = TYPE_CODE_INT;
 233       convert_to_boolean = 1;
 234     }
 235   if (code1 == TYPE_CODE_CHAR)
 236     code1 = TYPE_CODE_INT;
 237   if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
 238     code2 = TYPE_CODE_INT;
 239
 240   scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
 241             || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
 242
 243   if (   code1 == TYPE_CODE_STRUCT
 244       && code2 == TYPE_CODE_STRUCT
 245       && TYPE_NAME (type) != 0)
 246     {
 247       /* Look in the type of the source to see if it contains the
 248          type of the target as a superclass.  If so, we'll need to
 249          offset the object in addition to changing its type.  */
 250       value_ptr v = search_struct_field (type_name_no_tag (type),
 251                                          arg2, 0, type2, 1);
 252       if (v)
 253         {
 254           VALUE_TYPE (v) = type;
 255           return v;
 256         }
 257     }
 258   if (code1 == TYPE_CODE_FLT && scalar)
 259     return value_from_double (type, value_as_double (arg2));
 260   else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
 261             || code1 == TYPE_CODE_RANGE)
 262            && (scalar || code2 == TYPE_CODE_PTR))
 263     {
 264       LONGEST longest;
 265
 266       if (hp_som_som_object_present &&  /* if target compiled by HP aCC */
 267           (code2 == TYPE_CODE_PTR))
 268         {
 269           unsigned int * ptr;
 270           value_ptr retvalp;
 271
 272           switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
 273             {
 274               /* With HP aCC, pointers to data members have a bias */
 275               case TYPE_CODE_MEMBER:
 276                 retvalp = value_from_longest (type, value_as_long (arg2));
 277                 ptr = (unsigned int *) VALUE_CONTENTS (retvalp); /* force evaluation */
 278                 *ptr &= ~0x20000000; /* zap 29th bit to remove bias */
 279                 return retvalp;
 280
 281               /* While pointers to methods don't really point to a function */
 282               case TYPE_CODE_METHOD:
 283                 error ("Pointers to methods not supported with HP aCC");
 284
 285               default:
 286                 break; /* fall out and go to normal handling */
 287             }
 288         }
 289       longest = value_as_long (arg2);
 290       return value_from_longest (type, convert_to_boolean ? (LONGEST) (longest ? 1 : 0) : longest);
 291     }
 292   else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
 293     {
 294       if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
 295         {
 296           struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
 297           struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
 298           if (   TYPE_CODE (t1) == TYPE_CODE_STRUCT
 299               && TYPE_CODE (t2) == TYPE_CODE_STRUCT
 300               && !value_logical_not (arg2))
 301             {
 302               value_ptr v;
 303
 304               /* Look in the type of the source to see if it contains the
 305                  type of the target as a superclass.  If so, we'll need to
 306                  offset the pointer rather than just change its type.  */
 307               if (TYPE_NAME (t1) != NULL)
 308                 {
 309                   v = search_struct_field (type_name_no_tag (t1),
 310                                            value_ind (arg2), 0, t2, 1);
 311                   if (v)
 312                     {
 313                       v = value_addr (v);
 314                       VALUE_TYPE (v) = type;
 315                       return v;
 316                     }
 317                 }
 318
 319               /* Look in the type of the target to see if it contains the
 320                  type of the source as a superclass.  If so, we'll need to
 321                  offset the pointer rather than just change its type.
 322                  FIXME: This fails silently with virtual inheritance.  */
 323               if (TYPE_NAME (t2) != NULL)
 324                 {
 325                   v = search_struct_field (type_name_no_tag (t2),
 326                                            value_zero (t1, not_lval), 0, t1, 1);
 327                   if (v)
 328                     {
 329                       value_ptr v2 = value_ind (arg2);
 330                       VALUE_ADDRESS (v2) -= VALUE_ADDRESS (v)
 331                                             + VALUE_OFFSET (v);
 332                       v2 = value_addr (v2);
 333                       VALUE_TYPE (v2) = type;
 334                       return v2;
 335                     }
 336                 }
 337             }
 338           /* No superclass found, just fall through to change ptr type.  */
 339         }
 340       VALUE_TYPE (arg2) = type;
 341       VALUE_ENCLOSING_TYPE (arg2) = type;  /* pai: chk_val */
 342       VALUE_POINTED_TO_OFFSET (arg2) = 0;  /* pai: chk_val */
 343       return arg2;
 344     }
 345   else if (chill_varying_type (type))
 346     {
 347       struct type *range1, *range2, *eltype1, *eltype2;
 348       value_ptr val;
 349       int count1, count2;
 350       LONGEST low_bound, high_bound;
 351       char *valaddr, *valaddr_data;
 352       /* For lint warning about eltype2 possibly uninitialized: */
 353       eltype2 = NULL;
 354       if (code2 == TYPE_CODE_BITSTRING)
 355         error ("not implemented: converting bitstring to varying type");
 356       if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING)
 357           || (eltype1 = check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1))),
 358               eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)),
 359               (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
 360                /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
 361         error ("Invalid conversion to varying type");
 362       range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0);
 363       range2 = TYPE_FIELD_TYPE (type2, 0);
 364       if (get_discrete_bounds (range1, &low_bound, &high_bound) < 0)
 365         count1 = -1;
 366       else
 367         count1 = high_bound - low_bound + 1;
 368       if (get_discrete_bounds (range2, &low_bound, &high_bound) < 0)
 369         count1 = -1, count2 = 0;  /* To force error before */
 370       else
 371         count2 = high_bound - low_bound + 1;
 372       if (count2 > count1)
 373         error ("target varying type is too small");
 374       val = allocate_value (type);
 375       valaddr = VALUE_CONTENTS_RAW (val);
 376       valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
 377       /* Set val's __var_length field to count2. */
 378       store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)),
 379                             count2);
 380       /* Set the __var_data field to count2 elements copied from arg2. */
 381       memcpy (valaddr_data, VALUE_CONTENTS (arg2),
 382               count2 * TYPE_LENGTH (eltype2));
 383       /* Zero the rest of the __var_data field of val. */
 384       memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0',
 385               (count1 - count2) * TYPE_LENGTH (eltype2));
 386       return val;
 387     }
 388   else if (VALUE_LVAL (arg2) == lval_memory)
 389     {
 390       return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2),
 391                             VALUE_BFD_SECTION (arg2));
 392     }
 393   else if (code1 == TYPE_CODE_VOID)
 394     {
 395       return value_zero (builtin_type_void, not_lval);
 396     }
 397   else
 398     {
 399       error ("Invalid cast.");
 400       return 0;
 401     }
 402 }
 403
 404 /* Create a value of type TYPE that is zero, and return it.  */
 405
 406 value_ptr
 407 value_zero (type, lv)
 408      struct type *type;
 409      enum lval_type lv;
 410 {
 411   register value_ptr val = allocate_value (type);
 412
 413   memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
 414   VALUE_LVAL (val) = lv;
 415
 416   return val;
 417 }
 418
 419 /* Return a value with type TYPE located at ADDR.
 420
 421    Call value_at only if the data needs to be fetched immediately;
 422    if we can be 'lazy' and defer the fetch, perhaps indefinately, call
 423    value_at_lazy instead.  value_at_lazy simply records the address of
 424    the data and sets the lazy-evaluation-required flag.  The lazy flag
 425    is tested in the VALUE_CONTENTS macro, which is used if and when
 426    the contents are actually required.
 427
 428    Note: value_at does *NOT* handle embedded offsets; perform such
 429    adjustments before or after calling it. */
 430
 431 value_ptr
 432 value_at (type, addr, sect)
 433      struct type *type;
 434      CORE_ADDR addr;
 435      asection *sect;
 436 {
 437   register value_ptr val;
 438
 439   if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
 440     error ("Attempt to dereference a generic pointer.");
 441
 442   val = allocate_value (type);
 443
 444   if (GDB_TARGET_IS_D10V
 445       && TYPE_CODE (type) == TYPE_CODE_PTR
 446       && TYPE_TARGET_TYPE (type)
 447       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
 448     {
 449       /* pointer to function */
 450       unsigned long num;
 451       unsigned short snum;
 452       snum = read_memory_unsigned_integer (addr, 2);
 453       num = D10V_MAKE_IADDR (snum);
 454       store_address (VALUE_CONTENTS_RAW (val), 4, num);
 455     }
 456   else if (GDB_TARGET_IS_D10V
 457            && TYPE_CODE(type) == TYPE_CODE_PTR)
 458     {
 459       /* pointer to data */
 460       unsigned long num;
 461       unsigned short snum;
 462       snum = read_memory_unsigned_integer (addr, 2);
 463       num = D10V_MAKE_DADDR (snum);
 464       store_address (VALUE_CONTENTS_RAW (val), 4, num);
 465     }
 466   else
 467     read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type), sect);
 468
 469   VALUE_LVAL (val) = lval_memory;
 470   VALUE_ADDRESS (val) = addr;
 471   VALUE_BFD_SECTION (val) = sect;
 472
 473   return val;
 474 }
 475
 476 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
 477
 478 value_ptr
 479 value_at_lazy (type, addr, sect)
 480      struct type *type;
 481      CORE_ADDR addr;
 482      asection *sect;
 483 {
 484   register value_ptr val;
 485
 486   if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
 487     error ("Attempt to dereference a generic pointer.");
 488
 489   val = allocate_value (type);
 490
 491   VALUE_LVAL (val) = lval_memory;
 492   VALUE_ADDRESS (val) = addr;
 493   VALUE_LAZY (val) = 1;
 494   VALUE_BFD_SECTION (val) = sect;
 495
 496   return val;
 497 }
 498
 499 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
 500    if the current data for a variable needs to be loaded into
 501    VALUE_CONTENTS(VAL).  Fetches the data from the user's process, and
 502    clears the lazy flag to indicate that the data in the buffer is valid.
 503
 504    If the value is zero-length, we avoid calling read_memory, which would
 505    abort.  We mark the value as fetched anyway -- all 0 bytes of it.
 506
 507    This function returns a value because it is used in the VALUE_CONTENTS
 508    macro as part of an expression, where a void would not work.  The
 509    value is ignored.  */
 510
 511 int
 512 value_fetch_lazy (val)
 513      register value_ptr val;
 514 {
 515   CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
 516   int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
 517
 518   struct type *type = VALUE_TYPE(val);
 519   if (GDB_TARGET_IS_D10V
 520       && TYPE_CODE (type) == TYPE_CODE_PTR
 521       && TYPE_TARGET_TYPE (type)
 522       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
 523     {
 524       /* pointer to function */
 525       unsigned long num;
 526       unsigned short snum;
 527       snum = read_memory_unsigned_integer (addr, 2);
 528       num = D10V_MAKE_IADDR(snum);
 529       store_address ( VALUE_CONTENTS_RAW (val), 4, num);
 530     }
 531   else if (GDB_TARGET_IS_D10V
 532            && TYPE_CODE(type) == TYPE_CODE_PTR)
 533     {
 534       /* pointer to data */
 535       unsigned long num;
 536       unsigned short snum;
 537       snum = read_memory_unsigned_integer (addr, 2);
 538       num = D10V_MAKE_DADDR(snum);
 539       store_address ( VALUE_CONTENTS_RAW (val), 4, num);
 540     }
 541   else if (length)
 542     read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), length,
 543                          VALUE_BFD_SECTION (val));
 544   VALUE_LAZY (val) = 0;
 545   return 0;
 546 }
 547
 548
 549 /* Store the contents of FROMVAL into the location of TOVAL.
 550    Return a new value with the location of TOVAL and contents of FROMVAL.  */
 551
 552 value_ptr
 553 value_assign (toval, fromval)
 554      register value_ptr toval, fromval;
 555 {
 556   register struct type *type;
 557   register value_ptr val;
 558   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 559   int use_buffer = 0;
 560
 561   if (!toval->modifiable)
 562     error ("Left operand of assignment is not a modifiable lvalue.");
 563
 564   COERCE_REF (toval);
 565
 566   type = VALUE_TYPE (toval);
 567   if (VALUE_LVAL (toval) != lval_internalvar)
 568     fromval = value_cast (type, fromval);
 569   else
 570     COERCE_ARRAY (fromval);
 571   CHECK_TYPEDEF (type);
 572
 573   /* If TOVAL is a special machine register requiring conversion
 574      of program values to a special raw format,
 575      convert FROMVAL's contents now, with result in `raw_buffer',
 576      and set USE_BUFFER to the number of bytes to write.  */
 577
 578   if (VALUE_REGNO (toval) >= 0
 579       && REGISTER_CONVERTIBLE (VALUE_REGNO (toval)))
 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, struct_return, sp, struct_addr)
1100      int nargs;
1101      value_ptr *args;
1102      int struct_return;
1103      CORE_ADDR sp;
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   {
1641     char retbuf[REGISTER_BYTES];
1642     char *name;
1643     struct symbol *symbol;
1644
1645     name = NULL;
1646     symbol = find_pc_function (funaddr);
1647     if (symbol)
1648       {
1649         name = SYMBOL_SOURCE_NAME (symbol);
1650       }
1651     else
1652       {
1653         /* Try the minimal symbols.  */
1654         struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
1655
1656         if (msymbol)
1657           {
1658             name = SYMBOL_SOURCE_NAME (msymbol);
1659           }
1660       }
1661     if (name == NULL)
1662       {
1663         char format[80];
1664         sprintf (format, "at %s", local_hex_format ());
1665         name = alloca (80);
1666         /* FIXME-32x64: assumes funaddr fits in a long.  */
1667         sprintf (name, format, (unsigned long) funaddr);
1668       }
1669
1670     /* Execute the stack dummy routine, calling FUNCTION.
1671        When it is done, discard the empty frame
1672        after storing the contents of all regs into retbuf.  */
1673     if (run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf))
1674       {
1675         /* We stopped somewhere besides the call dummy.  */
1676
1677         /* If we did the cleanups, we would print a spurious error
1678            message (Unable to restore previously selected frame),
1679            would write the registers from the inf_status (which is
1680            wrong), and would do other wrong things.  */
1681         discard_cleanups (old_chain);
1682         discard_inferior_status (inf_status);
1683
1684         /* The following error message used to say "The expression
1685            which contained the function call has been discarded."  It
1686            is a hard concept to explain in a few words.  Ideally, GDB
1687            would be able to resume evaluation of the expression when
1688            the function finally is done executing.  Perhaps someday
1689            this will be implemented (it would not be easy).  */
1690
1691         /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1692            a C++ name with arguments and stuff.  */
1693         error ("\
1694 The program being debugged stopped while in a function called from GDB.\n\
1695 When the function (%s) is done executing, GDB will silently\n\
1696 stop (instead of continuing to evaluate the expression containing\n\
1697 the function call).", name);
1698       }
1699
1700     do_cleanups (old_chain);
1701
1702     /* Figure out the value returned by the function.  */
1703 /* elz: I defined this new macro for the hppa architecture only.
1704    this gives us a way to get the value returned by the function from the stack,
1705    at the same address we told the function to put it.
1706    We cannot assume on the pa that r28 still contains the address of the returned
1707    structure. Usually this will be overwritten by the callee.
1708    I don't know about other architectures, so I defined this macro
1709 */
1710
1711 #ifdef VALUE_RETURNED_FROM_STACK
1712     if (struct_return)
1713       return (value_ptr) VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
1714 #endif
1715
1716     return value_being_returned (value_type, retbuf, struct_return);
1717   }
1718 }
1719
1720 value_ptr
1721 call_function_by_hand (function, nargs, args)
1722      value_ptr function;
1723      int nargs;
1724      value_ptr *args;
1725 {
1726   if (CALL_DUMMY_P)
1727     {
1728       return hand_function_call (function, nargs, args);
1729     }
1730   else
1731     {
1732       error ("Cannot invoke functions on this machine.");
1733     }
1734 }
1735
1736
1737 \f
1738 /* Create a value for an array by allocating space in the inferior, copying
1739    the data into that space, and then setting up an array value.
1740
1741    The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1742    populated from the values passed in ELEMVEC.
1743
1744    The element type of the array is inherited from the type of the
1745    first element, and all elements must have the same size (though we
1746    don't currently enforce any restriction on their types). */
1747
1748 value_ptr
1749 value_array (lowbound, highbound, elemvec)
1750      int lowbound;
1751      int highbound;
1752      value_ptr *elemvec;
1753 {
1754   int nelem;
1755   int idx;
1756   unsigned int typelength;
1757   value_ptr val;
1758   struct type *rangetype;
1759   struct type *arraytype;
1760   CORE_ADDR addr;
1761
1762   /* Validate that the bounds are reasonable and that each of the elements
1763      have the same size. */
1764
1765   nelem = highbound - lowbound + 1;
1766   if (nelem <= 0)
1767     {
1768       error ("bad array bounds (%d, %d)", lowbound, highbound);
1769     }
1770   typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
1771   for (idx = 1; idx < nelem; idx++)
1772     {
1773       if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
1774         {
1775           error ("array elements must all be the same size");
1776         }
1777     }
1778
1779   rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1780                                  lowbound, highbound);
1781   arraytype = create_array_type ((struct type *) NULL,
1782                                  VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
1783
1784   if (!current_language->c_style_arrays)
1785     {
1786       val = allocate_value (arraytype);
1787       for (idx = 0; idx < nelem; idx++)
1788         {
1789           memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
1790                   VALUE_CONTENTS_ALL (elemvec[idx]),
1791                   typelength);
1792         }
1793       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
1794       return val;
1795     }
1796
1797   /* Allocate space to store the array in the inferior, and then initialize
1798      it by copying in each element.  FIXME:  Is it worth it to create a
1799      local buffer in which to collect each value and then write all the
1800      bytes in one operation? */
1801
1802   addr = allocate_space_in_inferior (nelem * typelength);
1803   for (idx = 0; idx < nelem; idx++)
1804     {
1805       write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
1806                     typelength);
1807     }
1808
1809   /* Create the array type and set up an array value to be evaluated lazily. */
1810
1811   val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
1812   return (val);
1813 }
1814
1815 /* Create a value for a string constant by allocating space in the inferior,
1816    copying the data into that space, and returning the address with type
1817    TYPE_CODE_STRING.  PTR points to the string constant data; LEN is number
1818    of characters.
1819    Note that string types are like array of char types with a lower bound of
1820    zero and an upper bound of LEN - 1.  Also note that the string may contain
1821    embedded null bytes. */
1822
1823 value_ptr
1824 value_string (ptr, len)
1825      char *ptr;
1826      int len;
1827 {
1828   value_ptr val;
1829   int lowbound = current_language->string_lower_bound;
1830   struct type *rangetype = create_range_type ((struct type *) NULL,
1831                                               builtin_type_int,
1832                                               lowbound, len + lowbound - 1);
1833   struct type *stringtype
1834     = create_string_type ((struct type *) NULL, rangetype);
1835   CORE_ADDR addr;
1836
1837   if (current_language->c_style_arrays == 0)
1838     {
1839       val = allocate_value (stringtype);
1840       memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1841       return val;
1842     }
1843
1844
1845   /* Allocate space to store the string in the inferior, and then
1846      copy LEN bytes from PTR in gdb to that address in the inferior. */
1847
1848   addr = allocate_space_in_inferior (len);
1849   write_memory (addr, ptr, len);
1850
1851   val = value_at_lazy (stringtype, addr, NULL);
1852   return (val);
1853 }
1854
1855 value_ptr
1856 value_bitstring (ptr, len)
1857      char *ptr;
1858      int len;
1859 {
1860   value_ptr val;
1861   struct type *domain_type = create_range_type (NULL, builtin_type_int,
1862                                                 0, len - 1);
1863   struct type *type = create_set_type ((struct type*) NULL, domain_type);
1864   TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1865   val = allocate_value (type);
1866   memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
1867   return val;
1868 }
1869 \f
1870 /* See if we can pass arguments in T2 to a function which takes arguments
1871    of types T1.  Both t1 and t2 are NULL-terminated vectors.  If some
1872    arguments need coercion of some sort, then the coerced values are written
1873    into T2.  Return value is 0 if the arguments could be matched, or the
1874    position at which they differ if not.
1875
1876    STATICP is nonzero if the T1 argument list came from a
1877    static member function.
1878
1879    For non-static member functions, we ignore the first argument,
1880    which is the type of the instance variable.  This is because we want
1881    to handle calls with objects from derived classes.  This is not
1882    entirely correct: we should actually check to make sure that a
1883    requested operation is type secure, shouldn't we?  FIXME.  */
1884
1885 static int
1886 typecmp (staticp, t1, t2)
1887      int staticp;
1888      struct type *t1[];
1889      value_ptr t2[];
1890 {
1891   int i;
1892
1893   if (t2 == 0)
1894     return 1;
1895   if (staticp && t1 == 0)
1896     return t2[1] != 0;
1897   if (t1 == 0)
1898     return 1;
1899   if (TYPE_CODE (t1[0]) == TYPE_CODE_VOID) return 0;
1900   if (t1[!staticp] == 0) return 0;
1901   for (i = !staticp; t1[i] && TYPE_CODE (t1[i]) != TYPE_CODE_VOID; i++)
1902     {
1903     struct type *tt1, *tt2;
1904       if (! t2[i])
1905         return i+1;
1906       tt1 = check_typedef (t1[i]);
1907       tt2 = check_typedef (VALUE_TYPE(t2[i]));
1908       if (TYPE_CODE (tt1) == TYPE_CODE_REF
1909           /* We should be doing hairy argument matching, as below.  */
1910           && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1911         {
1912           if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1913             t2[i] = value_coerce_array (t2[i]);
1914           else
1915             t2[i] = value_addr (t2[i]);
1916           continue;
1917         }
1918
1919       while (TYPE_CODE (tt1) == TYPE_CODE_PTR
1920           && (   TYPE_CODE (tt2) == TYPE_CODE_ARRAY
1921               || TYPE_CODE (tt2) == TYPE_CODE_PTR))
1922         {
1923            tt1 = check_typedef (TYPE_TARGET_TYPE(tt1));
1924            tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1925         }
1926       if (TYPE_CODE(tt1) == TYPE_CODE(tt2)) continue;
1927       /* Array to pointer is a `trivial conversion' according to the ARM.  */
1928
1929       /* We should be doing much hairier argument matching (see section 13.2
1930          of the ARM), but as a quick kludge, just check for the same type
1931          code.  */
1932       if (TYPE_CODE (t1[i]) != TYPE_CODE (VALUE_TYPE (t2[i])))
1933         return i+1;
1934     }
1935   if (!t1[i]) return 0;
1936   return t2[i] ? i+1 : 0;
1937 }
1938
1939 /* Helper function used by value_struct_elt to recurse through baseclasses.
1940    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1941    and search in it assuming it has (class) type TYPE.
1942    If found, return value, else return NULL.
1943
1944    If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1945    look for a baseclass named NAME.  */
1946
1947 static value_ptr
1948 search_struct_field (name, arg1, offset, type, looking_for_baseclass)
1949      char *name;
1950      register value_ptr arg1;
1951      int offset;
1952      register struct type *type;
1953      int looking_for_baseclass;
1954 {
1955   int i;
1956   int nbases = TYPE_N_BASECLASSES (type);
1957
1958   CHECK_TYPEDEF (type);
1959
1960   if (! looking_for_baseclass)
1961     for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1962       {
1963         char *t_field_name = TYPE_FIELD_NAME (type, i);
1964
1965         if (t_field_name && STREQ (t_field_name, name))
1966           {
1967             value_ptr v;
1968             if (TYPE_FIELD_STATIC (type, i))
1969               v = value_static_field (type, i);
1970             else
1971               v = value_primitive_field (arg1, offset, i, type);
1972             if (v == 0)
1973               error("there is no field named %s", name);
1974             return v;
1975           }
1976
1977         if (t_field_name
1978             && (t_field_name[0] == '\0'
1979                 || (TYPE_CODE (type) == TYPE_CODE_UNION
1980                     && STREQ (t_field_name, "else"))))
1981           {
1982             struct type *field_type = TYPE_FIELD_TYPE (type, i);
1983             if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1984                 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1985               {
1986                 /* Look for a match through the fields of an anonymous union,
1987                    or anonymous struct.  C++ provides anonymous unions.
1988
1989                    In the GNU Chill implementation of variant record types,
1990                    each <alternative field> has an (anonymous) union type,
1991                    each member of the union represents a <variant alternative>.
1992                    Each <variant alternative> is represented as a struct,
1993                    with a member for each <variant field>.  */
1994
1995                 value_ptr v;
1996                 int new_offset = offset;
1997
1998                 /* This is pretty gross.  In G++, the offset in an anonymous
1999                    union is relative to the beginning of the enclosing struct.
2000                    In the GNU Chill implementation of variant records,
2001                    the bitpos is zero in an anonymous union field, so we
2002                    have to add the offset of the union here. */
2003                 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
2004                     || (TYPE_NFIELDS (field_type) > 0
2005                         && TYPE_FIELD_BITPOS (field_type, 0) == 0))
2006                   new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
2007
2008                 v = search_struct_field (name, arg1, new_offset, field_type,
2009                                          looking_for_baseclass);
2010                 if (v)
2011                   return v;
2012               }
2013           }
2014       }
2015
2016   for (i = 0;  i < nbases;  i++)
2017     {
2018       value_ptr v;
2019       struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
2020       /* If we are looking for baseclasses, this is what we get when we
2021          hit them.  But it could happen that the base part's member name
2022          is not yet filled in.  */
2023       int found_baseclass = (looking_for_baseclass
2024                              && TYPE_BASECLASS_NAME (type, i) != NULL
2025                              && STREQ (name, TYPE_BASECLASS_NAME (type, i)));
2026
2027       if (BASETYPE_VIA_VIRTUAL (type, i))
2028         {
2029           int boffset;
2030           value_ptr v2 = allocate_value (basetype);
2031
2032           boffset = baseclass_offset (type, i,
2033                                       VALUE_CONTENTS (arg1) + offset,
2034                                       VALUE_ADDRESS (arg1)
2035                                         + VALUE_OFFSET (arg1) + offset);
2036           if (boffset == -1)
2037             error ("virtual baseclass botch");
2038
2039           /* The virtual base class pointer might have been clobbered by the
2040              user program. Make sure that it still points to a valid memory
2041              location.  */
2042
2043           boffset += offset;
2044           if (boffset < 0 || boffset >= TYPE_LENGTH (type))
2045             {
2046               CORE_ADDR base_addr;
2047
2048               base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
2049               if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
2050                                       TYPE_LENGTH (basetype)) != 0)
2051                 error ("virtual baseclass botch");
2052               VALUE_LVAL (v2) = lval_memory;
2053               VALUE_ADDRESS (v2) = base_addr;
2054             }
2055           else
2056             {
2057               VALUE_LVAL (v2) = VALUE_LVAL (arg1);
2058               VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
2059               VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
2060               if (VALUE_LAZY (arg1))
2061                 VALUE_LAZY (v2) = 1;
2062               else
2063                 memcpy (VALUE_CONTENTS_RAW (v2),
2064                         VALUE_CONTENTS_RAW (arg1) + boffset,
2065                         TYPE_LENGTH (basetype));
2066             }
2067
2068           if (found_baseclass)
2069             return v2;
2070           v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
2071                                    looking_for_baseclass);
2072         }
2073       else if (found_baseclass)
2074         v = value_primitive_field (arg1, offset, i, type);
2075       else
2076         v = search_struct_field (name, arg1,
2077                                  offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
2078                                  basetype, looking_for_baseclass);
2079       if (v) return v;
2080     }
2081   return NULL;
2082 }
2083
2084
2085 /* Return the offset (in bytes) of the virtual base of type BASETYPE
2086  * in an object pointed to by VALADDR (on the host), assumed to be of
2087  * type TYPE.  OFFSET is number of bytes beyond start of ARG to start
2088  * looking (in case VALADDR is the contents of an enclosing object).
2089  *
2090  * This routine recurses on the primary base of the derived class because
2091  * the virtual base entries of the primary base appear before the other
2092  * virtual base entries.
2093  *
2094  * If the virtual base is not found, a negative integer is returned.
2095  * The magnitude of the negative integer is the number of entries in
2096  * the virtual table to skip over (entries corresponding to various
2097  * ancestral classes in the chain of primary bases).
2098  *
2099  * Important: This assumes the HP / Taligent C++ runtime
2100  * conventions. Use baseclass_offset() instead to deal with g++
2101  * conventions.  */
2102
2103 void
2104 find_rt_vbase_offset(type, basetype, valaddr, offset, boffset_p, skip_p)
2105   struct type * type;
2106   struct type * basetype;
2107   char * valaddr;
2108   int offset;
2109   int * boffset_p;
2110   int * skip_p;
2111 {
2112   int boffset;           /* offset of virtual base */
2113   int index;             /* displacement to use in virtual table */
2114   int skip;
2115
2116   value_ptr vp;
2117   CORE_ADDR vtbl;      /* the virtual table pointer */
2118   struct type * pbc;   /* the primary base class */
2119
2120   /* Look for the virtual base recursively in the primary base, first.
2121    * This is because the derived class object and its primary base
2122    * subobject share the primary virtual table.  */
2123
2124   boffset = 0;
2125   pbc = TYPE_PRIMARY_BASE(type);
2126   if (pbc)
2127     {
2128       find_rt_vbase_offset (pbc, basetype, valaddr, offset, &boffset, &skip);
2129       if (skip < 0)
2130         {
2131           *boffset_p = boffset;
2132           *skip_p = -1;
2133           return;
2134         }
2135     }
2136   else
2137     skip = 0;
2138
2139
2140   /* Find the index of the virtual base according to HP/Taligent
2141      runtime spec. (Depth-first, left-to-right.)  */
2142   index = virtual_base_index_skip_primaries (basetype, type);
2143
2144   if (index < 0) {
2145     *skip_p = skip + virtual_base_list_length_skip_primaries (type);
2146     *boffset_p = 0;
2147     return;
2148   }
2149
2150   /* pai: FIXME -- 32x64 possible problem */
2151   /* First word (4 bytes) in object layout is the vtable pointer */
2152   vtbl = * (CORE_ADDR *) (valaddr + offset);
2153
2154   /* Before the constructor is invoked, things are usually zero'd out. */
2155   if (vtbl == 0)
2156     error ("Couldn't find virtual table -- object may not be constructed yet.");
2157
2158
2159   /* Find virtual base's offset -- jump over entries for primary base
2160    * ancestors, then use the index computed above.  But also adjust by
2161    * HP_ACC_VBASE_START for the vtable slots before the start of the
2162    * virtual base entries.  Offset is negative -- virtual base entries
2163    * appear _before_ the address point of the virtual table. */
2164
2165   /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2166      & use long type */
2167
2168   /* epstein : FIXME -- added param for overlay section. May not be correct */
2169    vp = value_at (builtin_type_int, vtbl + 4 * (- skip - index - HP_ACC_VBASE_START), NULL);
2170   boffset = value_as_long (vp);
2171   *skip_p = -1;
2172   *boffset_p = boffset;
2173   return;
2174 }
2175
2176
2177 /* Helper function used by value_struct_elt to recurse through baseclasses.
2178    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2179    and search in it assuming it has (class) type TYPE.
2180    If found, return value, else if name matched and args not return (value)-1,
2181    else return NULL. */
2182
2183 static value_ptr
2184 search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
2185      char *name;
2186      register value_ptr *arg1p, *args;
2187      int offset, *static_memfuncp;
2188      register struct type *type;
2189 {
2190   int i;
2191   value_ptr v;
2192   int name_matched = 0;
2193   char dem_opname[64];
2194
2195   CHECK_TYPEDEF (type);
2196   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2197     {
2198       char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2199       /* FIXME!  May need to check for ARM demangling here */
2200       if (strncmp(t_field_name, "__", 2)==0 ||
2201         strncmp(t_field_name, "op", 2)==0 ||
2202         strncmp(t_field_name, "type", 4)==0 )
2203         {
2204           if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
2205             t_field_name = dem_opname;
2206           else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
2207             t_field_name = dem_opname;
2208         }
2209       if (t_field_name && STREQ (t_field_name, name))
2210         {
2211           int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2212           struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2213           name_matched = 1;
2214
2215           if (j > 0 && args == 0)
2216             error ("cannot resolve overloaded method `%s': no arguments supplied", name);
2217           while (j >= 0)
2218             {
2219               if (TYPE_FN_FIELD_STUB (f, j))
2220                 check_stub_method (type, i, j);
2221               if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2222                             TYPE_FN_FIELD_ARGS (f, j), args))
2223                 {
2224                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2225                     return value_virtual_fn_field (arg1p, f, j, type, offset);
2226                   if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
2227                     *static_memfuncp = 1;
2228                   v = value_fn_field (arg1p, f, j, type, offset);
2229                   if (v != NULL) return v;
2230                 }
2231               j--;
2232             }
2233         }
2234     }
2235
2236   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2237     {
2238       int base_offset;
2239
2240       if (BASETYPE_VIA_VIRTUAL (type, i))
2241         {
2242          if (TYPE_HAS_VTABLE (type))
2243             {
2244               /* HP aCC compiled type, search for virtual base offset
2245                  according to HP/Taligent runtime spec.  */
2246               int skip;
2247               find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2248                                     VALUE_CONTENTS_ALL (*arg1p),
2249                                     offset + VALUE_EMBEDDED_OFFSET (*arg1p),
2250                                     &base_offset, &skip);
2251               if (skip >= 0)
2252                 error ("Virtual base class offset not found in vtable");
2253             }
2254          else
2255            {
2256              struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2257              char *base_valaddr;
2258
2259              /* The virtual base class pointer might have been clobbered by the
2260                 user program. Make sure that it still points to a valid memory
2261                 location.  */
2262
2263              if (offset < 0 || offset >= TYPE_LENGTH (type))
2264                {
2265                  base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
2266                  if (target_read_memory (VALUE_ADDRESS (*arg1p)
2267                                          + VALUE_OFFSET (*arg1p) + offset,
2268                                          base_valaddr,
2269                                          TYPE_LENGTH (baseclass)) != 0)
2270                    error ("virtual baseclass botch");
2271                }
2272             else
2273                base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
2274
2275             base_offset =
2276                baseclass_offset (type, i, base_valaddr,
2277                                  VALUE_ADDRESS (*arg1p)
2278                                    + VALUE_OFFSET (*arg1p) + offset);
2279             if (base_offset == -1)
2280                error ("virtual baseclass botch");
2281            }
2282         }
2283       else
2284         {
2285           base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2286         }
2287       v = search_struct_method (name, arg1p, args, base_offset + offset,
2288                                 static_memfuncp, TYPE_BASECLASS (type, i));
2289       if (v == (value_ptr) -1)
2290         {
2291           name_matched = 1;
2292         }
2293       else if (v)
2294         {
2295 /* FIXME-bothner:  Why is this commented out?  Why is it here?  */
2296 /*        *arg1p = arg1_tmp;*/
2297           return v;
2298         }
2299     }
2300   if (name_matched) return (value_ptr) -1;
2301   else return NULL;
2302 }
2303
2304 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2305    extract the component named NAME from the ultimate target structure/union
2306    and return it as a value with its appropriate type.
2307    ERR is used in the error message if *ARGP's type is wrong.
2308
2309    C++: ARGS is a list of argument types to aid in the selection of
2310    an appropriate method. Also, handle derived types.
2311
2312    STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2313    where the truthvalue of whether the function that was resolved was
2314    a static member function or not is stored.
2315
2316    ERR is an error message to be printed in case the field is not found.  */
2317
2318 value_ptr
2319 value_struct_elt (argp, args, name, static_memfuncp, err)
2320      register value_ptr *argp, *args;
2321      char *name;
2322      int *static_memfuncp;
2323      char *err;
2324 {
2325   register struct type *t;
2326   value_ptr v;
2327
2328   COERCE_ARRAY (*argp);
2329
2330   t = check_typedef (VALUE_TYPE (*argp));
2331
2332   /* Follow pointers until we get to a non-pointer.  */
2333
2334   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2335     {
2336       *argp = value_ind (*argp);
2337       /* Don't coerce fn pointer to fn and then back again!  */
2338       if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2339         COERCE_ARRAY (*argp);
2340       t = check_typedef (VALUE_TYPE (*argp));
2341     }
2342
2343   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2344     error ("not implemented: member type in value_struct_elt");
2345
2346   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
2347       && TYPE_CODE (t) != TYPE_CODE_UNION)
2348     error ("Attempt to extract a component of a value that is not a %s.", err);
2349
2350   /* Assume it's not, unless we see that it is.  */
2351   if (static_memfuncp)
2352     *static_memfuncp =0;
2353
2354   if (!args)
2355     {
2356       /* if there are no arguments ...do this...  */
2357
2358       /* Try as a field first, because if we succeed, there
2359          is less work to be done.  */
2360       v = search_struct_field (name, *argp, 0, t, 0);
2361       if (v)
2362         return v;
2363
2364       /* C++: If it was not found as a data field, then try to
2365          return it as a pointer to a method.  */
2366
2367       if (destructor_name_p (name, t))
2368         error ("Cannot get value of destructor");
2369
2370       v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2371
2372       if (v == (value_ptr) -1)
2373         error ("Cannot take address of a method");
2374       else if (v == 0)
2375         {
2376           if (TYPE_NFN_FIELDS (t))
2377             error ("There is no member or method named %s.", name);
2378           else
2379             error ("There is no member named %s.", name);
2380         }
2381       return v;
2382     }
2383
2384   if (destructor_name_p (name, t))
2385     {
2386       if (!args[1])
2387         {
2388           /* Destructors are a special case.  */
2389           int m_index, f_index;
2390
2391           v = NULL;
2392           if (get_destructor_fn_field (t, &m_index, &f_index))
2393             {
2394               v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, m_index),
2395                                   f_index, NULL, 0);
2396             }
2397           if (v == NULL)
2398             error ("could not find destructor function named %s.", name);
2399           else
2400             return v;
2401         }
2402       else
2403         {
2404           error ("destructor should not have any argument");
2405         }
2406     }
2407   else
2408     v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2409
2410   if (v == (value_ptr) -1)
2411     {
2412         error("Argument list of %s mismatch with component in the structure.", name);
2413     }
2414   else if (v == 0)
2415     {
2416       /* See if user tried to invoke data as function.  If so,
2417          hand it back.  If it's not callable (i.e., a pointer to function),
2418          gdb should give an error.  */
2419       v = search_struct_field (name, *argp, 0, t, 0);
2420     }
2421
2422   if (!v)
2423     error ("Structure has no component named %s.", name);
2424   return v;
2425 }
2426
2427 /* Search through the methods of an object (and its bases)
2428  * to find a specified method. Return the pointer to the
2429  * fn_field list of overloaded instances.
2430  * Helper function for value_find_oload_list.
2431  * ARGP is a pointer to a pointer to a value (the object)
2432  * METHOD is a string containing the method name
2433  * OFFSET is the offset within the value
2434  * STATIC_MEMFUNCP is set if the method is static
2435  * TYPE is the assumed type of the object
2436  * NUM_FNS is the number of overloaded instances
2437  * BASETYPE is set to the actual type of the subobject where the method is found
2438  * BOFFSET is the offset of the base subobject where the method is found */
2439
2440 static struct fn_field *
2441 find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset)
2442      value_ptr *argp;
2443      char * method;
2444      int offset;
2445      int * static_memfuncp;
2446      struct type * type;
2447      int * num_fns;
2448      struct type ** basetype;
2449      int * boffset;
2450 {
2451   int i;
2452   struct fn_field * f;
2453   CHECK_TYPEDEF (type);
2454
2455   *num_fns = 0;
2456
2457   /* First check in object itself */
2458   for (i = TYPE_NFN_FIELDS (type) -1; i >= 0; i--)
2459     {
2460       /* pai: FIXME What about operators and type conversions? */
2461       char * fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2462       if (fn_field_name && STREQ (fn_field_name, method))
2463         {
2464           *num_fns = TYPE_FN_FIELDLIST_LENGTH (type, i);
2465           *basetype = type;
2466           *boffset = offset;
2467           return TYPE_FN_FIELDLIST1 (type, i);
2468         }
2469     }
2470
2471   /* Not found in object, check in base subobjects */
2472   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2473     {
2474       int base_offset;
2475       if (BASETYPE_VIA_VIRTUAL (type, i))
2476         {
2477           if (TYPE_HAS_VTABLE (type))
2478             {
2479               /* HP aCC compiled type, search for virtual base offset
2480                * according to HP/Taligent runtime spec.  */
2481               int skip;
2482               find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2483                                     VALUE_CONTENTS_ALL (*argp),
2484                                     offset + VALUE_EMBEDDED_OFFSET (*argp),
2485                                     &base_offset, &skip);
2486               if (skip >= 0)
2487                 error ("Virtual base class offset not found in vtable");
2488             }
2489           else
2490             {
2491               /* probably g++ runtime model */
2492               base_offset = VALUE_OFFSET (*argp) + offset;
2493               base_offset =
2494                 baseclass_offset (type, i,
2495                                   VALUE_CONTENTS (*argp) + base_offset,
2496                                   VALUE_ADDRESS (*argp) + base_offset);
2497               if (base_offset == -1)
2498                 error ("virtual baseclass botch");
2499             }
2500         }
2501       else /* non-virtual base, simply use bit position from debug info */
2502         {
2503           base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2504         }
2505       f = find_method_list (argp, method, base_offset + offset,
2506                             static_memfuncp, TYPE_BASECLASS (type, i), num_fns, basetype, boffset);
2507       if (f)
2508         return f;
2509     }
2510   return NULL;
2511 }
2512
2513 /* Return the list of overloaded methods of a specified name.
2514  * ARGP is a pointer to a pointer to a value (the object)
2515  * METHOD is the method name
2516  * OFFSET is the offset within the value contents
2517  * STATIC_MEMFUNCP is set if the method is static
2518  * NUM_FNS is the number of overloaded instances
2519  * BASETYPE is set to the type of the base subobject that defines the method
2520  * BOFFSET is the offset of the base subobject which defines the method */
2521
2522 struct fn_field *
2523 value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, basetype, boffset)
2524   value_ptr *argp;
2525   char * method;
2526   int offset;
2527   int * static_memfuncp;
2528   int * num_fns;
2529   struct type ** basetype;
2530   int * boffset;
2531 {
2532   struct type * t;
2533   value_ptr v;
2534
2535   t = check_typedef (VALUE_TYPE (*argp));
2536
2537   /* code snarfed from value_struct_elt */
2538   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2539     {
2540       *argp = value_ind (*argp);
2541       /* Don't coerce fn pointer to fn and then back again!  */
2542       if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2543         COERCE_ARRAY (*argp);
2544       t = check_typedef (VALUE_TYPE (*argp));
2545     }
2546
2547   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2548     error ("Not implemented: member type in value_find_oload_lis");
2549
2550   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
2551          && TYPE_CODE (t) != TYPE_CODE_UNION)
2552     error ("Attempt to extract a component of a value that is not a struct or union");
2553
2554   /* Assume it's not static, unless we see that it is.  */
2555   if (static_memfuncp)
2556     *static_memfuncp =0;
2557
2558   return find_method_list (argp, method, 0, static_memfuncp, t, num_fns, basetype, boffset);
2559
2560 }
2561
2562 /* Given an array of argument types (ARGTYPES) (which includes an
2563    entry for "this" in the case of C++ methods), the number of
2564    arguments NARGS, the NAME of a function whether it's a method or
2565    not (METHOD), and the degree of laxness (LAX) in conforming to
2566    overload resolution rules in ANSI C++, find the best function that
2567    matches on the argument types according to the overload resolution
2568    rules.
2569
2570    In the case of class methods, the parameter OBJ is an object value
2571    in which to search for overloaded methods.
2572
2573    In the case of non-method functions, the parameter FSYM is a symbol
2574    corresponding to one of the overloaded functions.
2575
2576    Return value is an integer: 0 -> good match, 10 -> debugger applied
2577    non-standard coercions, 100 -> incompatible.
2578
2579    If a method is being searched for, VALP will hold the value.
2580    If a non-method is being searched for, SYMP will hold the symbol for it.
2581
2582    If a method is being searched for, and it is a static method,
2583    then STATICP will point to a non-zero value.
2584
2585    Note: This function does *not* check the value of
2586    overload_resolution.  Caller must check it to see whether overload
2587    resolution is permitted.
2588    */
2589
2590 int
2591 find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, staticp)
2592   struct type ** arg_types;
2593   int nargs;
2594   char * name;
2595   int method;
2596   int lax;
2597   value_ptr obj;
2598   struct symbol * fsym;
2599   value_ptr * valp;
2600   struct symbol ** symp;
2601   int * staticp;
2602 {
2603   int nparms;
2604   struct type ** parm_types;
2605   int champ_nparms = 0;
2606
2607   short oload_champ = -1;          /* Index of best overloaded function */
2608   short oload_ambiguous = 0;       /* Current ambiguity state for overload resolution */
2609                                    /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2610   short oload_ambig_champ = -1;    /* 2nd contender for best match */
2611   short oload_non_standard = 0;    /* did we have to use non-standard conversions? */
2612   short oload_incompatible = 0;    /* are args supplied incompatible with any function? */
2613
2614   struct badness_vector * bv;      /* A measure of how good an overloaded instance is */
2615   struct badness_vector * oload_champ_bv = NULL; /* The measure for the current best match */
2616
2617   value_ptr temp = obj;
2618   struct fn_field * fns_ptr = NULL;   /* For methods, the list of overloaded methods */
2619   struct symbol ** oload_syms = NULL; /* For non-methods, the list of overloaded function symbols */
2620   int num_fns = 0;                    /* Number of overloaded instances being considered */
2621   struct type * basetype = NULL;
2622   int boffset;
2623   register int jj;
2624   register int ix;
2625
2626   char * obj_type_name = NULL;
2627   char * func_name = NULL;
2628
2629   /* Get the list of overloaded methods or functions */
2630   if (method)
2631     {
2632       obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
2633       /* Hack: evaluate_subexp_standard often passes in a pointer
2634          value rather than the object itself, so try again */
2635       if ((!obj_type_name || !*obj_type_name) &&
2636           (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
2637         obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
2638
2639       fns_ptr = value_find_oload_method_list (&temp, name, 0,
2640                                               staticp,
2641                                               &num_fns,
2642                                               &basetype, &boffset);
2643       if (!fns_ptr || !num_fns)
2644         error ("Couldn't find method %s%s%s",
2645                obj_type_name,
2646                (obj_type_name && *obj_type_name) ? "::" : "",
2647                name);
2648     }
2649   else
2650     {
2651       int i = -1;
2652       func_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_NO_OPTS);
2653
2654       oload_syms = make_symbol_overload_list (fsym);
2655       while (oload_syms[++i])
2656         num_fns++;
2657       if (!num_fns)
2658         error ("Couldn't find function %s", func_name);
2659     }
2660
2661   oload_champ_bv = NULL;
2662
2663   /* Consider each candidate in turn */
2664   for (ix = 0; ix < num_fns; ix++)
2665     {
2666       int jj;
2667
2668       /* Number of parameters for current candidate */
2669       nparms = method ? TYPE_NFIELDS (fns_ptr[ix].type)
2670                       : TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
2671
2672       /* Prepare array of parameter types */
2673       parm_types = (struct type **) xmalloc (nparms * (sizeof (struct type *)));
2674       for (jj = 0; jj < nparms; jj++)
2675         parm_types[jj] = method ? TYPE_FIELD_TYPE (fns_ptr[ix].type, jj)
2676                                 : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj);
2677
2678       /* Compare parameter types to supplied argument types */
2679       bv = rank_function (parm_types, nparms, arg_types, nargs);
2680
2681       if (!oload_champ_bv)
2682         {
2683           oload_champ_bv = bv;
2684           oload_champ = 0;
2685           champ_nparms = nparms;
2686         }
2687       else
2688         /* See whether current candidate is better or worse than previous best */
2689         switch (compare_badness (bv, oload_champ_bv))
2690           {
2691             case 0:
2692               oload_ambiguous = 1;    /* top two contenders are equally good */
2693               oload_ambig_champ = ix;
2694               break;
2695             case 1:
2696               oload_ambiguous = 2;    /* incomparable top contenders */
2697               oload_ambig_champ = ix;
2698               break;
2699             case 2:
2700               oload_champ_bv = bv;    /* new champion, record details */
2701               oload_ambiguous = 0;
2702               oload_champ = ix;
2703               oload_ambig_champ = -1;
2704               champ_nparms = nparms;
2705               break;
2706             case 3:
2707             default:
2708               break;
2709           }
2710       free (parm_types);
2711 #ifdef DEBUG_OLOAD
2712       if (method)
2713         printf("Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
2714       else
2715         printf("Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME(oload_syms[ix]),nparms);
2716       for (jj = 0; jj <= nargs; jj++)
2717         printf("...Badness @ %d : %d\n", jj, bv->rank[jj]);
2718       printf("Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
2719 #endif
2720     } /* end loop over all candidates */
2721
2722   if (oload_ambiguous)
2723     {
2724       if (method)
2725         error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2726                obj_type_name,
2727                (obj_type_name && *obj_type_name) ? "::" : "",
2728                name);
2729       else
2730         error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2731                func_name);
2732     }
2733
2734   /* Check how bad the best match is */
2735   for (ix = 1; ix <= nargs; ix++)
2736     {
2737       switch (oload_champ_bv->rank[ix])
2738         {
2739           case 10:
2740             oload_non_standard = 1;  /* non-standard type conversions needed */
2741             break;
2742           case 100:
2743             oload_incompatible = 1;  /* truly mismatched types */
2744             break;
2745         }
2746     }
2747   if (oload_incompatible)
2748     {
2749       if (method)
2750         error ("Cannot resolve method %s%s%s to any overloaded instance",
2751                obj_type_name,
2752                (obj_type_name && *obj_type_name) ? "::" : "",
2753                name);
2754       else
2755         error ("Cannot resolve function %s to any overloaded instance",
2756                func_name);
2757     }
2758   else if (oload_non_standard)
2759     {
2760       if (method)
2761         warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2762                  obj_type_name,
2763                  (obj_type_name && *obj_type_name) ? "::" : "",
2764                  name);
2765       else
2766         warning ("Using non-standard conversion to match function %s to supplied arguments",
2767                  func_name);
2768     }
2769
2770   if (method)
2771     {
2772       if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
2773         *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2774       else
2775         *valp = value_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2776     }
2777   else
2778     {
2779       *symp = oload_syms[oload_champ];
2780       free (func_name);
2781     }
2782
2783   return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
2784 }
2785
2786 /* C++: return 1 is NAME is a legitimate name for the destructor
2787    of type TYPE.  If TYPE does not have a destructor, or
2788    if NAME is inappropriate for TYPE, an error is signaled.  */
2789 int
2790 destructor_name_p (name, type)
2791      const char *name;
2792      const struct type *type;
2793 {
2794   /* destructors are a special case.  */
2795
2796   if (name[0] == '~')
2797     {
2798       char *dname = type_name_no_tag (type);
2799       char *cp = strchr (dname, '<');
2800       unsigned int len;
2801
2802       /* Do not compare the template part for template classes.  */
2803       if (cp == NULL)
2804         len = strlen (dname);
2805       else
2806         len = cp - dname;
2807       if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
2808         error ("name of destructor must equal name of class");
2809       else
2810         return 1;
2811     }
2812   return 0;
2813 }
2814
2815 /* Helper function for check_field: Given TYPE, a structure/union,
2816    return 1 if the component named NAME from the ultimate
2817    target structure/union is defined, otherwise, return 0. */
2818
2819 static int
2820 check_field_in (type, name)
2821      register struct type *type;
2822      const char *name;
2823 {
2824   register int i;
2825
2826   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2827     {
2828       char *t_field_name = TYPE_FIELD_NAME (type, i);
2829       if (t_field_name && STREQ (t_field_name, name))
2830         return 1;
2831     }
2832
2833   /* C++: If it was not found as a data field, then try to
2834      return it as a pointer to a method.  */
2835
2836   /* Destructors are a special case.  */
2837   if (destructor_name_p (name, type))
2838     {
2839       int m_index, f_index;
2840
2841       return get_destructor_fn_field (type, &m_index, &f_index);
2842     }
2843
2844   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2845     {
2846       if (STREQ (TYPE_FN_FIELDLIST_NAME (type, i), name))
2847         return 1;
2848     }
2849
2850   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2851     if (check_field_in (TYPE_BASECLASS (type, i), name))
2852       return 1;
2853
2854   return 0;
2855 }
2856
2857
2858 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2859    return 1 if the component named NAME from the ultimate
2860    target structure/union is defined, otherwise, return 0.  */
2861
2862 int
2863 check_field (arg1, name)
2864      register value_ptr arg1;
2865      const char *name;
2866 {
2867   register struct type *t;
2868
2869   COERCE_ARRAY (arg1);
2870
2871   t = VALUE_TYPE (arg1);
2872
2873   /* Follow pointers until we get to a non-pointer.  */
2874
2875   for (;;)
2876     {
2877       CHECK_TYPEDEF (t);
2878       if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF)
2879         break;
2880       t = TYPE_TARGET_TYPE (t);
2881     }
2882
2883   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2884     error ("not implemented: member type in check_field");
2885
2886   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
2887       && TYPE_CODE (t) != TYPE_CODE_UNION)
2888     error ("Internal error: `this' is not an aggregate");
2889
2890   return check_field_in (t, name);
2891 }
2892
2893 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
2894    return the address of this member as a "pointer to member"
2895    type.  If INTYPE is non-null, then it will be the type
2896    of the member we are looking for.  This will help us resolve
2897    "pointers to member functions".  This function is used
2898    to resolve user expressions of the form "DOMAIN::NAME".  */
2899
2900 value_ptr
2901 value_struct_elt_for_reference (domain, offset, curtype, name, intype)
2902      struct type *domain, *curtype, *intype;
2903      int offset;
2904      char *name;
2905 {
2906   register struct type *t = curtype;
2907   register int i;
2908   value_ptr v;
2909
2910   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
2911       && TYPE_CODE (t) != TYPE_CODE_UNION)
2912     error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
2913
2914   for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
2915     {
2916       char *t_field_name = TYPE_FIELD_NAME (t, i);
2917
2918       if (t_field_name && STREQ (t_field_name, name))
2919         {
2920           if (TYPE_FIELD_STATIC (t, i))
2921             {
2922               v = value_static_field (t, i);
2923               if (v == NULL)
2924                 error ("Internal error: could not find static variable %s",
2925                        name);
2926               return v;
2927             }
2928           if (TYPE_FIELD_PACKED (t, i))
2929             error ("pointers to bitfield members not allowed");
2930
2931           return value_from_longest
2932             (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
2933                                                         domain)),
2934              offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
2935         }
2936     }
2937
2938   /* C++: If it was not found as a data field, then try to
2939      return it as a pointer to a method.  */
2940
2941   /* Destructors are a special case.  */
2942   if (destructor_name_p (name, t))
2943     {
2944       error ("member pointers to destructors not implemented yet");
2945     }
2946
2947   /* Perform all necessary dereferencing.  */
2948   while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
2949     intype = TYPE_TARGET_TYPE (intype);
2950
2951   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
2952     {
2953       char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
2954       char dem_opname[64];
2955
2956       if (strncmp(t_field_name, "__", 2)==0 ||
2957         strncmp(t_field_name, "op", 2)==0 ||
2958         strncmp(t_field_name, "type", 4)==0 )
2959         {
2960           if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
2961             t_field_name = dem_opname;
2962           else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
2963             t_field_name = dem_opname;
2964         }
2965       if (t_field_name && STREQ (t_field_name, name))
2966         {
2967           int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
2968           struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
2969
2970           if (intype == 0 && j > 1)
2971             error ("non-unique member `%s' requires type instantiation", name);
2972           if (intype)
2973             {
2974               while (j--)
2975                 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
2976                   break;
2977               if (j < 0)
2978                 error ("no member function matches that type instantiation");
2979             }
2980           else
2981             j = 0;
2982
2983           if (TYPE_FN_FIELD_STUB (f, j))
2984             check_stub_method (t, i, j);
2985           if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2986             {
2987               return value_from_longest
2988                 (lookup_reference_type
2989                  (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
2990                                       domain)),
2991                  (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
2992             }
2993           else
2994             {
2995               struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
2996                                                 0, VAR_NAMESPACE, 0, NULL);
2997               if (s == NULL)
2998                 {
2999                   v = 0;
3000                 }
3001               else
3002                 {
3003                   v = read_var_value (s, 0);
3004 #if 0
3005                   VALUE_TYPE (v) = lookup_reference_type
3006                     (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
3007                                          domain));
3008 #endif
3009                 }
3010               return v;
3011             }
3012         }
3013     }
3014   for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3015     {
3016       value_ptr v;
3017       int base_offset;
3018
3019       if (BASETYPE_VIA_VIRTUAL (t, i))
3020         base_offset = 0;
3021       else
3022         base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3023       v = value_struct_elt_for_reference (domain,
3024                                           offset + base_offset,
3025                                           TYPE_BASECLASS (t, i),
3026                                           name,
3027                                           intype);
3028       if (v)
3029         return v;
3030     }
3031   return 0;
3032 }
3033
3034
3035 /* Find the real run-time type of a value using RTTI.
3036  * V is a pointer to the value.
3037  * A pointer to the struct type entry of the run-time type
3038  * is returneed.
3039  * FULL is a flag that is set only if the value V includes
3040  * the entire contents of an object of the RTTI type.
3041  * TOP is the offset to the top of the enclosing object of
3042  * the real run-time type.  This offset may be for the embedded
3043  * object, or for the enclosing object of V.
3044  * USING_ENC is the flag that distinguishes the two cases.
3045  * If it is 1, then the offset is for the enclosing object,
3046  * otherwise for the embedded object.
3047  *
3048  * This currently works only for RTTI information generated
3049  * by the HP ANSI C++ compiler (aCC).  g++ today (1997-06-10)
3050  * does not appear to support RTTI. This function returns a
3051  * NULL value for objects in the g++ runtime model. */
3052
3053 struct type *
3054 value_rtti_type (v, full, top, using_enc)
3055   value_ptr v;
3056   int * full;
3057   int * top;
3058   int * using_enc;
3059 {
3060   struct type * known_type;
3061   struct type * rtti_type;
3062   CORE_ADDR coreptr;
3063   value_ptr vp;
3064   int using_enclosing = 0;
3065   long top_offset = 0;
3066   char rtti_type_name[256];
3067
3068   if (full)
3069     *full = 0;
3070   if (top)
3071     *top = -1;
3072   if (using_enc)
3073     *using_enc = 0;
3074
3075   /* Get declared type */
3076   known_type = VALUE_TYPE (v);
3077   CHECK_TYPEDEF (known_type);
3078   /* RTTI works only or class objects */
3079   if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
3080     return NULL;
3081
3082   /* If neither the declared type nor the enclosing type of the
3083    * value structure has a HP ANSI C++ style virtual table,
3084    * we can't do anything. */
3085   if (!TYPE_HAS_VTABLE (known_type))
3086     {
3087       known_type = VALUE_ENCLOSING_TYPE (v);
3088       CHECK_TYPEDEF (known_type);
3089       if ((TYPE_CODE (known_type) != TYPE_CODE_CLASS) ||
3090           !TYPE_HAS_VTABLE (known_type))
3091         return NULL; /* No RTTI, or not HP-compiled types */
3092       CHECK_TYPEDEF (known_type);
3093       using_enclosing = 1;
3094     }
3095
3096   if (using_enclosing && using_enc)
3097     *using_enc = 1;
3098
3099   /* First get the virtual table address */
3100   coreptr = * (CORE_ADDR *) ((VALUE_CONTENTS_ALL (v))
3101                              + VALUE_OFFSET (v)
3102                              + (using_enclosing ? 0 : VALUE_EMBEDDED_OFFSET (v)));
3103   if (coreptr == 0)
3104     return NULL; /* return silently -- maybe called on gdb-generated value */
3105
3106   /* Fetch the top offset of the object */
3107   /* FIXME possible 32x64 problem with pointer size & arithmetic */
3108   vp = value_at (builtin_type_int,
3109                  coreptr + 4 * HP_ACC_TOP_OFFSET_OFFSET,
3110                  VALUE_BFD_SECTION (v));
3111   top_offset = value_as_long (vp);
3112   if (top)
3113     *top = top_offset;
3114
3115   /* Fetch the typeinfo pointer */
3116   /* FIXME possible 32x64 problem with pointer size & arithmetic */
3117   vp = value_at (builtin_type_int, coreptr + 4 * HP_ACC_TYPEINFO_OFFSET, VALUE_BFD_SECTION (v));
3118   /* Indirect through the typeinfo pointer and retrieve the pointer
3119    * to the string name */
3120   coreptr = * (CORE_ADDR *) (VALUE_CONTENTS (vp));
3121   if (!coreptr)
3122     error ("Retrieved null typeinfo pointer in trying to determine run-time type");
3123   vp = value_at (builtin_type_int, coreptr + 4, VALUE_BFD_SECTION (v));  /* 4 -> offset of name field */
3124                                                   /* FIXME possible 32x64 problem */
3125
3126   coreptr = * (CORE_ADDR *) (VALUE_CONTENTS (vp));
3127
3128   read_memory_string (coreptr, rtti_type_name, 256);
3129
3130   if (strlen (rtti_type_name) == 0)
3131     error ("Retrieved null type name from typeinfo");
3132
3133   /* search for type */
3134   rtti_type = lookup_typename (rtti_type_name, (struct block *) 0, 1);
3135
3136   if (!rtti_type)
3137     error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name);
3138   CHECK_TYPEDEF (rtti_type);
3139
3140 #if 0 /* debugging*/
3141   printf("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1);
3142 #endif
3143
3144   /* Check whether we have the entire object */
3145   if (full /* Non-null pointer passed */
3146
3147       &&
3148            /* Either we checked on the whole object in hand and found the
3149               top offset to be zero */
3150       (((top_offset == 0) &&
3151        using_enclosing &&
3152        TYPE_LENGTH (known_type) == TYPE_LENGTH (rtti_type))
3153       ||
3154            /* Or we checked on the embedded object and top offset was the
3155               same as the embedded offset */
3156       ((top_offset == VALUE_EMBEDDED_OFFSET (v)) &&
3157        !using_enclosing &&
3158        TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type))))
3159
3160     *full = 1;
3161
3162   return rtti_type;
3163 }
3164
3165 /* Given a pointer value V, find the real (RTTI) type
3166    of the object it points to.
3167    Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3168    and refer to the values computed for the object pointed to. */
3169
3170 struct type *
3171 value_rtti_target_type (v, full, top, using_enc)
3172   value_ptr v;
3173   int * full;
3174   int * top;
3175   int * using_enc;
3176 {
3177   value_ptr target;
3178
3179   target = value_ind (v);
3180
3181   return value_rtti_type (target, full, top, using_enc);
3182 }
3183
3184 /* Given a value pointed to by ARGP, check its real run-time type, and
3185    if that is different from the enclosing type, create a new value
3186    using the real run-time type as the enclosing type (and of the same
3187    type as ARGP) and return it, with the embedded offset adjusted to
3188    be the correct offset to the enclosed object
3189    RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3190    parameters, computed by value_rtti_type(). If these are available,
3191    they can be supplied and a second call to value_rtti_type() is avoided.
3192    (Pass RTYPE == NULL if they're not available */
3193
3194 value_ptr
3195 value_full_object (argp, rtype, xfull, xtop, xusing_enc)
3196   value_ptr argp;
3197   struct type * rtype;
3198   int xfull;
3199   int xtop;
3200   int xusing_enc;
3201
3202 {
3203   struct type * real_type;
3204   int full = 0;
3205   int top = -1;
3206   int using_enc = 0;
3207   value_ptr new_val;
3208
3209   if (rtype)
3210     {
3211       real_type = rtype;
3212       full = xfull;
3213       top = xtop;
3214       using_enc = xusing_enc;
3215     }
3216   else
3217     real_type = value_rtti_type (argp, &full, &top, &using_enc);
3218
3219   /* If no RTTI data, or if object is already complete, do nothing */
3220   if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
3221     return argp;
3222
3223   /* If we have the full object, but for some reason the enclosing
3224      type is wrong, set it */ /* pai: FIXME -- sounds iffy */
3225   if (full)
3226     {
3227       VALUE_ENCLOSING_TYPE (argp) = real_type;
3228       return argp;
3229     }
3230
3231   /* Check if object is in memory */
3232   if (VALUE_LVAL (argp) != lval_memory)
3233     {
3234       warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
3235
3236       return argp;
3237     }
3238
3239   /* All other cases -- retrieve the complete object */
3240   /* Go back by the computed top_offset from the beginning of the object,
3241      adjusting for the embedded offset of argp if that's what value_rtti_type
3242      used for its computation. */
3243   new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
3244                            (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
3245                            VALUE_BFD_SECTION (argp));
3246   VALUE_TYPE (new_val) = VALUE_TYPE (argp);
3247   VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
3248   return new_val;
3249 }
3250
3251
3252
3253
3254 /* C++: return the value of the class instance variable, if one exists.
3255    Flag COMPLAIN signals an error if the request is made in an
3256    inappropriate context.  */
3257
3258 value_ptr
3259 value_of_this (complain)
3260      int complain;
3261 {
3262   struct symbol *func, *sym;
3263   struct block *b;
3264   int i;
3265   static const char funny_this[] = "this";
3266   value_ptr this;
3267
3268   if (selected_frame == 0)
3269     {
3270       if (complain)
3271         error ("no frame selected");
3272       else return 0;
3273     }
3274
3275   func = get_frame_function (selected_frame);
3276   if (!func)
3277     {
3278       if (complain)
3279         error ("no `this' in nameless context");
3280       else return 0;
3281     }
3282
3283   b = SYMBOL_BLOCK_VALUE (func);
3284   i = BLOCK_NSYMS (b);
3285   if (i <= 0)
3286     {
3287       if (complain)
3288         error ("no args, no `this'");
3289       else return 0;
3290     }
3291
3292   /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3293      symbol instead of the LOC_ARG one (if both exist).  */
3294   sym = lookup_block_symbol (b, funny_this, VAR_NAMESPACE);
3295   if (sym == NULL)
3296     {
3297       if (complain)
3298         error ("current stack frame not in method");
3299       else
3300         return NULL;
3301     }
3302
3303   this = read_var_value (sym, selected_frame);
3304   if (this == 0 && complain)
3305     error ("`this' argument at unknown address");
3306   return this;
3307 }
3308
3309 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3310    long, starting at LOWBOUND.  The result has the same lower bound as
3311    the original ARRAY.  */
3312
3313 value_ptr
3314 value_slice (array, lowbound, length)
3315      value_ptr array;
3316      int lowbound, length;
3317 {
3318   struct type *slice_range_type, *slice_type, *range_type;
3319   LONGEST lowerbound, upperbound, offset;
3320   value_ptr slice;
3321   struct type *array_type;
3322   array_type = check_typedef (VALUE_TYPE (array));
3323   COERCE_VARYING_ARRAY (array, array_type);
3324   if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3325       && TYPE_CODE (array_type) != TYPE_CODE_STRING
3326       && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
3327     error ("cannot take slice of non-array");
3328   range_type = TYPE_INDEX_TYPE (array_type);
3329   if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3330     error ("slice from bad array or bitstring");
3331   if (lowbound < lowerbound || length < 0
3332       || lowbound + length - 1 > upperbound
3333       /* Chill allows zero-length strings but not arrays. */
3334       || (current_language->la_language == language_chill
3335           && length == 0 && TYPE_CODE (array_type) == TYPE_CODE_ARRAY))
3336     error ("slice out of range");
3337   /* FIXME-type-allocation: need a way to free this type when we are
3338      done with it.  */
3339   slice_range_type = create_range_type ((struct type*) NULL,
3340                                         TYPE_TARGET_TYPE (range_type),
3341                                         lowbound, lowbound + length - 1);
3342   if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
3343     {
3344       int i;
3345       slice_type = create_set_type ((struct type*) NULL, slice_range_type);
3346       TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
3347       slice = value_zero (slice_type, not_lval);
3348       for (i = 0; i < length; i++)
3349         {
3350           int element = value_bit_index (array_type,
3351                                          VALUE_CONTENTS (array),
3352                                          lowbound + i);
3353           if (element < 0)
3354             error ("internal error accessing bitstring");
3355           else if (element > 0)
3356             {
3357               int j = i % TARGET_CHAR_BIT;
3358               if (BITS_BIG_ENDIAN)
3359                 j = TARGET_CHAR_BIT - 1 - j;
3360               VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
3361             }
3362         }
3363       /* We should set the address, bitssize, and bitspos, so the clice
3364          can be used on the LHS, but that may require extensions to
3365          value_assign.  For now, just leave as a non_lval.  FIXME.  */
3366     }
3367   else
3368     {
3369       struct type *element_type = TYPE_TARGET_TYPE (array_type);
3370       offset
3371         = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3372       slice_type = create_array_type ((struct type*) NULL, element_type,
3373                                       slice_range_type);
3374       TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3375       slice = allocate_value (slice_type);
3376       if (VALUE_LAZY (array))
3377         VALUE_LAZY (slice) = 1;
3378       else
3379         memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
3380                 TYPE_LENGTH (slice_type));
3381       if (VALUE_LVAL (array) == lval_internalvar)
3382         VALUE_LVAL (slice) = lval_internalvar_component;
3383       else
3384         VALUE_LVAL (slice) = VALUE_LVAL (array);
3385       VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
3386       VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
3387     }
3388   return slice;
3389 }
3390
3391 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
3392    value as a fixed-length array. */
3393
3394 value_ptr
3395 varying_to_slice (varray)
3396      value_ptr varray;
3397 {
3398   struct type *vtype = check_typedef (VALUE_TYPE (varray));
3399   LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
3400                                 VALUE_CONTENTS (varray)
3401                                 + TYPE_FIELD_BITPOS (vtype, 0) / 8);
3402   return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
3403 }
3404
3405 /* Create a value for a FORTRAN complex number.  Currently most of
3406    the time values are coerced to COMPLEX*16 (i.e. a complex number
3407    composed of 2 doubles.  This really should be a smarter routine
3408    that figures out precision inteligently as opposed to assuming
3409    doubles. FIXME: fmb */
3410
3411 value_ptr
3412 value_literal_complex (arg1, arg2, type)
3413      value_ptr arg1;
3414      value_ptr arg2;
3415      struct type *type;
3416 {
3417   register value_ptr val;
3418   struct type *real_type = TYPE_TARGET_TYPE (type);
3419
3420   val = allocate_value (type);
3421   arg1 = value_cast (real_type, arg1);
3422   arg2 = value_cast (real_type, arg2);
3423
3424   memcpy (VALUE_CONTENTS_RAW (val),
3425           VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
3426   memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
3427           VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
3428   return val;
3429 }
3430
3431 /* Cast a value into the appropriate complex data type. */
3432
3433 static value_ptr
3434 cast_into_complex (type, val)
3435      struct type *type;
3436      register value_ptr val;
3437 {
3438   struct type *real_type = TYPE_TARGET_TYPE (type);
3439   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
3440     {
3441       struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
3442       value_ptr re_val = allocate_value (val_real_type);
3443       value_ptr im_val = allocate_value (val_real_type);
3444
3445       memcpy (VALUE_CONTENTS_RAW (re_val),
3446               VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
3447       memcpy (VALUE_CONTENTS_RAW (im_val),
3448               VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
3449                TYPE_LENGTH (val_real_type));
3450
3451       return value_literal_complex (re_val, im_val, type);
3452     }
3453   else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
3454            || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
3455     return value_literal_complex (val, value_zero (real_type, not_lval), type);
3456   else
3457     error ("cannot cast non-number to complex");
3458 }
3459
3460 void
3461 _initialize_valops ()
3462 {
3463 #if 0
3464   add_show_from_set
3465     (add_set_cmd ("abandon", class_support, var_boolean, (char *)&auto_abandon,
3466                   "Set automatic abandonment of expressions upon failure.",
3467                   &setlist),
3468      &showlist);
3469 #endif
3470
3471   add_show_from_set
3472     (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *)&overload_resolution,
3473                   "Set overload resolution in evaluating C++ functions.",
3474                   &setlist),
3475      &showlist);
3476   overload_resolution = 1;
3477
3478 }