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