gdb/valops.c

   1 /* Perform non-arithmetic operations on values, for GDB.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995
   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
  32 #include <errno.h>
  33 #include "gdb_string.h"
  34
  35 /* Local functions.  */
  36
  37 static int typecmp PARAMS ((int staticp, struct type *t1[], value_ptr t2[]));
  38
  39 static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
  40
  41 static CORE_ADDR value_push PARAMS ((CORE_ADDR, value_ptr));
  42
  43 static value_ptr search_struct_field PARAMS ((char *, value_ptr, int,
  44                                               struct type *, int));
  45
  46 static value_ptr search_struct_method PARAMS ((char *, value_ptr *,
  47                                                value_ptr *,
  48                                                int, int *, struct type *));
  49
  50 static int check_field_in PARAMS ((struct type *, const char *));
  51
  52 static CORE_ADDR allocate_space_in_inferior PARAMS ((int));
  53
  54 static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
  55
  56 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
  57
  58 \f
  59 /* Allocate NBYTES of space in the inferior using the inferior's malloc
  60    and return a value that is a pointer to the allocated space. */
  61
  62 static CORE_ADDR
  63 allocate_space_in_inferior (len)
  64      int len;
  65 {
  66   register value_ptr val;
  67   register struct symbol *sym;
  68   struct minimal_symbol *msymbol;
  69   struct type *type;
  70   value_ptr blocklen;
  71   LONGEST maddr;
  72
  73   /* Find the address of malloc in the inferior.  */
  74
  75   sym = lookup_symbol ("malloc", 0, VAR_NAMESPACE, 0, NULL);
  76   if (sym != NULL)
  77     {
  78       if (SYMBOL_CLASS (sym) != LOC_BLOCK)
  79         {
  80           error ("\"malloc\" exists in this program but is not a function.");
  81         }
  82       val = value_of_variable (sym, NULL);
  83     }
  84   else
  85     {
  86       msymbol = lookup_minimal_symbol ("malloc", NULL, NULL);
  87       if (msymbol != NULL)
  88         {
  89           type = lookup_pointer_type (builtin_type_char);
  90           type = lookup_function_type (type);
  91           type = lookup_pointer_type (type);
  92           maddr = (LONGEST) SYMBOL_VALUE_ADDRESS (msymbol);
  93           val = value_from_longest (type, maddr);
  94         }
  95       else
  96         {
  97           error ("evaluation of this expression requires the program to have a function \"malloc\".");
  98         }
  99     }
 100
 101   blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
 102   val = call_function_by_hand (val, 1, &blocklen);
 103   if (value_logical_not (val))
 104     {
 105       error ("No memory available to program.");
 106     }
 107   return (value_as_long (val));
 108 }
 109
 110 /* Cast value ARG2 to type TYPE and return as a value.
 111    More general than a C cast: accepts any two types of the same length,
 112    and if ARG2 is an lvalue it can be cast into anything at all.  */
 113 /* In C++, casts may change pointer or object representations.  */
 114
 115 value_ptr
 116 value_cast (type, arg2)
 117      struct type *type;
 118      register value_ptr arg2;
 119 {
 120   register enum type_code code1 = TYPE_CODE (type);
 121   register enum type_code code2;
 122   register int scalar;
 123
 124   if (VALUE_TYPE (arg2) == type)
 125     return arg2;
 126
 127   COERCE_REF(arg2);
 128
 129   /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
 130      is treated like a cast to (TYPE [N])OBJECT,
 131      where N is sizeof(OBJECT)/sizeof(TYPE). */
 132   if (code1 == TYPE_CODE_ARRAY
 133       && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 134       && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
 135     {
 136       struct type *element_type = TYPE_TARGET_TYPE (type);
 137       struct type *range_type = TYPE_INDEX_TYPE (type);
 138       int low_bound = TYPE_LOW_BOUND (range_type);
 139       int val_length = TYPE_LENGTH (VALUE_TYPE (arg2));
 140       int new_length = val_length / TYPE_LENGTH (element_type);
 141       if (val_length % TYPE_LENGTH (element_type) != 0)
 142         warning("array element type size does not divide object size in cast");
 143       /* FIXME-type-allocation: need a way to free this type when we are
 144          done with it.  */
 145       range_type = create_range_type ((struct type *) NULL,
 146                                       TYPE_TARGET_TYPE (range_type),
 147                                       low_bound, new_length + low_bound - 1);
 148       VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
 149                                              element_type, range_type);
 150       return arg2;
 151     }
 152
 153   if (current_language->c_style_arrays
 154       && (VALUE_REPEATED (arg2)
 155           || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_ARRAY))
 156     arg2 = value_coerce_array (arg2);
 157
 158   if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FUNC)
 159     arg2 = value_coerce_function (arg2);
 160
 161   COERCE_VARYING_ARRAY (arg2);
 162
 163   code2 = TYPE_CODE (VALUE_TYPE (arg2));
 164
 165   if (code1 == TYPE_CODE_COMPLEX)
 166     return cast_into_complex (type, arg2);
 167   if (code1 == TYPE_CODE_BOOL)
 168     code1 = TYPE_CODE_INT;
 169   if (code2 == TYPE_CODE_BOOL)
 170     code2 = TYPE_CODE_INT;
 171
 172   scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
 173             || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
 174
 175   if (   code1 == TYPE_CODE_STRUCT
 176       && code2 == TYPE_CODE_STRUCT
 177       && TYPE_NAME (type) != 0)
 178     {
 179       /* Look in the type of the source to see if it contains the
 180          type of the target as a superclass.  If so, we'll need to
 181          offset the object in addition to changing its type.  */
 182       value_ptr v = search_struct_field (type_name_no_tag (type),
 183                                          arg2, 0, VALUE_TYPE (arg2), 1);
 184       if (v)
 185         {
 186           VALUE_TYPE (v) = type;
 187           return v;
 188         }
 189     }
 190   if (code1 == TYPE_CODE_FLT && scalar)
 191     return value_from_double (type, value_as_double (arg2));
 192   else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
 193             || code1 == TYPE_CODE_RANGE)
 194            && (scalar || code2 == TYPE_CODE_PTR))
 195     return value_from_longest (type, value_as_long (arg2));
 196   else if (TYPE_LENGTH (type) == TYPE_LENGTH (VALUE_TYPE (arg2)))
 197     {
 198       if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
 199         {
 200           /* Look in the type of the source to see if it contains the
 201              type of the target as a superclass.  If so, we'll need to
 202              offset the pointer rather than just change its type.  */
 203           struct type *t1 = TYPE_TARGET_TYPE (type);
 204           struct type *t2 = TYPE_TARGET_TYPE (VALUE_TYPE (arg2));
 205           if (   TYPE_CODE (t1) == TYPE_CODE_STRUCT
 206               && TYPE_CODE (t2) == TYPE_CODE_STRUCT
 207               && TYPE_NAME (t1) != 0) /* if name unknown, can't have supercl */
 208             {
 209               value_ptr v = search_struct_field (type_name_no_tag (t1),
 210                                                  value_ind (arg2), 0, t2, 1);
 211               if (v)
 212                 {
 213                   v = value_addr (v);
 214                   VALUE_TYPE (v) = type;
 215                   return v;
 216                 }
 217             }
 218           /* No superclass found, just fall through to change ptr type.  */
 219         }
 220       VALUE_TYPE (arg2) = type;
 221       return arg2;
 222     }
 223   else if (chill_varying_type (type))
 224     {
 225       struct type *range1, *range2, *eltype1, *eltype2;
 226       value_ptr val;
 227       int count1, count2;
 228       char *valaddr, *valaddr_data;
 229       if (code2 == TYPE_CODE_BITSTRING)
 230         error ("not implemented: converting bitstring to varying type");
 231       if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING)
 232           || (eltype1 = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1)),
 233               eltype2 = TYPE_TARGET_TYPE (VALUE_TYPE (arg2)),
 234               (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
 235                /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
 236         error ("Invalid conversion to varying type");
 237       range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0);
 238       range2 = TYPE_FIELD_TYPE (VALUE_TYPE (arg2), 0);
 239       count1 = TYPE_HIGH_BOUND (range1) - TYPE_LOW_BOUND (range1) + 1;
 240       count2 = TYPE_HIGH_BOUND (range2) - TYPE_LOW_BOUND (range2) + 1;
 241       if (count2 > count1)
 242         error ("target varying type is too small");
 243       val = allocate_value (type);
 244       valaddr = VALUE_CONTENTS_RAW (val);
 245       valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
 246       /* Set val's __var_length field to count2. */
 247       store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)),
 248                             count2);
 249       /* Set the __var_data field to count2 elements copied from arg2. */
 250       memcpy (valaddr_data, VALUE_CONTENTS (arg2),
 251               count2 * TYPE_LENGTH (eltype2));
 252       /* Zero the rest of the __var_data field of val. */
 253       memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0',
 254               (count1 - count2) * TYPE_LENGTH (eltype2));
 255       return val;
 256     }
 257   else if (VALUE_LVAL (arg2) == lval_memory)
 258     {
 259       return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2));
 260     }
 261   else if (code1 == TYPE_CODE_VOID)
 262     {
 263       return value_zero (builtin_type_void, not_lval);
 264     }
 265   else
 266     {
 267       error ("Invalid cast.");
 268       return 0;
 269     }
 270 }
 271
 272 /* Create a value of type TYPE that is zero, and return it.  */
 273
 274 value_ptr
 275 value_zero (type, lv)
 276      struct type *type;
 277      enum lval_type lv;
 278 {
 279   register value_ptr val = allocate_value (type);
 280
 281   memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (type));
 282   VALUE_LVAL (val) = lv;
 283
 284   return val;
 285 }
 286
 287 /* Return a value with type TYPE located at ADDR.
 288
 289    Call value_at only if the data needs to be fetched immediately;
 290    if we can be 'lazy' and defer the fetch, perhaps indefinately, call
 291    value_at_lazy instead.  value_at_lazy simply records the address of
 292    the data and sets the lazy-evaluation-required flag.  The lazy flag
 293    is tested in the VALUE_CONTENTS macro, which is used if and when
 294    the contents are actually required.  */
 295
 296 value_ptr
 297 value_at (type, addr)
 298      struct type *type;
 299      CORE_ADDR addr;
 300 {
 301   register value_ptr val;
 302
 303   if (TYPE_CODE (type) == TYPE_CODE_VOID)
 304     error ("Attempt to dereference a generic pointer.");
 305
 306   val = allocate_value (type);
 307
 308   read_memory (addr, VALUE_CONTENTS_RAW (val), TYPE_LENGTH (type));
 309
 310   VALUE_LVAL (val) = lval_memory;
 311   VALUE_ADDRESS (val) = addr;
 312
 313   return val;
 314 }
 315
 316 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
 317
 318 value_ptr
 319 value_at_lazy (type, addr)
 320      struct type *type;
 321      CORE_ADDR addr;
 322 {
 323   register value_ptr val;
 324
 325   if (TYPE_CODE (type) == TYPE_CODE_VOID)
 326     error ("Attempt to dereference a generic pointer.");
 327
 328   val = allocate_value (type);
 329
 330   VALUE_LVAL (val) = lval_memory;
 331   VALUE_ADDRESS (val) = addr;
 332   VALUE_LAZY (val) = 1;
 333
 334   return val;
 335 }
 336
 337 /* Called only from the VALUE_CONTENTS macro, if the current data for
 338    a variable needs to be loaded into VALUE_CONTENTS(VAL).  Fetches the
 339    data from the user's process, and clears the lazy flag to indicate
 340    that the data in the buffer is valid.
 341
 342    If the value is zero-length, we avoid calling read_memory, which would
 343    abort.  We mark the value as fetched anyway -- all 0 bytes of it.
 344
 345    This function returns a value because it is used in the VALUE_CONTENTS
 346    macro as part of an expression, where a void would not work.  The
 347    value is ignored.  */
 348
 349 int
 350 value_fetch_lazy (val)
 351      register value_ptr val;
 352 {
 353   CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
 354
 355   if (TYPE_LENGTH (VALUE_TYPE (val)))
 356     read_memory (addr, VALUE_CONTENTS_RAW (val),
 357                  TYPE_LENGTH (VALUE_TYPE (val)));
 358   VALUE_LAZY (val) = 0;
 359   return 0;
 360 }
 361
 362
 363 /* Store the contents of FROMVAL into the location of TOVAL.
 364    Return a new value with the location of TOVAL and contents of FROMVAL.  */
 365
 366 value_ptr
 367 value_assign (toval, fromval)
 368      register value_ptr toval, fromval;
 369 {
 370   register struct type *type;
 371   register value_ptr val;
 372   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 373   int use_buffer = 0;
 374
 375   if (!toval->modifiable)
 376     error ("Left operand of assignment is not a modifiable lvalue.");
 377
 378   COERCE_ARRAY (fromval);
 379   COERCE_REF (toval);
 380
 381   type = VALUE_TYPE (toval);
 382   if (VALUE_LVAL (toval) != lval_internalvar)
 383     fromval = value_cast (type, fromval);
 384
 385   /* If TOVAL is a special machine register requiring conversion
 386      of program values to a special raw format,
 387      convert FROMVAL's contents now, with result in `raw_buffer',
 388      and set USE_BUFFER to the number of bytes to write.  */
 389
 390 #ifdef REGISTER_CONVERTIBLE
 391   if (VALUE_REGNO (toval) >= 0
 392       && REGISTER_CONVERTIBLE (VALUE_REGNO (toval)))
 393     {
 394       int regno = VALUE_REGNO (toval);
 395       if (REGISTER_CONVERTIBLE (regno))
 396         {
 397           REGISTER_CONVERT_TO_RAW (VALUE_TYPE (fromval), regno,
 398                                    VALUE_CONTENTS (fromval), raw_buffer);
 399           use_buffer = REGISTER_RAW_SIZE (regno);
 400         }
 401     }
 402 #endif
 403
 404   switch (VALUE_LVAL (toval))
 405     {
 406     case lval_internalvar:
 407       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
 408       break;
 409
 410     case lval_internalvar_component:
 411       set_internalvar_component (VALUE_INTERNALVAR (toval),
 412                                  VALUE_OFFSET (toval),
 413                                  VALUE_BITPOS (toval),
 414                                  VALUE_BITSIZE (toval),
 415                                  fromval);
 416       break;
 417
 418     case lval_memory:
 419       if (VALUE_BITSIZE (toval))
 420         {
 421           char buffer[sizeof (LONGEST)];
 422           /* We assume that the argument to read_memory is in units of
 423              host chars.  FIXME:  Is that correct?  */
 424           int len = (VALUE_BITPOS (toval)
 425                      + VALUE_BITSIZE (toval)
 426                      + HOST_CHAR_BIT - 1)
 427                     / HOST_CHAR_BIT;
 428
 429           if (len > sizeof (LONGEST))
 430             error ("Can't handle bitfields which don't fit in a %d bit word.",
 431                    sizeof (LONGEST) * HOST_CHAR_BIT);
 432
 433           read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 434                        buffer, len);
 435           modify_field (buffer, value_as_long (fromval),
 436                         VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 437           write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 438                         buffer, len);
 439         }
 440       else if (use_buffer)
 441         write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 442                       raw_buffer, use_buffer);
 443       else
 444         write_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 445                       VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
 446       break;
 447
 448     case lval_register:
 449       if (VALUE_BITSIZE (toval))
 450         {
 451           char buffer[sizeof (LONGEST)];
 452           int len = REGISTER_RAW_SIZE (VALUE_REGNO (toval));
 453
 454           if (len > sizeof (LONGEST))
 455             error ("Can't handle bitfields in registers larger than %d bits.",
 456                    sizeof (LONGEST) * HOST_CHAR_BIT);
 457
 458           if (VALUE_BITPOS (toval) + VALUE_BITSIZE (toval)
 459               > len * HOST_CHAR_BIT)
 460             /* Getting this right would involve being very careful about
 461                byte order.  */
 462             error ("\
 463 Can't handle bitfield which doesn't fit in a single register.");
 464
 465           read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 466                                buffer, len);
 467           modify_field (buffer, value_as_long (fromval),
 468                         VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 469           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 470                                 buffer, len);
 471         }
 472       else if (use_buffer)
 473         write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 474                               raw_buffer, use_buffer);
 475       else
 476         {
 477           /* Do any conversion necessary when storing this type to more
 478              than one register.  */
 479 #ifdef REGISTER_CONVERT_FROM_TYPE
 480           memcpy (raw_buffer, VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
 481           REGISTER_CONVERT_FROM_TYPE(VALUE_REGNO (toval), type, raw_buffer);
 482           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 483                                 raw_buffer, TYPE_LENGTH (type));
 484 #else
 485           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 486                                 VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
 487 #endif
 488         }
 489       /* Assigning to the stack pointer, frame pointer, and other
 490          (architecture and calling convention specific) registers may
 491          cause the frame cache to be out of date.  We just do this
 492          on all assignments to registers for simplicity; I doubt the slowdown
 493          matters.  */
 494       reinit_frame_cache ();
 495       break;
 496
 497     case lval_reg_frame_relative:
 498       {
 499         /* value is stored in a series of registers in the frame
 500            specified by the structure.  Copy that value out, modify
 501            it, and copy it back in.  */
 502         int amount_to_copy = (VALUE_BITSIZE (toval) ? 1 : TYPE_LENGTH (type));
 503         int reg_size = REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval));
 504         int byte_offset = VALUE_OFFSET (toval) % reg_size;
 505         int reg_offset = VALUE_OFFSET (toval) / reg_size;
 506         int amount_copied;
 507
 508         /* Make the buffer large enough in all cases.  */
 509         char *buffer = (char *) alloca (amount_to_copy
 510                                         + sizeof (LONGEST)
 511                                         + MAX_REGISTER_RAW_SIZE);
 512
 513         int regno;
 514         struct frame_info *frame;
 515
 516         /* Figure out which frame this is in currently.  */
 517         for (frame = get_current_frame ();
 518              frame && FRAME_FP (frame) != VALUE_FRAME (toval);
 519              frame = get_prev_frame (frame))
 520           ;
 521
 522         if (!frame)
 523           error ("Value being assigned to is no longer active.");
 524
 525         amount_to_copy += (reg_size - amount_to_copy % reg_size);
 526
 527         /* Copy it out.  */
 528         for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
 529               amount_copied = 0);
 530              amount_copied < amount_to_copy;
 531              amount_copied += reg_size, regno++)
 532           {
 533             get_saved_register (buffer + amount_copied,
 534                                 (int *)NULL, (CORE_ADDR *)NULL,
 535                                 frame, regno, (enum lval_type *)NULL);
 536           }
 537
 538         /* Modify what needs to be modified.  */
 539         if (VALUE_BITSIZE (toval))
 540           modify_field (buffer + byte_offset,
 541                         value_as_long (fromval),
 542                         VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 543         else if (use_buffer)
 544           memcpy (buffer + byte_offset, raw_buffer, use_buffer);
 545         else
 546           memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
 547                   TYPE_LENGTH (type));
 548
 549         /* Copy it back.  */
 550         for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
 551               amount_copied = 0);
 552              amount_copied < amount_to_copy;
 553              amount_copied += reg_size, regno++)
 554           {
 555             enum lval_type lval;
 556             CORE_ADDR addr;
 557             int optim;
 558
 559             /* Just find out where to put it.  */
 560             get_saved_register ((char *)NULL,
 561                                 &optim, &addr, frame, regno, &lval);
 562
 563             if (optim)
 564               error ("Attempt to assign to a value that was optimized out.");
 565             if (lval == lval_memory)
 566               write_memory (addr, buffer + amount_copied, reg_size);
 567             else if (lval == lval_register)
 568               write_register_bytes (addr, buffer + amount_copied, reg_size);
 569             else
 570               error ("Attempt to assign to an unmodifiable value.");
 571           }
 572       }
 573       break;
 574
 575
 576     default:
 577       error ("Left operand of assignment is not an lvalue.");
 578     }
 579
 580   /* If the field does not entirely fill a LONGEST, then zero the sign bits.
 581      If the field is signed, and is negative, then sign extend. */
 582   if ((VALUE_BITSIZE (toval) > 0)
 583       && (VALUE_BITSIZE (toval) < 8 * sizeof (LONGEST)))
 584     {
 585       LONGEST fieldval = value_as_long (fromval);
 586       LONGEST valmask = (((unsigned LONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
 587
 588       fieldval &= valmask;
 589       if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
 590         fieldval |= ~valmask;
 591
 592       fromval = value_from_longest (type, fieldval);
 593     }
 594
 595   /* Return a value just like TOVAL except with the contents of FROMVAL
 596      (except in the case of the type if TOVAL is an internalvar).  */
 597
 598   if (VALUE_LVAL (toval) == lval_internalvar
 599       || VALUE_LVAL (toval) == lval_internalvar_component)
 600     {
 601       type = VALUE_TYPE (fromval);
 602     }
 603
 604   val = value_copy (toval);
 605   memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
 606           TYPE_LENGTH (type));
 607   VALUE_TYPE (val) = type;
 608
 609   return val;
 610 }
 611
 612 /* Extend a value VAL to COUNT repetitions of its type.  */
 613
 614 value_ptr
 615 value_repeat (arg1, count)
 616      value_ptr arg1;
 617      int count;
 618 {
 619   register value_ptr val;
 620
 621   if (VALUE_LVAL (arg1) != lval_memory)
 622     error ("Only values in memory can be extended with '@'.");
 623   if (count < 1)
 624     error ("Invalid number %d of repetitions.", count);
 625   if (VALUE_REPEATED (arg1))
 626     error ("Cannot create artificial arrays of artificial arrays.");
 627
 628   val = allocate_repeat_value (VALUE_TYPE (arg1), count);
 629
 630   read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
 631                VALUE_CONTENTS_RAW (val),
 632                TYPE_LENGTH (VALUE_TYPE (val)) * count);
 633   VALUE_LVAL (val) = lval_memory;
 634   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
 635
 636   return val;
 637 }
 638
 639 value_ptr
 640 value_of_variable (var, b)
 641      struct symbol *var;
 642      struct block *b;
 643 {
 644   value_ptr val;
 645   struct frame_info *frame;
 646
 647   if (b == NULL)
 648     /* Use selected frame.  */
 649     frame = NULL;
 650   else
 651     {
 652       frame = block_innermost_frame (b);
 653       if (frame == NULL && symbol_read_needs_frame (var))
 654         {
 655           if (BLOCK_FUNCTION (b) != NULL
 656               && SYMBOL_NAME (BLOCK_FUNCTION (b)) != NULL)
 657             error ("No frame is currently executing in block %s.",
 658                    SYMBOL_NAME (BLOCK_FUNCTION (b)));
 659           else
 660             error ("No frame is currently executing in specified block");
 661         }
 662     }
 663   val = read_var_value (var, frame);
 664   if (val == 0)
 665     error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 666   return val;
 667 }
 668
 669 /* Given a value which is an array, return a value which is a pointer to its
 670    first element, regardless of whether or not the array has a nonzero lower
 671    bound.
 672
 673    FIXME:  A previous comment here indicated that this routine should be
 674    substracting the array's lower bound.  It's not clear to me that this
 675    is correct.  Given an array subscripting operation, it would certainly
 676    work to do the adjustment here, essentially computing:
 677
 678    (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
 679
 680    However I believe a more appropriate and logical place to account for
 681    the lower bound is to do so in value_subscript, essentially computing:
 682
 683    (&array[0] + ((index - lowerbound) * sizeof array[0]))
 684
 685    As further evidence consider what would happen with operations other
 686    than array subscripting, where the caller would get back a value that
 687    had an address somewhere before the actual first element of the array,
 688    and the information about the lower bound would be lost because of
 689    the coercion to pointer type.
 690    */
 691
 692 value_ptr
 693 value_coerce_array (arg1)
 694      value_ptr arg1;
 695 {
 696   register struct type *type;
 697
 698   if (VALUE_LVAL (arg1) != lval_memory)
 699     error ("Attempt to take address of value not located in memory.");
 700
 701   /* Get type of elements.  */
 702   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY
 703       || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRING)
 704     type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
 705   else
 706     /* A phony array made by value_repeat.
 707        Its type is the type of the elements, not an array type.  */
 708     type = VALUE_TYPE (arg1);
 709
 710   return value_from_longest (lookup_pointer_type (type),
 711                        (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 712 }
 713
 714 /* Given a value which is a function, return a value which is a pointer
 715    to it.  */
 716
 717 value_ptr
 718 value_coerce_function (arg1)
 719      value_ptr arg1;
 720 {
 721
 722   if (VALUE_LVAL (arg1) != lval_memory)
 723     error ("Attempt to take address of value not located in memory.");
 724
 725   return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
 726                 (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 727 }
 728
 729 /* Return a pointer value for the object for which ARG1 is the contents.  */
 730
 731 value_ptr
 732 value_addr (arg1)
 733      value_ptr arg1;
 734 {
 735   struct type *type = VALUE_TYPE (arg1);
 736   if (TYPE_CODE (type) == TYPE_CODE_REF)
 737     {
 738       /* Copy the value, but change the type from (T&) to (T*).
 739          We keep the same location information, which is efficient,
 740          and allows &(&X) to get the location containing the reference. */
 741       value_ptr arg2 = value_copy (arg1);
 742       VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
 743       return arg2;
 744     }
 745   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
 746     return value_coerce_function (arg1);
 747
 748   if (VALUE_LVAL (arg1) != lval_memory)
 749     error ("Attempt to take address of value not located in memory.");
 750
 751   return value_from_longest (lookup_pointer_type (type),
 752                 (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 753 }
 754
 755 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 756
 757 value_ptr
 758 value_ind (arg1)
 759      value_ptr arg1;
 760 {
 761   COERCE_ARRAY (arg1);
 762
 763   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_MEMBER)
 764     error ("not implemented: member types in value_ind");
 765
 766   /* Allow * on an integer so we can cast it to whatever we want.
 767      This returns an int, which seems like the most C-like thing
 768      to do.  "long long" variables are rare enough that
 769      BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
 770   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
 771     return value_at (builtin_type_int,
 772                      (CORE_ADDR) value_as_long (arg1));
 773   else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
 774     return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
 775                           value_as_pointer (arg1));
 776   error ("Attempt to take contents of a non-pointer value.");
 777   return 0;  /* For lint -- never reached */
 778 }
 779 \f
 780 /* Pushing small parts of stack frames.  */
 781
 782 /* Push one word (the size of object that a register holds).  */
 783
 784 CORE_ADDR
 785 push_word (sp, word)
 786      CORE_ADDR sp;
 787      unsigned LONGEST word;
 788 {
 789   register int len = REGISTER_SIZE;
 790   char buffer[MAX_REGISTER_RAW_SIZE];
 791
 792   store_unsigned_integer (buffer, len, word);
 793 #if 1 INNER_THAN 2
 794   sp -= len;
 795   write_memory (sp, buffer, len);
 796 #else /* stack grows upward */
 797   write_memory (sp, buffer, len);
 798   sp += len;
 799 #endif /* stack grows upward */
 800
 801   return sp;
 802 }
 803
 804 /* Push LEN bytes with data at BUFFER.  */
 805
 806 CORE_ADDR
 807 push_bytes (sp, buffer, len)
 808      CORE_ADDR sp;
 809      char *buffer;
 810      int len;
 811 {
 812 #if 1 INNER_THAN 2
 813   sp -= len;
 814   write_memory (sp, buffer, len);
 815 #else /* stack grows upward */
 816   write_memory (sp, buffer, len);
 817   sp += len;
 818 #endif /* stack grows upward */
 819
 820   return sp;
 821 }
 822
 823 /* Push onto the stack the specified value VALUE.  */
 824
 825 static CORE_ADDR
 826 value_push (sp, arg)
 827      register CORE_ADDR sp;
 828      value_ptr arg;
 829 {
 830   register int len = TYPE_LENGTH (VALUE_TYPE (arg));
 831
 832 #if 1 INNER_THAN 2
 833   sp -= len;
 834   write_memory (sp, VALUE_CONTENTS (arg), len);
 835 #else /* stack grows upward */
 836   write_memory (sp, VALUE_CONTENTS (arg), len);
 837   sp += len;
 838 #endif /* stack grows upward */
 839
 840   return sp;
 841 }
 842
 843 /* Perform the standard coercions that are specified
 844    for arguments to be passed to C functions.
 845
 846    If PARAM_TYPE is non-NULL, it is the expected parameter type. */
 847
 848 static value_ptr
 849 value_arg_coerce (arg, param_type)
 850      value_ptr arg;
 851      struct type *param_type;
 852 {
 853   register struct type *type;
 854
 855 #if 1   /* FIXME:  This is only a temporary patch.  -fnf */
 856   if (current_language->c_style_arrays
 857       && (VALUE_REPEATED (arg)
 858           || TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ARRAY))
 859     arg = value_coerce_array (arg);
 860 #endif
 861
 862   type = param_type ? param_type : VALUE_TYPE (arg);
 863
 864   switch (TYPE_CODE (type))
 865     {
 866     case TYPE_CODE_REF:
 867       if (TYPE_CODE (VALUE_TYPE (arg)) != TYPE_CODE_REF)
 868         {
 869           arg = value_addr (arg);
 870           VALUE_TYPE (arg) = param_type;
 871           return arg;
 872         }
 873       break;
 874     case TYPE_CODE_INT:
 875     case TYPE_CODE_CHAR:
 876     case TYPE_CODE_BOOL:
 877     case TYPE_CODE_ENUM:
 878       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
 879         type = builtin_type_int;
 880       break;
 881     case TYPE_CODE_FLT:
 882       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
 883         type = builtin_type_double;
 884       break;
 885     case TYPE_CODE_FUNC:
 886       type = lookup_pointer_type (type);
 887       break;
 888     case TYPE_CODE_UNDEF:
 889     case TYPE_CODE_PTR:
 890     case TYPE_CODE_ARRAY:
 891     case TYPE_CODE_STRUCT:
 892     case TYPE_CODE_UNION:
 893     case TYPE_CODE_VOID:
 894     case TYPE_CODE_SET:
 895     case TYPE_CODE_RANGE:
 896     case TYPE_CODE_STRING:
 897     case TYPE_CODE_BITSTRING:
 898     case TYPE_CODE_ERROR:
 899     case TYPE_CODE_MEMBER:
 900     case TYPE_CODE_METHOD:
 901     case TYPE_CODE_COMPLEX:
 902     default:
 903       break;
 904     }
 905
 906   return value_cast (type, arg);
 907 }
 908
 909 /* Determine a function's address and its return type from its value.
 910    Calls error() if the function is not valid for calling.  */
 911
 912 static CORE_ADDR
 913 find_function_addr (function, retval_type)
 914      value_ptr function;
 915      struct type **retval_type;
 916 {
 917   register struct type *ftype = VALUE_TYPE (function);
 918   register enum type_code code = TYPE_CODE (ftype);
 919   struct type *value_type;
 920   CORE_ADDR funaddr;
 921
 922   /* If it's a member function, just look at the function
 923      part of it.  */
 924
 925   /* Determine address to call.  */
 926   if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
 927     {
 928       funaddr = VALUE_ADDRESS (function);
 929       value_type = TYPE_TARGET_TYPE (ftype);
 930     }
 931   else if (code == TYPE_CODE_PTR)
 932     {
 933       funaddr = value_as_pointer (function);
 934       if (TYPE_CODE (TYPE_TARGET_TYPE (ftype)) == TYPE_CODE_FUNC
 935           || TYPE_CODE (TYPE_TARGET_TYPE (ftype)) == TYPE_CODE_METHOD)
 936         {
 937 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
 938           /* FIXME: This is a workaround for the unusual function
 939              pointer representation on the RS/6000, see comment
 940              in config/rs6000/tm-rs6000.h  */
 941           funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
 942 #endif
 943           value_type = TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype));
 944         }
 945       else
 946         value_type = builtin_type_int;
 947     }
 948   else if (code == TYPE_CODE_INT)
 949     {
 950       /* Handle the case of functions lacking debugging info.
 951          Their values are characters since their addresses are char */
 952       if (TYPE_LENGTH (ftype) == 1)
 953         funaddr = value_as_pointer (value_addr (function));
 954       else
 955         /* Handle integer used as address of a function.  */
 956         funaddr = (CORE_ADDR) value_as_long (function);
 957
 958       value_type = builtin_type_int;
 959     }
 960   else
 961     error ("Invalid data type for function to be called.");
 962
 963   *retval_type = value_type;
 964   return funaddr;
 965 }
 966
 967 #if defined (CALL_DUMMY)
 968 /* All this stuff with a dummy frame may seem unnecessarily complicated
 969    (why not just save registers in GDB?).  The purpose of pushing a dummy
 970    frame which looks just like a real frame is so that if you call a
 971    function and then hit a breakpoint (get a signal, etc), "backtrace"
 972    will look right.  Whether the backtrace needs to actually show the
 973    stack at the time the inferior function was called is debatable, but
 974    it certainly needs to not display garbage.  So if you are contemplating
 975    making dummy frames be different from normal frames, consider that.  */
 976
 977 /* Perform a function call in the inferior.
 978    ARGS is a vector of values of arguments (NARGS of them).
 979    FUNCTION is a value, the function to be called.
 980    Returns a value representing what the function returned.
 981    May fail to return, if a breakpoint or signal is hit
 982    during the execution of the function.
 983
 984    ARGS is modified to contain coerced values. */
 985
 986 value_ptr
 987 call_function_by_hand (function, nargs, args)
 988      value_ptr function;
 989      int nargs;
 990      value_ptr *args;
 991 {
 992   register CORE_ADDR sp;
 993   register int i;
 994   CORE_ADDR start_sp;
 995   /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
 996      is in host byte order.  Before calling FIX_CALL_DUMMY, we byteswap it
 997      and remove any extra bytes which might exist because unsigned LONGEST is
 998      bigger than REGISTER_SIZE.  */
 999   static unsigned LONGEST dummy[] = CALL_DUMMY;
1000   char dummy1[REGISTER_SIZE * sizeof dummy / sizeof (unsigned LONGEST)];
1001   CORE_ADDR old_sp;
1002   struct type *value_type;
1003   unsigned char struct_return;
1004   CORE_ADDR struct_addr;
1005   struct inferior_status inf_status;
1006   struct cleanup *old_chain;
1007   CORE_ADDR funaddr;
1008   int using_gcc;
1009   CORE_ADDR real_pc;
1010   struct type *ftype = SYMBOL_TYPE (function);
1011
1012   if (!target_has_execution)
1013     noprocess();
1014
1015   save_inferior_status (&inf_status, 1);
1016   old_chain = make_cleanup (restore_inferior_status, &inf_status);
1017
1018   /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1019      (and POP_FRAME for restoring them).  (At least on most machines)
1020      they are saved on the stack in the inferior.  */
1021   PUSH_DUMMY_FRAME;
1022
1023   old_sp = sp = read_sp ();
1024
1025 #if 1 INNER_THAN 2              /* Stack grows down */
1026   sp -= sizeof dummy1;
1027   start_sp = sp;
1028 #else                           /* Stack grows up */
1029   start_sp = sp;
1030   sp += sizeof dummy1;
1031 #endif
1032
1033   funaddr = find_function_addr (function, &value_type);
1034
1035   {
1036     struct block *b = block_for_pc (funaddr);
1037     /* If compiled without -g, assume GCC.  */
1038     using_gcc = b == NULL ? 0 : BLOCK_GCC_COMPILED (b);
1039   }
1040
1041   /* Are we returning a value using a structure return or a normal
1042      value return? */
1043
1044   struct_return = using_struct_return (function, funaddr, value_type,
1045                                        using_gcc);
1046
1047   /* Create a call sequence customized for this function
1048      and the number of arguments for it.  */
1049   for (i = 0; i < sizeof dummy / sizeof (dummy[0]); i++)
1050     store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
1051                             REGISTER_SIZE,
1052                             (unsigned LONGEST)dummy[i]);
1053
1054 #ifdef GDB_TARGET_IS_HPPA
1055   real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1056                             value_type, using_gcc);
1057 #else
1058   FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1059                   value_type, using_gcc);
1060   real_pc = start_sp;
1061 #endif
1062
1063 #if CALL_DUMMY_LOCATION == ON_STACK
1064   write_memory (start_sp, (char *)dummy1, sizeof dummy1);
1065 #endif /* On stack.  */
1066
1067 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1068   /* Convex Unix prohibits executing in the stack segment. */
1069   /* Hope there is empty room at the top of the text segment. */
1070   {
1071     extern CORE_ADDR text_end;
1072     static checked = 0;
1073     if (!checked)
1074       for (start_sp = text_end - sizeof dummy1; start_sp < text_end; ++start_sp)
1075         if (read_memory_integer (start_sp, 1) != 0)
1076           error ("text segment full -- no place to put call");
1077     checked = 1;
1078     sp = old_sp;
1079     real_pc = text_end - sizeof dummy1;
1080     write_memory (real_pc, (char *)dummy1, sizeof dummy1);
1081   }
1082 #endif /* Before text_end.  */
1083
1084 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1085   {
1086     extern CORE_ADDR text_end;
1087     int errcode;
1088     sp = old_sp;
1089     real_pc = text_end;
1090     errcode = target_write_memory (real_pc, (char *)dummy1, sizeof dummy1);
1091     if (errcode != 0)
1092       error ("Cannot write text segment -- call_function failed");
1093   }
1094 #endif /* After text_end.  */
1095
1096 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1097   real_pc = funaddr;
1098 #endif /* At entry point.  */
1099
1100 #ifdef lint
1101   sp = old_sp;          /* It really is used, for some ifdef's... */
1102 #endif
1103
1104   if (nargs < TYPE_NFIELDS (ftype))
1105     error ("too few arguments in function call");
1106
1107   for (i = nargs - 1; i >= 0; i--)
1108     {
1109       struct type *param_type;
1110       if (TYPE_NFIELDS (ftype) > i)
1111         param_type = TYPE_FIELD_TYPE (ftype, i);
1112       else
1113         param_type = 0;
1114       args[i] = value_arg_coerce (args[i], param_type);
1115     }
1116
1117 #if defined (REG_STRUCT_HAS_ADDR)
1118   {
1119     /* This is a machine like the sparc, where we may need to pass a pointer
1120        to the structure, not the structure itself.  */
1121     for (i = nargs - 1; i >= 0; i--)
1122       if ((TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_STRUCT
1123            || TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_UNION
1124            || TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_ARRAY
1125            || TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_STRING)
1126           && REG_STRUCT_HAS_ADDR (using_gcc, VALUE_TYPE (args[i])))
1127         {
1128           CORE_ADDR addr;
1129           int len = TYPE_LENGTH (VALUE_TYPE (args[i]));
1130 #ifdef STACK_ALIGN
1131           int aligned_len = STACK_ALIGN (len);
1132 #else
1133           int aligned_len = len;
1134 #endif
1135 #if !(1 INNER_THAN 2)
1136           /* The stack grows up, so the address of the thing we push
1137              is the stack pointer before we push it.  */
1138           addr = sp;
1139 #else
1140           sp -= aligned_len;
1141 #endif
1142           /* Push the structure.  */
1143           write_memory (sp, VALUE_CONTENTS (args[i]), len);
1144 #if 1 INNER_THAN 2
1145           /* The stack grows down, so the address of the thing we push
1146              is the stack pointer after we push it.  */
1147           addr = sp;
1148 #else
1149           sp += aligned_len;
1150 #endif
1151           /* The value we're going to pass is the address of the thing
1152              we just pushed.  */
1153           args[i] = value_from_longest (lookup_pointer_type (value_type),
1154                                         (LONGEST) addr);
1155         }
1156   }
1157 #endif /* REG_STRUCT_HAS_ADDR.  */
1158
1159   /* Reserve space for the return structure to be written on the
1160      stack, if necessary */
1161
1162   if (struct_return)
1163     {
1164       int len = TYPE_LENGTH (value_type);
1165 #ifdef STACK_ALIGN
1166       len = STACK_ALIGN (len);
1167 #endif
1168 #if 1 INNER_THAN 2
1169       sp -= len;
1170       struct_addr = sp;
1171 #else
1172       struct_addr = sp;
1173       sp += len;
1174 #endif
1175     }
1176
1177 #ifdef STACK_ALIGN
1178   /* If stack grows down, we must leave a hole at the top. */
1179   {
1180     int len = 0;
1181
1182     for (i = nargs - 1; i >= 0; i--)
1183       len += TYPE_LENGTH (VALUE_TYPE (args[i]));
1184 #ifdef CALL_DUMMY_STACK_ADJUST
1185     len += CALL_DUMMY_STACK_ADJUST;
1186 #endif
1187 #if 1 INNER_THAN 2
1188     sp -= STACK_ALIGN (len) - len;
1189 #else
1190     sp += STACK_ALIGN (len) - len;
1191 #endif
1192   }
1193 #endif /* STACK_ALIGN */
1194
1195 #ifdef PUSH_ARGUMENTS
1196   PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr);
1197 #else /* !PUSH_ARGUMENTS */
1198   for (i = nargs - 1; i >= 0; i--)
1199     sp = value_push (sp, args[i]);
1200 #endif /* !PUSH_ARGUMENTS */
1201
1202 #ifdef CALL_DUMMY_STACK_ADJUST
1203 #if 1 INNER_THAN 2
1204   sp -= CALL_DUMMY_STACK_ADJUST;
1205 #else
1206   sp += CALL_DUMMY_STACK_ADJUST;
1207 #endif
1208 #endif /* CALL_DUMMY_STACK_ADJUST */
1209
1210   /* Store the address at which the structure is supposed to be
1211      written.  Note that this (and the code which reserved the space
1212      above) assumes that gcc was used to compile this function.  Since
1213      it doesn't cost us anything but space and if the function is pcc
1214      it will ignore this value, we will make that assumption.
1215
1216      Also note that on some machines (like the sparc) pcc uses a
1217      convention like gcc's.  */
1218
1219   if (struct_return)
1220     STORE_STRUCT_RETURN (struct_addr, sp);
1221
1222   /* Write the stack pointer.  This is here because the statements above
1223      might fool with it.  On SPARC, this write also stores the register
1224      window into the right place in the new stack frame, which otherwise
1225      wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
1226   write_sp (sp);
1227
1228   {
1229     char retbuf[REGISTER_BYTES];
1230     char *name;
1231     struct symbol *symbol;
1232
1233     name = NULL;
1234     symbol = find_pc_function (funaddr);
1235     if (symbol)
1236       {
1237         name = SYMBOL_SOURCE_NAME (symbol);
1238       }
1239     else
1240       {
1241         /* Try the minimal symbols.  */
1242         struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
1243
1244         if (msymbol)
1245           {
1246             name = SYMBOL_SOURCE_NAME (msymbol);
1247           }
1248       }
1249     if (name == NULL)
1250       {
1251         char format[80];
1252         sprintf (format, "at %s", local_hex_format ());
1253         name = alloca (80);
1254         /* FIXME-32x64: assumes funaddr fits in a long.  */
1255         sprintf (name, format, (unsigned long) funaddr);
1256       }
1257
1258     /* Execute the stack dummy routine, calling FUNCTION.
1259        When it is done, discard the empty frame
1260        after storing the contents of all regs into retbuf.  */
1261     if (run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf))
1262       {
1263         /* We stopped somewhere besides the call dummy.  */
1264
1265         /* If we did the cleanups, we would print a spurious error message
1266            (Unable to restore previously selected frame), would write the
1267            registers from the inf_status (which is wrong), and would do other
1268            wrong things (like set stop_bpstat to the wrong thing).  */
1269         discard_cleanups (old_chain);
1270         /* Prevent memory leak.  */
1271         bpstat_clear (&inf_status.stop_bpstat);
1272
1273         /* The following error message used to say "The expression
1274            which contained the function call has been discarded."  It
1275            is a hard concept to explain in a few words.  Ideally, GDB
1276            would be able to resume evaluation of the expression when
1277            the function finally is done executing.  Perhaps someday
1278            this will be implemented (it would not be easy).  */
1279
1280         /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1281            a C++ name with arguments and stuff.  */
1282         error ("\
1283 The program being debugged stopped while in a function called from GDB.\n\
1284 When the function (%s) is done executing, GDB will silently\n\
1285 stop (instead of continuing to evaluate the expression containing\n\
1286 the function call).", name);
1287       }
1288
1289     do_cleanups (old_chain);
1290
1291     /* Figure out the value returned by the function.  */
1292     return value_being_returned (value_type, retbuf, struct_return);
1293   }
1294 }
1295 #else /* no CALL_DUMMY.  */
1296 value_ptr
1297 call_function_by_hand (function, nargs, args)
1298      value_ptr function;
1299      int nargs;
1300      value_ptr *args;
1301 {
1302   error ("Cannot invoke functions on this machine.");
1303 }
1304 #endif /* no CALL_DUMMY.  */
1305
1306 \f
1307 /* Create a value for an array by allocating space in the inferior, copying
1308    the data into that space, and then setting up an array value.
1309
1310    The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1311    populated from the values passed in ELEMVEC.
1312
1313    The element type of the array is inherited from the type of the
1314    first element, and all elements must have the same size (though we
1315    don't currently enforce any restriction on their types). */
1316
1317 value_ptr
1318 value_array (lowbound, highbound, elemvec)
1319      int lowbound;
1320      int highbound;
1321      value_ptr *elemvec;
1322 {
1323   int nelem;
1324   int idx;
1325   int typelength;
1326   value_ptr val;
1327   struct type *rangetype;
1328   struct type *arraytype;
1329   CORE_ADDR addr;
1330
1331   /* Validate that the bounds are reasonable and that each of the elements
1332      have the same size. */
1333
1334   nelem = highbound - lowbound + 1;
1335   if (nelem <= 0)
1336     {
1337       error ("bad array bounds (%d, %d)", lowbound, highbound);
1338     }
1339   typelength = TYPE_LENGTH (VALUE_TYPE (elemvec[0]));
1340   for (idx = 0; idx < nelem; idx++)
1341     {
1342       if (TYPE_LENGTH (VALUE_TYPE (elemvec[idx])) != typelength)
1343         {
1344           error ("array elements must all be the same size");
1345         }
1346     }
1347
1348   /* Allocate space to store the array in the inferior, and then initialize
1349      it by copying in each element.  FIXME:  Is it worth it to create a
1350      local buffer in which to collect each value and then write all the
1351      bytes in one operation? */
1352
1353   addr = allocate_space_in_inferior (nelem * typelength);
1354   for (idx = 0; idx < nelem; idx++)
1355     {
1356       write_memory (addr + (idx * typelength), VALUE_CONTENTS (elemvec[idx]),
1357                     typelength);
1358     }
1359
1360   /* Create the array type and set up an array value to be evaluated lazily. */
1361
1362   rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1363                                  lowbound, highbound);
1364   arraytype = create_array_type ((struct type *) NULL,
1365                                  VALUE_TYPE (elemvec[0]), rangetype);
1366   val = value_at_lazy (arraytype, addr);
1367   return (val);
1368 }
1369
1370 /* Create a value for a string constant by allocating space in the inferior,
1371    copying the data into that space, and returning the address with type
1372    TYPE_CODE_STRING.  PTR points to the string constant data; LEN is number
1373    of characters.
1374    Note that string types are like array of char types with a lower bound of
1375    zero and an upper bound of LEN - 1.  Also note that the string may contain
1376    embedded null bytes. */
1377
1378 value_ptr
1379 value_string (ptr, len)
1380      char *ptr;
1381      int len;
1382 {
1383   value_ptr val;
1384   int lowbound = current_language->string_lower_bound;
1385   struct type *rangetype = create_range_type ((struct type *) NULL,
1386                                               builtin_type_int,
1387                                               lowbound, len + lowbound - 1);
1388   struct type *stringtype
1389     = create_string_type ((struct type *) NULL, rangetype);
1390   CORE_ADDR addr;
1391
1392   if (current_language->c_style_arrays == 0)
1393     {
1394       val = allocate_value (stringtype);
1395       memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1396       return val;
1397     }
1398
1399
1400   /* Allocate space to store the string in the inferior, and then
1401      copy LEN bytes from PTR in gdb to that address in the inferior. */
1402
1403   addr = allocate_space_in_inferior (len);
1404   write_memory (addr, ptr, len);
1405
1406   val = value_at_lazy (stringtype, addr);
1407   return (val);
1408 }
1409
1410 value_ptr
1411 value_bitstring (ptr, len)
1412      char *ptr;
1413      int len;
1414 {
1415   value_ptr val;
1416   struct type *domain_type = create_range_type (NULL, builtin_type_int,
1417                                                 0, len - 1);
1418   struct type *type = create_set_type ((struct type*) NULL, domain_type);
1419   TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1420   val = allocate_value (type);
1421   memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
1422   return val;
1423 }
1424 \f
1425 /* See if we can pass arguments in T2 to a function which takes arguments
1426    of types T1.  Both t1 and t2 are NULL-terminated vectors.  If some
1427    arguments need coercion of some sort, then the coerced values are written
1428    into T2.  Return value is 0 if the arguments could be matched, or the
1429    position at which they differ if not.
1430
1431    STATICP is nonzero if the T1 argument list came from a
1432    static member function.
1433
1434    For non-static member functions, we ignore the first argument,
1435    which is the type of the instance variable.  This is because we want
1436    to handle calls with objects from derived classes.  This is not
1437    entirely correct: we should actually check to make sure that a
1438    requested operation is type secure, shouldn't we?  FIXME.  */
1439
1440 static int
1441 typecmp (staticp, t1, t2)
1442      int staticp;
1443      struct type *t1[];
1444      value_ptr t2[];
1445 {
1446   int i;
1447
1448   if (t2 == 0)
1449     return 1;
1450   if (staticp && t1 == 0)
1451     return t2[1] != 0;
1452   if (t1 == 0)
1453     return 1;
1454   if (TYPE_CODE (t1[0]) == TYPE_CODE_VOID) return 0;
1455   if (t1[!staticp] == 0) return 0;
1456   for (i = !staticp; t1[i] && TYPE_CODE (t1[i]) != TYPE_CODE_VOID; i++)
1457     {
1458     struct type *tt1, *tt2;
1459       if (! t2[i])
1460         return i+1;
1461       tt1 = t1[i];
1462       tt2 = VALUE_TYPE(t2[i]);
1463       if (TYPE_CODE (tt1) == TYPE_CODE_REF
1464           /* We should be doing hairy argument matching, as below.  */
1465           && (TYPE_CODE (TYPE_TARGET_TYPE (tt1)) == TYPE_CODE (tt2)))
1466         {
1467           if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY || VALUE_REPEATED (t2[i]))
1468             t2[i] = value_coerce_array (t2[i]);
1469           else
1470             t2[i] = value_addr (t2[i]);
1471           continue;
1472         }
1473
1474       while (TYPE_CODE (tt1) == TYPE_CODE_PTR
1475           && (TYPE_CODE(tt2)==TYPE_CODE_ARRAY || TYPE_CODE(tt2)==TYPE_CODE_PTR))
1476         {
1477            tt1 = TYPE_TARGET_TYPE(tt1);
1478            tt2 = TYPE_TARGET_TYPE(tt2);
1479         }
1480       if (TYPE_CODE(tt1) == TYPE_CODE(tt2)) continue;
1481       /* Array to pointer is a `trivial conversion' according to the ARM.  */
1482
1483       /* We should be doing much hairier argument matching (see section 13.2
1484          of the ARM), but as a quick kludge, just check for the same type
1485          code.  */
1486       if (TYPE_CODE (t1[i]) != TYPE_CODE (VALUE_TYPE (t2[i])))
1487         return i+1;
1488     }
1489   if (!t1[i]) return 0;
1490   return t2[i] ? i+1 : 0;
1491 }
1492
1493 /* Helper function used by value_struct_elt to recurse through baseclasses.
1494    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1495    and search in it assuming it has (class) type TYPE.
1496    If found, return value, else return NULL.
1497
1498    If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1499    look for a baseclass named NAME.  */
1500
1501 static value_ptr
1502 search_struct_field (name, arg1, offset, type, looking_for_baseclass)
1503      char *name;
1504      register value_ptr arg1;
1505      int offset;
1506      register struct type *type;
1507      int looking_for_baseclass;
1508 {
1509   int i;
1510
1511   check_stub_type (type);
1512
1513   if (! looking_for_baseclass)
1514     for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1515       {
1516         char *t_field_name = TYPE_FIELD_NAME (type, i);
1517
1518         if (t_field_name && STREQ (t_field_name, name))
1519           {
1520             value_ptr v;
1521             if (TYPE_FIELD_STATIC (type, i))
1522               {
1523                 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, i);
1524                 struct symbol *sym =
1525                     lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
1526                 if (sym == NULL)
1527                     error ("Internal error: could not find physical static variable named %s",
1528                            phys_name);
1529                 v = value_at (TYPE_FIELD_TYPE (type, i),
1530                               (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
1531               }
1532             else
1533               v = value_primitive_field (arg1, offset, i, type);
1534             if (v == 0)
1535               error("there is no field named %s", name);
1536             return v;
1537           }
1538         if (t_field_name && t_field_name[0] == '\0'
1539             && TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION)
1540           {
1541             /* Look for a match through the fields of an anonymous union.  */
1542             value_ptr v;
1543             v = search_struct_field (name, arg1, offset,
1544                                      TYPE_FIELD_TYPE (type, i),
1545                                      looking_for_baseclass);
1546             if (v)
1547               return v;
1548           }
1549       }
1550
1551   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1552     {
1553       value_ptr v;
1554       /* If we are looking for baseclasses, this is what we get when we
1555          hit them.  But it could happen that the base part's member name
1556          is not yet filled in.  */
1557       int found_baseclass = (looking_for_baseclass
1558                              && TYPE_BASECLASS_NAME (type, i) != NULL
1559                              && STREQ (name, TYPE_BASECLASS_NAME (type, i)));
1560
1561       if (BASETYPE_VIA_VIRTUAL (type, i))
1562         {
1563           value_ptr v2;
1564           /* Fix to use baseclass_offset instead. FIXME */
1565           baseclass_addr (type, i, VALUE_CONTENTS (arg1) + offset,
1566                           &v2, (int *)NULL);
1567           if (v2 == 0)
1568             error ("virtual baseclass botch");
1569           if (found_baseclass)
1570             return v2;
1571           v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
1572                                    looking_for_baseclass);
1573         }
1574       else if (found_baseclass)
1575         v = value_primitive_field (arg1, offset, i, type);
1576       else
1577         v = search_struct_field (name, arg1,
1578                                  offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
1579                                  TYPE_BASECLASS (type, i),
1580                                  looking_for_baseclass);
1581       if (v) return v;
1582     }
1583   return NULL;
1584 }
1585
1586 /* Helper function used by value_struct_elt to recurse through baseclasses.
1587    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1588    and search in it assuming it has (class) type TYPE.
1589    If found, return value, else if name matched and args not return (value)-1,
1590    else return NULL. */
1591
1592 static value_ptr
1593 search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
1594      char *name;
1595      register value_ptr *arg1p, *args;
1596      int offset, *static_memfuncp;
1597      register struct type *type;
1598 {
1599   int i;
1600   value_ptr v;
1601   int name_matched = 0;
1602   char dem_opname[64];
1603
1604   check_stub_type (type);
1605   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1606     {
1607       char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1608       if (strncmp(t_field_name, "__", 2)==0 ||
1609         strncmp(t_field_name, "op", 2)==0 ||
1610         strncmp(t_field_name, "type", 4)==0 )
1611         {
1612           if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
1613             t_field_name = dem_opname;
1614           else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
1615             t_field_name = dem_opname;
1616         }
1617       if (t_field_name && STREQ (t_field_name, name))
1618         {
1619           int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
1620           struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1621           name_matched = 1;
1622
1623           if (j > 0 && args == 0)
1624             error ("cannot resolve overloaded method `%s'", name);
1625           while (j >= 0)
1626             {
1627               if (TYPE_FN_FIELD_STUB (f, j))
1628                 check_stub_method (type, i, j);
1629               if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
1630                             TYPE_FN_FIELD_ARGS (f, j), args))
1631                 {
1632                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1633                     return value_virtual_fn_field (arg1p, f, j, type, offset);
1634                   if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
1635                     *static_memfuncp = 1;
1636                   v = value_fn_field (arg1p, f, j, type, offset);
1637                   if (v != NULL) return v;
1638                 }
1639               j--;
1640             }
1641         }
1642     }
1643
1644   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1645     {
1646       int base_offset;
1647
1648       if (BASETYPE_VIA_VIRTUAL (type, i))
1649         {
1650           base_offset = baseclass_offset (type, i, *arg1p, offset);
1651           if (base_offset == -1)
1652             error ("virtual baseclass botch");
1653         }
1654       else
1655         {
1656           base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1657         }
1658       v = search_struct_method (name, arg1p, args, base_offset + offset,
1659                                 static_memfuncp, TYPE_BASECLASS (type, i));
1660       if (v == (value_ptr) -1)
1661         {
1662           name_matched = 1;
1663         }
1664       else if (v)
1665         {
1666 /* FIXME-bothner:  Why is this commented out?  Why is it here?  */
1667 /*        *arg1p = arg1_tmp;*/
1668           return v;
1669         }
1670     }
1671   if (name_matched) return (value_ptr) -1;
1672   else return NULL;
1673 }
1674
1675 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1676    extract the component named NAME from the ultimate target structure/union
1677    and return it as a value with its appropriate type.
1678    ERR is used in the error message if *ARGP's type is wrong.
1679
1680    C++: ARGS is a list of argument types to aid in the selection of
1681    an appropriate method. Also, handle derived types.
1682
1683    STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1684    where the truthvalue of whether the function that was resolved was
1685    a static member function or not is stored.
1686
1687    ERR is an error message to be printed in case the field is not found.  */
1688
1689 value_ptr
1690 value_struct_elt (argp, args, name, static_memfuncp, err)
1691      register value_ptr *argp, *args;
1692      char *name;
1693      int *static_memfuncp;
1694      char *err;
1695 {
1696   register struct type *t;
1697   value_ptr v;
1698
1699   COERCE_ARRAY (*argp);
1700
1701   t = VALUE_TYPE (*argp);
1702
1703   /* Follow pointers until we get to a non-pointer.  */
1704
1705   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1706     {
1707       *argp = value_ind (*argp);
1708       /* Don't coerce fn pointer to fn and then back again!  */
1709       if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
1710         COERCE_ARRAY (*argp);
1711       t = VALUE_TYPE (*argp);
1712     }
1713
1714   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
1715     error ("not implemented: member type in value_struct_elt");
1716
1717   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
1718       && TYPE_CODE (t) != TYPE_CODE_UNION)
1719     error ("Attempt to extract a component of a value that is not a %s.", err);
1720
1721   /* Assume it's not, unless we see that it is.  */
1722   if (static_memfuncp)
1723     *static_memfuncp =0;
1724
1725   if (!args)
1726     {
1727       /* if there are no arguments ...do this...  */
1728
1729       /* Try as a field first, because if we succeed, there
1730          is less work to be done.  */
1731       v = search_struct_field (name, *argp, 0, t, 0);
1732       if (v)
1733         return v;
1734
1735       /* C++: If it was not found as a data field, then try to
1736          return it as a pointer to a method.  */
1737
1738       if (destructor_name_p (name, t))
1739         error ("Cannot get value of destructor");
1740
1741       v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
1742
1743       if (v == (value_ptr) -1)
1744         error ("Cannot take address of a method");
1745       else if (v == 0)
1746         {
1747           if (TYPE_NFN_FIELDS (t))
1748             error ("There is no member or method named %s.", name);
1749           else
1750             error ("There is no member named %s.", name);
1751         }
1752       return v;
1753     }
1754
1755   if (destructor_name_p (name, t))
1756     {
1757       if (!args[1])
1758         {
1759           /* destructors are a special case.  */
1760           v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, 0),
1761                               TYPE_FN_FIELDLIST_LENGTH (t, 0), 0, 0);
1762           if (!v) error("could not find destructor function named %s.", name);
1763           else return v;
1764         }
1765       else
1766         {
1767           error ("destructor should not have any argument");
1768         }
1769     }
1770   else
1771     v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
1772
1773   if (v == (value_ptr) -1)
1774     {
1775         error("Argument list of %s mismatch with component in the structure.", name);
1776     }
1777   else if (v == 0)
1778     {
1779       /* See if user tried to invoke data as function.  If so,
1780          hand it back.  If it's not callable (i.e., a pointer to function),
1781          gdb should give an error.  */
1782       v = search_struct_field (name, *argp, 0, t, 0);
1783     }
1784
1785   if (!v)
1786     error ("Structure has no component named %s.", name);
1787   return v;
1788 }
1789
1790 /* C++: return 1 is NAME is a legitimate name for the destructor
1791    of type TYPE.  If TYPE does not have a destructor, or
1792    if NAME is inappropriate for TYPE, an error is signaled.  */
1793 int
1794 destructor_name_p (name, type)
1795      const char *name;
1796      const struct type *type;
1797 {
1798   /* destructors are a special case.  */
1799
1800   if (name[0] == '~')
1801     {
1802       char *dname = type_name_no_tag (type);
1803       char *cp = strchr (dname, '<');
1804       int len;
1805
1806       /* Do not compare the template part for template classes.  */
1807       if (cp == NULL)
1808         len = strlen (dname);
1809       else
1810         len = cp - dname;
1811       if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
1812         error ("name of destructor must equal name of class");
1813       else
1814         return 1;
1815     }
1816   return 0;
1817 }
1818
1819 /* Helper function for check_field: Given TYPE, a structure/union,
1820    return 1 if the component named NAME from the ultimate
1821    target structure/union is defined, otherwise, return 0. */
1822
1823 static int
1824 check_field_in (type, name)
1825      register struct type *type;
1826      const char *name;
1827 {
1828   register int i;
1829
1830   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1831     {
1832       char *t_field_name = TYPE_FIELD_NAME (type, i);
1833       if (t_field_name && STREQ (t_field_name, name))
1834         return 1;
1835     }
1836
1837   /* C++: If it was not found as a data field, then try to
1838      return it as a pointer to a method.  */
1839
1840   /* Destructors are a special case.  */
1841   if (destructor_name_p (name, type))
1842     return 1;
1843
1844   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1845     {
1846       if (STREQ (TYPE_FN_FIELDLIST_NAME (type, i), name))
1847         return 1;
1848     }
1849
1850   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1851     if (check_field_in (TYPE_BASECLASS (type, i), name))
1852       return 1;
1853
1854   return 0;
1855 }
1856
1857
1858 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1859    return 1 if the component named NAME from the ultimate
1860    target structure/union is defined, otherwise, return 0.  */
1861
1862 int
1863 check_field (arg1, name)
1864      register value_ptr arg1;
1865      const char *name;
1866 {
1867   register struct type *t;
1868
1869   COERCE_ARRAY (arg1);
1870
1871   t = VALUE_TYPE (arg1);
1872
1873   /* Follow pointers until we get to a non-pointer.  */
1874
1875   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1876     t = TYPE_TARGET_TYPE (t);
1877
1878   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
1879     error ("not implemented: member type in check_field");
1880
1881   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
1882       && TYPE_CODE (t) != TYPE_CODE_UNION)
1883     error ("Internal error: `this' is not an aggregate");
1884
1885   return check_field_in (t, name);
1886 }
1887
1888 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1889    return the address of this member as a "pointer to member"
1890    type.  If INTYPE is non-null, then it will be the type
1891    of the member we are looking for.  This will help us resolve
1892    "pointers to member functions".  This function is used
1893    to resolve user expressions of the form "DOMAIN::NAME".  */
1894
1895 value_ptr
1896 value_struct_elt_for_reference (domain, offset, curtype, name, intype)
1897      struct type *domain, *curtype, *intype;
1898      int offset;
1899      char *name;
1900 {
1901   register struct type *t = curtype;
1902   register int i;
1903   value_ptr v;
1904
1905   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
1906       && TYPE_CODE (t) != TYPE_CODE_UNION)
1907     error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1908
1909   for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
1910     {
1911       char *t_field_name = TYPE_FIELD_NAME (t, i);
1912
1913       if (t_field_name && STREQ (t_field_name, name))
1914         {
1915           if (TYPE_FIELD_STATIC (t, i))
1916             {
1917               char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (t, i);
1918               struct symbol *sym =
1919                 lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
1920               if (sym == NULL)
1921                 error ("Internal error: could not find physical static variable named %s",
1922                        phys_name);
1923               return value_at (SYMBOL_TYPE (sym),
1924                                (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
1925             }
1926           if (TYPE_FIELD_PACKED (t, i))
1927             error ("pointers to bitfield members not allowed");
1928
1929           return value_from_longest
1930             (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
1931                                                         domain)),
1932              offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
1933         }
1934     }
1935
1936   /* C++: If it was not found as a data field, then try to
1937      return it as a pointer to a method.  */
1938
1939   /* Destructors are a special case.  */
1940   if (destructor_name_p (name, t))
1941     {
1942       error ("member pointers to destructors not implemented yet");
1943     }
1944
1945   /* Perform all necessary dereferencing.  */
1946   while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
1947     intype = TYPE_TARGET_TYPE (intype);
1948
1949   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
1950     {
1951       char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
1952       char dem_opname[64];
1953
1954       if (strncmp(t_field_name, "__", 2)==0 ||
1955         strncmp(t_field_name, "op", 2)==0 ||
1956         strncmp(t_field_name, "type", 4)==0 )
1957         {
1958           if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
1959             t_field_name = dem_opname;
1960           else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
1961             t_field_name = dem_opname;
1962         }
1963       if (t_field_name && STREQ (t_field_name, name))
1964         {
1965           int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
1966           struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
1967
1968           if (intype == 0 && j > 1)
1969             error ("non-unique member `%s' requires type instantiation", name);
1970           if (intype)
1971             {
1972               while (j--)
1973                 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
1974                   break;
1975               if (j < 0)
1976                 error ("no member function matches that type instantiation");
1977             }
1978           else
1979             j = 0;
1980
1981           if (TYPE_FN_FIELD_STUB (f, j))
1982             check_stub_method (t, i, j);
1983           if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1984             {
1985               return value_from_longest
1986                 (lookup_reference_type
1987                  (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
1988                                       domain)),
1989                  (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
1990             }
1991           else
1992             {
1993               struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
1994                                                 0, VAR_NAMESPACE, 0, NULL);
1995               if (s == NULL)
1996                 {
1997                   v = 0;
1998                 }
1999               else
2000                 {
2001                   v = read_var_value (s, 0);
2002 #if 0
2003                   VALUE_TYPE (v) = lookup_reference_type
2004                     (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
2005                                          domain));
2006 #endif
2007                 }
2008               return v;
2009             }
2010         }
2011     }
2012   for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
2013     {
2014       value_ptr v;
2015       int base_offset;
2016
2017       if (BASETYPE_VIA_VIRTUAL (t, i))
2018         base_offset = 0;
2019       else
2020         base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
2021       v = value_struct_elt_for_reference (domain,
2022                                           offset + base_offset,
2023                                           TYPE_BASECLASS (t, i),
2024                                           name,
2025                                           intype);
2026       if (v)
2027         return v;
2028     }
2029   return 0;
2030 }
2031
2032 /* C++: return the value of the class instance variable, if one exists.
2033    Flag COMPLAIN signals an error if the request is made in an
2034    inappropriate context.  */
2035
2036 value_ptr
2037 value_of_this (complain)
2038      int complain;
2039 {
2040   struct symbol *func, *sym;
2041   struct block *b;
2042   int i;
2043   static const char funny_this[] = "this";
2044   value_ptr this;
2045
2046   if (selected_frame == 0)
2047     if (complain)
2048       error ("no frame selected");
2049     else return 0;
2050
2051   func = get_frame_function (selected_frame);
2052   if (!func)
2053     {
2054       if (complain)
2055         error ("no `this' in nameless context");
2056       else return 0;
2057     }
2058
2059   b = SYMBOL_BLOCK_VALUE (func);
2060   i = BLOCK_NSYMS (b);
2061   if (i <= 0)
2062     if (complain)
2063       error ("no args, no `this'");
2064     else return 0;
2065
2066   /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2067      symbol instead of the LOC_ARG one (if both exist).  */
2068   sym = lookup_block_symbol (b, funny_this, VAR_NAMESPACE);
2069   if (sym == NULL)
2070     {
2071       if (complain)
2072         error ("current stack frame not in method");
2073       else
2074         return NULL;
2075     }
2076
2077   this = read_var_value (sym, selected_frame);
2078   if (this == 0 && complain)
2079     error ("`this' argument at unknown address");
2080   return this;
2081 }
2082
2083 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2084    long, starting at LOWBOUND.  The result has the same lower bound as
2085    the original ARRAY.  */
2086
2087 value_ptr
2088 value_slice (array, lowbound, length)
2089      value_ptr array;
2090      int lowbound, length;
2091 {
2092   COERCE_VARYING_ARRAY (array);
2093   if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_BITSTRING)
2094     error ("not implemented - bitstring slice");
2095   if (TYPE_CODE (VALUE_TYPE (array)) != TYPE_CODE_ARRAY
2096       && TYPE_CODE (VALUE_TYPE (array)) != TYPE_CODE_STRING)
2097     error ("cannot take slice of non-array");
2098   else
2099     {
2100       struct type *slice_range_type, *slice_type;
2101       value_ptr slice;
2102       struct type *range_type = TYPE_FIELD_TYPE (VALUE_TYPE (array), 0);
2103       struct type *element_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
2104       int lowerbound = TYPE_LOW_BOUND (range_type);
2105       int upperbound = TYPE_HIGH_BOUND (range_type);
2106       int offset = (lowbound - lowerbound) * TYPE_LENGTH (element_type);
2107       if (lowbound < lowerbound || length < 0
2108           || lowbound + length - 1 > upperbound)
2109         error ("slice out of range");
2110       /* FIXME-type-allocation: need a way to free this type when we are
2111          done with it.  */
2112       slice_range_type = create_range_type ((struct type*) NULL,
2113                                             TYPE_TARGET_TYPE (range_type),
2114                                             lowerbound,
2115                                             lowerbound + length - 1);
2116       slice_type = create_array_type ((struct type*) NULL, element_type,
2117                                       slice_range_type);
2118       TYPE_CODE (slice_type) = TYPE_CODE (VALUE_TYPE (array));
2119       slice = allocate_value (slice_type);
2120       if (VALUE_LAZY (array))
2121         VALUE_LAZY (slice) = 1;
2122       else
2123         memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
2124                 TYPE_LENGTH (slice_type));
2125       if (VALUE_LVAL (array) == lval_internalvar)
2126         VALUE_LVAL (slice) = lval_internalvar_component;
2127       else
2128         VALUE_LVAL (slice) = VALUE_LVAL (array);
2129       VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
2130       VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
2131       return slice;
2132     }
2133 }
2134
2135 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
2136    value as a fixed-length array. */
2137
2138 value_ptr
2139 varying_to_slice (varray)
2140      value_ptr varray;
2141 {
2142   struct type *vtype = VALUE_TYPE (varray);
2143   LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
2144                                 VALUE_CONTENTS (varray)
2145                                 + TYPE_FIELD_BITPOS (vtype, 0) / 8);
2146   return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
2147 }
2148
2149 /* Create a value for a FORTRAN complex number.  Currently most of
2150    the time values are coerced to COMPLEX*16 (i.e. a complex number
2151    composed of 2 doubles.  This really should be a smarter routine
2152    that figures out precision inteligently as opposed to assuming
2153    doubles. FIXME: fmb */
2154
2155 value_ptr
2156 value_literal_complex (arg1, arg2, type)
2157      value_ptr arg1;
2158      value_ptr arg2;
2159      struct type *type;
2160 {
2161   register value_ptr val;
2162   struct type *real_type = TYPE_TARGET_TYPE (type);
2163
2164   val = allocate_value (type);
2165   arg1 = value_cast (real_type, arg1);
2166   arg2 = value_cast (real_type, arg2);
2167
2168   memcpy (VALUE_CONTENTS_RAW (val),
2169           VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
2170   memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
2171           VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
2172   return val;
2173 }
2174
2175 /* Cast a value into the appropriate complex data type. */
2176
2177 static value_ptr
2178 cast_into_complex (type, val)
2179      struct type *type;
2180      register value_ptr val;
2181 {
2182   struct type *real_type = TYPE_TARGET_TYPE (type);
2183   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
2184     {
2185       struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
2186       value_ptr re_val = allocate_value (val_real_type);
2187       value_ptr im_val = allocate_value (val_real_type);
2188
2189       memcpy (VALUE_CONTENTS_RAW (re_val),
2190               VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
2191       memcpy (VALUE_CONTENTS_RAW (im_val),
2192               VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
2193                TYPE_LENGTH (val_real_type));
2194
2195       return value_literal_complex (re_val, im_val, type);
2196     }
2197   else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
2198            || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
2199     return value_literal_complex (val, value_zero (real_type, not_lval), type);
2200   else
2201     error ("cannot cast non-number to complex");
2202 }