gdb/valops.c

   1 /* Perform non-arithmetic operations on values, for GDB.
   2    Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "value.h"
  26 #include "frame.h"
  27 #include "inferior.h"
  28 #include "gdbcore.h"
  29 #include "target.h"
  30 #include "demangle.h"
  31 #include "language.h"
  32 #include "gdbcmd.h"
  33
  34 #include <errno.h>
  35 #include "gdb_string.h"
  36
  37 /* Flag indicating HP compilers were used; needed to correctly handle some
  38    value operations with HP aCC code/runtime. */
  39 extern int hp_som_som_object_present;
  40
  41 extern int overload_debug;
  42 /* Local functions.  */
  43
  44 static int typecmp PARAMS ((int staticp, struct type * t1[], value_ptr t2[]));
  45
  46 static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
  47 static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *, int));
  48
  49
  50 static CORE_ADDR value_push PARAMS ((CORE_ADDR, value_ptr));
  51
  52 static value_ptr search_struct_field PARAMS ((char *, value_ptr, int,
  53                                               struct type *, int));
  54
  55 static value_ptr search_struct_method PARAMS ((char *, value_ptr *,
  56                                                value_ptr *,
  57                                                int, int *, struct type *));
  58
  59 static int check_field_in PARAMS ((struct type *, const char *));
  60
  61 static CORE_ADDR allocate_space_in_inferior PARAMS ((int));
  62
  63 static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
  64
  65 static struct fn_field *find_method_list PARAMS ((value_ptr * argp, char *method, int offset, int *static_memfuncp, struct type * type, int *num_fns, struct type ** basetype, int *boffset));
  66
  67 void _initialize_valops PARAMS ((void));
  68
  69 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
  70
  71 /* Flag for whether we want to abandon failed expression evals by default.  */
  72
  73 #if 0
  74 static int auto_abandon = 0;
  75 #endif
  76
  77 int overload_resolution = 0;
  78
  79 /* This boolean tells what gdb should do if a signal is received while in
  80    a function called from gdb (call dummy).  If set, gdb unwinds the stack
  81    and restore the context to what as it was before the call.
  82    The default is to stop in the frame where the signal was received. */
  83
  84 int unwind_on_signal_p = 0;
  85 \f
  86
  87
  88 /* Find the address of function name NAME in the inferior.  */
  89
  90 value_ptr
  91 find_function_in_inferior (name)
  92      char *name;
  93 {
  94   register struct symbol *sym;
  95   sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
  96   if (sym != NULL)
  97     {
  98       if (SYMBOL_CLASS (sym) != LOC_BLOCK)
  99         {
 100           error ("\"%s\" exists in this program but is not a function.",
 101                  name);
 102         }
 103       return value_of_variable (sym, NULL);
 104     }
 105   else
 106     {
 107       struct minimal_symbol *msymbol = lookup_minimal_symbol (name, NULL, NULL);
 108       if (msymbol != NULL)
 109         {
 110           struct type *type;
 111           LONGEST maddr;
 112           type = lookup_pointer_type (builtin_type_char);
 113           type = lookup_function_type (type);
 114           type = lookup_pointer_type (type);
 115           maddr = (LONGEST) SYMBOL_VALUE_ADDRESS (msymbol);
 116           return value_from_longest (type, maddr);
 117         }
 118       else
 119         {
 120           if (!target_has_execution)
 121             error ("evaluation of this expression requires the target program to be active");
 122           else
 123             error ("evaluation of this expression requires the program to have a function \"%s\".", name);
 124         }
 125     }
 126 }
 127
 128 /* Allocate NBYTES of space in the inferior using the inferior's malloc
 129    and return a value that is a pointer to the allocated space. */
 130
 131 value_ptr
 132 value_allocate_space_in_inferior (len)
 133      int len;
 134 {
 135   value_ptr blocklen;
 136   register value_ptr val = find_function_in_inferior ("malloc");
 137
 138   blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
 139   val = call_function_by_hand (val, 1, &blocklen);
 140   if (value_logical_not (val))
 141     {
 142       if (!target_has_execution)
 143         error ("No memory available to program now: you need to start the target first");
 144       else
 145         error ("No memory available to program: call to malloc failed");
 146     }
 147   return val;
 148 }
 149
 150 static CORE_ADDR
 151 allocate_space_in_inferior (len)
 152      int len;
 153 {
 154   return value_as_long (value_allocate_space_in_inferior (len));
 155 }
 156
 157 /* Cast value ARG2 to type TYPE and return as a value.
 158    More general than a C cast: accepts any two types of the same length,
 159    and if ARG2 is an lvalue it can be cast into anything at all.  */
 160 /* In C++, casts may change pointer or object representations.  */
 161
 162 value_ptr
 163 value_cast (type, arg2)
 164      struct type *type;
 165      register value_ptr arg2;
 166 {
 167   register enum type_code code1;
 168   register enum type_code code2;
 169   register int scalar;
 170   struct type *type2;
 171
 172   int convert_to_boolean = 0;
 173
 174   if (VALUE_TYPE (arg2) == type)
 175     return arg2;
 176
 177   CHECK_TYPEDEF (type);
 178   code1 = TYPE_CODE (type);
 179   COERCE_REF (arg2);
 180   type2 = check_typedef (VALUE_TYPE (arg2));
 181
 182   /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
 183      is treated like a cast to (TYPE [N])OBJECT,
 184      where N is sizeof(OBJECT)/sizeof(TYPE). */
 185   if (code1 == TYPE_CODE_ARRAY)
 186     {
 187       struct type *element_type = TYPE_TARGET_TYPE (type);
 188       unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
 189       if (element_length > 0
 190         && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
 191         {
 192           struct type *range_type = TYPE_INDEX_TYPE (type);
 193           int val_length = TYPE_LENGTH (type2);
 194           LONGEST low_bound, high_bound, new_length;
 195           if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
 196             low_bound = 0, high_bound = 0;
 197           new_length = val_length / element_length;
 198           if (val_length % element_length != 0)
 199             warning ("array element type size does not divide object size in cast");
 200           /* FIXME-type-allocation: need a way to free this type when we are
 201              done with it.  */
 202           range_type = create_range_type ((struct type *) NULL,
 203                                           TYPE_TARGET_TYPE (range_type),
 204                                           low_bound,
 205                                           new_length + low_bound - 1);
 206           VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
 207                                                  element_type, range_type);
 208           return arg2;
 209         }
 210     }
 211
 212   if (current_language->c_style_arrays
 213       && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
 214     arg2 = value_coerce_array (arg2);
 215
 216   if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
 217     arg2 = value_coerce_function (arg2);
 218
 219   type2 = check_typedef (VALUE_TYPE (arg2));
 220   COERCE_VARYING_ARRAY (arg2, type2);
 221   code2 = TYPE_CODE (type2);
 222
 223   if (code1 == TYPE_CODE_COMPLEX)
 224     return cast_into_complex (type, arg2);
 225   if (code1 == TYPE_CODE_BOOL)
 226     {
 227       code1 = TYPE_CODE_INT;
 228       convert_to_boolean = 1;
 229     }
 230   if (code1 == TYPE_CODE_CHAR)
 231     code1 = TYPE_CODE_INT;
 232   if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
 233     code2 = TYPE_CODE_INT;
 234
 235   scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
 236             || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
 237
 238   if (code1 == TYPE_CODE_STRUCT
 239       && code2 == TYPE_CODE_STRUCT
 240       && TYPE_NAME (type) != 0)
 241     {
 242       /* Look in the type of the source to see if it contains the
 243          type of the target as a superclass.  If so, we'll need to
 244          offset the object in addition to changing its type.  */
 245       value_ptr v = search_struct_field (type_name_no_tag (type),
 246                                          arg2, 0, type2, 1);
 247       if (v)
 248         {
 249           VALUE_TYPE (v) = type;
 250           return v;
 251         }
 252     }
 253   if (code1 == TYPE_CODE_FLT && scalar)
 254     return value_from_double (type, value_as_double (arg2));
 255   else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
 256             || code1 == TYPE_CODE_RANGE)
 257            && (scalar || code2 == TYPE_CODE_PTR))
 258     {
 259       LONGEST longest;
 260
 261       if (hp_som_som_object_present &&  /* if target compiled by HP aCC */
 262           (code2 == TYPE_CODE_PTR))
 263         {
 264           unsigned int *ptr;
 265           value_ptr retvalp;
 266
 267           switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
 268             {
 269               /* With HP aCC, pointers to data members have a bias */
 270             case TYPE_CODE_MEMBER:
 271               retvalp = value_from_longest (type, value_as_long (arg2));
 272               ptr = (unsigned int *) VALUE_CONTENTS (retvalp);  /* force evaluation */
 273               *ptr &= ~0x20000000;      /* zap 29th bit to remove bias */
 274               return retvalp;
 275
 276               /* While pointers to methods don't really point to a function */
 277             case TYPE_CODE_METHOD:
 278               error ("Pointers to methods not supported with HP aCC");
 279
 280             default:
 281               break;            /* fall out and go to normal handling */
 282             }
 283         }
 284       longest = value_as_long (arg2);
 285       return value_from_longest (type, convert_to_boolean ? (LONGEST) (longest ? 1 : 0) : longest);
 286     }
 287   else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
 288     {
 289       if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
 290         {
 291           struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
 292           struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
 293           if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
 294               && TYPE_CODE (t2) == TYPE_CODE_STRUCT
 295               && !value_logical_not (arg2))
 296             {
 297               value_ptr v;
 298
 299               /* Look in the type of the source to see if it contains the
 300                  type of the target as a superclass.  If so, we'll need to
 301                  offset the pointer rather than just change its type.  */
 302               if (TYPE_NAME (t1) != NULL)
 303                 {
 304                   v = search_struct_field (type_name_no_tag (t1),
 305                                            value_ind (arg2), 0, t2, 1);
 306                   if (v)
 307                     {
 308                       v = value_addr (v);
 309                       VALUE_TYPE (v) = type;
 310                       return v;
 311                     }
 312                 }
 313
 314               /* Look in the type of the target to see if it contains the
 315                  type of the source as a superclass.  If so, we'll need to
 316                  offset the pointer rather than just change its type.
 317                  FIXME: This fails silently with virtual inheritance.  */
 318               if (TYPE_NAME (t2) != NULL)
 319                 {
 320                   v = search_struct_field (type_name_no_tag (t2),
 321                                        value_zero (t1, not_lval), 0, t1, 1);
 322                   if (v)
 323                     {
 324                       value_ptr v2 = value_ind (arg2);
 325                       VALUE_ADDRESS (v2) -= VALUE_ADDRESS (v)
 326                         + VALUE_OFFSET (v);
 327
 328                       /* JYG: adjust the new pointer value and
 329                          embedded offset. */
 330                       v2->aligner.contents[0] -=  VALUE_EMBEDDED_OFFSET (v);
 331                       VALUE_EMBEDDED_OFFSET (v2) = 0;
 332
 333                       v2 = value_addr (v2);
 334                       VALUE_TYPE (v2) = type;
 335                       return v2;
 336                     }
 337                 }
 338             }
 339           /* No superclass found, just fall through to change ptr type.  */
 340         }
 341       VALUE_TYPE (arg2) = type;
 342       VALUE_ENCLOSING_TYPE (arg2) = type;       /* pai: chk_val */
 343       VALUE_POINTED_TO_OFFSET (arg2) = 0;       /* pai: chk_val */
 344       return arg2;
 345     }
 346   else if (chill_varying_type (type))
 347     {
 348       struct type *range1, *range2, *eltype1, *eltype2;
 349       value_ptr val;
 350       int count1, count2;
 351       LONGEST low_bound, high_bound;
 352       char *valaddr, *valaddr_data;
 353       /* For lint warning about eltype2 possibly uninitialized: */
 354       eltype2 = NULL;
 355       if (code2 == TYPE_CODE_BITSTRING)
 356         error ("not implemented: converting bitstring to varying type");
 357       if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING)
 358           || (eltype1 = check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1))),
 359               eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)),
 360               (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2)
 361       /* || TYPE_CODE (eltype1) != TYPE_CODE (eltype2) */ )))
 362         error ("Invalid conversion to varying type");
 363       range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0);
 364       range2 = TYPE_FIELD_TYPE (type2, 0);
 365       if (get_discrete_bounds (range1, &low_bound, &high_bound) < 0)
 366         count1 = -1;
 367       else
 368         count1 = high_bound - low_bound + 1;
 369       if (get_discrete_bounds (range2, &low_bound, &high_bound) < 0)
 370         count1 = -1, count2 = 0;        /* To force error before */
 371       else
 372         count2 = high_bound - low_bound + 1;
 373       if (count2 > count1)
 374         error ("target varying type is too small");
 375       val = allocate_value (type);
 376       valaddr = VALUE_CONTENTS_RAW (val);
 377       valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
 378       /* Set val's __var_length field to count2. */
 379       store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)),
 380                             count2);
 381       /* Set the __var_data field to count2 elements copied from arg2. */
 382       memcpy (valaddr_data, VALUE_CONTENTS (arg2),
 383               count2 * TYPE_LENGTH (eltype2));
 384       /* Zero the rest of the __var_data field of val. */
 385       memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0',
 386               (count1 - count2) * TYPE_LENGTH (eltype2));
 387       return val;
 388     }
 389   else if (VALUE_LVAL (arg2) == lval_memory)
 390     {
 391       return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2),
 392                             VALUE_BFD_SECTION (arg2));
 393     }
 394   else if (code1 == TYPE_CODE_VOID)
 395     {
 396       return value_zero (builtin_type_void, not_lval);
 397     }
 398   else
 399     {
 400       error ("Invalid cast.");
 401       return 0;
 402     }
 403 }
 404
 405 /* Create a value of type TYPE that is zero, and return it.  */
 406
 407 value_ptr
 408 value_zero (type, lv)
 409      struct type *type;
 410      enum lval_type lv;
 411 {
 412   register value_ptr val = allocate_value (type);
 413
 414   memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
 415   VALUE_LVAL (val) = lv;
 416
 417   return val;
 418 }
 419
 420 /* Return a value with type TYPE located at ADDR.
 421
 422    Call value_at only if the data needs to be fetched immediately;
 423    if we can be 'lazy' and defer the fetch, perhaps indefinately, call
 424    value_at_lazy instead.  value_at_lazy simply records the address of
 425    the data and sets the lazy-evaluation-required flag.  The lazy flag
 426    is tested in the VALUE_CONTENTS macro, which is used if and when
 427    the contents are actually required.
 428
 429    Note: value_at does *NOT* handle embedded offsets; perform such
 430    adjustments before or after calling it. */
 431
 432 value_ptr
 433 value_at (type, addr, sect)
 434      struct type *type;
 435      CORE_ADDR addr;
 436      asection *sect;
 437 {
 438   register value_ptr val;
 439
 440   if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
 441     error ("Attempt to dereference a generic pointer.");
 442
 443   val = allocate_value (type);
 444
 445   if (GDB_TARGET_IS_D10V
 446       && TYPE_CODE (type) == TYPE_CODE_PTR
 447       && TYPE_TARGET_TYPE (type)
 448       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
 449     {
 450       /* pointer to function */
 451       unsigned long num;
 452       unsigned short snum;
 453       snum = read_memory_unsigned_integer (addr, 2);
 454       num = D10V_MAKE_IADDR (snum);
 455       store_address (VALUE_CONTENTS_RAW (val), 4, num);
 456     }
 457   else if (GDB_TARGET_IS_D10V
 458            && TYPE_CODE (type) == TYPE_CODE_PTR)
 459     {
 460       /* pointer to data */
 461       unsigned long num;
 462       unsigned short snum;
 463       snum = read_memory_unsigned_integer (addr, 2);
 464       num = D10V_MAKE_DADDR (snum);
 465       store_address (VALUE_CONTENTS_RAW (val), 4, num);
 466     }
 467   else
 468     read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type), sect);
 469
 470   VALUE_LVAL (val) = lval_memory;
 471   VALUE_ADDRESS (val) = addr;
 472   VALUE_BFD_SECTION (val) = sect;
 473
 474   return val;
 475 }
 476
 477 /* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
 478
 479 value_ptr
 480 value_at_lazy (type, addr, sect)
 481      struct type *type;
 482      CORE_ADDR addr;
 483      asection *sect;
 484 {
 485   register value_ptr val;
 486
 487   if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
 488     error ("Attempt to dereference a generic pointer.");
 489
 490   val = allocate_value (type);
 491
 492   VALUE_LVAL (val) = lval_memory;
 493   VALUE_ADDRESS (val) = addr;
 494   VALUE_LAZY (val) = 1;
 495   VALUE_BFD_SECTION (val) = sect;
 496
 497   return val;
 498 }
 499
 500 /* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
 501    if the current data for a variable needs to be loaded into
 502    VALUE_CONTENTS(VAL).  Fetches the data from the user's process, and
 503    clears the lazy flag to indicate that the data in the buffer is valid.
 504
 505    If the value is zero-length, we avoid calling read_memory, which would
 506    abort.  We mark the value as fetched anyway -- all 0 bytes of it.
 507
 508    This function returns a value because it is used in the VALUE_CONTENTS
 509    macro as part of an expression, where a void would not work.  The
 510    value is ignored.  */
 511
 512 int
 513 value_fetch_lazy (val)
 514      register value_ptr val;
 515 {
 516   CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
 517   int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
 518
 519   struct type *type = VALUE_TYPE (val);
 520   if (GDB_TARGET_IS_D10V
 521       && TYPE_CODE (type) == TYPE_CODE_PTR
 522       && TYPE_TARGET_TYPE (type)
 523       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
 524     {
 525       /* pointer to function */
 526       unsigned long num;
 527       unsigned short snum;
 528       snum = read_memory_unsigned_integer (addr, 2);
 529       num = D10V_MAKE_IADDR (snum);
 530       store_address (VALUE_CONTENTS_RAW (val), 4, num);
 531     }
 532   else if (GDB_TARGET_IS_D10V
 533            && TYPE_CODE (type) == TYPE_CODE_PTR)
 534     {
 535       /* pointer to data */
 536       unsigned long num;
 537       unsigned short snum;
 538       snum = read_memory_unsigned_integer (addr, 2);
 539       num = D10V_MAKE_DADDR (snum);
 540       store_address (VALUE_CONTENTS_RAW (val), 4, num);
 541     }
 542   else if (length)
 543     read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), length,
 544                          VALUE_BFD_SECTION (val));
 545   VALUE_LAZY (val) = 0;
 546   return 0;
 547 }
 548
 549
 550 /* Store the contents of FROMVAL into the location of TOVAL.
 551    Return a new value with the location of TOVAL and contents of FROMVAL.  */
 552
 553 value_ptr
 554 value_assign (toval, fromval)
 555      register value_ptr toval, fromval;
 556 {
 557   register struct type *type;
 558   register value_ptr val;
 559   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 560   int use_buffer = 0;
 561
 562   if (!toval->modifiable)
 563     error ("Left operand of assignment is not a modifiable lvalue.");
 564
 565   COERCE_REF (toval);
 566
 567   type = VALUE_TYPE (toval);
 568   if (VALUE_LVAL (toval) != lval_internalvar)
 569     fromval = value_cast (type, fromval);
 570   else
 571     COERCE_ARRAY (fromval);
 572   CHECK_TYPEDEF (type);
 573
 574   /* If TOVAL is a special machine register requiring conversion
 575      of program values to a special raw format,
 576      convert FROMVAL's contents now, with result in `raw_buffer',
 577      and set USE_BUFFER to the number of bytes to write.  */
 578
 579   if (VALUE_REGNO (toval) >= 0)
 580     {
 581       int regno = VALUE_REGNO (toval);
 582       if (REGISTER_CONVERTIBLE (regno))
 583         {
 584           struct type *fromtype = check_typedef (VALUE_TYPE (fromval));
 585           REGISTER_CONVERT_TO_RAW (fromtype, regno,
 586                                    VALUE_CONTENTS (fromval), raw_buffer);
 587           use_buffer = REGISTER_RAW_SIZE (regno);
 588         }
 589     }
 590
 591   switch (VALUE_LVAL (toval))
 592     {
 593     case lval_internalvar:
 594       set_internalvar (VALUE_INTERNALVAR (toval), fromval);
 595       val = value_copy (VALUE_INTERNALVAR (toval)->value);
 596       VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval);
 597       VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
 598       VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
 599       return val;
 600
 601     case lval_internalvar_component:
 602       set_internalvar_component (VALUE_INTERNALVAR (toval),
 603                                  VALUE_OFFSET (toval),
 604                                  VALUE_BITPOS (toval),
 605                                  VALUE_BITSIZE (toval),
 606                                  fromval);
 607       break;
 608
 609     case lval_memory:
 610       {
 611         char *dest_buffer;
 612         CORE_ADDR changed_addr;
 613         int changed_len;
 614
 615         if (VALUE_BITSIZE (toval))
 616           {
 617             char buffer[sizeof (LONGEST)];
 618             /* We assume that the argument to read_memory is in units of
 619                host chars.  FIXME:  Is that correct?  */
 620             changed_len = (VALUE_BITPOS (toval)
 621                            + VALUE_BITSIZE (toval)
 622                            + HOST_CHAR_BIT - 1)
 623               / HOST_CHAR_BIT;
 624
 625             if (changed_len > (int) sizeof (LONGEST))
 626               error ("Can't handle bitfields which don't fit in a %d bit word.",
 627                      sizeof (LONGEST) * HOST_CHAR_BIT);
 628
 629             read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 630                          buffer, changed_len);
 631             modify_field (buffer, value_as_long (fromval),
 632                           VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 633             changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
 634             dest_buffer = buffer;
 635           }
 636         else if (use_buffer)
 637           {
 638             changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
 639             changed_len = use_buffer;
 640             dest_buffer = raw_buffer;
 641           }
 642         else
 643           {
 644             changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
 645             changed_len = TYPE_LENGTH (type);
 646             dest_buffer = VALUE_CONTENTS (fromval);
 647           }
 648
 649         write_memory (changed_addr, dest_buffer, changed_len);
 650         if (memory_changed_hook)
 651           memory_changed_hook (changed_addr, changed_len);
 652       }
 653       break;
 654
 655     case lval_register:
 656       if (VALUE_BITSIZE (toval))
 657         {
 658           char buffer[sizeof (LONGEST)];
 659           int len = REGISTER_RAW_SIZE (VALUE_REGNO (toval));
 660
 661           if (len > (int) sizeof (LONGEST))
 662             error ("Can't handle bitfields in registers larger than %d bits.",
 663                    sizeof (LONGEST) * HOST_CHAR_BIT);
 664
 665           if (VALUE_BITPOS (toval) + VALUE_BITSIZE (toval)
 666               > len * HOST_CHAR_BIT)
 667             /* Getting this right would involve being very careful about
 668                byte order.  */
 669             error ("Can't assign to bitfields that cross register "
 670                    "boundaries.");
 671
 672           read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 673                                buffer, len);
 674           modify_field (buffer, value_as_long (fromval),
 675                         VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 676           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 677                                 buffer, len);
 678         }
 679       else if (use_buffer)
 680         write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 681                               raw_buffer, use_buffer);
 682       else
 683         {
 684           /* Do any conversion necessary when storing this type to more
 685              than one register.  */
 686 #ifdef REGISTER_CONVERT_FROM_TYPE
 687           memcpy (raw_buffer, VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
 688           REGISTER_CONVERT_FROM_TYPE (VALUE_REGNO (toval), type, raw_buffer);
 689           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 690                                 raw_buffer, TYPE_LENGTH (type));
 691 #else
 692           write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
 693                               VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
 694 #endif
 695         }
 696       /* Assigning to the stack pointer, frame pointer, and other
 697          (architecture and calling convention specific) registers may
 698          cause the frame cache to be out of date.  We just do this
 699          on all assignments to registers for simplicity; I doubt the slowdown
 700          matters.  */
 701       reinit_frame_cache ();
 702       break;
 703
 704     case lval_reg_frame_relative:
 705       {
 706         /* value is stored in a series of registers in the frame
 707            specified by the structure.  Copy that value out, modify
 708            it, and copy it back in.  */
 709         int amount_to_copy = (VALUE_BITSIZE (toval) ? 1 : TYPE_LENGTH (type));
 710         int reg_size = REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval));
 711         int byte_offset = VALUE_OFFSET (toval) % reg_size;
 712         int reg_offset = VALUE_OFFSET (toval) / reg_size;
 713         int amount_copied;
 714
 715         /* Make the buffer large enough in all cases.  */
 716         char *buffer = (char *) alloca (amount_to_copy
 717                                         + sizeof (LONGEST)
 718                                         + MAX_REGISTER_RAW_SIZE);
 719
 720         int regno;
 721         struct frame_info *frame;
 722
 723         /* Figure out which frame this is in currently.  */
 724         for (frame = get_current_frame ();
 725              frame && FRAME_FP (frame) != VALUE_FRAME (toval);
 726              frame = get_prev_frame (frame))
 727           ;
 728
 729         if (!frame)
 730           error ("Value being assigned to is no longer active.");
 731
 732         amount_to_copy += (reg_size - amount_to_copy % reg_size);
 733
 734         /* Copy it out.  */
 735         for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
 736               amount_copied = 0);
 737              amount_copied < amount_to_copy;
 738              amount_copied += reg_size, regno++)
 739           {
 740             get_saved_register (buffer + amount_copied,
 741                                 (int *) NULL, (CORE_ADDR *) NULL,
 742                                 frame, regno, (enum lval_type *) NULL);
 743           }
 744
 745         /* Modify what needs to be modified.  */
 746         if (VALUE_BITSIZE (toval))
 747           modify_field (buffer + byte_offset,
 748                         value_as_long (fromval),
 749                         VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
 750         else if (use_buffer)
 751           memcpy (buffer + byte_offset, raw_buffer, use_buffer);
 752         else
 753           memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
 754                   TYPE_LENGTH (type));
 755
 756         /* Copy it back.  */
 757         for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
 758               amount_copied = 0);
 759              amount_copied < amount_to_copy;
 760              amount_copied += reg_size, regno++)
 761           {
 762             enum lval_type lval;
 763             CORE_ADDR addr;
 764             int optim;
 765
 766             /* Just find out where to put it.  */
 767             get_saved_register ((char *) NULL,
 768                                 &optim, &addr, frame, regno, &lval);
 769
 770             if (optim)
 771               error ("Attempt to assign to a value that was optimized out.");
 772             if (lval == lval_memory)
 773               write_memory (addr, buffer + amount_copied, reg_size);
 774             else if (lval == lval_register)
 775               write_register_bytes (addr, buffer + amount_copied, reg_size);
 776             else
 777               error ("Attempt to assign to an unmodifiable value.");
 778           }
 779
 780         if (register_changed_hook)
 781           register_changed_hook (-1);
 782       }
 783       break;
 784
 785
 786     default:
 787       error ("Left operand of assignment is not an lvalue.");
 788     }
 789
 790   /* If the field does not entirely fill a LONGEST, then zero the sign bits.
 791      If the field is signed, and is negative, then sign extend. */
 792   if ((VALUE_BITSIZE (toval) > 0)
 793       && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST)))
 794     {
 795       LONGEST fieldval = value_as_long (fromval);
 796       LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
 797
 798       fieldval &= valmask;
 799       if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
 800         fieldval |= ~valmask;
 801
 802       fromval = value_from_longest (type, fieldval);
 803     }
 804
 805   val = value_copy (toval);
 806   memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
 807           TYPE_LENGTH (type));
 808   VALUE_TYPE (val) = type;
 809   VALUE_ENCLOSING_TYPE (val) = VALUE_ENCLOSING_TYPE (fromval);
 810   VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
 811   VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
 812
 813   return val;
 814 }
 815
 816 /* Extend a value VAL to COUNT repetitions of its type.  */
 817
 818 value_ptr
 819 value_repeat (arg1, count)
 820      value_ptr arg1;
 821      int count;
 822 {
 823   register value_ptr val;
 824
 825   if (VALUE_LVAL (arg1) != lval_memory)
 826     error ("Only values in memory can be extended with '@'.");
 827   if (count < 1)
 828     error ("Invalid number %d of repetitions.", count);
 829
 830   val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count);
 831
 832   read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
 833                VALUE_CONTENTS_ALL_RAW (val),
 834                TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)));
 835   VALUE_LVAL (val) = lval_memory;
 836   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
 837
 838   return val;
 839 }
 840
 841 value_ptr
 842 value_of_variable (var, b)
 843      struct symbol *var;
 844      struct block *b;
 845 {
 846   value_ptr val;
 847   struct frame_info *frame = NULL;
 848
 849   if (!b)
 850     frame = NULL;               /* Use selected frame.  */
 851   else if (symbol_read_needs_frame (var))
 852     {
 853       frame = block_innermost_frame (b);
 854       if (!frame)
 855         {
 856           if (BLOCK_FUNCTION (b)
 857               && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)))
 858             error ("No frame is currently executing in block %s.",
 859                    SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)));
 860           else
 861             error ("No frame is currently executing in specified block");
 862         }
 863     }
 864
 865   val = read_var_value (var, frame);
 866   if (!val)
 867     error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 868
 869   return val;
 870 }
 871
 872 /* Given a value which is an array, return a value which is a pointer to its
 873    first element, regardless of whether or not the array has a nonzero lower
 874    bound.
 875
 876    FIXME:  A previous comment here indicated that this routine should be
 877    substracting the array's lower bound.  It's not clear to me that this
 878    is correct.  Given an array subscripting operation, it would certainly
 879    work to do the adjustment here, essentially computing:
 880
 881    (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
 882
 883    However I believe a more appropriate and logical place to account for
 884    the lower bound is to do so in value_subscript, essentially computing:
 885
 886    (&array[0] + ((index - lowerbound) * sizeof array[0]))
 887
 888    As further evidence consider what would happen with operations other
 889    than array subscripting, where the caller would get back a value that
 890    had an address somewhere before the actual first element of the array,
 891    and the information about the lower bound would be lost because of
 892    the coercion to pointer type.
 893  */
 894
 895 value_ptr
 896 value_coerce_array (arg1)
 897      value_ptr arg1;
 898 {
 899   register struct type *type = check_typedef (VALUE_TYPE (arg1));
 900
 901   if (VALUE_LVAL (arg1) != lval_memory)
 902     error ("Attempt to take address of value not located in memory.");
 903
 904   return value_from_longest (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
 905                     (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 906 }
 907
 908 /* Given a value which is a function, return a value which is a pointer
 909    to it.  */
 910
 911 value_ptr
 912 value_coerce_function (arg1)
 913      value_ptr arg1;
 914 {
 915   value_ptr retval;
 916
 917   if (VALUE_LVAL (arg1) != lval_memory)
 918     error ("Attempt to take address of value not located in memory.");
 919
 920   retval = value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
 921                     (LONGEST) (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
 922   VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1);
 923   return retval;
 924 }
 925
 926 /* Return a pointer value for the object for which ARG1 is the contents.  */
 927
 928 value_ptr
 929 value_addr (arg1)
 930      value_ptr arg1;
 931 {
 932   value_ptr arg2;
 933
 934   struct type *type = check_typedef (VALUE_TYPE (arg1));
 935   if (TYPE_CODE (type) == TYPE_CODE_REF)
 936     {
 937       /* Copy the value, but change the type from (T&) to (T*).
 938          We keep the same location information, which is efficient,
 939          and allows &(&X) to get the location containing the reference. */
 940       arg2 = value_copy (arg1);
 941       VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
 942       return arg2;
 943     }
 944   if (TYPE_CODE (type) == TYPE_CODE_FUNC)
 945     return value_coerce_function (arg1);
 946
 947   if (VALUE_LVAL (arg1) != lval_memory)
 948     error ("Attempt to take address of value not located in memory.");
 949
 950   /* Get target memory address */
 951   arg2 = value_from_longest (lookup_pointer_type (VALUE_TYPE (arg1)),
 952                              (LONGEST) (VALUE_ADDRESS (arg1)
 953                                         + VALUE_OFFSET (arg1)
 954                                         + VALUE_EMBEDDED_OFFSET (arg1)));
 955
 956   /* This may be a pointer to a base subobject; so remember the
 957      full derived object's type ... */
 958   VALUE_ENCLOSING_TYPE (arg2) = lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1));
 959   /* ... and also the relative position of the subobject in the full object */
 960   VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
 961   VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1);
 962   return arg2;
 963 }
 964
 965 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 966
 967 value_ptr
 968 value_ind (arg1)
 969      value_ptr arg1;
 970 {
 971   struct type *base_type;
 972   value_ptr arg2;
 973
 974   COERCE_ARRAY (arg1);
 975
 976   base_type = check_typedef (VALUE_TYPE (arg1));
 977
 978   if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
 979     error ("not implemented: member types in value_ind");
 980
 981   /* Allow * on an integer so we can cast it to whatever we want.
 982      This returns an int, which seems like the most C-like thing
 983      to do.  "long long" variables are rare enough that
 984      BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
 985   if (TYPE_CODE (base_type) == TYPE_CODE_INT)
 986     return value_at (builtin_type_int,
 987                      (CORE_ADDR) value_as_long (arg1),
 988                      VALUE_BFD_SECTION (arg1));
 989   else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
 990     {
 991       struct type *enc_type;
 992       /* We may be pointing to something embedded in a larger object */
 993       /* Get the real type of the enclosing object */
 994       enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1));
 995       enc_type = TYPE_TARGET_TYPE (enc_type);
 996       /* Retrieve the enclosing object pointed to */
 997       arg2 = value_at_lazy (enc_type,
 998                    value_as_pointer (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
 999                             VALUE_BFD_SECTION (arg1));
1000       /* Re-adjust type */
1001       VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
1002       /* Add embedding info */
1003       VALUE_ENCLOSING_TYPE (arg2) = enc_type;
1004       VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
1005
1006       /* We may be pointing to an object of some derived type */
1007       arg2 = value_full_object (arg2, NULL, 0, 0, 0);
1008       return arg2;
1009     }
1010
1011   error ("Attempt to take contents of a non-pointer value.");
1012   return 0;                     /* For lint -- never reached */
1013 }
1014 \f
1015 /* Pushing small parts of stack frames.  */
1016
1017 /* Push one word (the size of object that a register holds).  */
1018
1019 CORE_ADDR
1020 push_word (sp, word)
1021      CORE_ADDR sp;
1022      ULONGEST word;
1023 {
1024   register int len = REGISTER_SIZE;
1025   char buffer[MAX_REGISTER_RAW_SIZE];
1026
1027   store_unsigned_integer (buffer, len, word);
1028   if (INNER_THAN (1, 2))
1029     {
1030       /* stack grows downward */
1031       sp -= len;
1032       write_memory (sp, buffer, len);
1033     }
1034   else
1035     {
1036       /* stack grows upward */
1037       write_memory (sp, buffer, len);
1038       sp += len;
1039     }
1040
1041   return sp;
1042 }
1043
1044 /* Push LEN bytes with data at BUFFER.  */
1045
1046 CORE_ADDR
1047 push_bytes (sp, buffer, len)
1048      CORE_ADDR sp;
1049      char *buffer;
1050      int len;
1051 {
1052   if (INNER_THAN (1, 2))
1053     {
1054       /* stack grows downward */
1055       sp -= len;
1056       write_memory (sp, buffer, len);
1057     }
1058   else
1059     {
1060       /* stack grows upward */
1061       write_memory (sp, buffer, len);
1062       sp += len;
1063     }
1064
1065   return sp;
1066 }
1067
1068 #ifndef PARM_BOUNDARY
1069 #define PARM_BOUNDARY (0)
1070 #endif
1071
1072 /* Push onto the stack the specified value VALUE.  Pad it correctly for
1073    it to be an argument to a function.  */
1074
1075 static CORE_ADDR
1076 value_push (sp, arg)
1077      register CORE_ADDR sp;
1078      value_ptr arg;
1079 {
1080   register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
1081   register int container_len = len;
1082   register int offset;
1083
1084   /* How big is the container we're going to put this value in?  */
1085   if (PARM_BOUNDARY)
1086     container_len = ((len + PARM_BOUNDARY / TARGET_CHAR_BIT - 1)
1087                      & ~(PARM_BOUNDARY / TARGET_CHAR_BIT - 1));
1088
1089   /* Are we going to put it at the high or low end of the container?  */
1090   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
1091     offset = container_len - len;
1092   else
1093     offset = 0;
1094
1095   if (INNER_THAN (1, 2))
1096     {
1097       /* stack grows downward */
1098       sp -= container_len;
1099       write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
1100     }
1101   else
1102     {
1103       /* stack grows upward */
1104       write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
1105       sp += container_len;
1106     }
1107
1108   return sp;
1109 }
1110
1111 #ifndef PUSH_ARGUMENTS
1112 #define PUSH_ARGUMENTS default_push_arguments
1113 #endif
1114
1115 CORE_ADDR
1116 default_push_arguments (nargs, args, sp, struct_return, struct_addr)
1117      int nargs;
1118      value_ptr *args;
1119      CORE_ADDR sp;
1120      int struct_return;
1121      CORE_ADDR struct_addr;
1122 {
1123   /* ASSERT ( !struct_return); */
1124   int i;
1125   for (i = nargs - 1; i >= 0; i--)
1126     sp = value_push (sp, args[i]);
1127   return sp;
1128 }
1129
1130
1131 /* If we're calling a function declared without a prototype, should we
1132    promote floats to doubles?  FORMAL and ACTUAL are the types of the
1133    arguments; FORMAL may be NULL.
1134
1135    If we have no definition for this macro, either from the target or
1136    from gdbarch, provide a default.  */
1137 #ifndef COERCE_FLOAT_TO_DOUBLE
1138 #define COERCE_FLOAT_TO_DOUBLE(formal, actual) \
1139   (default_coerce_float_to_double ((formal), (actual)))
1140 #endif
1141
1142
1143 /* A default function for COERCE_FLOAT_TO_DOUBLE: do the coercion only
1144    when we don't have any type for the argument at hand.  This occurs
1145    when we have no debug info, or when passing varargs.
1146
1147    This is an annoying default: the rule the compiler follows is to do
1148    the standard promotions whenever there is no prototype in scope,
1149    and almost all targets want this behavior.  But there are some old
1150    architectures which want this odd behavior.  If you want to go
1151    through them all and fix them, please do.  Modern gdbarch-style
1152    targets may find it convenient to use standard_coerce_float_to_double.  */
1153 int
1154 default_coerce_float_to_double (struct type *formal, struct type *actual)
1155 {
1156   return formal == NULL;
1157 }
1158
1159
1160 /* Always coerce floats to doubles when there is no prototype in scope.
1161    If your architecture follows the standard type promotion rules for
1162    calling unprototyped functions, your gdbarch init function can pass
1163    this function to set_gdbarch_coerce_float_to_double to use its logic.  */
1164 int
1165 standard_coerce_float_to_double (struct type *formal, struct type *actual)
1166 {
1167   return 1;
1168 }
1169
1170
1171 /* Perform the standard coercions that are specified
1172    for arguments to be passed to C functions.
1173
1174    If PARAM_TYPE is non-NULL, it is the expected parameter type.
1175    IS_PROTOTYPED is non-zero if the function declaration is prototyped.  */
1176
1177 static value_ptr
1178 value_arg_coerce (arg, param_type, is_prototyped)
1179      value_ptr arg;
1180      struct type *param_type;
1181      int is_prototyped;
1182 {
1183   register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
1184   register struct type *type
1185   = param_type ? check_typedef (param_type) : arg_type;
1186
1187   switch (TYPE_CODE (type))
1188     {
1189     case TYPE_CODE_REF:
1190       if (TYPE_CODE (arg_type) != TYPE_CODE_REF)
1191         {
1192           arg = value_addr (arg);
1193           VALUE_TYPE (arg) = param_type;
1194           return arg;
1195         }
1196       break;
1197     case TYPE_CODE_INT:
1198     case TYPE_CODE_CHAR:
1199     case TYPE_CODE_BOOL:
1200     case TYPE_CODE_ENUM:
1201       /* If we don't have a prototype, coerce to integer type if necessary.  */
1202       if (!is_prototyped)
1203         {
1204           if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1205             type = builtin_type_int;
1206         }
1207       /* Currently all target ABIs require at least the width of an integer
1208          type for an argument.  We may have to conditionalize the following
1209          type coercion for future targets.  */
1210       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1211         type = builtin_type_int;
1212       break;
1213     case TYPE_CODE_FLT:
1214       /* FIXME: We should always convert floats to doubles in the
1215          non-prototyped case.  As many debugging formats include
1216          no information about prototyping, we have to live with
1217          COERCE_FLOAT_TO_DOUBLE for now.  */
1218       if (!is_prototyped && COERCE_FLOAT_TO_DOUBLE (param_type, arg_type))
1219         {
1220           if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
1221             type = builtin_type_double;
1222           else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
1223             type = builtin_type_long_double;
1224         }
1225       break;
1226     case TYPE_CODE_FUNC:
1227       type = lookup_pointer_type (type);
1228       break;
1229     case TYPE_CODE_ARRAY:
1230       if (current_language->c_style_arrays)
1231         type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1232       break;
1233     case TYPE_CODE_UNDEF:
1234     case TYPE_CODE_PTR:
1235     case TYPE_CODE_STRUCT:
1236     case TYPE_CODE_UNION:
1237     case TYPE_CODE_VOID:
1238     case TYPE_CODE_SET:
1239     case TYPE_CODE_RANGE:
1240     case TYPE_CODE_STRING:
1241     case TYPE_CODE_BITSTRING:
1242     case TYPE_CODE_ERROR:
1243     case TYPE_CODE_MEMBER:
1244     case TYPE_CODE_METHOD:
1245     case TYPE_CODE_COMPLEX:
1246     default:
1247       break;
1248     }
1249
1250   return value_cast (type, arg);
1251 }
1252
1253 /* Determine a function's address and its return type from its value.
1254    Calls error() if the function is not valid for calling.  */
1255
1256 static CORE_ADDR
1257 find_function_addr (function, retval_type)
1258      value_ptr function;
1259      struct type **retval_type;
1260 {
1261   register struct type *ftype = check_typedef (VALUE_TYPE (function));
1262   register enum type_code code = TYPE_CODE (ftype);
1263   struct type *value_type;
1264   CORE_ADDR funaddr;
1265
1266   /* If it's a member function, just look at the function
1267      part of it.  */
1268
1269   /* Determine address to call.  */
1270   if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
1271     {
1272       funaddr = VALUE_ADDRESS (function);
1273       value_type = TYPE_TARGET_TYPE (ftype);
1274     }
1275   else if (code == TYPE_CODE_PTR)
1276     {
1277       funaddr = value_as_pointer (function);
1278       ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
1279       if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
1280           || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
1281         {
1282 #ifdef CONVERT_FROM_FUNC_PTR_ADDR
1283           /* FIXME: This is a workaround for the unusual function
1284              pointer representation on the RS/6000, see comment
1285              in config/rs6000/tm-rs6000.h  */
1286           funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
1287 #endif
1288           value_type = TYPE_TARGET_TYPE (ftype);
1289         }
1290       else
1291         value_type = builtin_type_int;
1292     }
1293   else if (code == TYPE_CODE_INT)
1294     {
1295       /* Handle the case of functions lacking debugging info.
1296          Their values are characters since their addresses are char */
1297       if (TYPE_LENGTH (ftype) == 1)
1298         funaddr = value_as_pointer (value_addr (function));
1299       else
1300         /* Handle integer used as address of a function.  */
1301         funaddr = (CORE_ADDR) value_as_long (function);
1302
1303       value_type = builtin_type_int;
1304     }
1305   else
1306     error ("Invalid data type for function to be called.");
1307
1308   *retval_type = value_type;
1309   return funaddr;
1310 }
1311
1312 /* All this stuff with a dummy frame may seem unnecessarily complicated
1313    (why not just save registers in GDB?).  The purpose of pushing a dummy
1314    frame which looks just like a real frame is so that if you call a
1315    function and then hit a breakpoint (get a signal, etc), "backtrace"
1316    will look right.  Whether the backtrace needs to actually show the
1317    stack at the time the inferior function was called is debatable, but
1318    it certainly needs to not display garbage.  So if you are contemplating
1319    making dummy frames be different from normal frames, consider that.  */
1320
1321 /* Perform a function call in the inferior.
1322    ARGS is a vector of values of arguments (NARGS of them).
1323    FUNCTION is a value, the function to be called.
1324    Returns a value representing what the function returned.
1325    May fail to return, if a breakpoint or signal is hit
1326    during the execution of the function.
1327
1328    ARGS is modified to contain coerced values. */
1329
1330 static value_ptr hand_function_call PARAMS ((value_ptr function, int nargs, value_ptr * args));
1331 static value_ptr
1332 hand_function_call (function, nargs, args)
1333      value_ptr function;
1334      int nargs;
1335      value_ptr *args;
1336 {
1337   register CORE_ADDR sp;
1338   register int i;
1339   int rc;
1340   CORE_ADDR start_sp;
1341   /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1342      is in host byte order.  Before calling FIX_CALL_DUMMY, we byteswap it
1343      and remove any extra bytes which might exist because ULONGEST is
1344      bigger than REGISTER_SIZE.
1345
1346      NOTE: This is pretty wierd, as the call dummy is actually a
1347      sequence of instructions.  But CISC machines will have
1348      to pack the instructions into REGISTER_SIZE units (and
1349      so will RISC machines for which INSTRUCTION_SIZE is not
1350      REGISTER_SIZE).
1351
1352      NOTE: This is pretty stupid.  CALL_DUMMY should be in strict
1353      target byte order. */
1354
1355   static ULONGEST *dummy;
1356   int sizeof_dummy1;
1357   char *dummy1;
1358   CORE_ADDR old_sp;
1359   struct type *value_type;
1360   unsigned char struct_return;
1361   CORE_ADDR struct_addr = 0;
1362   struct inferior_status *inf_status;
1363   struct cleanup *old_chain;
1364   CORE_ADDR funaddr;
1365   int using_gcc;                /* Set to version of gcc in use, or zero if not gcc */
1366   CORE_ADDR real_pc;
1367   struct type *param_type = NULL;
1368   struct type *ftype = check_typedef (SYMBOL_TYPE (function));
1369
1370   dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
1371   sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST);
1372   dummy1 = alloca (sizeof_dummy1);
1373   memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS);
1374
1375   if (!target_has_execution)
1376     noprocess ();
1377
1378   inf_status = save_inferior_status (1);
1379   old_chain = make_cleanup ((make_cleanup_func) restore_inferior_status,
1380                             inf_status);
1381
1382   /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1383      (and POP_FRAME for restoring them).  (At least on most machines)
1384      they are saved on the stack in the inferior.  */
1385   PUSH_DUMMY_FRAME;
1386
1387   old_sp = sp = read_sp ();
1388
1389   if (INNER_THAN (1, 2))
1390     {
1391       /* Stack grows down */
1392       sp -= sizeof_dummy1;
1393       start_sp = sp;
1394     }
1395   else
1396     {
1397       /* Stack grows up */
1398       start_sp = sp;
1399       sp += sizeof_dummy1;
1400     }
1401
1402   funaddr = find_function_addr (function, &value_type);
1403   CHECK_TYPEDEF (value_type);
1404
1405   {
1406     struct block *b = block_for_pc (funaddr);
1407     /* If compiled without -g, assume GCC 2.  */
1408     using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
1409   }
1410
1411   /* Are we returning a value using a structure return or a normal
1412      value return? */
1413
1414   struct_return = using_struct_return (function, funaddr, value_type,
1415                                        using_gcc);
1416
1417   /* Create a call sequence customized for this function
1418      and the number of arguments for it.  */
1419   for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); i++)
1420     store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
1421                             REGISTER_SIZE,
1422                             (ULONGEST) dummy[i]);
1423
1424 #ifdef GDB_TARGET_IS_HPPA
1425   real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1426                             value_type, using_gcc);
1427 #else
1428   FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1429                   value_type, using_gcc);
1430   real_pc = start_sp;
1431 #endif
1432
1433   if (CALL_DUMMY_LOCATION == ON_STACK)
1434     {
1435       write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
1436     }
1437
1438   if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END)
1439     {
1440       /* Convex Unix prohibits executing in the stack segment. */
1441       /* Hope there is empty room at the top of the text segment. */
1442       extern CORE_ADDR text_end;
1443       static int checked = 0;
1444       if (!checked)
1445         for (start_sp = text_end - sizeof_dummy1; start_sp < text_end; ++start_sp)
1446           if (read_memory_integer (start_sp, 1) != 0)
1447             error ("text segment full -- no place to put call");
1448       checked = 1;
1449       sp = old_sp;
1450       real_pc = text_end - sizeof_dummy1;
1451       write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
1452     }
1453
1454   if (CALL_DUMMY_LOCATION == AFTER_TEXT_END)
1455     {
1456       extern CORE_ADDR text_end;
1457       int errcode;
1458       sp = old_sp;
1459       real_pc = text_end;
1460       errcode = target_write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
1461       if (errcode != 0)
1462         error ("Cannot write text segment -- call_function failed");
1463     }
1464
1465   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
1466     {
1467       real_pc = funaddr;
1468     }
1469
1470 #ifdef lint
1471   sp = old_sp;                  /* It really is used, for some ifdef's... */
1472 #endif
1473
1474   if (nargs < TYPE_NFIELDS (ftype))
1475     error ("too few arguments in function call");
1476
1477   for (i = nargs - 1; i >= 0; i--)
1478     {
1479       /* If we're off the end of the known arguments, do the standard
1480          promotions.  FIXME: if we had a prototype, this should only
1481          be allowed if ... were present.  */
1482       if (i >= TYPE_NFIELDS (ftype))
1483         args[i] = value_arg_coerce (args[i], NULL, 0);
1484
1485       else
1486         {
1487           int is_prototyped = TYPE_FLAGS (ftype) & TYPE_FLAG_PROTOTYPED;
1488           param_type = TYPE_FIELD_TYPE (ftype, i);
1489
1490           args[i] = value_arg_coerce (args[i], param_type, is_prototyped);
1491         }
1492
1493       /*elz: this code is to handle the case in which the function to be called
1494          has a pointer to function as parameter and the corresponding actual argument
1495          is the address of a function and not a pointer to function variable.
1496          In aCC compiled code, the calls through pointers to functions (in the body
1497          of the function called by hand) are made via $$dyncall_external which
1498          requires some registers setting, this is taken care of if we call
1499          via a function pointer variable, but not via a function address.
1500          In cc this is not a problem. */
1501
1502       if (using_gcc == 0)
1503         if (param_type)
1504           /* if this parameter is a pointer to function */
1505           if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
1506             if (TYPE_CODE (param_type->target_type) == TYPE_CODE_FUNC)
1507               /* elz: FIXME here should go the test about the compiler used
1508                  to compile the target. We want to issue the error
1509                  message only if the compiler used was HP's aCC.
1510                  If we used HP's cc, then there is no problem and no need
1511                  to return at this point */
1512               if (using_gcc == 0)       /* && compiler == aCC */
1513                 /* go see if the actual parameter is a variable of type
1514                    pointer to function or just a function */
1515                 if (args[i]->lval == not_lval)
1516                   {
1517                     char *arg_name;
1518                     if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL))
1519                       error ("\
1520 You cannot use function <%s> as argument. \n\
1521 You must use a pointer to function type variable. Command ignored.", arg_name);
1522                   }
1523     }
1524
1525 #if defined (REG_STRUCT_HAS_ADDR)
1526   {
1527     /* This is a machine like the sparc, where we may need to pass a pointer
1528        to the structure, not the structure itself.  */
1529     for (i = nargs - 1; i >= 0; i--)
1530       {
1531         struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
1532         if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
1533              || TYPE_CODE (arg_type) == TYPE_CODE_UNION
1534              || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
1535              || TYPE_CODE (arg_type) == TYPE_CODE_STRING
1536              || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
1537              || TYPE_CODE (arg_type) == TYPE_CODE_SET
1538              || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
1539                  && TYPE_LENGTH (arg_type) > 8)
1540             )
1541             && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
1542           {
1543             CORE_ADDR addr;
1544             int len;            /*  = TYPE_LENGTH (arg_type); */
1545             int aligned_len;
1546             arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
1547             len = TYPE_LENGTH (arg_type);
1548
1549 #ifdef STACK_ALIGN
1550             /* MVS 11/22/96: I think at least some of this stack_align code is
1551                really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1552                a target-defined manner.  */
1553             aligned_len = STACK_ALIGN (len);
1554 #else
1555             aligned_len = len;
1556 #endif
1557             if (INNER_THAN (1, 2))
1558               {
1559                 /* stack grows downward */
1560                 sp -= aligned_len;
1561               }
1562             else
1563               {
1564                 /* The stack grows up, so the address of the thing we push
1565                    is the stack pointer before we push it.  */
1566                 addr = sp;
1567               }
1568             /* Push the structure.  */
1569             write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
1570             if (INNER_THAN (1, 2))
1571               {
1572                 /* The stack grows down, so the address of the thing we push
1573                    is the stack pointer after we push it.  */
1574                 addr = sp;
1575               }
1576             else
1577               {
1578                 /* stack grows upward */
1579                 sp += aligned_len;
1580               }
1581             /* The value we're going to pass is the address of the thing
1582                we just pushed.  */
1583             /*args[i] = value_from_longest (lookup_pointer_type (value_type),
1584                (LONGEST) addr); */
1585             args[i] = value_from_longest (lookup_pointer_type (arg_type),
1586                                           (LONGEST) addr);
1587           }
1588       }
1589   }
1590 #endif /* REG_STRUCT_HAS_ADDR.  */
1591
1592   /* Reserve space for the return structure to be written on the
1593      stack, if necessary */
1594
1595   if (struct_return)
1596     {
1597       int len = TYPE_LENGTH (value_type);
1598 #ifdef STACK_ALIGN
1599       /* MVS 11/22/96: I think at least some of this stack_align code is
1600          really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1601          a target-defined manner.  */
1602       len = STACK_ALIGN (len);
1603 #endif
1604       if (INNER_THAN (1, 2))
1605         {
1606           /* stack grows downward */
1607           sp -= len;
1608           struct_addr = sp;
1609         }
1610       else
1611         {
1612           /* stack grows upward */
1613           struct_addr = sp;
1614           sp += len;
1615         }
1616     }
1617
1618 /* elz: on HPPA no need for this extra alignment, maybe it is needed
1619    on other architectures. This is because all the alignment is taken care
1620    of in the above code (ifdef REG_STRUCT_HAS_ADDR) and in
1621    hppa_push_arguments */
1622 #ifndef NO_EXTRA_ALIGNMENT_NEEDED
1623
1624 #if defined(STACK_ALIGN)
1625   /* MVS 11/22/96: I think at least some of this stack_align code is
1626      really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1627      a target-defined manner.  */
1628   if (INNER_THAN (1, 2))
1629     {
1630       /* If stack grows down, we must leave a hole at the top. */
1631       int len = 0;
1632
1633       for (i = nargs - 1; i >= 0; i--)
1634         len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
1635       if (CALL_DUMMY_STACK_ADJUST_P)
1636         len += CALL_DUMMY_STACK_ADJUST;
1637       sp -= STACK_ALIGN (len) - len;
1638     }
1639 #endif /* STACK_ALIGN */
1640 #endif /* NO_EXTRA_ALIGNMENT_NEEDED */
1641
1642   sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr);
1643
1644 #ifdef PUSH_RETURN_ADDRESS      /* for targets that use no CALL_DUMMY */
1645   /* There are a number of targets now which actually don't write any
1646      CALL_DUMMY instructions into the target, but instead just save the
1647      machine state, push the arguments, and jump directly to the callee
1648      function.  Since this doesn't actually involve executing a JSR/BSR
1649      instruction, the return address must be set up by hand, either by
1650      pushing onto the stack or copying into a return-address register
1651      as appropriate.  Formerly this has been done in PUSH_ARGUMENTS,
1652      but that's overloading its functionality a bit, so I'm making it
1653      explicit to do it here.  */
1654   sp = PUSH_RETURN_ADDRESS (real_pc, sp);
1655 #endif /* PUSH_RETURN_ADDRESS */
1656
1657 #if defined(STACK_ALIGN)
1658   if (!INNER_THAN (1, 2))
1659     {
1660       /* If stack grows up, we must leave a hole at the bottom, note
1661          that sp already has been advanced for the arguments!  */
1662       if (CALL_DUMMY_STACK_ADJUST_P)
1663         sp += CALL_DUMMY_STACK_ADJUST;
1664       sp = STACK_ALIGN (sp);
1665     }
1666 #endif /* STACK_ALIGN */
1667
1668 /* XXX This seems wrong.  For stacks that grow down we shouldn't do
1669    anything here!  */
1670   /* MVS 11/22/96: I think at least some of this stack_align code is
1671      really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1672      a target-defined manner.  */
1673   if (CALL_DUMMY_STACK_ADJUST_P)
1674     if (INNER_THAN (1, 2))
1675       {
1676         /* stack grows downward */
1677         sp -= CALL_DUMMY_STACK_ADJUST;
1678       }
1679
1680   /* Store the address at which the structure is supposed to be
1681      written.  Note that this (and the code which reserved the space
1682      above) assumes that gcc was used to compile this function.  Since
1683      it doesn't cost us anything but space and if the function is pcc
1684      it will ignore this value, we will make that assumption.
1685
1686      Also note that on some machines (like the sparc) pcc uses a
1687      convention like gcc's.  */
1688
1689   if (struct_return)
1690     STORE_STRUCT_RETURN (struct_addr, sp);
1691
1692   /* Write the stack pointer.  This is here because the statements above
1693      might fool with it.  On SPARC, this write also stores the register
1694      window into the right place in the new stack frame, which otherwise
1695      wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
1696   write_sp (sp);
1697
1698 #ifdef SAVE_DUMMY_FRAME_TOS
1699   SAVE_DUMMY_FRAME_TOS (sp);
1700 #endif
1701
1702   {
1703     char retbuf[REGISTER_BYTES];
1704     char *name;
1705     struct symbol *symbol;
1706
1707     name = NULL;
1708     symbol = find_pc_function (funaddr);
1709     if (symbol)
1710       {
1711         name = SYMBOL_SOURCE_NAME (symbol);
1712       }
1713     else
1714       {
1715         /* Try the minimal symbols.  */
1716         struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
1717
1718         if (msymbol)
1719           {
1720             name = SYMBOL_SOURCE_NAME (msymbol);
1721           }
1722       }
1723     if (name == NULL)
1724       {
1725         char format[80];
1726         sprintf (format, "at %s", local_hex_format ());
1727         name = alloca (80);
1728         /* FIXME-32x64: assumes funaddr fits in a long.  */
1729         sprintf (name, format, (unsigned long) funaddr);
1730       }
1731
1732     /* Execute the stack dummy routine, calling FUNCTION.
1733        When it is done, discard the empty frame
1734        after storing the contents of all regs into retbuf.  */
1735     rc = run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf);
1736
1737     if (rc == 1)
1738       {
1739         /* We stopped inside the FUNCTION because of a random signal.
1740            Further execution of the FUNCTION is not allowed. */
1741
1742         if (unwind_on_signal_p)
1743           {
1744             /* The user wants the context restored. */
1745
1746             /* We must get back to the frame we were before the dummy call. */
1747             POP_FRAME;
1748
1749             /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1750                a C++ name with arguments and stuff.  */
1751             error ("\
1752 The program being debugged was signaled while in a function called from GDB.\n\
1753 GDB has restored the context to what it was before the call.\n\
1754 To change this behavior use \"set unwindonsignal off\"\n\
1755 Evaluation of the expression containing the function (%s) will be abandoned.",
1756                    name);
1757           }
1758         else
1759           {
1760             /* The user wants to stay in the frame where we stopped (default).*/
1761
1762             /* If we did the cleanups, we would print a spurious error
1763                message (Unable to restore previously selected frame),
1764                would write the registers from the inf_status (which is
1765                wrong), and would do other wrong things.  */
1766             discard_cleanups (old_chain);
1767             discard_inferior_status (inf_status);
1768
1769             /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1770                a C++ name with arguments and stuff.  */
1771             error ("\
1772 The program being debugged was signaled while in a function called from GDB.\n\
1773 GDB remains in the frame where the signal was received.\n\
1774 To change this behavior use \"set unwindonsignal on\"\n\
1775 Evaluation of the expression containing the function (%s) will be abandoned.",
1776                    name);
1777           }
1778       }
1779
1780     if (rc == 2)
1781       {
1782         /* We hit a breakpoint inside the FUNCTION. */
1783
1784         /* If we did the cleanups, we would print a spurious error
1785            message (Unable to restore previously selected frame),
1786            would write the registers from the inf_status (which is
1787            wrong), and would do other wrong things.  */
1788         discard_cleanups (old_chain);
1789         discard_inferior_status (inf_status);
1790
1791         /* The following error message used to say "The expression
1792            which contained the function call has been discarded."  It
1793            is a hard concept to explain in a few words.  Ideally, GDB
1794            would be able to resume evaluation of the expression when
1795            the function finally is done executing.  Perhaps someday
1796            this will be implemented (it would not be easy).  */
1797
1798         /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1799            a C++ name with arguments and stuff.  */
1800         error ("\
1801 The program being debugged stopped while in a function called from GDB.\n\
1802 When the function (%s) is done executing, GDB will silently\n\
1803 stop (instead of continuing to evaluate the expression containing\n\
1804 the function call).", name);
1805       }
1806
1807     /* If we get here the called FUNCTION run to completion. */
1808     do_cleanups (old_chain);
1809
1810     /* Figure out the value returned by the function.  */
1811 /* elz: I defined this new macro for the hppa architecture only.
1812    this gives us a way to get the value returned by the function from the stack,
1813    at the same address we told the function to put it.
1814    We cannot assume on the pa that r28 still contains the address of the returned
1815    structure. Usually this will be overwritten by the callee.
1816    I don't know about other architectures, so I defined this macro
1817  */
1818
1819 #ifdef VALUE_RETURNED_FROM_STACK
1820     if (struct_return)
1821       return (value_ptr) VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
1822 #endif
1823
1824     return value_being_returned (value_type, retbuf, struct_return);
1825   }
1826 }
1827
1828 value_ptr
1829 call_function_by_hand (function, nargs, args)
1830      value_ptr function;
1831      int nargs;
1832      value_ptr *args;
1833 {
1834   if (CALL_DUMMY_P)
1835     {
1836       return hand_function_call (function, nargs, args);
1837     }
1838   else
1839     {
1840       error ("Cannot invoke functions on this machine.");
1841     }
1842 }
1843 \f
1844
1845
1846 /* Create a value for an array by allocating space in the inferior, copying
1847    the data into that space, and then setting up an array value.
1848
1849    The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1850    populated from the values passed in ELEMVEC.
1851
1852    The element type of the array is inherited from the type of the
1853    first element, and all elements must have the same size (though we
1854    don't currently enforce any restriction on their types). */
1855
1856 value_ptr
1857 value_array (lowbound, highbound, elemvec)
1858      int lowbound;
1859      int highbound;
1860      value_ptr *elemvec;
1861 {
1862   int nelem;
1863   int idx;
1864   unsigned int typelength;
1865   value_ptr val;
1866   struct type *rangetype;
1867   struct type *arraytype;
1868   CORE_ADDR addr;
1869
1870   /* Validate that the bounds are reasonable and that each of the elements
1871      have the same size. */
1872
1873   nelem = highbound - lowbound + 1;
1874   if (nelem <= 0)
1875     {
1876       error ("bad array bounds (%d, %d)", lowbound, highbound);
1877     }
1878   typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
1879   for (idx = 1; idx < nelem; idx++)
1880     {
1881       if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
1882         {
1883           error ("array elements must all be the same size");
1884         }
1885     }
1886
1887   rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1888                                  lowbound, highbound);
1889   arraytype = create_array_type ((struct type *) NULL,
1890                               VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
1891
1892   if (!current_language->c_style_arrays)
1893     {
1894       val = allocate_value (arraytype);
1895       for (idx = 0; idx < nelem; idx++)
1896         {
1897           memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
1898                   VALUE_CONTENTS_ALL (elemvec[idx]),
1899                   typelength);
1900         }
1901       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
1902       return val;
1903     }
1904
1905   /* Allocate space to store the array in the inferior, and then initialize
1906      it by copying in each element.  FIXME:  Is it worth it to create a
1907      local buffer in which to collect each value and then write all the
1908      bytes in one operation? */
1909
1910   addr = allocate_space_in_inferior (nelem * typelength);
1911   for (idx = 0; idx < nelem; idx++)
1912     {
1913       write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
1914                     typelength);
1915     }
1916
1917   /* Create the array type and set up an array value to be evaluated lazily. */
1918
1919   val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
1920   return (val);
1921 }
1922
1923 /* Create a value for a string constant by allocating space in the inferior,
1924    copying the data into that space, and returning the address with type
1925    TYPE_CODE_STRING.  PTR points to the string constant data; LEN is number
1926    of characters.
1927    Note that string types are like array of char types with a lower bound of
1928    zero and an upper bound of LEN - 1.  Also note that the string may contain
1929    embedded null bytes. */
1930
1931 value_ptr
1932 value_string (ptr, len)
1933      char *ptr;
1934      int len;
1935 {
1936   value_ptr val;
1937   int lowbound = current_language->string_lower_bound;
1938   struct type *rangetype = create_range_type ((struct type *) NULL,
1939                                               builtin_type_int,
1940                                               lowbound, len + lowbound - 1);
1941   struct type *stringtype
1942   = create_string_type ((struct type *) NULL, rangetype);
1943   CORE_ADDR addr;
1944
1945   if (current_language->c_style_arrays == 0)
1946     {
1947       val = allocate_value (stringtype);
1948       memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1949       return val;
1950     }
1951
1952
1953   /* Allocate space to store the string in the inferior, and then
1954      copy LEN bytes from PTR in gdb to that address in the inferior. */
1955
1956   addr = allocate_space_in_inferior (len);
1957   write_memory (addr, ptr, len);
1958
1959   val = value_at_lazy (stringtype, addr, NULL);
1960   return (val);
1961 }
1962
1963 value_ptr
1964 value_bitstring (ptr, len)
1965      char *ptr;
1966      int len;
1967 {
1968   value_ptr val;
1969   struct type *domain_type = create_range_type (NULL, builtin_type_int,
1970                                                 0, len - 1);
1971   struct type *type = create_set_type ((struct type *) NULL, domain_type);
1972   TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1973   val = allocate_value (type);
1974   memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
1975   return val;
1976 }
1977 \f
1978 /* See if we can pass arguments in T2 to a function which takes arguments
1979    of types T1.  Both t1 and t2 are NULL-terminated vectors.  If some
1980    arguments need coercion of some sort, then the coerced values are written
1981    into T2.  Return value is 0 if the arguments could be matched, or the
1982    position at which they differ if not.
1983
1984    STATICP is nonzero if the T1 argument list came from a
1985    static member function.
1986
1987    For non-static member functions, we ignore the first argument,
1988    which is the type of the instance variable.  This is because we want
1989    to handle calls with objects from derived classes.  This is not
1990    entirely correct: we should actually check to make sure that a
1991    requested operation is type secure, shouldn't we?  FIXME.  */
1992
1993 static int
1994 typecmp (staticp, t1, t2)
1995      int staticp;
1996      struct type *t1[];
1997      value_ptr t2[];
1998 {
1999   int i;
2000
2001   if (t2 == 0)
2002     return 1;
2003   if (staticp && t1 == 0)
2004     return t2[1] != 0;
2005   if (t1 == 0)
2006     return 1;
2007   if (TYPE_CODE (t1[0]) == TYPE_CODE_VOID)
2008     return 0;
2009   if (t1[!staticp] == 0)
2010     return 0;
2011   for (i = !staticp; t1[i] && TYPE_CODE (t1[i]) != TYPE_CODE_VOID; i++)
2012     {
2013       struct type *tt1, *tt2;
2014       if (!t2[i])
2015         return i + 1;
2016       tt1 = check_typedef (t1[i]);
2017       tt2 = check_typedef (VALUE_TYPE (t2[i]));
2018       if (TYPE_CODE (tt1) == TYPE_CODE_REF
2019       /* We should be doing hairy argument matching, as below.  */
2020           && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
2021         {
2022           if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
2023             t2[i] = value_coerce_array (t2[i]);
2024           else
2025             t2[i] = value_addr (t2[i]);
2026           continue;
2027         }
2028
2029       while (TYPE_CODE (tt1) == TYPE_CODE_PTR
2030              && (TYPE_CODE (tt2) == TYPE_CODE_ARRAY
2031                  || TYPE_CODE (tt2) == TYPE_CODE_PTR))
2032         {
2033           tt1 = check_typedef (TYPE_TARGET_TYPE (tt1));
2034           tt2 = check_typedef (TYPE_TARGET_TYPE (tt2));
2035         }
2036       if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
2037         continue;
2038       /* Array to pointer is a `trivial conversion' according to the ARM.  */
2039
2040       /* We should be doing much hairier argument matching (see section 13.2
2041          of the ARM), but as a quick kludge, just check for the same type
2042          code.  */
2043       if (TYPE_CODE (t1[i]) != TYPE_CODE (VALUE_TYPE (t2[i])))
2044         return i + 1;
2045     }
2046   if (!t1[i])
2047     return 0;
2048   return t2[i] ? i + 1 : 0;
2049 }
2050
2051 /* Helper function used by value_struct_elt to recurse through baseclasses.
2052    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2053    and search in it assuming it has (class) type TYPE.
2054    If found, return value, else return NULL.
2055
2056    If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
2057    look for a baseclass named NAME.  */
2058
2059 static value_ptr
2060 search_struct_field (name, arg1, offset, type, looking_for_baseclass)
2061      char *name;
2062      register value_ptr arg1;
2063      int offset;
2064      register struct type *type;
2065      int looking_for_baseclass;
2066 {
2067   int i;
2068   int nbases = TYPE_N_BASECLASSES (type);
2069
2070   CHECK_TYPEDEF (type);
2071
2072   if (!looking_for_baseclass)
2073     for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
2074       {
2075         char *t_field_name = TYPE_FIELD_NAME (type, i);
2076
2077         if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2078           {
2079             value_ptr v;
2080             if (TYPE_FIELD_STATIC (type, i))
2081               v = value_static_field (type, i);
2082             else
2083               v = value_primitive_field (arg1, offset, i, type);
2084             if (v == 0)
2085               error ("there is no field named %s", name);
2086             return v;
2087           }
2088
2089         if (t_field_name
2090             && (t_field_name[0] == '\0'
2091                 || (TYPE_CODE (type) == TYPE_CODE_UNION
2092                     && (strcmp_iw (t_field_name, "else") == 0))))
2093           {
2094             struct type *field_type = TYPE_FIELD_TYPE (type, i);
2095             if (TYPE_CODE (field_type) == TYPE_CODE_UNION
2096                 || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
2097               {
2098                 /* Look for a match through the fields of an anonymous union,
2099                    or anonymous struct.  C++ provides anonymous unions.
2100
2101                    In the GNU Chill implementation of variant record types,
2102                    each <alternative field> has an (anonymous) union type,
2103                    each member of the union represents a <variant alternative>.
2104                    Each <variant alternative> is represented as a struct,
2105                    with a member for each <variant field>.  */
2106
2107                 value_ptr v;
2108                 int new_offset = offset;
2109
2110                 /* This is pretty gross.  In G++, the offset in an anonymous
2111                    union is relative to the beginning of the enclosing struct.
2112                    In the GNU Chill implementation of variant records,
2113                    the bitpos is zero in an anonymous union field, so we
2114                    have to add the offset of the union here. */
2115                 if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
2116                     || (TYPE_NFIELDS (field_type) > 0
2117                         && TYPE_FIELD_BITPOS (field_type, 0) == 0))
2118                   new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
2119
2120                 v = search_struct_field (name, arg1, new_offset, field_type,
2121                                          looking_for_baseclass);
2122                 if (v)
2123                   return v;
2124               }
2125           }
2126       }
2127
2128   for (i = 0; i < nbases; i++)
2129     {
2130       value_ptr v;
2131       struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
2132       /* If we are looking for baseclasses, this is what we get when we
2133          hit them.  But it could happen that the base part's member name
2134          is not yet filled in.  */
2135       int found_baseclass = (looking_for_baseclass
2136                              && TYPE_BASECLASS_NAME (type, i) != NULL
2137                              && (strcmp_iw (name, TYPE_BASECLASS_NAME (type, i)) == 0));
2138
2139       if (BASETYPE_VIA_VIRTUAL (type, i))
2140         {
2141           int boffset;
2142           value_ptr v2 = allocate_value (basetype);
2143
2144           boffset = baseclass_offset (type, i,
2145                                       VALUE_CONTENTS (arg1) + offset,
2146                                       VALUE_ADDRESS (arg1)
2147                                       + VALUE_OFFSET (arg1) + offset);
2148           if (boffset == -1)
2149             error ("virtual baseclass botch");
2150
2151           /* The virtual base class pointer might have been clobbered by the
2152              user program. Make sure that it still points to a valid memory
2153              location.  */
2154
2155           boffset += offset;
2156           if (boffset < 0 || boffset >= TYPE_LENGTH (type))
2157             {
2158               CORE_ADDR base_addr;
2159
2160               base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
2161               if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
2162                                       TYPE_LENGTH (basetype)) != 0)
2163                 error ("virtual baseclass botch");
2164               VALUE_LVAL (v2) = lval_memory;
2165               VALUE_ADDRESS (v2) = base_addr;
2166             }
2167           else
2168             {
2169               VALUE_LVAL (v2) = VALUE_LVAL (arg1);
2170               VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
2171               VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
2172               if (VALUE_LAZY (arg1))
2173                 VALUE_LAZY (v2) = 1;
2174               else
2175                 memcpy (VALUE_CONTENTS_RAW (v2),
2176                         VALUE_CONTENTS_RAW (arg1) + boffset,
2177                         TYPE_LENGTH (basetype));
2178             }
2179
2180           if (found_baseclass)
2181             return v2;
2182           v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
2183                                    looking_for_baseclass);
2184         }
2185       else if (found_baseclass)
2186         v = value_primitive_field (arg1, offset, i, type);
2187       else
2188         v = search_struct_field (name, arg1,
2189                                offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
2190                                  basetype, looking_for_baseclass);
2191       if (v)
2192         return v;
2193     }
2194   return NULL;
2195 }
2196
2197
2198 /* Return the offset (in bytes) of the virtual base of type BASETYPE
2199  * in an object pointed to by VALADDR (on the host), assumed to be of
2200  * type TYPE.  OFFSET is number of bytes beyond start of ARG to start
2201  * looking (in case VALADDR is the contents of an enclosing object).
2202  *
2203  * This routine recurses on the primary base of the derived class because
2204  * the virtual base entries of the primary base appear before the other
2205  * virtual base entries.
2206  *
2207  * If the virtual base is not found, a negative integer is returned.
2208  * The magnitude of the negative integer is the number of entries in
2209  * the virtual table to skip over (entries corresponding to various
2210  * ancestral classes in the chain of primary bases).
2211  *
2212  * Important: This assumes the HP / Taligent C++ runtime
2213  * conventions. Use baseclass_offset() instead to deal with g++
2214  * conventions.  */
2215
2216 void
2217 find_rt_vbase_offset (type, basetype, valaddr, offset, boffset_p, skip_p)
2218      struct type *type;
2219      struct type *basetype;
2220      char *valaddr;
2221      int offset;
2222      int *boffset_p;
2223      int *skip_p;
2224 {
2225   int boffset;                  /* offset of virtual base */
2226   int index;                    /* displacement to use in virtual table */
2227   int skip;
2228
2229   value_ptr vp;
2230   CORE_ADDR vtbl;               /* the virtual table pointer */
2231   struct type *pbc;             /* the primary base class */
2232
2233   /* Look for the virtual base recursively in the primary base, first.
2234    * This is because the derived class object and its primary base
2235    * subobject share the primary virtual table.  */
2236
2237   boffset = 0;
2238   pbc = TYPE_PRIMARY_BASE (type);
2239   if (pbc)
2240     {
2241       find_rt_vbase_offset (pbc, basetype, valaddr, offset, &boffset, &skip);
2242       if (skip < 0)
2243         {
2244           *boffset_p = boffset;
2245           *skip_p = -1;
2246           return;
2247         }
2248     }
2249   else
2250     skip = 0;
2251
2252
2253   /* Find the index of the virtual base according to HP/Taligent
2254      runtime spec. (Depth-first, left-to-right.)  */
2255   index = virtual_base_index_skip_primaries (basetype, type);
2256
2257   if (index < 0)
2258     {
2259       *skip_p = skip + virtual_base_list_length_skip_primaries (type);
2260       *boffset_p = 0;
2261       return;
2262     }
2263
2264   /* pai: FIXME -- 32x64 possible problem */
2265   /* First word (4 bytes) in object layout is the vtable pointer */
2266   vtbl = *(CORE_ADDR *) (valaddr + offset);
2267
2268   /* Before the constructor is invoked, things are usually zero'd out. */
2269   if (vtbl == 0)
2270     error ("Couldn't find virtual table -- object may not be constructed yet.");
2271
2272
2273   /* Find virtual base's offset -- jump over entries for primary base
2274    * ancestors, then use the index computed above.  But also adjust by
2275    * HP_ACC_VBASE_START for the vtable slots before the start of the
2276    * virtual base entries.  Offset is negative -- virtual base entries
2277    * appear _before_ the address point of the virtual table. */
2278
2279   /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2280      & use long type */
2281
2282   /* epstein : FIXME -- added param for overlay section. May not be correct */
2283   vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START), NULL);
2284   boffset = value_as_long (vp);
2285   *skip_p = -1;
2286   *boffset_p = boffset;
2287   return;
2288 }
2289
2290
2291 /* Helper function used by value_struct_elt to recurse through baseclasses.
2292    Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2293    and search in it assuming it has (class) type TYPE.
2294    If found, return value, else if name matched and args not return (value)-1,
2295    else return NULL. */
2296
2297 static value_ptr
2298 search_struct_method (name, arg1p, args, offset, static_memfuncp, type)
2299      char *name;
2300      register value_ptr *arg1p, *args;
2301      int offset, *static_memfuncp;
2302      register struct type *type;
2303 {
2304   int i;
2305   value_ptr v;
2306   int name_matched = 0;
2307   char dem_opname[64];
2308
2309   CHECK_TYPEDEF (type);
2310   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2311     {
2312       char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2313       /* FIXME!  May need to check for ARM demangling here */
2314       if (strncmp (t_field_name, "__", 2) == 0 ||
2315           strncmp (t_field_name, "op", 2) == 0 ||
2316           strncmp (t_field_name, "type", 4) == 0)
2317         {
2318           if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
2319             t_field_name = dem_opname;
2320           else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2321             t_field_name = dem_opname;
2322         }
2323       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2324         {
2325           int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2326           struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2327           name_matched = 1;
2328
2329           if (j > 0 && args == 0)
2330             error ("cannot resolve overloaded method `%s': no arguments supplied", name);
2331           while (j >= 0)
2332             {
2333               if (TYPE_FN_FIELD_STUB (f, j))
2334                 check_stub_method (type, i, j);
2335               if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2336                             TYPE_FN_FIELD_ARGS (f, j), args))
2337                 {
2338                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2339                     return value_virtual_fn_field (arg1p, f, j, type, offset);
2340                   if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
2341                     *static_memfuncp = 1;
2342                   v = value_fn_field (arg1p, f, j, type, offset);
2343                   if (v != NULL)
2344                     return v;
2345                 }
2346               j--;
2347             }
2348         }
2349     }
2350
2351   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2352     {
2353       int base_offset;
2354
2355       if (BASETYPE_VIA_VIRTUAL (type, i))
2356         {
2357           if (TYPE_HAS_VTABLE (type))
2358             {
2359               /* HP aCC compiled type, search for virtual base offset
2360                  according to HP/Taligent runtime spec.  */
2361               int skip;
2362               find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2363                                     VALUE_CONTENTS_ALL (*arg1p),
2364                                     offset + VALUE_EMBEDDED_OFFSET (*arg1p),
2365                                     &base_offset, &skip);
2366               if (skip >= 0)
2367                 error ("Virtual base class offset not found in vtable");
2368             }
2369           else
2370             {
2371               struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2372               char *base_valaddr;
2373
2374               /* The virtual base class pointer might have been clobbered by the
2375                  user program. Make sure that it still points to a valid memory
2376                  location.  */
2377
2378               if (offset < 0 || offset >= TYPE_LENGTH (type))
2379                 {
2380                   base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
2381                   if (target_read_memory (VALUE_ADDRESS (*arg1p)
2382                                           + VALUE_OFFSET (*arg1p) + offset,
2383                                           base_valaddr,
2384                                           TYPE_LENGTH (baseclass)) != 0)
2385                     error ("virtual baseclass botch");
2386                 }
2387               else
2388                 base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
2389
2390               base_offset =
2391                 baseclass_offset (type, i, base_valaddr,
2392                                   VALUE_ADDRESS (*arg1p)
2393                                   + VALUE_OFFSET (*arg1p) + offset);
2394               if (base_offset == -1)
2395                 error ("virtual baseclass botch");
2396             }
2397         }
2398       else
2399         {
2400           base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2401         }
2402       v = search_struct_method (name, arg1p, args, base_offset + offset,
2403                                 static_memfuncp, TYPE_BASECLASS (type, i));
2404       if (v == (value_ptr) - 1)
2405         {
2406           name_matched = 1;
2407         }
2408       else if (v)
2409         {
2410 /* FIXME-bothner:  Why is this commented out?  Why is it here?  */
2411 /*        *arg1p = arg1_tmp; */
2412           return v;
2413         }
2414     }
2415   if (name_matched)
2416     return (value_ptr) - 1;
2417   else
2418     return NULL;
2419 }
2420
2421 /* Given *ARGP, a value of type (pointer to a)* structure/union,
2422    extract the component named NAME from the ultimate target structure/union
2423    and return it as a value with its appropriate type.
2424    ERR is used in the error message if *ARGP's type is wrong.
2425
2426    C++: ARGS is a list of argument types to aid in the selection of
2427    an appropriate method. Also, handle derived types.
2428
2429    STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2430    where the truthvalue of whether the function that was resolved was
2431    a static member function or not is stored.
2432
2433    ERR is an error message to be printed in case the field is not found.  */
2434
2435 value_ptr
2436 value_struct_elt (argp, args, name, static_memfuncp, err)
2437      register value_ptr *argp, *args;
2438      char *name;
2439      int *static_memfuncp;
2440      char *err;
2441 {
2442   register struct type *t;
2443   value_ptr v;
2444
2445   COERCE_ARRAY (*argp);
2446
2447   t = check_typedef (VALUE_TYPE (*argp));
2448
2449   /* Follow pointers until we get to a non-pointer.  */
2450
2451   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2452     {
2453       *argp = value_ind (*argp);
2454       /* Don't coerce fn pointer to fn and then back again!  */
2455       if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2456         COERCE_ARRAY (*argp);
2457       t = check_typedef (VALUE_TYPE (*argp));
2458     }
2459
2460   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2461     error ("not implemented: member type in value_struct_elt");
2462
2463   if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2464       && TYPE_CODE (t) != TYPE_CODE_UNION)
2465     error ("Attempt to extract a component of a value that is not a %s.", err);
2466
2467   /* Assume it's not, unless we see that it is.  */
2468   if (static_memfuncp)
2469     *static_memfuncp = 0;
2470
2471   if (!args)
2472     {
2473       /* if there are no arguments ...do this...  */
2474
2475       /* Try as a field first, because if we succeed, there
2476          is less work to be done.  */
2477       v = search_struct_field (name, *argp, 0, t, 0);
2478       if (v)
2479         return v;
2480
2481       /* C++: If it was not found as a data field, then try to
2482          return it as a pointer to a method.  */
2483
2484       if (destructor_name_p (name, t))
2485         error ("Cannot get value of destructor");
2486
2487       v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2488
2489       if (v == (value_ptr) - 1)
2490         error ("Cannot take address of a method");
2491       else if (v == 0)
2492         {
2493           if (TYPE_NFN_FIELDS (t))
2494             error ("There is no member or method named %s.", name);
2495           else
2496             error ("There is no member named %s.", name);
2497         }
2498       return v;
2499     }
2500
2501   if (destructor_name_p (name, t))
2502     {
2503       if (!args[1])
2504         {
2505           /* Destructors are a special case.  */
2506           int m_index, f_index;
2507
2508           v = NULL;
2509           if (get_destructor_fn_field (t, &m_index, &f_index))
2510             {
2511               v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, m_index),
2512                                   f_index, NULL, 0);
2513             }
2514           if (v == NULL)
2515             error ("could not find destructor function named %s.", name);
2516           else
2517             return v;
2518         }
2519       else
2520         {
2521           error ("destructor should not have any argument");
2522         }
2523     }
2524   else
2525     v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2526
2527   if (v == (value_ptr) - 1)
2528     {
2529       error ("Argument list of %s mismatch with component in the structure.", name);
2530     }
2531   else if (v == 0)
2532     {
2533       /* See if user tried to invoke data as function.  If so,
2534          hand it back.  If it's not callable (i.e., a pointer to function),
2535          gdb should give an error.  */
2536       v = search_struct_field (name, *argp, 0, t, 0);
2537     }
2538
2539   if (!v)
2540     error ("Structure has no component named %s.", name);
2541   return v;
2542 }
2543
2544 /* Search through the methods of an object (and its bases)
2545  * to find a specified method. Return the pointer to the
2546  * fn_field list of overloaded instances.
2547  * Helper function for value_find_oload_list.
2548  * ARGP is a pointer to a pointer to a value (the object)
2549  * METHOD is a string containing the method name
2550  * OFFSET is the offset within the value
2551  * STATIC_MEMFUNCP is set if the method is static
2552  * TYPE is the assumed type of the object
2553  * NUM_FNS is the number of overloaded instances
2554  * BASETYPE is set to the actual type of the subobject where the method is found
2555  * BOFFSET is the offset of the base subobject where the method is found */
2556
2557 static struct fn_field *
2558 find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset)
2559      value_ptr *argp;
2560      char *method;
2561      int offset;
2562      int *static_memfuncp;
2563      struct type *type;
2564      int *num_fns;
2565      struct type **basetype;
2566      int *boffset;
2567 {
2568   int i;
2569   struct fn_field *f;
2570   CHECK_TYPEDEF (type);
2571
2572   *num_fns = 0;
2573
2574   /* First check in object itself */
2575   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2576     {
2577       /* pai: FIXME What about operators and type conversions? */
2578       char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2579       if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2580         {
2581           *num_fns = TYPE_FN_FIELDLIST_LENGTH (type, i);
2582           *basetype = type;
2583           *boffset = offset;
2584           return TYPE_FN_FIELDLIST1 (type, i);
2585         }
2586     }
2587
2588   /* Not found in object, check in base subobjects */
2589   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2590     {
2591       int base_offset;
2592       if (BASETYPE_VIA_VIRTUAL (type, i))
2593         {
2594           if (TYPE_HAS_VTABLE (type))
2595             {
2596               /* HP aCC compiled type, search for virtual base offset
2597                * according to HP/Taligent runtime spec.  */
2598               int skip;
2599               find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2600                                     VALUE_CONTENTS_ALL (*argp),
2601                                     offset + VALUE_EMBEDDED_OFFSET (*argp),
2602                                     &base_offset, &skip);
2603               if (skip >= 0)
2604                 error ("Virtual base class offset not found in vtable");
2605             }
2606           else
2607             {
2608               /* probably g++ runtime model */
2609               base_offset = VALUE_OFFSET (*argp) + offset;
2610               base_offset =
2611                 baseclass_offset (type, i,
2612                                   VALUE_CONTENTS (*argp) + base_offset,
2613                                   VALUE_ADDRESS (*argp) + base_offset);
2614               if (base_offset == -1)
2615                 error ("virtual baseclass botch");
2616             }
2617         }
2618       else
2619         /* non-virtual base, simply use bit position from debug info */
2620         {
2621           base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2622         }
2623       f = find_method_list (argp, method, base_offset + offset,
2624       static_memfuncp, TYPE_BASECLASS (type, i), num_fns, basetype, boffset);
2625       if (f)
2626         return f;
2627     }
2628   return NULL;
2629 }
2630
2631 /* Return the list of overloaded methods of a specified name.
2632  * ARGP is a pointer to a pointer to a value (the object)
2633  * METHOD is the method name
2634  * OFFSET is the offset within the value contents
2635  * STATIC_MEMFUNCP is set if the method is static
2636  * NUM_FNS is the number of overloaded instances
2637  * BASETYPE is set to the type of the base subobject that defines the method
2638  * BOFFSET is the offset of the base subobject which defines the method */
2639
2640 struct fn_field *
2641 value_find_oload_method_list (argp, method, offset, static_memfuncp, num_fns, basetype, boffset)
2642      value_ptr *argp;
2643      char *method;
2644      int offset;
2645      int *static_memfuncp;
2646      int *num_fns;
2647      struct type **basetype;
2648      int *boffset;
2649 {
2650   struct type *t;
2651
2652   t = check_typedef (VALUE_TYPE (*argp));
2653
2654   /* code snarfed from value_struct_elt */
2655   while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2656     {
2657       *argp = value_ind (*argp);
2658       /* Don't coerce fn pointer to fn and then back again!  */
2659       if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2660         COERCE_ARRAY (*argp);
2661       t = check_typedef (VALUE_TYPE (*argp));
2662     }
2663
2664   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2665     error ("Not implemented: member type in value_find_oload_lis");
2666
2667   if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2668       && TYPE_CODE (t) != TYPE_CODE_UNION)
2669     error ("Attempt to extract a component of a value that is not a struct or union");
2670
2671   /* Assume it's not static, unless we see that it is.  */
2672   if (static_memfuncp)
2673     *static_memfuncp = 0;
2674
2675   return find_method_list (argp, method, 0, static_memfuncp, t, num_fns, basetype, boffset);
2676
2677 }
2678
2679 /* Given an array of argument types (ARGTYPES) (which includes an
2680    entry for "this" in the case of C++ methods), the number of
2681    arguments NARGS, the NAME of a function whether it's a method or
2682    not (METHOD), and the degree of laxness (LAX) in conforming to
2683    overload resolution rules in ANSI C++, find the best function that
2684    matches on the argument types according to the overload resolution
2685    rules.
2686
2687    In the case of class methods, the parameter OBJ is an object value
2688    in which to search for overloaded methods.
2689
2690    In the case of non-method functions, the parameter FSYM is a symbol
2691    corresponding to one of the overloaded functions.
2692
2693    Return value is an integer: 0 -> good match, 10 -> debugger applied
2694    non-standard coercions, 100 -> incompatible.
2695
2696    If a method is being searched for, VALP will hold the value.
2697    If a non-method is being searched for, SYMP will hold the symbol for it.
2698
2699    If a method is being searched for, and it is a static method,
2700    then STATICP will point to a non-zero value.
2701
2702    Note: This function does *not* check the value of
2703    overload_resolution.  Caller must check it to see whether overload
2704    resolution is permitted.
2705  */
2706
2707 int
2708 find_overload_match (arg_types, nargs, name, method, lax, obj, fsym, valp, symp, staticp)
2709      struct type **arg_types;
2710      int nargs;
2711      char *name;
2712      int method;
2713      int lax;
2714      value_ptr obj;
2715      struct symbol *fsym;
2716      value_ptr *valp;
2717      struct symbol **symp;
2718      int *staticp;
2719 {
2720   int nparms;
2721   struct type **parm_types;
2722   int champ_nparms = 0;
2723
2724   short oload_champ = -1;       /* Index of best overloaded function */
2725   short oload_ambiguous = 0;    /* Current ambiguity state for overload resolution */
2726   /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2727   short oload_ambig_champ = -1; /* 2nd contender for best match */
2728   short oload_non_standard = 0; /* did we have to use non-standard conversions? */
2729   short oload_incompatible = 0; /* are args supplied incompatible with any function? */
2730
2731   struct badness_vector *bv;    /* A measure of how good an overloaded instance is */
2732   struct badness_vector *oload_champ_bv = NULL;         /* The measure for the current best match */
2733
2734   value_ptr temp = obj;
2735   struct fn_field *fns_ptr = NULL;      /* For methods, the list of overloaded methods */
2736   struct symbol **oload_syms = NULL;    /* For non-methods, the list of overloaded function symbols */
2737   int num_fns = 0;              /* Number of overloaded instances being considered */
2738   struct type *basetype = NULL;
2739   int boffset;
2740   register int jj;
2741   register int ix;
2742
2743   char *obj_type_name = NULL;
2744   char *func_name = NULL;
2745
2746   /* Get the list of overloaded methods or functions */
2747   if (method)
2748     {
2749       int i;
2750       int len;
2751       struct type *domain;
2752       obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
2753       /* Hack: evaluate_subexp_standard often passes in a pointer
2754          value rather than the object itself, so try again */
2755       if ((!obj_type_name || !*obj_type_name) &&
2756           (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
2757         obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
2758
2759       fns_ptr = value_find_oload_method_list (&temp, name, 0,
2760                                               staticp,
2761                                               &num_fns,
2762                                               &basetype, &boffset);
2763       if (!fns_ptr || !num_fns)
2764         error ("Couldn't find method %s%s%s",
2765                obj_type_name,
2766                (obj_type_name && *obj_type_name) ? "::" : "",
2767                name);
2768       domain = TYPE_DOMAIN_TYPE (fns_ptr[0].type);
2769       len = TYPE_NFN_FIELDS (domain);
2770       /* NOTE: dan/2000-03-10: This stuff is for STABS, which won't
2771          give us the info we need directly in the types. We have to
2772          use the method stub conversion to get it. Be aware that this
2773          is by no means perfect, and if you use STABS, please move to
2774          DWARF-2, or something like it, because trying to improve
2775          overloading using STABS is really a waste of time. */
2776       for (i = 0; i < len; i++)
2777         {
2778           int j;
2779           struct fn_field *f = TYPE_FN_FIELDLIST1 (domain, i);
2780           int len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
2781
2782           for (j = 0; j < len2; j++)
2783             {
2784               if (TYPE_FN_FIELD_STUB (f, j) && (!strcmp_iw (TYPE_FN_FIELDLIST_NAME (domain,i),name)))
2785                 check_stub_method (domain, i, j);
2786             }
2787         }
2788     }
2789   else
2790     {
2791       int i = -1;
2792       func_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_NO_OPTS);
2793
2794       /* If the name is NULL this must be a C-style function.
2795          Just return the same symbol. */
2796       if (!func_name)
2797         {
2798           *symp = fsym;
2799           return 0;
2800         }
2801
2802       oload_syms = make_symbol_overload_list (fsym);
2803       while (oload_syms[++i])
2804         num_fns++;
2805       if (!num_fns)
2806         error ("Couldn't find function %s", func_name);
2807     }
2808
2809   oload_champ_bv = NULL;
2810
2811   /* Consider each candidate in turn */
2812   for (ix = 0; ix < num_fns; ix++)
2813     {
2814       if (method)
2815         {
2816           /* For static member functions, we won't have a this pointer, but nothing
2817              else seems to handle them right now, so we just pretend ourselves */
2818           nparms=0;
2819
2820           if (TYPE_FN_FIELD_ARGS(fns_ptr,ix))
2821             {
2822               while (TYPE_CODE(TYPE_FN_FIELD_ARGS(fns_ptr,ix)[nparms]) != TYPE_CODE_VOID)
2823                 nparms++;
2824             }
2825         }
2826       else
2827         {
2828           /* If it's not a method, this is the proper place */
2829           nparms=TYPE_NFIELDS(SYMBOL_TYPE(oload_syms[ix]));
2830         }
2831
2832       /* Prepare array of parameter types */
2833       parm_types = (struct type **) xmalloc (nparms * (sizeof (struct type *)));
2834       for (jj = 0; jj < nparms; jj++)
2835         parm_types[jj] = (method
2836                           ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj])
2837                           : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj));
2838
2839       /* Compare parameter types to supplied argument types */
2840       bv = rank_function (parm_types, nparms, arg_types, nargs);
2841
2842       if (!oload_champ_bv)
2843         {
2844           oload_champ_bv = bv;
2845           oload_champ = 0;
2846           champ_nparms = nparms;
2847         }
2848       else
2849         /* See whether current candidate is better or worse than previous best */
2850         switch (compare_badness (bv, oload_champ_bv))
2851           {
2852           case 0:
2853             oload_ambiguous = 1;        /* top two contenders are equally good */
2854             oload_ambig_champ = ix;
2855             break;
2856           case 1:
2857             oload_ambiguous = 2;        /* incomparable top contenders */
2858             oload_ambig_champ = ix;
2859             break;
2860           case 2:
2861             oload_champ_bv = bv;        /* new champion, record details */
2862             oload_ambiguous = 0;
2863             oload_champ = ix;
2864             oload_ambig_champ = -1;
2865             champ_nparms = nparms;
2866             break;
2867           case 3:
2868           default:
2869             break;
2870           }
2871       free (parm_types);
2872 if (overload_debug)
2873 {
2874       if (method)
2875         fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
2876       else
2877         fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
2878       for (jj = 0; jj < nargs; jj++)
2879         fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
2880       fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
2881 }
2882     }                           /* end loop over all candidates */
2883   /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
2884      if they have the exact same goodness. This is because there is no
2885      way to differentiate based on return type, which we need to in
2886      cases like overloads of .begin() <It's both const and non-const> */
2887 #if 0
2888   if (oload_ambiguous)
2889     {
2890       if (method)
2891         error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2892                obj_type_name,
2893                (obj_type_name && *obj_type_name) ? "::" : "",
2894                name);
2895       else
2896         error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2897                func_name);
2898     }
2899 #endif
2900
2901   /* Check how bad the best match is */
2902   for (ix = 1; ix <= nargs; ix++)
2903     {
2904       switch (oload_champ_bv->rank[ix])
2905         {
2906         case 10:
2907           oload_non_standard = 1;       /* non-standard type conversions needed */
2908           break;
2909         case 100:
2910           oload_incompatible = 1;       /* truly mismatched types */
2911           break;
2912         }
2913     }
2914   if (oload_incompatible)
2915     {
2916       if (method)
2917         error ("Cannot resolve method %s%s%s to any overloaded instance",
2918                obj_type_name,
2919                (obj_type_name && *obj_type_name) ? "::" : "",
2920                name);
2921       else
2922         error ("Cannot resolve function %s to any overloaded instance",
2923                func_name);
2924     }
2925   else if (oload_non_standard)
2926     {
2927       if (method)
2928         warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2929                  obj_type_name,
2930                  (obj_type_name && *obj_type_name) ? "::" : "",
2931                  name);
2932       else
2933         warning ("Using non-standard conversion to match function %s to supplied arguments",
2934                  func_name);
2935     }
2936
2937   if (method)
2938     {
2939       if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
2940         *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2941       else
2942         *valp = value_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2943     }
2944   else
2945     {
2946       *symp = oload_syms[oload_champ];
2947       free (func_name);
2948     }
2949
2950   return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
2951 }
2952
2953 /* C++: return 1 is NAME is a legitimate name for the destructor
2954    of type TYPE.  If TYPE does not have a destructor, or
2955    if NAME is inappropriate for TYPE, an error is signaled.  */
2956 int
2957 destructor_name_p (name, type)
2958      const char *name;
2959      const struct type *type;
2960 {
2961   /* destructors are a special case.  */
2962
2963   if (name[0] == '~')
2964     {
2965       char *dname = type_name_no_tag (type);
2966       char *cp = strchr (dname, '<');
2967       unsigned int len;
2968
2969       /* Do not compare the template part for template classes.  */
2970       if (cp == NULL)
2971         len = strlen (dname);
2972       else
2973         len = cp - dname;
2974       if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
2975         error ("name of destructor must equal name of class");
2976       else
2977         return 1;
2978     }
2979   return 0;
2980 }
2981
2982 /* Helper function for check_field: Given TYPE, a structure/union,
2983    return 1 if the component named NAME from the ultimate
2984    target structure/union is defined, otherwise, return 0. */
2985
2986 static int
2987 check_field_in (type, name)
2988      register struct type *type;
2989      const char *name;
2990 {
2991   register int i;
2992
2993   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2994     {
2995       char *t_field_name = TYPE_FIELD_NAME (type, i);
2996       if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2997         return 1;
2998     }
2999
3000   /* C++: If it was not found as a data field, then try to
3001      return it as a pointer to a method.  */
3002
3003   /* Destructors are a special case.  */
3004   if (destructor_name_p (name, type))
3005     {
3006       int m_index, f_index;
3007
3008       return get_destructor_fn_field (type, &m_index, &f_index);
3009     }
3010
3011   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
3012     {
3013       if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
3014         return 1;
3015     }
3016
3017   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
3018     if (check_field_in (TYPE_BASECLASS (type, i), name))
3019       return 1;
3020
3021   return 0;
3022 }
3023
3024
3025 /* C++: Given ARG1, a value of type (pointer to a)* structure/union,
3026    return 1 if the component named NAME from the ultimate
3027    target structure/union is defined, otherwise, return 0.  */
3028
3029 int
3030 check_field (arg1, name)
3031      register value_ptr arg1;
3032      const char *name;
3033 {
3034   register struct type *t;
3035
3036   COERCE_ARRAY (arg1);
3037
3038   t = VALUE_TYPE (arg1);
3039
3040   /* Follow pointers until we get to a non-pointer.  */
3041
3042   for (;;)
3043     {
3044       CHECK_TYPEDEF (t);
3045       if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF)
3046         break;
3047       t = TYPE_TARGET_TYPE (t);
3048     }
3049
3050   if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
3051     error ("not implemented: member type in check_field");
3052
3053   if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3054       && TYPE_CODE (t) != TYPE_CODE_UNION)
3055     error ("Internal error: `this' is not an aggregate");
3056
3057   return check_field_in (t, name);
3058 }
3059
3060 /* C++: Given an aggregate type CURTYPE, and a member name NAME,
3061    return the address of this member as a "pointer to member"
3062    type.  If INTYPE is non-null, then it will be the type
3063    of the member we are looking for.  This will help us resolve
3064    "pointers to member functions".  This function is used
3065    to resolve user expressions of the form "DOMAIN::NAME".  */
3066
3067 value_ptr
3068 value_struct_elt_for_reference (domain, offset, curtype, name, intype)
3069      struct type *domain, *curtype, *intype;
3070      int offset;
3071      char *name;
3072 {
3073   register struct type *t = curtype;
3074   register int i;
3075   value_ptr v;
3076
3077   if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3078       && TYPE_CODE (t) != TYPE_CODE_UNION)
3079     error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
3080
3081   for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3082     {
3083       char *t_field_name = TYPE_FIELD_NAME (t, i);
3084
3085       if (t_field_name && STREQ (t_field_name, name))
3086         {
3087           if (TYPE_FIELD_STATIC (t, i))
3088             {
3089               v = value_static_field (t, i);
3090               if (v == NULL)
3091                 error ("Internal error: could not find static variable %s",
3092                        name);
3093               return v;
3094             }
3095           if (TYPE_FIELD_PACKED (t, i))
3096             error ("pointers to bitfield members not allowed");
3097
3098           return value_from_longest
3099             (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
3100                                                         domain)),
3101              offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3102         }
3103     }
3104
3105   /* C++: If it was not found as a data field, then try to
3106      return it as a pointer to a method.  */
3107
3108   /* Destructors are a special case.  */
3109   if (destructor_name_p (name, t))
3110     {
3111       error ("member pointers to destructors not implemented yet");
3112     }
3113
3114   /* Perform all necessary dereferencing.  */
3115   while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3116     intype = TYPE_TARGET_TYPE (intype);
3117
3118   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3119     {
3120       char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3121       char dem_opname[64];
3122
3123       if (strncmp (t_field_name, "__", 2) == 0 ||
3124           strncmp (t_field_name, "op", 2) == 0 ||
3125           strncmp (t_field_name, "type", 4) == 0)
3126         {
3127           if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
3128             t_field_name = dem_opname;
3129           else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
3130             t_field_name = dem_opname;
3131         }
3132       if (t_field_name && STREQ (t_field_name, name))
3133         {
3134           int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
3135           struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3136
3137           if (intype == 0 && j > 1)
3138             error ("non-unique member `%s' requires type instantiation", name);
3139           if (intype)
3140             {
3141               while (j--)
3142                 if (TYPE_FN_FIELD_TYPE (f, j) == intype)
3143                   break;
3144               if (j < 0)
3145                 error ("no member function matches that type instantiation");
3146             }
3147           else
3148             j = 0;
3149
3150           if (TYPE_FN_FIELD_STUB (f, j))
3151             check_stub_method (t, i, j);
3152           if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3153             {
3154               return value_from_longest
3155                 (lookup_reference_type
3156                  (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
3157                                       domain)),
3158                  (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
3159             }
3160           else
3161             {
3162               struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3163                                                 0, VAR_NAMESPACE, 0, NULL);
3164               if (s == NULL)
3165                 {
3166                   v = 0;
3167                 }
3168               else
3169                 {
3170                   v = read_var_value (s, 0);
3171 #if 0
3172                   VALUE_TYPE (v) = lookup_reference_type
3173                     (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
3174                                          domain));
3175 #endif
3176                 }
3177               return v;
3178             }
3179         }
3180     }
3181   for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3182     {
3183       value_ptr v;
3184       int base_offset;
3185
3186       if (BASETYPE_VIA_VIRTUAL (t, i))
3187         base_offset = 0;
3188       else
3189         base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3190       v = value_struct_elt_for_reference (domain,
3191                                           offset + base_offset,
3192                                           TYPE_BASECLASS (t, i),
3193                                           name,
3194                                           intype);
3195       if (v)
3196         return v;
3197     }
3198   return 0;
3199 }
3200
3201
3202 /* Find the real run-time type of a value using RTTI.
3203  * V is a pointer to the value.
3204  * A pointer to the struct type entry of the run-time type
3205  * is returneed.
3206  * FULL is a flag that is set only if the value V includes
3207  * the entire contents of an object of the RTTI type.
3208  * TOP is the offset to the top of the enclosing object of
3209  * the real run-time type.  This offset may be for the embedded
3210  * object, or for the enclosing object of V.
3211  * USING_ENC is the flag that distinguishes the two cases.
3212  * If it is 1, then the offset is for the enclosing object,
3213  * otherwise for the embedded object.
3214  *
3215  */
3216
3217 struct type *
3218 value_rtti_type (v, full, top, using_enc)
3219      value_ptr v;
3220      int *full;
3221      int *top;
3222      int *using_enc;
3223 {
3224   struct type *known_type;
3225   struct type *rtti_type;
3226   CORE_ADDR coreptr;
3227   value_ptr vp;
3228   int using_enclosing = 0;
3229   long top_offset = 0;
3230   char rtti_type_name[256];
3231
3232   if (full)
3233     *full = 0;
3234   if (top)
3235     *top = -1;
3236   if (using_enc)
3237     *using_enc = 0;
3238
3239   /* Get declared type */
3240   known_type = VALUE_TYPE (v);
3241   CHECK_TYPEDEF (known_type);
3242   /* RTTI works only or class objects */
3243   if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
3244     return NULL;
3245   if (TYPE_HAS_VTABLE(known_type))
3246     {
3247       /* If neither the declared type nor the enclosing type of the
3248        * value structure has a HP ANSI C++ style virtual table,
3249        * we can't do anything. */
3250       if (!TYPE_HAS_VTABLE (known_type))
3251         {
3252           known_type = VALUE_ENCLOSING_TYPE (v);
3253           CHECK_TYPEDEF (known_type);
3254           if ((TYPE_CODE (known_type) != TYPE_CODE_CLASS) ||
3255               !TYPE_HAS_VTABLE (known_type))
3256             return NULL;                /* No RTTI, or not HP-compiled types */
3257           CHECK_TYPEDEF (known_type);
3258           using_enclosing = 1;
3259         }
3260
3261       if (using_enclosing && using_enc)
3262         *using_enc = 1;
3263
3264       /* First get the virtual table address */
3265       coreptr = *(CORE_ADDR *) ((VALUE_CONTENTS_ALL (v))
3266                                 + VALUE_OFFSET (v)
3267                                 + (using_enclosing ? 0 : VALUE_EMBEDDED_OFFSET (v)));
3268       if (coreptr == 0)
3269         return NULL;            /* return silently -- maybe called on gdb-generated value */
3270
3271       /* Fetch the top offset of the object */
3272       /* FIXME possible 32x64 problem with pointer size & arithmetic */
3273       vp = value_at (builtin_type_int,
3274                      coreptr + 4 * HP_ACC_TOP_OFFSET_OFFSET,
3275                      VALUE_BFD_SECTION (v));
3276       top_offset = value_as_long (vp);
3277       if (top)
3278         *top = top_offset;
3279
3280       /* Fetch the typeinfo pointer */
3281       /* FIXME possible 32x64 problem with pointer size & arithmetic */
3282       vp = value_at (builtin_type_int, coreptr + 4 * HP_ACC_TYPEINFO_OFFSET, VALUE_BFD_SECTION (v));
3283       /* Indirect through the typeinfo pointer and retrieve the pointer
3284        * to the string name */
3285       coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
3286       if (!coreptr)
3287         error ("Retrieved null typeinfo pointer in trying to determine run-time type");
3288       vp = value_at (builtin_type_int, coreptr + 4, VALUE_BFD_SECTION (v));             /* 4 -> offset of name field */
3289       /* FIXME possible 32x64 problem */
3290
3291       coreptr = *(CORE_ADDR *) (VALUE_CONTENTS (vp));
3292
3293       read_memory_string (coreptr, rtti_type_name, 256);
3294
3295       if (strlen (rtti_type_name) == 0)
3296         error ("Retrieved null type name from typeinfo");
3297
3298       /* search for type */
3299       rtti_type = lookup_typename (rtti_type_name, (struct block *) 0, 1);
3300
3301       if (!rtti_type)
3302         error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name);
3303       CHECK_TYPEDEF (rtti_type);
3304 #if 0
3305       printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1);
3306 #endif
3307       /* Check whether we have the entire object */
3308       if (full                  /* Non-null pointer passed */
3309           &&
3310           /* Either we checked on the whole object in hand and found the
3311              top offset to be zero */
3312           (((top_offset == 0) &&
3313             using_enclosing &&
3314             TYPE_LENGTH (known_type) == TYPE_LENGTH (rtti_type))
3315            ||
3316            /* Or we checked on the embedded object and top offset was the
3317               same as the embedded offset */
3318            ((top_offset == VALUE_EMBEDDED_OFFSET (v)) &&
3319             !using_enclosing &&
3320             TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type))))
3321
3322         *full = 1;
3323     }
3324   else
3325     /*
3326       Right now this is G++ RTTI. Plan on this changing in the
3327       future as i get around to setting the vtables properly for G++
3328       compiled stuff. Also, i'll be using the type info functions,
3329       which are always right. Deal with it until then.
3330     */
3331     {
3332       CORE_ADDR vtbl;
3333       struct minimal_symbol *minsym;
3334       struct symbol *sym;
3335       char *demangled_name;
3336       struct type *btype;
3337       /* If the type has no vptr fieldno, try to get it filled in */
3338       if (TYPE_VPTR_FIELDNO(known_type) < 0)
3339         fill_in_vptr_fieldno(known_type);
3340
3341       /* If we still can't find one, give up */
3342       if (TYPE_VPTR_FIELDNO(known_type) < 0)
3343         return NULL;
3344
3345       /* Make sure our basetype and known type match, otherwise, cast
3346          so we can get at the vtable properly.
3347       */
3348       btype = TYPE_VPTR_BASETYPE (known_type);
3349       CHECK_TYPEDEF (btype);
3350       if (btype != known_type )
3351         {
3352           v = value_cast (btype, v);
3353           if (using_enc)
3354             *using_enc=1;
3355         }
3356       /*
3357         We can't use value_ind here, because it would want to use RTTI, and
3358         we'd waste a bunch of time figuring out we already know the type.
3359         Besides, we don't care about the type, just the actual pointer
3360       */
3361       if (VALUE_ADDRESS(value_field(v,TYPE_VPTR_FIELDNO(known_type))) == NULL)
3362         return NULL;
3363
3364       /*
3365          If we are enclosed by something that isn't us, adjust the
3366          address properly and set using_enclosing.
3367       */
3368       if (VALUE_ENCLOSING_TYPE(v) != VALUE_TYPE(v))
3369         {
3370           value_ptr tempval;
3371           tempval=value_field(v,TYPE_VPTR_FIELDNO(known_type));
3372           VALUE_ADDRESS(tempval)+=(TYPE_BASECLASS_BITPOS(known_type,TYPE_VPTR_FIELDNO(known_type))/8);
3373           vtbl=value_as_pointer(tempval);
3374           using_enclosing=1;
3375         }
3376       else
3377         {
3378           vtbl=value_as_pointer(value_field(v,TYPE_VPTR_FIELDNO(known_type)));
3379           using_enclosing=0;
3380         }
3381
3382       /* Try to find a symbol that is the vtable */
3383       minsym=lookup_minimal_symbol_by_pc(vtbl);
3384       if (minsym==NULL || (demangled_name=SYMBOL_NAME(minsym))==NULL || !VTBL_PREFIX_P(demangled_name))
3385         return NULL;
3386
3387       /* If we just skip the prefix, we get screwed by namespaces */
3388       demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI);
3389       *(strchr(demangled_name,' '))=0;
3390
3391       /* Lookup the type for the name */
3392       rtti_type=lookup_typename(demangled_name, (struct block *)0,1);
3393
3394       if (rtti_type==NULL)
3395         return NULL;
3396
3397       if (TYPE_N_BASECLASSES(rtti_type) > 1 &&  full && (*full) != 1)
3398         {
3399           if (top)
3400             *top=TYPE_BASECLASS_BITPOS(rtti_type,TYPE_VPTR_FIELDNO(rtti_type))/8;
3401           if (top && ((*top) >0))
3402             {
3403               if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
3404                 {
3405                   if (full)
3406                     *full=0;
3407                 }
3408               else
3409                 {
3410                   if (full)
3411                     *full=1;
3412                 }
3413             }
3414         }
3415       else
3416         {
3417           if (full)
3418             *full=1;
3419         }
3420       if (using_enc)
3421         *using_enc=using_enclosing;
3422     }
3423   return rtti_type;
3424 }
3425
3426 /* Given a pointer value V, find the real (RTTI) type
3427    of the object it points to.
3428    Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3429    and refer to the values computed for the object pointed to. */
3430
3431 struct type *
3432 value_rtti_target_type (v, full, top, using_enc)
3433      value_ptr v;
3434      int *full;
3435      int *top;
3436      int *using_enc;
3437 {
3438   value_ptr target;
3439
3440   target = value_ind (v);
3441
3442   return value_rtti_type (target, full, top, using_enc);
3443 }
3444
3445 /* Given a value pointed to by ARGP, check its real run-time type, and
3446    if that is different from the enclosing type, create a new value
3447    using the real run-time type as the enclosing type (and of the same
3448    type as ARGP) and return it, with the embedded offset adjusted to
3449    be the correct offset to the enclosed object
3450    RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3451    parameters, computed by value_rtti_type(). If these are available,
3452    they can be supplied and a second call to value_rtti_type() is avoided.
3453    (Pass RTYPE == NULL if they're not available */
3454
3455 value_ptr
3456 value_full_object (argp, rtype, xfull, xtop, xusing_enc)
3457      value_ptr argp;
3458      struct type *rtype;
3459      int xfull;
3460      int xtop;
3461      int xusing_enc;
3462
3463 {
3464   struct type *real_type;
3465   int full = 0;
3466   int top = -1;
3467   int using_enc = 0;
3468   value_ptr new_val;
3469
3470   if (rtype)
3471     {
3472       real_type = rtype;
3473       full = xfull;
3474       top = xtop;
3475       using_enc = xusing_enc;
3476     }
3477   else
3478     real_type = value_rtti_type (argp, &full, &top, &using_enc);
3479
3480   /* If no RTTI data, or if object is already complete, do nothing */
3481   if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
3482     return argp;
3483
3484   /* If we have the full object, but for some reason the enclosing
3485      type is wrong, set it *//* pai: FIXME -- sounds iffy */
3486   if (full)
3487     {
3488       VALUE_ENCLOSING_TYPE (argp) = real_type;
3489       return argp;
3490     }
3491
3492   /* Check if object is in memory */
3493   if (VALUE_LVAL (argp) != lval_memory)
3494     {
3495       warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
3496
3497       return argp;
3498     }
3499
3500   /* All other cases -- retrieve the complete object */
3501   /* Go back by the computed top_offset from the beginning of the object,
3502      adjusting for the embedded offset of argp if that's what value_rtti_type
3503      used for its computation. */
3504   new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
3505                            (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
3506                            VALUE_BFD_SECTION (argp));
3507   VALUE_TYPE (new_val) = VALUE_TYPE (argp);
3508   VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
3509   return new_val;
3510 }
3511
3512
3513
3514
3515 /* C++: return the value of the class instance variable, if one exists.
3516    Flag COMPLAIN signals an error if the request is made in an
3517    inappropriate context.  */
3518
3519 value_ptr
3520 value_of_this (complain)
3521      int complain;
3522 {
3523   struct symbol *func, *sym;
3524   struct block *b;
3525   int i;
3526   static const char funny_this[] = "this";
3527   value_ptr this;
3528
3529   if (selected_frame == 0)
3530     {
3531       if (complain)
3532         error ("no frame selected");
3533       else
3534         return 0;
3535     }
3536
3537   func = get_frame_function (selected_frame);
3538   if (!func)
3539     {
3540       if (complain)
3541         error ("no `this' in nameless context");
3542       else
3543         return 0;
3544     }
3545
3546   b = SYMBOL_BLOCK_VALUE (func);
3547   i = BLOCK_NSYMS (b);
3548   if (i <= 0)
3549     {
3550       if (complain)
3551         error ("no args, no `this'");
3552       else
3553         return 0;
3554     }
3555
3556   /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3557      symbol instead of the LOC_ARG one (if both exist).  */
3558   sym = lookup_block_symbol (b, funny_this, VAR_NAMESPACE);
3559   if (sym == NULL)
3560     {
3561       if (complain)
3562         error ("current stack frame not in method");
3563       else
3564         return NULL;
3565     }
3566
3567   this = read_var_value (sym, selected_frame);
3568   if (this == 0 && complain)
3569     error ("`this' argument at unknown address");
3570   return this;
3571 }
3572
3573 /* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3574    long, starting at LOWBOUND.  The result has the same lower bound as
3575    the original ARRAY.  */
3576
3577 value_ptr
3578 value_slice (array, lowbound, length)
3579      value_ptr array;
3580      int lowbound, length;
3581 {
3582   struct type *slice_range_type, *slice_type, *range_type;
3583   LONGEST lowerbound, upperbound, offset;
3584   value_ptr slice;
3585   struct type *array_type;
3586   array_type = check_typedef (VALUE_TYPE (array));
3587   COERCE_VARYING_ARRAY (array, array_type);
3588   if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3589       && TYPE_CODE (array_type) != TYPE_CODE_STRING
3590       && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
3591     error ("cannot take slice of non-array");
3592   range_type = TYPE_INDEX_TYPE (array_type);
3593   if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3594     error ("slice from bad array or bitstring");
3595   if (lowbound < lowerbound || length < 0
3596       || lowbound + length - 1 > upperbound
3597   /* Chill allows zero-length strings but not arrays. */
3598       || (current_language->la_language == language_chill
3599           && length == 0 && TYPE_CODE (array_type) == TYPE_CODE_ARRAY))
3600     error ("slice out of range");
3601   /* FIXME-type-allocation: need a way to free this type when we are
3602      done with it.  */
3603   slice_range_type = create_range_type ((struct type *) NULL,
3604                                         TYPE_TARGET_TYPE (range_type),
3605                                         lowbound, lowbound + length - 1);
3606   if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
3607     {
3608       int i;
3609       slice_type = create_set_type ((struct type *) NULL, slice_range_type);
3610       TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
3611       slice = value_zero (slice_type, not_lval);
3612       for (i = 0; i < length; i++)
3613         {
3614           int element = value_bit_index (array_type,
3615                                          VALUE_CONTENTS (array),
3616                                          lowbound + i);
3617           if (element < 0)
3618             error ("internal error accessing bitstring");
3619           else if (element > 0)
3620             {
3621               int j = i % TARGET_CHAR_BIT;
3622               if (BITS_BIG_ENDIAN)
3623                 j = TARGET_CHAR_BIT - 1 - j;
3624               VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
3625             }
3626         }
3627       /* We should set the address, bitssize, and bitspos, so the clice
3628          can be used on the LHS, but that may require extensions to
3629          value_assign.  For now, just leave as a non_lval.  FIXME.  */
3630     }
3631   else
3632     {
3633       struct type *element_type = TYPE_TARGET_TYPE (array_type);
3634       offset
3635         = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3636       slice_type = create_array_type ((struct type *) NULL, element_type,
3637                                       slice_range_type);
3638       TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3639       slice = allocate_value (slice_type);
3640       if (VALUE_LAZY (array))
3641         VALUE_LAZY (slice) = 1;
3642       else
3643         memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
3644                 TYPE_LENGTH (slice_type));
3645       if (VALUE_LVAL (array) == lval_internalvar)
3646         VALUE_LVAL (slice) = lval_internalvar_component;
3647       else
3648         VALUE_LVAL (slice) = VALUE_LVAL (array);
3649       VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
3650       VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
3651     }
3652   return slice;
3653 }
3654
3655 /* Assuming chill_varying_type (VARRAY) is true, return an equivalent
3656    value as a fixed-length array. */
3657
3658 value_ptr
3659 varying_to_slice (varray)
3660      value_ptr varray;
3661 {
3662   struct type *vtype = check_typedef (VALUE_TYPE (varray));
3663   LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
3664                                 VALUE_CONTENTS (varray)
3665                                 + TYPE_FIELD_BITPOS (vtype, 0) / 8);
3666   return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
3667 }
3668
3669 /* Create a value for a FORTRAN complex number.  Currently most of
3670    the time values are coerced to COMPLEX*16 (i.e. a complex number
3671    composed of 2 doubles.  This really should be a smarter routine
3672    that figures out precision inteligently as opposed to assuming
3673    doubles. FIXME: fmb */
3674
3675 value_ptr
3676 value_literal_complex (arg1, arg2, type)
3677      value_ptr arg1;
3678      value_ptr arg2;
3679      struct type *type;
3680 {
3681   register value_ptr val;
3682   struct type *real_type = TYPE_TARGET_TYPE (type);
3683
3684   val = allocate_value (type);
3685   arg1 = value_cast (real_type, arg1);
3686   arg2 = value_cast (real_type, arg2);
3687
3688   memcpy (VALUE_CONTENTS_RAW (val),
3689           VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
3690   memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
3691           VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
3692   return val;
3693 }
3694
3695 /* Cast a value into the appropriate complex data type. */
3696
3697 static value_ptr
3698 cast_into_complex (type, val)
3699      struct type *type;
3700      register value_ptr val;
3701 {
3702   struct type *real_type = TYPE_TARGET_TYPE (type);
3703   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
3704     {
3705       struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
3706       value_ptr re_val = allocate_value (val_real_type);
3707       value_ptr im_val = allocate_value (val_real_type);
3708
3709       memcpy (VALUE_CONTENTS_RAW (re_val),
3710               VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
3711       memcpy (VALUE_CONTENTS_RAW (im_val),
3712               VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
3713               TYPE_LENGTH (val_real_type));
3714
3715       return value_literal_complex (re_val, im_val, type);
3716     }
3717   else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
3718            || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
3719     return value_literal_complex (val, value_zero (real_type, not_lval), type);
3720   else
3721     error ("cannot cast non-number to complex");
3722 }
3723
3724 void
3725 _initialize_valops ()
3726 {
3727 #if 0
3728   add_show_from_set
3729     (add_set_cmd ("abandon", class_support, var_boolean, (char *) &auto_abandon,
3730                   "Set automatic abandonment of expressions upon failure.",
3731                   &setlist),
3732      &showlist);
3733 #endif
3734
3735   add_show_from_set
3736     (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *) &overload_resolution,
3737                   "Set overload resolution in evaluating C++ functions.",
3738                   &setlist),
3739      &showlist);
3740   overload_resolution = 1;
3741
3742   add_show_from_set (
3743   add_set_cmd ("unwindonsignal", no_class, var_boolean,
3744                (char *) &unwind_on_signal_p,
3745 "Set unwinding of stack if a signal is received while in a call dummy.\n\
3746 The unwindonsignal lets the user determine what gdb should do if a signal\n\
3747 is received while in a function called from gdb (call dummy).  If set, gdb\n\
3748 unwinds the stack and restore the context to what as it was before the call.\n\
3749 The default is to stop in the frame where the signal was received.", &setlist),
3750                      &showlist);
3751 }