gdb/valops.c

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