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., 675 Mass Ave, Cambridge, MA 02139, 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   /* Return a value just like TOVAL except with the contents of FROMVAL
 581      (except in the case of the type if TOVAL is an internalvar).  */
 582
 583   if (VALUE_LVAL (toval) == lval_internalvar
 584       || VALUE_LVAL (toval) == lval_internalvar_component)
 585     {
 586       type = VALUE_TYPE (fromval);
 587     }
 588
 589   val = allocate_value (type);
 590   memcpy (val, toval, VALUE_CONTENTS_RAW (val) - (char *) val);
 591   memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
 592           TYPE_LENGTH (type));
 593   VALUE_TYPE (val) = type;
 594
 595   return val;
 596 }
 597
 598 /* Extend a value VAL to COUNT repetitions of its type.  */
 599
 600 value_ptr
 601 value_repeat (arg1, count)
 602      value_ptr arg1;
 603      int count;
 604 {
 605   register value_ptr val;
 606
 607   if (VALUE_LVAL (arg1) != lval_memory)
 608     error ("Only values in memory can be extended with '@'.");
 609   if (count < 1)
 610     error ("Invalid number %d of repetitions.", count);
 611   if (VALUE_REPEATED (arg1))
 612     error ("Cannot create artificial arrays of artificial arrays.");
 613
 614   val = allocate_repeat_value (VALUE_TYPE (arg1), count);
 615
 616   read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
 617                VALUE_CONTENTS_RAW (val),
 618                TYPE_LENGTH (VALUE_TYPE (val)) * count);
 619   VALUE_LVAL (val) = lval_memory;
 620   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
 621
 622   return val;
 623 }
 624
 625 value_ptr
 626 value_of_variable (var, b)
 627      struct symbol *var;
 628      struct block *b;
 629 {
 630   value_ptr val;
 631   struct frame_info *frame;
 632
 633   if (b == NULL)
 634     /* Use selected frame.  */
 635     frame = NULL;
 636   else
 637     {
 638       frame = block_innermost_frame (b);
 639       if (frame == NULL && symbol_read_needs_frame (var))
 640         {
 641           if (BLOCK_FUNCTION (b) != NULL
 642               && SYMBOL_NAME (BLOCK_FUNCTION (b)) != NULL)
 643             error ("No frame is currently executing in block %s.",
 644                    SYMBOL_NAME (BLOCK_FUNCTION (b)));
 645           else
 646             error ("No frame is currently executing in specified block");
 647         }
 648     }
 649   val = read_var_value (var, frame);
 650   if (val == 0)
 651     error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 652   return val;
 653 }
 654
 655 /* Given a value which is an array, return a value which is a pointer to its
 656    first element, regardless of whether or not the array has a nonzero lower
 657    bound.
 658
 659    FIXME:  A previous comment here indicated that this routine should be
 660    substracting the array's lower bound.  It's not clear to me that this
 661    is correct.  Given an array subscripting operation, it would certainly
 662    work to do the adjustment here, essentially computing:
 663
 664    (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
 665
 666    However I believe a more appropriate and logical place to account for
 667    the lower bound is to do so in value_subscript, essentially computing:
 668
 669    (&array[0] + ((index - lowerbound) * sizeof array[0]))
 670
 671    As further evidence consider what would happen with operations other
 672    than array subscripting, where the caller would get back a value that
 673    had an address somewhere before the actual first element of the array,
 674    and the information about the lower bound would be lost because of
 675    the coercion to pointer type.
 676    */
 677
 678 value_ptr
 679 value_coerce_array (arg1)
 680      value_ptr arg1;
 681 {
 682   register struct type *type;
 683
 684   if (VALUE_LVAL (arg1) != lval_memory)
 685     error ("Attempt to take address of value not located in memory.");
 686
 687   /* Get type of elements.  */
 688   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY
 689       || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRING)
 690     type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
 691   else
 692     /* A phony array made by value_repeat.
 693        Its type is the type of the elements, not an array type.  */
 694     type = VALUE_TYPE (arg1);
 695
 696   return value_from_longest (lookup_pointer_type (type),
 697                        (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 698 }
 699
 700 /* Given a value which is a function, return a value which is a pointer
 701    to it.  */
 702
 703 value_ptr
 704 value_coerce_function (arg1)
 705      value_ptr arg1;
 706 {
 707
 708   if (VALUE_LVAL (arg1) != lval_memory)
 709     error ("Attempt to take address of value not located in memory.");
 710
 711   return value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
 712                 (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 713 }
 714
 715 /* Return a pointer value for the object for which ARG1 is the contents.  */
 716
 717 value_ptr
 718 value_addr (arg1)
 719      value_ptr arg1;
 720 {
 721   struct type *type = VALUE_TYPE (arg1);
 722   if (TYPE_CODE (type) == TYPE_CODE_REF)
 723     {
 724       /* Copy the value, but change the type from (T&) to (T*).
 725          We keep the same location information, which is efficient,
 726          and allows &(&X) to get the location containing the reference. */
 727       value_ptr arg2 = value_copy (arg1);
 728       VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
 729       return arg2;
 730     }
 731   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
 732     return value_coerce_function (arg1);
 733
 734   if (VALUE_LVAL (arg1) != lval_memory)
 735     error ("Attempt to take address of value not located in memory.");
 736
 737   return value_from_longest (lookup_pointer_type (type),
 738                 (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 739 }
 740
 741 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 742
 743 value_ptr
 744 value_ind (arg1)
 745      value_ptr arg1;
 746 {
 747   COERCE_ARRAY (arg1);
 748
 749   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_MEMBER)
 750     error ("not implemented: member types in value_ind");
 751
 752   /* Allow * on an integer so we can cast it to whatever we want.
 753      This returns an int, which seems like the most C-like thing
 754      to do.  "long long" variables are rare enough that
 755      BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
 756   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
 757     return value_at (builtin_type_int,
 758                      (CORE_ADDR) value_as_long (arg1));
 759   else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
 760     return value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
 761                           value_as_pointer (arg1));
 762   error ("Attempt to take contents of a non-pointer value.");
 763   return 0;  /* For lint -- never reached */
 764 }
 765 \f
 766 /* Pushing small parts of stack frames.  */
 767
 768 /* Push one word (the size of object that a register holds).  */
 769
 770 CORE_ADDR
 771 push_word (sp, word)
 772      CORE_ADDR sp;
 773      unsigned LONGEST word;
 774 {
 775   register int len = REGISTER_SIZE;
 776   char buffer[MAX_REGISTER_RAW_SIZE];
 777
 778   store_unsigned_integer (buffer, len, word);
 779 #if 1 INNER_THAN 2
 780   sp -= len;
 781   write_memory (sp, buffer, len);
 782 #else /* stack grows upward */
 783   write_memory (sp, buffer, len);
 784   sp += len;
 785 #endif /* stack grows upward */
 786
 787   return sp;
 788 }
 789
 790 /* Push LEN bytes with data at BUFFER.  */
 791
 792 CORE_ADDR
 793 push_bytes (sp, buffer, len)
 794      CORE_ADDR sp;
 795      char *buffer;
 796      int len;
 797 {
 798 #if 1 INNER_THAN 2
 799   sp -= len;
 800   write_memory (sp, buffer, len);
 801 #else /* stack grows upward */
 802   write_memory (sp, buffer, len);
 803   sp += len;
 804 #endif /* stack grows upward */
 805
 806   return sp;
 807 }
 808
 809 /* Push onto the stack the specified value VALUE.  */
 810
 811 static CORE_ADDR
 812 value_push (sp, arg)
 813      register CORE_ADDR sp;
 814      value_ptr arg;
 815 {
 816   register int len = TYPE_LENGTH (VALUE_TYPE (arg));
 817
 818 #if 1 INNER_THAN 2
 819   sp -= len;
 820   write_memory (sp, VALUE_CONTENTS (arg), len);
 821 #else /* stack grows upward */
 822   write_memory (sp, VALUE_CONTENTS (arg), len);
 823   sp += len;
 824 #endif /* stack grows upward */
 825
 826   return sp;
 827 }
 828
 829 /* Perform the standard coercions that are specified
 830    for arguments to be passed to C functions.
 831
 832    If PARAM_TYPE is non-NULL, it is the expected parameter type. */
 833
 834 static value_ptr
 835 value_arg_coerce (arg, param_type)
 836      value_ptr arg;
 837      struct type *param_type;
 838 {
 839   register struct type *type;
 840
 841 #if 1   /* FIXME:  This is only a temporary patch.  -fnf */
 842   if (current_language->c_style_arrays
 843       && (VALUE_REPEATED (arg)
 844           || TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ARRAY))
 845     arg = value_coerce_array (arg);
 846 #endif
 847
 848   type = param_type ? param_type : VALUE_TYPE (arg);
 849
 850   switch (TYPE_CODE (type))
 851     {
 852     case TYPE_CODE_REF:
 853       if (TYPE_CODE (VALUE_TYPE (arg)) != TYPE_CODE_REF)
 854         {
 855           arg = value_addr (arg);
 856           VALUE_TYPE (arg) = param_type;
 857           return arg;
 858         }
 859       break;
 860     case TYPE_CODE_INT:
 861     case TYPE_CODE_CHAR:
 862     case TYPE_CODE_BOOL:
 863     case TYPE_CODE_ENUM:
 864       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
 865         type = builtin_type_int;
 866       break;
 867     case TYPE_CODE_FLT:
 868       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
 869         type = builtin_type_double;
 870       break;
 871     case TYPE_CODE_FUNC:
 872       type = lookup_pointer_type (type);
 873       break;
 874     case TYPE_CODE_UNDEF:
 875     case TYPE_CODE_PTR:
 876     case TYPE_CODE_ARRAY:
 877     case TYPE_CODE_STRUCT:
 878     case TYPE_CODE_UNION:
 879     case TYPE_CODE_VOID:
 880     case TYPE_CODE_SET:
 881     case TYPE_CODE_RANGE:
 882     case TYPE_CODE_STRING:
 883     case TYPE_CODE_BITSTRING:
 884     case TYPE_CODE_ERROR:
 885     case TYPE_CODE_MEMBER:
 886     case TYPE_CODE_METHOD:
 887     case TYPE_CODE_COMPLEX:
 888     default:
 889       break;
 890     }
 891
 892   return value_cast (type, arg);
 893 }
 894
 895 /* Determine a function's address and its return type from its value.
 896    Calls error() if the function is not valid for calling.  */
 897
 898 static CORE_ADDR
 899 find_function_addr (function, retval_type)
 900      value_ptr function;
 901      struct type **retval_type;
 902 {
 903   register struct type *ftype = VALUE_TYPE (function);
 904   register enum type_code code = TYPE_CODE (ftype);
 905   struct type *value_type;
 906   CORE_ADDR funaddr;
 907
 908   /* If it's a member function, just look at the function
 909      part of it.  */
 910
 911   /* Determine address to call.  */
 912   if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
 913     {
 914       funaddr = VALUE_ADDRESS (function);
 915       value_type = TYPE_TARGET_TYPE (ftype);
 916     }
 917   else if (code == TYPE_CODE_PTR)
 918     {
 919       funaddr = value_as_pointer (function);
 920       if (TYPE_CODE (TYPE_TARGET_TYPE (ftype)) == TYPE_CODE_FUNC
 921           || TYPE_CODE (TYPE_TARGET_TYPE (ftype)) == TYPE_CODE_METHOD)
 922         {
 923 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
 924           /* FIXME: This is a workaround for the unusual function
 925              pointer representation on the RS/6000, see comment
 926              in config/rs6000/tm-rs6000.h  */
 927           funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
 928 #endif
 929           value_type = TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype));
 930         }
 931       else
 932         value_type = builtin_type_int;
 933     }
 934   else if (code == TYPE_CODE_INT)
 935     {
 936       /* Handle the case of functions lacking debugging info.
 937          Their values are characters since their addresses are char */
 938       if (TYPE_LENGTH (ftype) == 1)
 939         funaddr = value_as_pointer (value_addr (function));
 940       else
 941         /* Handle integer used as address of a function.  */
 942         funaddr = (CORE_ADDR) value_as_long (function);
 943
 944       value_type = builtin_type_int;
 945     }
 946   else
 947     error ("Invalid data type for function to be called.");
 948
 949   *retval_type = value_type;
 950   return funaddr;
 951 }
 952
 953 #if defined (CALL_DUMMY)
 954 /* All this stuff with a dummy frame may seem unnecessarily complicated
 955    (why not just save registers in GDB?).  The purpose of pushing a dummy
 956    frame which looks just like a real frame is so that if you call a
 957    function and then hit a breakpoint (get a signal, etc), "backtrace"
 958    will look right.  Whether the backtrace needs to actually show the
 959    stack at the time the inferior function was called is debatable, but
 960    it certainly needs to not display garbage.  So if you are contemplating
 961    making dummy frames be different from normal frames, consider that.  */
 962
 963 /* Perform a function call in the inferior.
 964    ARGS is a vector of values of arguments (NARGS of them).
 965    FUNCTION is a value, the function to be called.
 966    Returns a value representing what the function returned.
 967    May fail to return, if a breakpoint or signal is hit
 968    during the execution of the function.
 969
 970    ARGS is modified to contain coerced values. */
 971
 972 value_ptr
 973 call_function_by_hand (function, nargs, args)
 974      value_ptr function;
 975      int nargs;
 976      value_ptr *args;
 977 {
 978   register CORE_ADDR sp;
 979   register int i;
 980   CORE_ADDR start_sp;
 981   /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
 982      is in host byte order.  Before calling FIX_CALL_DUMMY, we byteswap it
 983      and remove any extra bytes which might exist because unsigned LONGEST is
 984      bigger than REGISTER_SIZE.  */
 985   static unsigned LONGEST dummy[] = CALL_DUMMY;
 986   char dummy1[REGISTER_SIZE * sizeof dummy / sizeof (unsigned LONGEST)];
 987   CORE_ADDR old_sp;
 988   struct type *value_type;
 989   unsigned char struct_return;
 990   CORE_ADDR struct_addr;
 991   struct inferior_status inf_status;
 992   struct cleanup *old_chain;
 993   CORE_ADDR funaddr;
 994   int using_gcc;
 995   CORE_ADDR real_pc;
 996   struct type *ftype = SYMBOL_TYPE (function);
 997
 998   if (!target_has_execution)
 999     noprocess();
1000
1001   save_inferior_status (&inf_status, 1);
1002   old_chain = make_cleanup (restore_inferior_status, &inf_status);
1003
1004   /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1005      (and POP_FRAME for restoring them).  (At least on most machines)
1006      they are saved on the stack in the inferior.  */
1007   PUSH_DUMMY_FRAME;
1008
1009   old_sp = sp = read_sp ();
1010
1011 #if 1 INNER_THAN 2              /* Stack grows down */
1012   sp -= sizeof dummy1;
1013   start_sp = sp;
1014 #else                           /* Stack grows up */
1015   start_sp = sp;
1016   sp += sizeof dummy1;
1017 #endif
1018
1019   funaddr = find_function_addr (function, &value_type);
1020
1021   {
1022     struct block *b = block_for_pc (funaddr);
1023     /* If compiled without -g, assume GCC.  */
1024     using_gcc = b == NULL ? 0 : BLOCK_GCC_COMPILED (b);
1025   }
1026
1027   /* Are we returning a value using a structure return or a normal
1028      value return? */
1029
1030   struct_return = using_struct_return (function, funaddr, value_type,
1031                                        using_gcc);
1032
1033   /* Create a call sequence customized for this function
1034      and the number of arguments for it.  */
1035   for (i = 0; i < sizeof dummy / sizeof (dummy[0]); i++)
1036     store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
1037                             REGISTER_SIZE,
1038                             (unsigned LONGEST)dummy[i]);
1039
1040 #ifdef GDB_TARGET_IS_HPPA
1041   real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1042                             value_type, using_gcc);
1043 #else
1044   FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1045                   value_type, using_gcc);
1046   real_pc = start_sp;
1047 #endif
1048
1049 #if CALL_DUMMY_LOCATION == ON_STACK
1050   write_memory (start_sp, (char *)dummy1, sizeof dummy1);
1051 #endif /* On stack.  */
1052
1053 #if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
1054   /* Convex Unix prohibits executing in the stack segment. */
1055   /* Hope there is empty room at the top of the text segment. */
1056   {
1057     extern CORE_ADDR text_end;
1058     static checked = 0;
1059     if (!checked)
1060       for (start_sp = text_end - sizeof dummy1; start_sp < text_end; ++start_sp)
1061         if (read_memory_integer (start_sp, 1) != 0)
1062           error ("text segment full -- no place to put call");
1063     checked = 1;
1064     sp = old_sp;
1065     real_pc = text_end - sizeof dummy1;
1066     write_memory (real_pc, (char *)dummy1, sizeof dummy1);
1067   }
1068 #endif /* Before text_end.  */
1069
1070 #if CALL_DUMMY_LOCATION == AFTER_TEXT_END
1071   {
1072     extern CORE_ADDR text_end;
1073     int errcode;
1074     sp = old_sp;
1075     real_pc = text_end;
1076     errcode = target_write_memory (real_pc, (char *)dummy1, sizeof dummy1);
1077     if (errcode != 0)
1078       error ("Cannot write text segment -- call_function failed");
1079   }
1080 #endif /* After text_end.  */
1081
1082 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
1083   real_pc = funaddr;
1084 #endif /* At entry point.  */
1085
1086 #ifdef lint
1087   sp = old_sp;          /* It really is used, for some ifdef's... */
1088 #endif
1089
1090   if (nargs < TYPE_NFIELDS (ftype))
1091     error ("too few arguments in function call");
1092
1093   for (i = nargs - 1; i >= 0; i--)
1094     {
1095       struct type *param_type;
1096       if (TYPE_NFIELDS (ftype) > i)
1097         param_type = TYPE_FIELD_TYPE (ftype, i);
1098       else
1099         param_type = 0;
1100       args[i] = value_arg_coerce (args[i], param_type);
1101     }
1102
1103 #if defined (REG_STRUCT_HAS_ADDR)
1104   {
1105     /* This is a machine like the sparc, where we may need to pass a pointer
1106        to the structure, not the structure itself.  */
1107     for (i = nargs - 1; i >= 0; i--)
1108       if ((TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_STRUCT
1109            || TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_UNION
1110            || TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_ARRAY
1111            || TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_STRING)
1112           && REG_STRUCT_HAS_ADDR (using_gcc, VALUE_TYPE (args[i])))
1113         {
1114           CORE_ADDR addr;
1115           int len = TYPE_LENGTH (VALUE_TYPE (args[i]));
1116 #ifdef STACK_ALIGN
1117           int aligned_len = STACK_ALIGN (len);
1118 #else
1119           int aligned_len = len;
1120 #endif
1121 #if !(1 INNER_THAN 2)
1122           /* The stack grows up, so the address of the thing we push
1123              is the stack pointer before we push it.  */
1124           addr = sp;
1125 #else
1126           sp -= aligned_len;
1127 #endif
1128           /* Push the structure.  */
1129           write_memory (sp, VALUE_CONTENTS (args[i]), len);
1130 #if 1 INNER_THAN 2
1131           /* The stack grows down, so the address of the thing we push
1132              is the stack pointer after we push it.  */
1133           addr = sp;
1134 #else
1135           sp += aligned_len;
1136 #endif
1137           /* The value we're going to pass is the address of the thing
1138              we just pushed.  */
1139           args[i] = value_from_longest (lookup_pointer_type (value_type),
1140                                         (LONGEST) addr);
1141         }
1142   }
1143 #endif /* REG_STRUCT_HAS_ADDR.  */
1144
1145   /* Reserve space for the return structure to be written on the
1146      stack, if necessary */
1147
1148   if (struct_return)
1149     {
1150       int len = TYPE_LENGTH (value_type);
1151 #ifdef STACK_ALIGN
1152       len = STACK_ALIGN (len);
1153 #endif
1154 #if 1 INNER_THAN 2
1155       sp -= len;
1156       struct_addr = sp;
1157 #else
1158       struct_addr = sp;
1159       sp += len;
1160 #endif
1161     }
1162
1163 #ifdef STACK_ALIGN
1164   /* If stack grows down, we must leave a hole at the top. */
1165   {
1166     int len = 0;
1167
1168     for (i = nargs - 1; i >= 0; i--)
1169       len += TYPE_LENGTH (VALUE_TYPE (args[i]));
1170 #ifdef CALL_DUMMY_STACK_ADJUST
1171     len += CALL_DUMMY_STACK_ADJUST;
1172 #endif
1173 #if 1 INNER_THAN 2
1174     sp -= STACK_ALIGN (len) - len;
1175 #else
1176     sp += STACK_ALIGN (len) - len;
1177 #endif
1178   }
1179 #endif /* STACK_ALIGN */
1180
1181 #ifdef PUSH_ARGUMENTS
1182   PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr);
1183 #else /* !PUSH_ARGUMENTS */
1184   for (i = nargs - 1; i >= 0; i--)
1185     sp = value_push (sp, args[i]);
1186 #endif /* !PUSH_ARGUMENTS */
1187
1188 #ifdef CALL_DUMMY_STACK_ADJUST
1189 #if 1 INNER_THAN 2
1190   sp -= CALL_DUMMY_STACK_ADJUST;
1191 #else
1192   sp += CALL_DUMMY_STACK_ADJUST;
1193 #endif
1194 #endif /* CALL_DUMMY_STACK_ADJUST */
1195
1196   /* Store the address at which the structure is supposed to be
1197      written.  Note that this (and the code which reserved the space
1198      above) assumes that gcc was used to compile this function.  Since
1199      it doesn't cost us anything but space and if the function is pcc
1200      it will ignore this value, we will make that assumption.
1201
1202      Also note that on some machines (like the sparc) pcc uses a
1203      convention like gcc's.  */
1204
1205   if (struct_return)
1206     STORE_STRUCT_RETURN (struct_addr, sp);
1207
1208   /* Write the stack pointer.  This is here because the statements above
1209      might fool with it.  On SPARC, this write also stores the register
1210      window into the right place in the new stack frame, which otherwise
1211      wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
1212   write_sp (sp);
1213
1214   {
1215     char retbuf[REGISTER_BYTES];
1216     char *name;
1217     struct symbol *symbol;
1218
1219     name = NULL;
1220     symbol = find_pc_function (funaddr);
1221     if (symbol)
1222       {
1223         name = SYMBOL_SOURCE_NAME (symbol);
1224       }
1225     else
1226       {
1227         /* Try the minimal symbols.  */
1228         struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
1229
1230         if (msymbol)
1231           {
1232             name = SYMBOL_SOURCE_NAME (msymbol);
1233           }
1234       }
1235     if (name == NULL)
1236       {
1237         char format[80];
1238         sprintf (format, "at %s", local_hex_format ());
1239         name = alloca (80);
1240         /* FIXME-32x64: assumes funaddr fits in a long.  */
1241         sprintf (name, format, (unsigned long) funaddr);
1242       }
1243
1244     /* Execute the stack dummy routine, calling FUNCTION.
1245        When it is done, discard the empty frame
1246        after storing the contents of all regs into retbuf.  */
1247     if (run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf))
1248       {
1249         /* We stopped somewhere besides the call dummy.  */
1250
1251         /* If we did the cleanups, we would print a spurious error message
1252            (Unable to restore previously selected frame), would write the
1253            registers from the inf_status (which is wrong), and would do other
1254            wrong things (like set stop_bpstat to the wrong thing).  */
1255         discard_cleanups (old_chain);
1256         /* Prevent memory leak.  */
1257         bpstat_clear (&inf_status.stop_bpstat);
1258
1259         /* The following error message used to say "The expression
1260            which contained the function call has been discarded."  It
1261            is a hard concept to explain in a few words.  Ideally, GDB
1262            would be able to resume evaluation of the expression when
1263            the function finally is done executing.  Perhaps someday
1264            this will be implemented (it would not be easy).  */
1265
1266         /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1267            a C++ name with arguments and stuff.  */
1268         error ("\
1269 The program being debugged stopped while in a function called from GDB.\n\
1270 When the function (%s) is done executing, GDB will silently\n\
1271 stop (instead of continuing to evaluate the expression containing\n\
1272 the function call).", name);
1273       }
1274
1275     do_cleanups (old_chain);
1276
1277     /* Figure out the value returned by the function.  */
1278     return value_being_returned (value_type, retbuf, struct_return);
1279   }
1280 }
1281 #else /* no CALL_DUMMY.  */
1282 value_ptr
1283 call_function_by_hand (function, nargs, args)
1284      value_ptr function;
1285      int nargs;
1286      value_ptr *args;
1287 {
1288   error ("Cannot invoke functions on this machine.");
1289 }
1290 #endif /* no CALL_DUMMY.  */
1291
1292 \f
1293 /* Create a value for an array by allocating space in the inferior, copying
1294    the data into that space, and then setting up an array value.
1295
1296    The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1297    populated from the values passed in ELEMVEC.
1298
1299    The element type of the array is inherited from the type of the
1300    first element, and all elements must have the same size (though we
1301    don't currently enforce any restriction on their types). */
1302
1303 value_ptr
1304 value_array (lowbound, highbound, elemvec)
1305      int lowbound;
1306      int highbound;
1307      value_ptr *elemvec;
1308 {
1309   int nelem;
1310   int idx;
1311   int typelength;
1312   value_ptr val;
1313   struct type *rangetype;
1314   struct type *arraytype;
1315   CORE_ADDR addr;
1316
1317   /* Validate that the bounds are reasonable and that each of the elements
1318      have the same size. */
1319
1320   nelem = highbound - lowbound + 1;
1321   if (nelem <= 0)
1322     {
1323       error ("bad array bounds (%d, %d)", lowbound, highbound);
1324     }
1325   typelength = TYPE_LENGTH (VALUE_TYPE (elemvec[0]));
1326   for (idx = 0; idx < nelem; idx++)
1327     {
1328       if (TYPE_LENGTH (VALUE_TYPE (elemvec[idx])) != typelength)
1329         {
1330           error ("array elements must all be the same size");
1331         }
1332     }
1333
1334   /* Allocate space to store the array in the inferior, and then initialize
1335      it by copying in each element.  FIXME:  Is it worth it to create a
1336      local buffer in which to collect each value and then write all the
1337      bytes in one operation? */
1338
1339   addr = allocate_space_in_inferior (nelem * typelength);
1340   for (idx = 0; idx < nelem; idx++)
1341     {
1342       write_memory (addr + (idx * typelength), VALUE_CONTENTS (elemvec[idx]),
1343                     typelength);
1344     }
1345
1346   /* Create the array type and set up an array value to be evaluated lazily. */
1347
1348   rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1349                                  lowbound, highbound);
1350   arraytype = create_array_type ((struct type *) NULL,
1351                                  VALUE_TYPE (elemvec[0]), rangetype);
1352   val = value_at_lazy (arraytype, addr);
1353   return (val);
1354 }
1355
1356 /* Create a value for a string constant by allocating space in the inferior,
1357    copying the data into that space, and returning the address with type
1358    TYPE_CODE_STRING.  PTR points to the string constant data; LEN is number
1359    of characters.
1360    Note that string types are like array of char types with a lower bound of
1361    zero and an upper bound of LEN - 1.  Also note that the string may contain
1362    embedded null bytes. */
1363
1364 value_ptr
1365 value_string (ptr, len)
1366      char *ptr;
1367      int len;
1368 {
1369   value_ptr val;
1370   int lowbound = current_language->string_lower_bound;
1371   struct type *rangetype = create_range_type ((struct type *) NULL,
1372                                               builtin_type_int,
1373                                               lowbound, len + lowbound - 1);
1374   struct type *stringtype
1375     = create_string_type ((struct type *) NULL, rangetype);
1376   CORE_ADDR addr;
1377
1378   if (current_language->c_style_arrays == 0)
1379     {
1380       val = allocate_value (stringtype);
1381       memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1382       return val;
1383     }
1384
1385
1386   /* Allocate space to store the string in the inferior, and then
1387      copy LEN bytes from PTR in gdb to that address in the inferior. */
1388
1389   addr = allocate_space_in_inferior (len);
1390   write_memory (addr, ptr, len);
1391
1392   val = value_at_lazy (stringtype, addr);
1393   return (val);
1394 }
1395
1396 value_ptr
1397 value_bitstring (ptr, len)
1398      char *ptr;
1399      int len;
1400 {
1401   value_ptr val;
1402   struct type *domain_type = create_range_type (NULL, builtin_type_int,
1403                                                 0, len - 1);
1404   struct type *type = create_set_type ((struct type*) NULL, domain_type);
1405   TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1406   val = allocate_value (type);
1407   memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type) / TARGET_CHAR_BIT);
1408   return val;
1409 }
1410 \f
1411 /* See if we can pass arguments in T2 to a function which takes arguments
1412    of types T1.  Both t1 and t2 are NULL-terminated vectors.  If some
1413    arguments need coercion of some sort, then the coerced values are written
1414    into T2.  Return value is 0 if the arguments could be matched, or the
1415    position at which they differ if not.
1416
1417    STATICP is nonzero if the T1 argument list came from a
1418    static member function.
1419
1420    For non-static member functions, we ignore the first argument,
1421    which is the type of the instance variable.  This is because we want
1422    to handle calls with objects from derived classes.  This is not
1423    entirely correct: we should actually check to make sure that a
1424    requested operation is type secure, shouldn't we?  FIXME.  */
1425
1426 static int
1427 typecmp (staticp, t1, t2)
1428      int staticp;
1429      struct type *t1[];
1430      value_ptr t2[];
1431 {
1432   int i;
1433
1434   if (t2 == 0)
1435     return 1;
1436   if (staticp && t1 == 0)
1437     return t2[1] != 0;
1438   if (t1 == 0)
1439     return 1;
1440   if (TYPE_CODE (t1[0]) == TYPE_CODE_VOID) return 0;
1441   if (t1[!staticp] == 0) return 0;
1442   for (i = !staticp; t1[i] && TYPE_CODE (t1[i]) != TYPE_CODE_VOID; i++)
1443     {
1444     struct type *tt1, *tt2;
1445       if (! t2[i])
1446         return i+1;
1447       tt1 = t1[i];
1448       tt2 = VALUE_TYPE(t2[i]);
1449       if (TYPE_CODE (tt1) == TYPE_CODE_REF
1450           /* We should be doing hairy argument matching, as below.  */
1451           && (TYPE_CODE (TYPE_TARGET_TYPE (tt1)) == TYPE_CODE (tt2)))
1452         {
1453           if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY || VALUE_REPEATED (t2[i]))
1454             t2[i] = value_coerce_array (t2[i]);
1455           else
1456             t2[i] = value_addr (t2[i]);
1457           continue;
1458         }
1459
1460       while (TYPE_CODE (tt1) == TYPE_CODE_PTR
1461           && (TYPE_CODE(tt2)==TYPE_CODE_ARRAY || TYPE_CODE(tt2)==TYPE_CODE_PTR))
1462         {
1463            tt1 = TYPE_TARGET_TYPE(tt1);
1464            tt2 = TYPE_TARGET_TYPE(tt2);
1465         }
1466       if (TYPE_CODE(tt1) == TYPE_CODE(tt2)) continue;
1467       /* Array to pointer is a `trivial conversion' according to the ARM.  */
1468
1469       /* We should be doing much hairier argument matching (see section 13.2
1470          of the ARM), but as a quick kludge, just check for the same type
1471          code.  */
1472       if (TYPE_CODE (t1[i]) != TYPE_CODE (VALUE_TYPE (t2[i])))
1473         return i+1;
1474     }
1475   if (!t1[i]) return 0;
1476   return t2[i] ? i+1 : 0;
1477 }
1478
1479 /* Helper function used by value_struct_elt to recurse through baseclasses.
1480    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1481    and search in it assuming it has (class) type TYPE.
1482    If found, return value, else return NULL.
1483
1484    If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
1485    look for a baseclass named NAME.  */
1486
1487 static value_ptr
1488 search_struct_field (name, arg1, offset, type, looking_for_baseclass)
1489      char *name;
1490      register value_ptr arg1;
1491      int offset;
1492      register struct type *type;
1493      int looking_for_baseclass;
1494 {
1495   int i;
1496
1497   check_stub_type (type);
1498
1499   if (! looking_for_baseclass)
1500     for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1501       {
1502         char *t_field_name = TYPE_FIELD_NAME (type, i);
1503
1504         if (t_field_name && STREQ (t_field_name, name))
1505           {
1506             value_ptr v;
1507             if (TYPE_FIELD_STATIC (type, i))
1508               {
1509                 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, i);
1510                 struct symbol *sym =
1511                     lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
1512                 if (sym == NULL)
1513                     error ("Internal error: could not find physical static variable named %s",
1514                            phys_name);
1515                 v = value_at (TYPE_FIELD_TYPE (type, i),
1516                               (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
1517               }
1518             else
1519               v = value_primitive_field (arg1, offset, i, type);
1520             if (v == 0)
1521               error("there is no field named %s", name);
1522             return v;
1523           }
1524         if (t_field_name && t_field_name[0] == '\0'
1525             && TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION)
1526           {
1527             /* Look for a match through the fields of an anonymous union.  */
1528             value_ptr v;
1529             v = search_struct_field (name, arg1, offset,
1530                                      TYPE_FIELD_TYPE (type, i),
1531                                      looking_for_baseclass);
1532             if (v)
1533               return v;
1534           }
1535       }
1536
1537   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1538     {
1539       value_ptr v;
1540       /* If we are looking for baseclasses, this is what we get when we
1541          hit them.  But it could happen that the base part's member name
1542          is not yet filled in.  */
1543       int found_baseclass = (looking_for_baseclass
1544                              && TYPE_BASECLASS_NAME (type, i) != NULL
1545                              && STREQ (name, TYPE_BASECLASS_NAME (type, i)));
1546
1547       if (BASETYPE_VIA_VIRTUAL (type, i))
1548         {
1549           value_ptr v2;
1550           /* Fix to use baseclass_offset instead. FIXME */
1551           baseclass_addr (type, i, VALUE_CONTENTS (arg1) + offset,
1552                           &v2, (int *)NULL);
1553           if (v2 == 0)
1554             error ("virtual baseclass botch");
1555           if (found_baseclass)
1556             return v2;
1557           v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
1558                                    looking_for_baseclass);
1559         }
1560       else if (found_baseclass)
1561         v = value_primitive_field (arg1, offset, i, type);
1562       else
1563         v = search_struct_field (name, arg1,
1564                                  offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
1565                                  TYPE_BASECLASS (type, i),
1566                                  looking_for_baseclass);
1567       if (v) return v;
1568     }
1569   return NULL;
1570 }
1571
1572 /* Helper function used by value_struct_elt to recurse through baseclasses.
1573    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
1574    and search in it assuming it has (class) type TYPE.
1575    If found, return value, else if name matched and args not return (value)-1,
1576    else return NULL. */
1577
1578 static value_ptr
1579 search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
1580      char *name;
1581      register value_ptr *arg1p, *args;
1582      int offset, *static_memfuncp;
1583      register struct type *type;
1584 {
1585   int i;
1586   value_ptr v;
1587   int name_matched = 0;
1588   char dem_opname[64];
1589
1590   check_stub_type (type);
1591   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1592     {
1593       char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1594       if (strncmp(t_field_name, "__", 2)==0 ||
1595         strncmp(t_field_name, "op", 2)==0 ||
1596         strncmp(t_field_name, "type", 4)==0 )
1597         {
1598           if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
1599             t_field_name = dem_opname;
1600           else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
1601             t_field_name = dem_opname;
1602         }
1603       if (t_field_name && STREQ (t_field_name, name))
1604         {
1605           int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
1606           struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1607           name_matched = 1;
1608
1609           if (j > 0 && args == 0)
1610             error ("cannot resolve overloaded method `%s'", name);
1611           while (j >= 0)
1612             {
1613               if (TYPE_FN_FIELD_STUB (f, j))
1614                 check_stub_method (type, i, j);
1615               if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
1616                             TYPE_FN_FIELD_ARGS (f, j), args))
1617                 {
1618                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1619                     return value_virtual_fn_field (arg1p, f, j, type, offset);
1620                   if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
1621                     *static_memfuncp = 1;
1622                   v = value_fn_field (arg1p, f, j, type, offset);
1623                   if (v != NULL) return v;
1624                 }
1625               j--;
1626             }
1627         }
1628     }
1629
1630   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1631     {
1632       int base_offset;
1633
1634       if (BASETYPE_VIA_VIRTUAL (type, i))
1635         {
1636           base_offset = baseclass_offset (type, i, *arg1p, offset);
1637           if (base_offset == -1)
1638             error ("virtual baseclass botch");
1639         }
1640       else
1641         {
1642           base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
1643         }
1644       v = search_struct_method (name, arg1p, args, base_offset + offset,
1645                                 static_memfuncp, TYPE_BASECLASS (type, i));
1646       if (v == (value_ptr) -1)
1647         {
1648           name_matched = 1;
1649         }
1650       else if (v)
1651         {
1652 /* FIXME-bothner:  Why is this commented out?  Why is it here?  */
1653 /*        *arg1p = arg1_tmp;*/
1654           return v;
1655         }
1656     }
1657   if (name_matched) return (value_ptr) -1;
1658   else return NULL;
1659 }
1660
1661 /* Given *ARGP, a value of type (pointer to a)* structure/union,
1662    extract the component named NAME from the ultimate target structure/union
1663    and return it as a value with its appropriate type.
1664    ERR is used in the error message if *ARGP's type is wrong.
1665
1666    C++: ARGS is a list of argument types to aid in the selection of
1667    an appropriate method. Also, handle derived types.
1668
1669    STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
1670    where the truthvalue of whether the function that was resolved was
1671    a static member function or not is stored.
1672
1673    ERR is an error message to be printed in case the field is not found.  */
1674
1675 value_ptr
1676 value_struct_elt (argp, args, name, static_memfuncp, err)
1677      register value_ptr *argp, *args;
1678      char *name;
1679      int *static_memfuncp;
1680      char *err;
1681 {
1682   register struct type *t;
1683   value_ptr v;
1684
1685   COERCE_ARRAY (*argp);
1686
1687   t = VALUE_TYPE (*argp);
1688
1689   /* Follow pointers until we get to a non-pointer.  */
1690
1691   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1692     {
1693       *argp = value_ind (*argp);
1694       /* Don't coerce fn pointer to fn and then back again!  */
1695       if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
1696         COERCE_ARRAY (*argp);
1697       t = VALUE_TYPE (*argp);
1698     }
1699
1700   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
1701     error ("not implemented: member type in value_struct_elt");
1702
1703   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
1704       && TYPE_CODE (t) != TYPE_CODE_UNION)
1705     error ("Attempt to extract a component of a value that is not a %s.", err);
1706
1707   /* Assume it's not, unless we see that it is.  */
1708   if (static_memfuncp)
1709     *static_memfuncp =0;
1710
1711   if (!args)
1712     {
1713       /* if there are no arguments ...do this...  */
1714
1715       /* Try as a field first, because if we succeed, there
1716          is less work to be done.  */
1717       v = search_struct_field (name, *argp, 0, t, 0);
1718       if (v)
1719         return v;
1720
1721       /* C++: If it was not found as a data field, then try to
1722          return it as a pointer to a method.  */
1723
1724       if (destructor_name_p (name, t))
1725         error ("Cannot get value of destructor");
1726
1727       v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
1728
1729       if (v == (value_ptr) -1)
1730         error ("Cannot take address of a method");
1731       else if (v == 0)
1732         {
1733           if (TYPE_NFN_FIELDS (t))
1734             error ("There is no member or method named %s.", name);
1735           else
1736             error ("There is no member named %s.", name);
1737         }
1738       return v;
1739     }
1740
1741   if (destructor_name_p (name, t))
1742     {
1743       if (!args[1])
1744         {
1745           /* destructors are a special case.  */
1746           v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, 0),
1747                               TYPE_FN_FIELDLIST_LENGTH (t, 0), 0, 0);
1748           if (!v) error("could not find destructor function named %s.", name);
1749           else return v;
1750         }
1751       else
1752         {
1753           error ("destructor should not have any argument");
1754         }
1755     }
1756   else
1757     v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
1758
1759   if (v == (value_ptr) -1)
1760     {
1761         error("Argument list of %s mismatch with component in the structure.", name);
1762     }
1763   else if (v == 0)
1764     {
1765       /* See if user tried to invoke data as function.  If so,
1766          hand it back.  If it's not callable (i.e., a pointer to function),
1767          gdb should give an error.  */
1768       v = search_struct_field (name, *argp, 0, t, 0);
1769     }
1770
1771   if (!v)
1772     error ("Structure has no component named %s.", name);
1773   return v;
1774 }
1775
1776 /* C++: return 1 is NAME is a legitimate name for the destructor
1777    of type TYPE.  If TYPE does not have a destructor, or
1778    if NAME is inappropriate for TYPE, an error is signaled.  */
1779 int
1780 destructor_name_p (name, type)
1781      const char *name;
1782      const struct type *type;
1783 {
1784   /* destructors are a special case.  */
1785
1786   if (name[0] == '~')
1787     {
1788       char *dname = type_name_no_tag (type);
1789       char *cp = strchr (dname, '<');
1790       int len;
1791
1792       /* Do not compare the template part for template classes.  */
1793       if (cp == NULL)
1794         len = strlen (dname);
1795       else
1796         len = cp - dname;
1797       if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
1798         error ("name of destructor must equal name of class");
1799       else
1800         return 1;
1801     }
1802   return 0;
1803 }
1804
1805 /* Helper function for check_field: Given TYPE, a structure/union,
1806    return 1 if the component named NAME from the ultimate
1807    target structure/union is defined, otherwise, return 0. */
1808
1809 static int
1810 check_field_in (type, name)
1811      register struct type *type;
1812      const char *name;
1813 {
1814   register int i;
1815
1816   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1817     {
1818       char *t_field_name = TYPE_FIELD_NAME (type, i);
1819       if (t_field_name && STREQ (t_field_name, name))
1820         return 1;
1821     }
1822
1823   /* C++: If it was not found as a data field, then try to
1824      return it as a pointer to a method.  */
1825
1826   /* Destructors are a special case.  */
1827   if (destructor_name_p (name, type))
1828     return 1;
1829
1830   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
1831     {
1832       if (STREQ (TYPE_FN_FIELDLIST_NAME (type, i), name))
1833         return 1;
1834     }
1835
1836   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
1837     if (check_field_in (TYPE_BASECLASS (type, i), name))
1838       return 1;
1839
1840   return 0;
1841 }
1842
1843
1844 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
1845    return 1 if the component named NAME from the ultimate
1846    target structure/union is defined, otherwise, return 0.  */
1847
1848 int
1849 check_field (arg1, name)
1850      register value_ptr arg1;
1851      const char *name;
1852 {
1853   register struct type *t;
1854
1855   COERCE_ARRAY (arg1);
1856
1857   t = VALUE_TYPE (arg1);
1858
1859   /* Follow pointers until we get to a non-pointer.  */
1860
1861   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
1862     t = TYPE_TARGET_TYPE (t);
1863
1864   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
1865     error ("not implemented: member type in check_field");
1866
1867   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
1868       && TYPE_CODE (t) != TYPE_CODE_UNION)
1869     error ("Internal error: `this' is not an aggregate");
1870
1871   return check_field_in (t, name);
1872 }
1873
1874 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
1875    return the address of this member as a "pointer to member"
1876    type.  If INTYPE is non-null, then it will be the type
1877    of the member we are looking for.  This will help us resolve
1878    "pointers to member functions".  This function is used
1879    to resolve user expressions of the form "DOMAIN::NAME".  */
1880
1881 value_ptr
1882 value_struct_elt_for_reference (domain, offset, curtype, name, intype)
1883      struct type *domain, *curtype, *intype;
1884      int offset;
1885      char *name;
1886 {
1887   register struct type *t = curtype;
1888   register int i;
1889   value_ptr v;
1890
1891   if (   TYPE_CODE (t) != TYPE_CODE_STRUCT
1892       && TYPE_CODE (t) != TYPE_CODE_UNION)
1893     error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
1894
1895   for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
1896     {
1897       char *t_field_name = TYPE_FIELD_NAME (t, i);
1898
1899       if (t_field_name && STREQ (t_field_name, name))
1900         {
1901           if (TYPE_FIELD_STATIC (t, i))
1902             {
1903               char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (t, i);
1904               struct symbol *sym =
1905                 lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
1906               if (sym == NULL)
1907                 error ("Internal error: could not find physical static variable named %s",
1908                        phys_name);
1909               return value_at (SYMBOL_TYPE (sym),
1910                                (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
1911             }
1912           if (TYPE_FIELD_PACKED (t, i))
1913             error ("pointers to bitfield members not allowed");
1914
1915           return value_from_longest
1916             (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
1917                                                         domain)),
1918              offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
1919         }
1920     }
1921
1922   /* C++: If it was not found as a data field, then try to
1923      return it as a pointer to a method.  */
1924
1925   /* Destructors are a special case.  */
1926   if (destructor_name_p (name, t))
1927     {
1928       error ("member pointers to destructors not implemented yet");
1929     }
1930
1931   /* Perform all necessary dereferencing.  */
1932   while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
1933     intype = TYPE_TARGET_TYPE (intype);
1934
1935   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
1936     {
1937       char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
1938       char dem_opname[64];
1939
1940       if (strncmp(t_field_name, "__", 2)==0 ||
1941         strncmp(t_field_name, "op", 2)==0 ||
1942         strncmp(t_field_name, "type", 4)==0 )
1943         {
1944           if (cplus_demangle_opname(t_field_name, dem_opname, DMGL_ANSI))
1945             t_field_name = dem_opname;
1946           else if (cplus_demangle_opname(t_field_name, dem_opname, 0))
1947             t_field_name = dem_opname;
1948         }
1949       if (t_field_name && STREQ (t_field_name, name))
1950         {
1951           int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
1952           struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
1953
1954           if (intype == 0 && j > 1)
1955             error ("non-unique member `%s' requires type instantiation", name);
1956           if (intype)
1957             {
1958               while (j--)
1959                 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
1960                   break;
1961               if (j < 0)
1962                 error ("no member function matches that type instantiation");
1963             }
1964           else
1965             j = 0;
1966
1967           if (TYPE_FN_FIELD_STUB (f, j))
1968             check_stub_method (t, i, j);
1969           if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1970             {
1971               return value_from_longest
1972                 (lookup_reference_type
1973                  (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
1974                                       domain)),
1975                  (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
1976             }
1977           else
1978             {
1979               struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
1980                                                 0, VAR_NAMESPACE, 0, NULL);
1981               if (s == NULL)
1982                 {
1983                   v = 0;
1984                 }
1985               else
1986                 {
1987                   v = read_var_value (s, 0);
1988 #if 0
1989                   VALUE_TYPE (v) = lookup_reference_type
1990                     (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
1991                                          domain));
1992 #endif
1993                 }
1994               return v;
1995             }
1996         }
1997     }
1998   for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
1999     {
2000       value_ptr v;
2001       int base_offset;
2002
2003       if (BASETYPE_VIA_VIRTUAL (t, i))
2004         base_offset = 0;
2005       else
2006         base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
2007       v = value_struct_elt_for_reference (domain,
2008                                           offset + base_offset,
2009                                           TYPE_BASECLASS (t, i),
2010                                           name,
2011                                           intype);
2012       if (v)
2013         return v;
2014     }
2015   return 0;
2016 }
2017
2018 /* C++: return the value of the class instance variable, if one exists.
2019    Flag COMPLAIN signals an error if the request is made in an
2020    inappropriate context.  */
2021
2022 value_ptr
2023 value_of_this (complain)
2024      int complain;
2025 {
2026   struct symbol *func, *sym;
2027   struct block *b;
2028   int i;
2029   static const char funny_this[] = "this";
2030   value_ptr this;
2031
2032   if (selected_frame == 0)
2033     if (complain)
2034       error ("no frame selected");
2035     else return 0;
2036
2037   func = get_frame_function (selected_frame);
2038   if (!func)
2039     {
2040       if (complain)
2041         error ("no `this' in nameless context");
2042       else return 0;
2043     }
2044
2045   b = SYMBOL_BLOCK_VALUE (func);
2046   i = BLOCK_NSYMS (b);
2047   if (i <= 0)
2048     if (complain)
2049       error ("no args, no `this'");
2050     else return 0;
2051
2052   /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
2053      symbol instead of the LOC_ARG one (if both exist).  */
2054   sym = lookup_block_symbol (b, funny_this, VAR_NAMESPACE);
2055   if (sym == NULL)
2056     {
2057       if (complain)
2058         error ("current stack frame not in method");
2059       else
2060         return NULL;
2061     }
2062
2063   this = read_var_value (sym, selected_frame);
2064   if (this == 0 && complain)
2065     error ("`this' argument at unknown address");
2066   return this;
2067 }
2068
2069 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
2070    long, starting at LOWBOUND.  The result has the same lower bound as
2071    the original ARRAY.  */
2072
2073 value_ptr
2074 value_slice (array, lowbound, length)
2075      value_ptr array;
2076      int lowbound, length;
2077 {
2078   COERCE_VARYING_ARRAY (array);
2079   if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_BITSTRING)
2080     error ("not implemented - bitstring slice");
2081   if (TYPE_CODE (VALUE_TYPE (array)) != TYPE_CODE_ARRAY
2082       && TYPE_CODE (VALUE_TYPE (array)) != TYPE_CODE_STRING)
2083     error ("cannot take slice of non-array");
2084   else
2085     {
2086       struct type *slice_range_type, *slice_type;
2087       value_ptr slice;
2088       struct type *range_type = TYPE_FIELD_TYPE (VALUE_TYPE (array), 0);
2089       struct type *element_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
2090       int lowerbound = TYPE_LOW_BOUND (range_type);
2091       int upperbound = TYPE_HIGH_BOUND (range_type);
2092       int offset = (lowbound - lowerbound) * TYPE_LENGTH (element_type);
2093       if (lowbound < lowerbound || length < 0
2094           || lowbound + length - 1 > upperbound)
2095         error ("slice out of range");
2096       /* FIXME-type-allocation: need a way to free this type when we are
2097          done with it.  */
2098       slice_range_type = create_range_type ((struct type*) NULL,
2099                                             TYPE_TARGET_TYPE (range_type),
2100                                             lowerbound,
2101                                             lowerbound + length - 1);
2102       slice_type = create_array_type ((struct type*) NULL, element_type,
2103                                       slice_range_type);
2104       TYPE_CODE (slice_type) = TYPE_CODE (VALUE_TYPE (array));
2105       slice = allocate_value (slice_type);
2106       if (VALUE_LAZY (array))
2107         VALUE_LAZY (slice) = 1;
2108       else
2109         memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
2110                 TYPE_LENGTH (slice_type));
2111       if (VALUE_LVAL (array) == lval_internalvar)
2112         VALUE_LVAL (slice) = lval_internalvar_component;
2113       else
2114         VALUE_LVAL (slice) = VALUE_LVAL (array);
2115       VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
2116       VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
2117       return slice;
2118     }
2119 }
2120
2121 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
2122    value as a fixed-length array. */
2123
2124 value_ptr
2125 varying_to_slice (varray)
2126      value_ptr varray;
2127 {
2128   struct type *vtype = VALUE_TYPE (varray);
2129   LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
2130                                 VALUE_CONTENTS (varray)
2131                                 + TYPE_FIELD_BITPOS (vtype, 0) / 8);
2132   return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
2133 }
2134
2135 /* Create a value for a FORTRAN complex number.  Currently most of
2136    the time values are coerced to COMPLEX*16 (i.e. a complex number
2137    composed of 2 doubles.  This really should be a smarter routine
2138    that figures out precision inteligently as opposed to assuming
2139    doubles. FIXME: fmb */
2140
2141 value_ptr
2142 value_literal_complex (arg1, arg2, type)
2143      value_ptr arg1;
2144      value_ptr arg2;
2145      struct type *type;
2146 {
2147   register value_ptr val;
2148   struct type *real_type = TYPE_TARGET_TYPE (type);
2149
2150   val = allocate_value (type);
2151   arg1 = value_cast (real_type, arg1);
2152   arg2 = value_cast (real_type, arg2);
2153
2154   memcpy (VALUE_CONTENTS_RAW (val),
2155           VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
2156   memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
2157           VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
2158   return val;
2159 }
2160
2161 /* Cast a value into the appropriate complex data type. */
2162
2163 static value_ptr
2164 cast_into_complex (type, val)
2165      struct type *type;
2166      register value_ptr val;
2167 {
2168   struct type *real_type = TYPE_TARGET_TYPE (type);
2169   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
2170     {
2171       struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
2172       value_ptr re_val = allocate_value (val_real_type);
2173       value_ptr im_val = allocate_value (val_real_type);
2174
2175       memcpy (VALUE_CONTENTS_RAW (re_val),
2176               VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
2177       memcpy (VALUE_CONTENTS_RAW (im_val),
2178               VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
2179                TYPE_LENGTH (val_real_type));
2180
2181       return value_literal_complex (re_val, im_val, type);
2182     }
2183   else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
2184            || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
2185     return value_literal_complex (val, value_zero (real_type, not_lval), type);
2186   else
2187     error ("cannot cast non-number to complex");
2188 }