gdb/valops.c

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