gdb/eval.c

   1 /* Evaluate expressions for GDB.
   2
   3    Copyright (C) 1986-2014 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "value.h"
  24 #include "expression.h"
  25 #include "target.h"
  26 #include "frame.h"
  27 #include "language.h"           /* For CAST_IS_CONVERSION.  */
  28 #include "f-lang.h"             /* For array bound stuff.  */
  29 #include "cp-abi.h"
  30 #include "infcall.h"
  31 #include "objc-lang.h"
  32 #include "block.h"
  33 #include "parser-defs.h"
  34 #include "cp-support.h"
  35 #include "ui-out.h"
  36 #include "regcache.h"
  37 #include "user-regs.h"
  38 #include "valprint.h"
  39 #include "gdb_obstack.h"
  40 #include "objfiles.h"
  41 #include <ctype.h>
  42
  43 /* This is defined in valops.c */
  44 extern int overload_resolution;
  45
  46 /* Prototypes for local functions.  */
  47
  48 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *,
  49                                                  enum noside);
  50
  51 static struct value *evaluate_subexp_for_address (struct expression *,
  52                                                   int *, enum noside);
  53
  54 static struct value *evaluate_struct_tuple (struct value *,
  55                                             struct expression *, int *,
  56                                             enum noside, int);
  57
  58 static LONGEST init_array_element (struct value *, struct value *,
  59                                    struct expression *, int *, enum noside,
  60                                    LONGEST, LONGEST);
  61
  62 struct value *
  63 evaluate_subexp (struct type *expect_type, struct expression *exp,
  64                  int *pos, enum noside noside)
  65 {
  66   return (*exp->language_defn->la_exp_desc->evaluate_exp)
  67     (expect_type, exp, pos, noside);
  68 }
  69 \f
  70 /* Parse the string EXP as a C expression, evaluate it,
  71    and return the result as a number.  */
  72
  73 CORE_ADDR
  74 parse_and_eval_address (const char *exp)
  75 {
  76   struct expression *expr = parse_expression (exp);
  77   CORE_ADDR addr;
  78   struct cleanup *old_chain =
  79     make_cleanup (free_current_contents, &expr);
  80
  81   addr = value_as_address (evaluate_expression (expr));
  82   do_cleanups (old_chain);
  83   return addr;
  84 }
  85
  86 /* Like parse_and_eval_address, but treats the value of the expression
  87    as an integer, not an address, returns a LONGEST, not a CORE_ADDR.  */
  88 LONGEST
  89 parse_and_eval_long (const char *exp)
  90 {
  91   struct expression *expr = parse_expression (exp);
  92   LONGEST retval;
  93   struct cleanup *old_chain =
  94     make_cleanup (free_current_contents, &expr);
  95
  96   retval = value_as_long (evaluate_expression (expr));
  97   do_cleanups (old_chain);
  98   return (retval);
  99 }
 100
 101 struct value *
 102 parse_and_eval (const char *exp)
 103 {
 104   struct expression *expr = parse_expression (exp);
 105   struct value *val;
 106   struct cleanup *old_chain =
 107     make_cleanup (free_current_contents, &expr);
 108
 109   val = evaluate_expression (expr);
 110   do_cleanups (old_chain);
 111   return val;
 112 }
 113
 114 /* Parse up to a comma (or to a closeparen)
 115    in the string EXPP as an expression, evaluate it, and return the value.
 116    EXPP is advanced to point to the comma.  */
 117
 118 struct value *
 119 parse_to_comma_and_eval (const char **expp)
 120 {
 121   struct expression *expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
 122   struct value *val;
 123   struct cleanup *old_chain =
 124     make_cleanup (free_current_contents, &expr);
 125
 126   val = evaluate_expression (expr);
 127   do_cleanups (old_chain);
 128   return val;
 129 }
 130 \f
 131 /* Evaluate an expression in internal prefix form
 132    such as is constructed by parse.y.
 133
 134    See expression.h for info on the format of an expression.  */
 135
 136 struct value *
 137 evaluate_expression (struct expression *exp)
 138 {
 139   int pc = 0;
 140
 141   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
 142 }
 143
 144 /* Evaluate an expression, avoiding all memory references
 145    and getting a value whose type alone is correct.  */
 146
 147 struct value *
 148 evaluate_type (struct expression *exp)
 149 {
 150   int pc = 0;
 151
 152   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
 153 }
 154
 155 /* Evaluate a subexpression, avoiding all memory references and
 156    getting a value whose type alone is correct.  */
 157
 158 struct value *
 159 evaluate_subexpression_type (struct expression *exp, int subexp)
 160 {
 161   return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
 162 }
 163
 164 /* Find the current value of a watchpoint on EXP.  Return the value in
 165    *VALP and *RESULTP and the chain of intermediate and final values
 166    in *VAL_CHAIN.  RESULTP and VAL_CHAIN may be NULL if the caller does
 167    not need them.
 168
 169    If PRESERVE_ERRORS is true, then exceptions are passed through.
 170    Otherwise, if PRESERVE_ERRORS is false, then if a memory error
 171    occurs while evaluating the expression, *RESULTP will be set to
 172    NULL.  *RESULTP may be a lazy value, if the result could not be
 173    read from memory.  It is used to determine whether a value is
 174    user-specified (we should watch the whole value) or intermediate
 175    (we should watch only the bit used to locate the final value).
 176
 177    If the final value, or any intermediate value, could not be read
 178    from memory, *VALP will be set to NULL.  *VAL_CHAIN will still be
 179    set to any referenced values.  *VALP will never be a lazy value.
 180    This is the value which we store in struct breakpoint.
 181
 182    If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
 183    value chain.  The caller must free the values individually.  If
 184    VAL_CHAIN is NULL, all generated values will be left on the value
 185    chain.  */
 186
 187 void
 188 fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
 189                     struct value **resultp, struct value **val_chain,
 190                     int preserve_errors)
 191 {
 192   struct value *mark, *new_mark, *result;
 193   volatile struct gdb_exception ex;
 194
 195   *valp = NULL;
 196   if (resultp)
 197     *resultp = NULL;
 198   if (val_chain)
 199     *val_chain = NULL;
 200
 201   /* Evaluate the expression.  */
 202   mark = value_mark ();
 203   result = NULL;
 204
 205   TRY_CATCH (ex, RETURN_MASK_ALL)
 206     {
 207       result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
 208     }
 209   if (ex.reason < 0)
 210     {
 211       /* Ignore memory errors if we want watchpoints pointing at
 212          inaccessible memory to still be created; otherwise, throw the
 213          error to some higher catcher.  */
 214       switch (ex.error)
 215         {
 216         case MEMORY_ERROR:
 217           if (!preserve_errors)
 218             break;
 219         default:
 220           throw_exception (ex);
 221           break;
 222         }
 223     }
 224
 225   new_mark = value_mark ();
 226   if (mark == new_mark)
 227     return;
 228   if (resultp)
 229     *resultp = result;
 230
 231   /* Make sure it's not lazy, so that after the target stops again we
 232      have a non-lazy previous value to compare with.  */
 233   if (result != NULL)
 234     {
 235       if (!value_lazy (result))
 236         *valp = result;
 237       else
 238         {
 239           volatile struct gdb_exception except;
 240
 241           TRY_CATCH (except, RETURN_MASK_ERROR)
 242             {
 243               value_fetch_lazy (result);
 244               *valp = result;
 245             }
 246         }
 247     }
 248
 249   if (val_chain)
 250     {
 251       /* Return the chain of intermediate values.  We use this to
 252          decide which addresses to watch.  */
 253       *val_chain = new_mark;
 254       value_release_to_mark (mark);
 255     }
 256 }
 257
 258 /* Extract a field operation from an expression.  If the subexpression
 259    of EXP starting at *SUBEXP is not a structure dereference
 260    operation, return NULL.  Otherwise, return the name of the
 261    dereferenced field, and advance *SUBEXP to point to the
 262    subexpression of the left-hand-side of the dereference.  This is
 263    used when completing field names.  */
 264
 265 char *
 266 extract_field_op (struct expression *exp, int *subexp)
 267 {
 268   int tem;
 269   char *result;
 270
 271   if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
 272       && exp->elts[*subexp].opcode != STRUCTOP_PTR)
 273     return NULL;
 274   tem = longest_to_int (exp->elts[*subexp + 1].longconst);
 275   result = &exp->elts[*subexp + 2].string;
 276   (*subexp) += 1 + 3 + BYTES_TO_EXP_ELEM (tem + 1);
 277   return result;
 278 }
 279
 280 /* This function evaluates brace-initializers (in C/C++) for
 281    structure types.  */
 282
 283 static struct value *
 284 evaluate_struct_tuple (struct value *struct_val,
 285                        struct expression *exp,
 286                        int *pos, enum noside noside, int nargs)
 287 {
 288   struct type *struct_type = check_typedef (value_type (struct_val));
 289   struct type *field_type;
 290   int fieldno = -1;
 291
 292   while (--nargs >= 0)
 293     {
 294       struct value *val = NULL;
 295       int bitpos, bitsize;
 296       bfd_byte *addr;
 297
 298       fieldno++;
 299       /* Skip static fields.  */
 300       while (fieldno < TYPE_NFIELDS (struct_type)
 301              && field_is_static (&TYPE_FIELD (struct_type,
 302                                               fieldno)))
 303         fieldno++;
 304       if (fieldno >= TYPE_NFIELDS (struct_type))
 305         error (_("too many initializers"));
 306       field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
 307       if (TYPE_CODE (field_type) == TYPE_CODE_UNION
 308           && TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
 309         error (_("don't know which variant you want to set"));
 310
 311       /* Here, struct_type is the type of the inner struct,
 312          while substruct_type is the type of the inner struct.
 313          These are the same for normal structures, but a variant struct
 314          contains anonymous union fields that contain substruct fields.
 315          The value fieldno is the index of the top-level (normal or
 316          anonymous union) field in struct_field, while the value
 317          subfieldno is the index of the actual real (named inner) field
 318          in substruct_type.  */
 319
 320       field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
 321       if (val == 0)
 322         val = evaluate_subexp (field_type, exp, pos, noside);
 323
 324       /* Now actually set the field in struct_val.  */
 325
 326       /* Assign val to field fieldno.  */
 327       if (value_type (val) != field_type)
 328         val = value_cast (field_type, val);
 329
 330       bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
 331       bitpos = TYPE_FIELD_BITPOS (struct_type, fieldno);
 332       addr = value_contents_writeable (struct_val) + bitpos / 8;
 333       if (bitsize)
 334         modify_field (struct_type, addr,
 335                       value_as_long (val), bitpos % 8, bitsize);
 336       else
 337         memcpy (addr, value_contents (val),
 338                 TYPE_LENGTH (value_type (val)));
 339
 340     }
 341   return struct_val;
 342 }
 343
 344 /* Recursive helper function for setting elements of array tuples.
 345    The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
 346    element value is ELEMENT; EXP, POS and NOSIDE are as usual.
 347    Evaluates index expresions and sets the specified element(s) of
 348    ARRAY to ELEMENT.  Returns last index value.  */
 349
 350 static LONGEST
 351 init_array_element (struct value *array, struct value *element,
 352                     struct expression *exp, int *pos,
 353                     enum noside noside, LONGEST low_bound, LONGEST high_bound)
 354 {
 355   LONGEST index;
 356   int element_size = TYPE_LENGTH (value_type (element));
 357
 358   if (exp->elts[*pos].opcode == BINOP_COMMA)
 359     {
 360       (*pos)++;
 361       init_array_element (array, element, exp, pos, noside,
 362                           low_bound, high_bound);
 363       return init_array_element (array, element,
 364                                  exp, pos, noside, low_bound, high_bound);
 365     }
 366   else
 367     {
 368       index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 369       if (index < low_bound || index > high_bound)
 370         error (_("tuple index out of range"));
 371       memcpy (value_contents_raw (array) + (index - low_bound) * element_size,
 372               value_contents (element), element_size);
 373     }
 374   return index;
 375 }
 376
 377 static struct value *
 378 value_f90_subarray (struct value *array,
 379                     struct expression *exp, int *pos, enum noside noside)
 380 {
 381   int pc = (*pos) + 1;
 382   LONGEST low_bound, high_bound;
 383   struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));
 384   enum f90_range_type range_type = longest_to_int (exp->elts[pc].longconst);
 385
 386   *pos += 3;
 387
 388   if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
 389     low_bound = TYPE_LOW_BOUND (range);
 390   else
 391     low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 392
 393   if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)
 394     high_bound = TYPE_HIGH_BOUND (range);
 395   else
 396     high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 397
 398   return value_slice (array, low_bound, high_bound - low_bound + 1);
 399 }
 400
 401
 402 /* Promote value ARG1 as appropriate before performing a unary operation
 403    on this argument.
 404    If the result is not appropriate for any particular language then it
 405    needs to patch this function.  */
 406
 407 void
 408 unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
 409               struct value **arg1)
 410 {
 411   struct type *type1;
 412
 413   *arg1 = coerce_ref (*arg1);
 414   type1 = check_typedef (value_type (*arg1));
 415
 416   if (is_integral_type (type1))
 417     {
 418       switch (language->la_language)
 419         {
 420         default:
 421           /* Perform integral promotion for ANSI C/C++.
 422              If not appropropriate for any particular language
 423              it needs to modify this function.  */
 424           {
 425             struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
 426
 427             if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
 428               *arg1 = value_cast (builtin_int, *arg1);
 429           }
 430           break;
 431         }
 432     }
 433 }
 434
 435 /* Promote values ARG1 and ARG2 as appropriate before performing a binary
 436    operation on those two operands.
 437    If the result is not appropriate for any particular language then it
 438    needs to patch this function.  */
 439
 440 void
 441 binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
 442                struct value **arg1, struct value **arg2)
 443 {
 444   struct type *promoted_type = NULL;
 445   struct type *type1;
 446   struct type *type2;
 447
 448   *arg1 = coerce_ref (*arg1);
 449   *arg2 = coerce_ref (*arg2);
 450
 451   type1 = check_typedef (value_type (*arg1));
 452   type2 = check_typedef (value_type (*arg2));
 453
 454   if ((TYPE_CODE (type1) != TYPE_CODE_FLT
 455        && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
 456        && !is_integral_type (type1))
 457       || (TYPE_CODE (type2) != TYPE_CODE_FLT
 458           && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
 459           && !is_integral_type (type2)))
 460     return;
 461
 462   if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
 463       || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
 464     {
 465       /* No promotion required.  */
 466     }
 467   else if (TYPE_CODE (type1) == TYPE_CODE_FLT
 468            || TYPE_CODE (type2) == TYPE_CODE_FLT)
 469     {
 470       switch (language->la_language)
 471         {
 472         case language_c:
 473         case language_cplus:
 474         case language_asm:
 475         case language_objc:
 476         case language_opencl:
 477           /* No promotion required.  */
 478           break;
 479
 480         default:
 481           /* For other languages the result type is unchanged from gdb
 482              version 6.7 for backward compatibility.
 483              If either arg was long double, make sure that value is also long
 484              double.  Otherwise use double.  */
 485           if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (gdbarch)
 486               || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (gdbarch))
 487             promoted_type = builtin_type (gdbarch)->builtin_long_double;
 488           else
 489             promoted_type = builtin_type (gdbarch)->builtin_double;
 490           break;
 491         }
 492     }
 493   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
 494            && TYPE_CODE (type2) == TYPE_CODE_BOOL)
 495     {
 496       /* No promotion required.  */
 497     }
 498   else
 499     /* Integral operations here.  */
 500     /* FIXME: Also mixed integral/booleans, with result an integer.  */
 501     {
 502       const struct builtin_type *builtin = builtin_type (gdbarch);
 503       unsigned int promoted_len1 = TYPE_LENGTH (type1);
 504       unsigned int promoted_len2 = TYPE_LENGTH (type2);
 505       int is_unsigned1 = TYPE_UNSIGNED (type1);
 506       int is_unsigned2 = TYPE_UNSIGNED (type2);
 507       unsigned int result_len;
 508       int unsigned_operation;
 509
 510       /* Determine type length and signedness after promotion for
 511          both operands.  */
 512       if (promoted_len1 < TYPE_LENGTH (builtin->builtin_int))
 513         {
 514           is_unsigned1 = 0;
 515           promoted_len1 = TYPE_LENGTH (builtin->builtin_int);
 516         }
 517       if (promoted_len2 < TYPE_LENGTH (builtin->builtin_int))
 518         {
 519           is_unsigned2 = 0;
 520           promoted_len2 = TYPE_LENGTH (builtin->builtin_int);
 521         }
 522
 523       if (promoted_len1 > promoted_len2)
 524         {
 525           unsigned_operation = is_unsigned1;
 526           result_len = promoted_len1;
 527         }
 528       else if (promoted_len2 > promoted_len1)
 529         {
 530           unsigned_operation = is_unsigned2;
 531           result_len = promoted_len2;
 532         }
 533       else
 534         {
 535           unsigned_operation = is_unsigned1 || is_unsigned2;
 536           result_len = promoted_len1;
 537         }
 538
 539       switch (language->la_language)
 540         {
 541         case language_c:
 542         case language_cplus:
 543         case language_asm:
 544         case language_objc:
 545           if (result_len <= TYPE_LENGTH (builtin->builtin_int))
 546             {
 547               promoted_type = (unsigned_operation
 548                                ? builtin->builtin_unsigned_int
 549                                : builtin->builtin_int);
 550             }
 551           else if (result_len <= TYPE_LENGTH (builtin->builtin_long))
 552             {
 553               promoted_type = (unsigned_operation
 554                                ? builtin->builtin_unsigned_long
 555                                : builtin->builtin_long);
 556             }
 557           else
 558             {
 559               promoted_type = (unsigned_operation
 560                                ? builtin->builtin_unsigned_long_long
 561                                : builtin->builtin_long_long);
 562             }
 563           break;
 564         case language_opencl:
 565           if (result_len <= TYPE_LENGTH (lookup_signed_typename
 566                                          (language, gdbarch, "int")))
 567             {
 568               promoted_type =
 569                 (unsigned_operation
 570                  ? lookup_unsigned_typename (language, gdbarch, "int")
 571                  : lookup_signed_typename (language, gdbarch, "int"));
 572             }
 573           else if (result_len <= TYPE_LENGTH (lookup_signed_typename
 574                                               (language, gdbarch, "long")))
 575             {
 576               promoted_type =
 577                 (unsigned_operation
 578                  ? lookup_unsigned_typename (language, gdbarch, "long")
 579                  : lookup_signed_typename (language, gdbarch,"long"));
 580             }
 581           break;
 582         default:
 583           /* For other languages the result type is unchanged from gdb
 584              version 6.7 for backward compatibility.
 585              If either arg was long long, make sure that value is also long
 586              long.  Otherwise use long.  */
 587           if (unsigned_operation)
 588             {
 589               if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
 590                 promoted_type = builtin->builtin_unsigned_long_long;
 591               else
 592                 promoted_type = builtin->builtin_unsigned_long;
 593             }
 594           else
 595             {
 596               if (result_len > gdbarch_long_bit (gdbarch) / HOST_CHAR_BIT)
 597                 promoted_type = builtin->builtin_long_long;
 598               else
 599                 promoted_type = builtin->builtin_long;
 600             }
 601           break;
 602         }
 603     }
 604
 605   if (promoted_type)
 606     {
 607       /* Promote both operands to common type.  */
 608       *arg1 = value_cast (promoted_type, *arg1);
 609       *arg2 = value_cast (promoted_type, *arg2);
 610     }
 611 }
 612
 613 static int
 614 ptrmath_type_p (const struct language_defn *lang, struct type *type)
 615 {
 616   type = check_typedef (type);
 617   if (TYPE_CODE (type) == TYPE_CODE_REF)
 618     type = TYPE_TARGET_TYPE (type);
 619
 620   switch (TYPE_CODE (type))
 621     {
 622     case TYPE_CODE_PTR:
 623     case TYPE_CODE_FUNC:
 624       return 1;
 625
 626     case TYPE_CODE_ARRAY:
 627       return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;
 628
 629     default:
 630       return 0;
 631     }
 632 }
 633
 634 /* Constructs a fake method with the given parameter types.
 635    This function is used by the parser to construct an "expected"
 636    type for method overload resolution.  */
 637
 638 static struct type *
 639 make_params (int num_types, struct type **param_types)
 640 {
 641   struct type *type = XCNEW (struct type);
 642   TYPE_MAIN_TYPE (type) = XCNEW (struct main_type);
 643   TYPE_LENGTH (type) = 1;
 644   TYPE_CODE (type) = TYPE_CODE_METHOD;
 645   TYPE_VPTR_FIELDNO (type) = -1;
 646   TYPE_CHAIN (type) = type;
 647   if (num_types > 0)
 648     {
 649       if (param_types[num_types - 1] == NULL)
 650         {
 651           --num_types;
 652           TYPE_VARARGS (type) = 1;
 653         }
 654       else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
 655                == TYPE_CODE_VOID)
 656         {
 657           --num_types;
 658           /* Caller should have ensured this.  */
 659           gdb_assert (num_types == 0);
 660           TYPE_PROTOTYPED (type) = 1;
 661         }
 662     }
 663
 664   TYPE_NFIELDS (type) = num_types;
 665   TYPE_FIELDS (type) = (struct field *)
 666     TYPE_ZALLOC (type, sizeof (struct field) * num_types);
 667
 668   while (num_types-- > 0)
 669     TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
 670
 671   return type;
 672 }
 673
 674 struct value *
 675 evaluate_subexp_standard (struct type *expect_type,
 676                           struct expression *exp, int *pos,
 677                           enum noside noside)
 678 {
 679   enum exp_opcode op;
 680   int tem, tem2, tem3;
 681   int pc, pc2 = 0, oldpos;
 682   struct value *arg1 = NULL;
 683   struct value *arg2 = NULL;
 684   struct value *arg3;
 685   struct type *type;
 686   int nargs;
 687   struct value **argvec;
 688   int code;
 689   int ix;
 690   long mem_offset;
 691   struct type **arg_types;
 692   int save_pos1;
 693   struct symbol *function = NULL;
 694   char *function_name = NULL;
 695
 696   pc = (*pos)++;
 697   op = exp->elts[pc].opcode;
 698
 699   switch (op)
 700     {
 701     case OP_SCOPE:
 702       tem = longest_to_int (exp->elts[pc + 2].longconst);
 703       (*pos) += 4 + BYTES_TO_EXP_ELEM (tem + 1);
 704       if (noside == EVAL_SKIP)
 705         goto nosideret;
 706       arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
 707                                   &exp->elts[pc + 3].string,
 708                                   expect_type, 0, noside);
 709       if (arg1 == NULL)
 710         error (_("There is no field named %s"), &exp->elts[pc + 3].string);
 711       return arg1;
 712
 713     case OP_LONG:
 714       (*pos) += 3;
 715       return value_from_longest (exp->elts[pc + 1].type,
 716                                  exp->elts[pc + 2].longconst);
 717
 718     case OP_DOUBLE:
 719       (*pos) += 3;
 720       return value_from_double (exp->elts[pc + 1].type,
 721                                 exp->elts[pc + 2].doubleconst);
 722
 723     case OP_DECFLOAT:
 724       (*pos) += 3;
 725       return value_from_decfloat (exp->elts[pc + 1].type,
 726                                   exp->elts[pc + 2].decfloatconst);
 727
 728     case OP_ADL_FUNC:
 729     case OP_VAR_VALUE:
 730       (*pos) += 3;
 731       if (noside == EVAL_SKIP)
 732         goto nosideret;
 733
 734       /* JYG: We used to just return value_zero of the symbol type
 735          if we're asked to avoid side effects.  Otherwise we return
 736          value_of_variable (...).  However I'm not sure if
 737          value_of_variable () has any side effect.
 738          We need a full value object returned here for whatis_exp ()
 739          to call evaluate_type () and then pass the full value to
 740          value_rtti_target_type () if we are dealing with a pointer
 741          or reference to a base class and print object is on.  */
 742
 743       {
 744         volatile struct gdb_exception except;
 745         struct value *ret = NULL;
 746
 747         TRY_CATCH (except, RETURN_MASK_ERROR)
 748           {
 749             ret = value_of_variable (exp->elts[pc + 2].symbol,
 750                                      exp->elts[pc + 1].block);
 751           }
 752
 753         if (except.reason < 0)
 754           {
 755             if (noside == EVAL_AVOID_SIDE_EFFECTS)
 756               ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
 757                                 not_lval);
 758             else
 759               throw_exception (except);
 760           }
 761
 762         return ret;
 763       }
 764
 765     case OP_VAR_ENTRY_VALUE:
 766       (*pos) += 2;
 767       if (noside == EVAL_SKIP)
 768         goto nosideret;
 769
 770       {
 771         struct symbol *sym = exp->elts[pc + 1].symbol;
 772         struct frame_info *frame;
 773
 774         if (noside == EVAL_AVOID_SIDE_EFFECTS)
 775           return value_zero (SYMBOL_TYPE (sym), not_lval);
 776
 777         if (SYMBOL_COMPUTED_OPS (sym) == NULL
 778             || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
 779           error (_("Symbol \"%s\" does not have any specific entry value"),
 780                  SYMBOL_PRINT_NAME (sym));
 781
 782         frame = get_selected_frame (NULL);
 783         return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
 784       }
 785
 786     case OP_LAST:
 787       (*pos) += 2;
 788       return
 789         access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
 790
 791     case OP_REGISTER:
 792       {
 793         const char *name = &exp->elts[pc + 2].string;
 794         int regno;
 795         struct value *val;
 796
 797         (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
 798         regno = user_reg_map_name_to_regnum (exp->gdbarch,
 799                                              name, strlen (name));
 800         if (regno == -1)
 801           error (_("Register $%s not available."), name);
 802
 803         /* In EVAL_AVOID_SIDE_EFFECTS mode, we only need to return
 804            a value with the appropriate register type.  Unfortunately,
 805            we don't have easy access to the type of user registers.
 806            So for these registers, we fetch the register value regardless
 807            of the evaluation mode.  */
 808         if (noside == EVAL_AVOID_SIDE_EFFECTS
 809             && regno < gdbarch_num_regs (exp->gdbarch)
 810                         + gdbarch_num_pseudo_regs (exp->gdbarch))
 811           val = value_zero (register_type (exp->gdbarch, regno), not_lval);
 812         else
 813           val = value_of_register (regno, get_selected_frame (NULL));
 814         if (val == NULL)
 815           error (_("Value of register %s not available."), name);
 816         else
 817           return val;
 818       }
 819     case OP_BOOL:
 820       (*pos) += 2;
 821       type = language_bool_type (exp->language_defn, exp->gdbarch);
 822       return value_from_longest (type, exp->elts[pc + 1].longconst);
 823
 824     case OP_INTERNALVAR:
 825       (*pos) += 2;
 826       return value_of_internalvar (exp->gdbarch,
 827                                    exp->elts[pc + 1].internalvar);
 828
 829     case OP_STRING:
 830       tem = longest_to_int (exp->elts[pc + 1].longconst);
 831       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
 832       if (noside == EVAL_SKIP)
 833         goto nosideret;
 834       type = language_string_char_type (exp->language_defn, exp->gdbarch);
 835       return value_string (&exp->elts[pc + 2].string, tem, type);
 836
 837     case OP_OBJC_NSSTRING:              /* Objective C Foundation Class
 838                                            NSString constant.  */
 839       tem = longest_to_int (exp->elts[pc + 1].longconst);
 840       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
 841       if (noside == EVAL_SKIP)
 842         {
 843           goto nosideret;
 844         }
 845       return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);
 846
 847     case OP_ARRAY:
 848       (*pos) += 3;
 849       tem2 = longest_to_int (exp->elts[pc + 1].longconst);
 850       tem3 = longest_to_int (exp->elts[pc + 2].longconst);
 851       nargs = tem3 - tem2 + 1;
 852       type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
 853
 854       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
 855           && TYPE_CODE (type) == TYPE_CODE_STRUCT)
 856         {
 857           struct value *rec = allocate_value (expect_type);
 858
 859           memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
 860           return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
 861         }
 862
 863       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
 864           && TYPE_CODE (type) == TYPE_CODE_ARRAY)
 865         {
 866           struct type *range_type = TYPE_INDEX_TYPE (type);
 867           struct type *element_type = TYPE_TARGET_TYPE (type);
 868           struct value *array = allocate_value (expect_type);
 869           int element_size = TYPE_LENGTH (check_typedef (element_type));
 870           LONGEST low_bound, high_bound, index;
 871
 872           if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
 873             {
 874               low_bound = 0;
 875               high_bound = (TYPE_LENGTH (type) / element_size) - 1;
 876             }
 877           index = low_bound;
 878           memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
 879           for (tem = nargs; --nargs >= 0;)
 880             {
 881               struct value *element;
 882               int index_pc = 0;
 883
 884               element = evaluate_subexp (element_type, exp, pos, noside);
 885               if (value_type (element) != element_type)
 886                 element = value_cast (element_type, element);
 887               if (index_pc)
 888                 {
 889                   int continue_pc = *pos;
 890
 891                   *pos = index_pc;
 892                   index = init_array_element (array, element, exp, pos, noside,
 893                                               low_bound, high_bound);
 894                   *pos = continue_pc;
 895                 }
 896               else
 897                 {
 898                   if (index > high_bound)
 899                     /* To avoid memory corruption.  */
 900                     error (_("Too many array elements"));
 901                   memcpy (value_contents_raw (array)
 902                           + (index - low_bound) * element_size,
 903                           value_contents (element),
 904                           element_size);
 905                 }
 906               index++;
 907             }
 908           return array;
 909         }
 910
 911       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
 912           && TYPE_CODE (type) == TYPE_CODE_SET)
 913         {
 914           struct value *set = allocate_value (expect_type);
 915           gdb_byte *valaddr = value_contents_raw (set);
 916           struct type *element_type = TYPE_INDEX_TYPE (type);
 917           struct type *check_type = element_type;
 918           LONGEST low_bound, high_bound;
 919
 920           /* Get targettype of elementtype.  */
 921           while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
 922                  || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
 923             check_type = TYPE_TARGET_TYPE (check_type);
 924
 925           if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
 926             error (_("(power)set type with unknown size"));
 927           memset (valaddr, '\0', TYPE_LENGTH (type));
 928           for (tem = 0; tem < nargs; tem++)
 929             {
 930               LONGEST range_low, range_high;
 931               struct type *range_low_type, *range_high_type;
 932               struct value *elem_val;
 933
 934               elem_val = evaluate_subexp (element_type, exp, pos, noside);
 935               range_low_type = range_high_type = value_type (elem_val);
 936               range_low = range_high = value_as_long (elem_val);
 937
 938               /* Check types of elements to avoid mixture of elements from
 939                  different types. Also check if type of element is "compatible"
 940                  with element type of powerset.  */
 941               if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
 942                 range_low_type = TYPE_TARGET_TYPE (range_low_type);
 943               if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
 944                 range_high_type = TYPE_TARGET_TYPE (range_high_type);
 945               if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
 946                   || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
 947                       && (range_low_type != range_high_type)))
 948                 /* different element modes.  */
 949                 error (_("POWERSET tuple elements of different mode"));
 950               if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
 951                   || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
 952                       && range_low_type != check_type))
 953                 error (_("incompatible POWERSET tuple elements"));
 954               if (range_low > range_high)
 955                 {
 956                   warning (_("empty POWERSET tuple range"));
 957                   continue;
 958                 }
 959               if (range_low < low_bound || range_high > high_bound)
 960                 error (_("POWERSET tuple element out of range"));
 961               range_low -= low_bound;
 962               range_high -= low_bound;
 963               for (; range_low <= range_high; range_low++)
 964                 {
 965                   int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
 966
 967                   if (gdbarch_bits_big_endian (exp->gdbarch))
 968                     bit_index = TARGET_CHAR_BIT - 1 - bit_index;
 969                   valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
 970                     |= 1 << bit_index;
 971                 }
 972             }
 973           return set;
 974         }
 975
 976       argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
 977       for (tem = 0; tem < nargs; tem++)
 978         {
 979           /* Ensure that array expressions are coerced into pointer
 980              objects.  */
 981           argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
 982         }
 983       if (noside == EVAL_SKIP)
 984         goto nosideret;
 985       return value_array (tem2, tem3, argvec);
 986
 987     case TERNOP_SLICE:
 988       {
 989         struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 990         int lowbound
 991           = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 992         int upper
 993           = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 994
 995         if (noside == EVAL_SKIP)
 996           goto nosideret;
 997         return value_slice (array, lowbound, upper - lowbound + 1);
 998       }
 999
1000     case TERNOP_COND:
1001       /* Skip third and second args to evaluate the first one.  */
1002       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1003       if (value_logical_not (arg1))
1004         {
1005           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1006           return evaluate_subexp (NULL_TYPE, exp, pos, noside);
1007         }
1008       else
1009         {
1010           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1011           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
1012           return arg2;
1013         }
1014
1015     case OP_OBJC_SELECTOR:
1016       {                         /* Objective C @selector operator.  */
1017         char *sel = &exp->elts[pc + 2].string;
1018         int len = longest_to_int (exp->elts[pc + 1].longconst);
1019         struct type *selector_type;
1020
1021         (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1022         if (noside == EVAL_SKIP)
1023           goto nosideret;
1024
1025         if (sel[len] != 0)
1026           sel[len] = 0;         /* Make sure it's terminated.  */
1027
1028         selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1029         return value_from_longest (selector_type,
1030                                    lookup_child_selector (exp->gdbarch, sel));
1031       }
1032
1033     case OP_OBJC_MSGCALL:
1034       {                         /* Objective C message (method) call.  */
1035
1036         CORE_ADDR responds_selector = 0;
1037         CORE_ADDR method_selector = 0;
1038
1039         CORE_ADDR selector = 0;
1040
1041         int struct_return = 0;
1042         int sub_no_side = 0;
1043
1044         struct value *msg_send = NULL;
1045         struct value *msg_send_stret = NULL;
1046         int gnu_runtime = 0;
1047
1048         struct value *target = NULL;
1049         struct value *method = NULL;
1050         struct value *called_method = NULL;
1051
1052         struct type *selector_type = NULL;
1053         struct type *long_type;
1054
1055         struct value *ret = NULL;
1056         CORE_ADDR addr = 0;
1057
1058         selector = exp->elts[pc + 1].longconst;
1059         nargs = exp->elts[pc + 2].longconst;
1060         argvec = (struct value **) alloca (sizeof (struct value *)
1061                                            * (nargs + 5));
1062
1063         (*pos) += 3;
1064
1065         long_type = builtin_type (exp->gdbarch)->builtin_long;
1066         selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1067
1068         if (noside == EVAL_AVOID_SIDE_EFFECTS)
1069           sub_no_side = EVAL_NORMAL;
1070         else
1071           sub_no_side = noside;
1072
1073         target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1074
1075         if (value_as_long (target) == 0)
1076           return value_from_longest (long_type, 0);
1077
1078         if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0).minsym)
1079           gnu_runtime = 1;
1080
1081         /* Find the method dispatch (Apple runtime) or method lookup
1082            (GNU runtime) function for Objective-C.  These will be used
1083            to lookup the symbol information for the method.  If we
1084            can't find any symbol information, then we'll use these to
1085            call the method, otherwise we can call the method
1086            directly.  The msg_send_stret function is used in the special
1087            case of a method that returns a structure (Apple runtime
1088            only).  */
1089         if (gnu_runtime)
1090           {
1091             struct type *type = selector_type;
1092
1093             type = lookup_function_type (type);
1094             type = lookup_pointer_type (type);
1095             type = lookup_function_type (type);
1096             type = lookup_pointer_type (type);
1097
1098             msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1099             msg_send_stret
1100               = find_function_in_inferior ("objc_msg_lookup", NULL);
1101
1102             msg_send = value_from_pointer (type, value_as_address (msg_send));
1103             msg_send_stret = value_from_pointer (type,
1104                                         value_as_address (msg_send_stret));
1105           }
1106         else
1107           {
1108             msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1109             /* Special dispatcher for methods returning structs.  */
1110             msg_send_stret
1111               = find_function_in_inferior ("objc_msgSend_stret", NULL);
1112           }
1113
1114         /* Verify the target object responds to this method.  The
1115            standard top-level 'Object' class uses a different name for
1116            the verification method than the non-standard, but more
1117            often used, 'NSObject' class.  Make sure we check for both.  */
1118
1119         responds_selector
1120           = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
1121         if (responds_selector == 0)
1122           responds_selector
1123             = lookup_child_selector (exp->gdbarch, "respondsTo:");
1124
1125         if (responds_selector == 0)
1126           error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1127
1128         method_selector
1129           = lookup_child_selector (exp->gdbarch, "methodForSelector:");
1130         if (method_selector == 0)
1131           method_selector
1132             = lookup_child_selector (exp->gdbarch, "methodFor:");
1133
1134         if (method_selector == 0)
1135           error (_("no 'methodFor:' or 'methodForSelector:' method"));
1136
1137         /* Call the verification method, to make sure that the target
1138          class implements the desired method.  */
1139
1140         argvec[0] = msg_send;
1141         argvec[1] = target;
1142         argvec[2] = value_from_longest (long_type, responds_selector);
1143         argvec[3] = value_from_longest (long_type, selector);
1144         argvec[4] = 0;
1145
1146         ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1147         if (gnu_runtime)
1148           {
1149             /* Function objc_msg_lookup returns a pointer.  */
1150             argvec[0] = ret;
1151             ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1152           }
1153         if (value_as_long (ret) == 0)
1154           error (_("Target does not respond to this message selector."));
1155
1156         /* Call "methodForSelector:" method, to get the address of a
1157            function method that implements this selector for this
1158            class.  If we can find a symbol at that address, then we
1159            know the return type, parameter types etc.  (that's a good
1160            thing).  */
1161
1162         argvec[0] = msg_send;
1163         argvec[1] = target;
1164         argvec[2] = value_from_longest (long_type, method_selector);
1165         argvec[3] = value_from_longest (long_type, selector);
1166         argvec[4] = 0;
1167
1168         ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1169         if (gnu_runtime)
1170           {
1171             argvec[0] = ret;
1172             ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1173           }
1174
1175         /* ret should now be the selector.  */
1176
1177         addr = value_as_long (ret);
1178         if (addr)
1179           {
1180             struct symbol *sym = NULL;
1181
1182             /* The address might point to a function descriptor;
1183                resolve it to the actual code address instead.  */
1184             addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
1185                                                        &current_target);
1186
1187             /* Is it a high_level symbol?  */
1188             sym = find_pc_function (addr);
1189             if (sym != NULL)
1190               method = value_of_variable (sym, 0);
1191           }
1192
1193         /* If we found a method with symbol information, check to see
1194            if it returns a struct.  Otherwise assume it doesn't.  */
1195
1196         if (method)
1197           {
1198             CORE_ADDR funaddr;
1199             struct type *val_type;
1200
1201             funaddr = find_function_addr (method, &val_type);
1202
1203             block_for_pc (funaddr);
1204
1205             CHECK_TYPEDEF (val_type);
1206
1207             if ((val_type == NULL)
1208                 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1209               {
1210                 if (expect_type != NULL)
1211                   val_type = expect_type;
1212               }
1213
1214             struct_return = using_struct_return (exp->gdbarch, method,
1215                                                  val_type);
1216           }
1217         else if (expect_type != NULL)
1218           {
1219             struct_return = using_struct_return (exp->gdbarch, NULL,
1220                                                  check_typedef (expect_type));
1221           }
1222
1223         /* Found a function symbol.  Now we will substitute its
1224            value in place of the message dispatcher (obj_msgSend),
1225            so that we call the method directly instead of thru
1226            the dispatcher.  The main reason for doing this is that
1227            we can now evaluate the return value and parameter values
1228            according to their known data types, in case we need to
1229            do things like promotion, dereferencing, special handling
1230            of structs and doubles, etc.
1231
1232            We want to use the type signature of 'method', but still
1233            jump to objc_msgSend() or objc_msgSend_stret() to better
1234            mimic the behavior of the runtime.  */
1235
1236         if (method)
1237           {
1238             if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1239               error (_("method address has symbol information "
1240                        "with non-function type; skipping"));
1241
1242             /* Create a function pointer of the appropriate type, and
1243                replace its value with the value of msg_send or
1244                msg_send_stret.  We must use a pointer here, as
1245                msg_send and msg_send_stret are of pointer type, and
1246                the representation may be different on systems that use
1247                function descriptors.  */
1248             if (struct_return)
1249               called_method
1250                 = value_from_pointer (lookup_pointer_type (value_type (method)),
1251                                       value_as_address (msg_send_stret));
1252             else
1253               called_method
1254                 = value_from_pointer (lookup_pointer_type (value_type (method)),
1255                                       value_as_address (msg_send));
1256           }
1257         else
1258           {
1259             if (struct_return)
1260               called_method = msg_send_stret;
1261             else
1262               called_method = msg_send;
1263           }
1264
1265         if (noside == EVAL_SKIP)
1266           goto nosideret;
1267
1268         if (noside == EVAL_AVOID_SIDE_EFFECTS)
1269           {
1270             /* If the return type doesn't look like a function type,
1271                call an error.  This can happen if somebody tries to
1272                turn a variable into a function call.  This is here
1273                because people often want to call, eg, strcmp, which
1274                gdb doesn't know is a function.  If gdb isn't asked for
1275                it's opinion (ie. through "whatis"), it won't offer
1276                it.  */
1277
1278             struct type *type = value_type (called_method);
1279
1280             if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1281               type = TYPE_TARGET_TYPE (type);
1282             type = TYPE_TARGET_TYPE (type);
1283
1284             if (type)
1285             {
1286               if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1287                 return allocate_value (expect_type);
1288               else
1289                 return allocate_value (type);
1290             }
1291             else
1292               error (_("Expression of type other than "
1293                        "\"method returning ...\" used as a method"));
1294           }
1295
1296         /* Now depending on whether we found a symbol for the method,
1297            we will either call the runtime dispatcher or the method
1298            directly.  */
1299
1300         argvec[0] = called_method;
1301         argvec[1] = target;
1302         argvec[2] = value_from_longest (long_type, selector);
1303         /* User-supplied arguments.  */
1304         for (tem = 0; tem < nargs; tem++)
1305           argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1306         argvec[tem + 3] = 0;
1307
1308         if (gnu_runtime && (method != NULL))
1309           {
1310             /* Function objc_msg_lookup returns a pointer.  */
1311             deprecated_set_value_type (argvec[0],
1312                                        lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
1313             argvec[0]
1314               = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1315           }
1316
1317         ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1318         return ret;
1319       }
1320       break;
1321
1322     case OP_FUNCALL:
1323       (*pos) += 2;
1324       op = exp->elts[*pos].opcode;
1325       nargs = longest_to_int (exp->elts[pc + 1].longconst);
1326       /* Allocate arg vector, including space for the function to be
1327          called in argvec[0], a potential `this', and a terminating NULL.  */
1328       argvec = (struct value **)
1329         alloca (sizeof (struct value *) * (nargs + 3));
1330       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1331         {
1332           /* First, evaluate the structure into arg2.  */
1333           pc2 = (*pos)++;
1334
1335           if (op == STRUCTOP_MEMBER)
1336             {
1337               arg2 = evaluate_subexp_for_address (exp, pos, noside);
1338             }
1339           else
1340             {
1341               arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1342             }
1343
1344           /* If the function is a virtual function, then the
1345              aggregate value (providing the structure) plays
1346              its part by providing the vtable.  Otherwise,
1347              it is just along for the ride: call the function
1348              directly.  */
1349
1350           arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1351
1352           type = check_typedef (value_type (arg1));
1353           if (noside == EVAL_SKIP)
1354             tem = 1;  /* Set it to the right arg index so that all arguments
1355                          can also be skipped.  */
1356           else if (TYPE_CODE (type) == TYPE_CODE_METHODPTR)
1357             {
1358               if (noside == EVAL_AVOID_SIDE_EFFECTS)
1359                 arg1 = value_zero (TYPE_TARGET_TYPE (type), not_lval);
1360               else
1361                 arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1362
1363               /* Now, say which argument to start evaluating from.  */
1364               nargs++;
1365               tem = 2;
1366               argvec[1] = arg2;
1367             }
1368           else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
1369             {
1370               struct type *type_ptr
1371                 = lookup_pointer_type (TYPE_DOMAIN_TYPE (type));
1372               struct type *target_type_ptr
1373                 = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1374
1375               /* Now, convert these values to an address.  */
1376               arg2 = value_cast (type_ptr, arg2);
1377
1378               mem_offset = value_as_long (arg1);
1379
1380               arg1 = value_from_pointer (target_type_ptr,
1381                                          value_as_long (arg2) + mem_offset);
1382               arg1 = value_ind (arg1);
1383               tem = 1;
1384             }
1385           else
1386             error (_("Non-pointer-to-member value used in pointer-to-member "
1387                      "construct"));
1388         }
1389       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1390         {
1391           /* Hair for method invocations.  */
1392           int tem2;
1393
1394           nargs++;
1395           /* First, evaluate the structure into arg2.  */
1396           pc2 = (*pos)++;
1397           tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1398           *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1399
1400           if (op == STRUCTOP_STRUCT)
1401             {
1402               /* If v is a variable in a register, and the user types
1403                  v.method (), this will produce an error, because v has
1404                  no address.
1405
1406                  A possible way around this would be to allocate a
1407                  copy of the variable on the stack, copy in the
1408                  contents, call the function, and copy out the
1409                  contents.  I.e. convert this from call by reference
1410                  to call by copy-return (or whatever it's called).
1411                  However, this does not work because it is not the
1412                  same: the method being called could stash a copy of
1413                  the address, and then future uses through that address
1414                  (after the method returns) would be expected to
1415                  use the variable itself, not some copy of it.  */
1416               arg2 = evaluate_subexp_for_address (exp, pos, noside);
1417             }
1418           else
1419             {
1420               arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1421
1422               /* Check to see if the operator '->' has been
1423                  overloaded.  If the operator has been overloaded
1424                  replace arg2 with the value returned by the custom
1425                  operator and continue evaluation.  */
1426               while (unop_user_defined_p (op, arg2))
1427                 {
1428                   volatile struct gdb_exception except;
1429                   struct value *value = NULL;
1430                   TRY_CATCH (except, RETURN_MASK_ERROR)
1431                     {
1432                       value = value_x_unop (arg2, op, noside);
1433                     }
1434
1435                   if (except.reason < 0)
1436                     {
1437                       if (except.error == NOT_FOUND_ERROR)
1438                         break;
1439                       else
1440                         throw_exception (except);
1441                     }
1442                   arg2 = value;
1443                 }
1444             }
1445           /* Now, say which argument to start evaluating from.  */
1446           tem = 2;
1447         }
1448       else if (op == OP_SCOPE
1449                && overload_resolution
1450                && (exp->language_defn->la_language == language_cplus))
1451         {
1452           /* Unpack it locally so we can properly handle overload
1453              resolution.  */
1454           char *name;
1455           int local_tem;
1456
1457           pc2 = (*pos)++;
1458           local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
1459           (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
1460           type = exp->elts[pc2 + 1].type;
1461           name = &exp->elts[pc2 + 3].string;
1462
1463           function = NULL;
1464           function_name = NULL;
1465           if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
1466             {
1467               function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
1468                                                      name,
1469                                                      get_selected_block (0),
1470                                                      VAR_DOMAIN);
1471               if (function == NULL)
1472                 error (_("No symbol \"%s\" in namespace \"%s\"."),
1473                        name, TYPE_TAG_NAME (type));
1474
1475               tem = 1;
1476               /* arg2 is left as NULL on purpose.  */
1477             }
1478           else
1479             {
1480               gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
1481                           || TYPE_CODE (type) == TYPE_CODE_UNION);
1482               function_name = name;
1483
1484               /* We need a properly typed value for method lookup.  For
1485                  static methods arg2 is otherwise unused.  */
1486               arg2 = value_zero (type, lval_memory);
1487               ++nargs;
1488               tem = 2;
1489             }
1490         }
1491       else if (op == OP_ADL_FUNC)
1492         {
1493           /* Save the function position and move pos so that the arguments
1494              can be evaluated.  */
1495           int func_name_len;
1496
1497           save_pos1 = *pos;
1498           tem = 1;
1499
1500           func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
1501           (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
1502         }
1503       else
1504         {
1505           /* Non-method function call.  */
1506           save_pos1 = *pos;
1507           tem = 1;
1508
1509           /* If this is a C++ function wait until overload resolution.  */
1510           if (op == OP_VAR_VALUE
1511               && overload_resolution
1512               && (exp->language_defn->la_language == language_cplus))
1513             {
1514               (*pos) += 4; /* Skip the evaluation of the symbol.  */
1515               argvec[0] = NULL;
1516             }
1517           else
1518             {
1519               argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1520               type = value_type (argvec[0]);
1521               if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1522                 type = TYPE_TARGET_TYPE (type);
1523               if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1524                 {
1525                   for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1526                     {
1527                       argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
1528                                                                       tem - 1),
1529                                                      exp, pos, noside);
1530                     }
1531                 }
1532             }
1533         }
1534
1535       /* Evaluate arguments (if not already done, e.g., namespace::func()
1536          and overload-resolution is off).  */
1537       for (; tem <= nargs; tem++)
1538         {
1539           /* Ensure that array expressions are coerced into pointer
1540              objects.  */
1541           argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1542         }
1543
1544       /* Signal end of arglist.  */
1545       argvec[tem] = 0;
1546
1547       if (noside == EVAL_SKIP)
1548         goto nosideret;
1549
1550       if (op == OP_ADL_FUNC)
1551         {
1552           struct symbol *symp;
1553           char *func_name;
1554           int  name_len;
1555           int string_pc = save_pos1 + 3;
1556
1557           /* Extract the function name.  */
1558           name_len = longest_to_int (exp->elts[string_pc].longconst);
1559           func_name = (char *) alloca (name_len + 1);
1560           strcpy (func_name, &exp->elts[string_pc + 1].string);
1561
1562           find_overload_match (&argvec[1], nargs, func_name,
1563                                NON_METHOD, /* not method */
1564                                NULL, NULL, /* pass NULL symbol since
1565                                               symbol is unknown */
1566                                NULL, &symp, NULL, 0, noside);
1567
1568           /* Now fix the expression being evaluated.  */
1569           exp->elts[save_pos1 + 2].symbol = symp;
1570           argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1571         }
1572
1573       if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
1574           || (op == OP_SCOPE && function_name != NULL))
1575         {
1576           int static_memfuncp;
1577           char *tstr;
1578
1579           /* Method invocation: stuff "this" as first parameter.
1580              If the method turns out to be static we undo this below.  */
1581           argvec[1] = arg2;
1582
1583           if (op != OP_SCOPE)
1584             {
1585               /* Name of method from expression.  */
1586               tstr = &exp->elts[pc2 + 2].string;
1587             }
1588           else
1589             tstr = function_name;
1590
1591           if (overload_resolution && (exp->language_defn->la_language
1592                                       == language_cplus))
1593             {
1594               /* Language is C++, do some overload resolution before
1595                  evaluation.  */
1596               struct value *valp = NULL;
1597
1598               (void) find_overload_match (&argvec[1], nargs, tstr,
1599                                           METHOD, /* method */
1600                                           &arg2,  /* the object */
1601                                           NULL, &valp, NULL,
1602                                           &static_memfuncp, 0, noside);
1603
1604               if (op == OP_SCOPE && !static_memfuncp)
1605                 {
1606                   /* For the time being, we don't handle this.  */
1607                   error (_("Call to overloaded function %s requires "
1608                            "`this' pointer"),
1609                          function_name);
1610                 }
1611               argvec[1] = arg2; /* the ``this'' pointer */
1612               argvec[0] = valp; /* Use the method found after overload
1613                                    resolution.  */
1614             }
1615           else
1616             /* Non-C++ case -- or no overload resolution.  */
1617             {
1618               struct value *temp = arg2;
1619
1620               argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1621                                             &static_memfuncp,
1622                                             op == STRUCTOP_STRUCT
1623                                        ? "structure" : "structure pointer");
1624               /* value_struct_elt updates temp with the correct value
1625                  of the ``this'' pointer if necessary, so modify argvec[1] to
1626                  reflect any ``this'' changes.  */
1627               arg2
1628                 = value_from_longest (lookup_pointer_type(value_type (temp)),
1629                                       value_address (temp)
1630                                       + value_embedded_offset (temp));
1631               argvec[1] = arg2; /* the ``this'' pointer */
1632             }
1633
1634           /* Take out `this' if needed.  */
1635           if (static_memfuncp)
1636             {
1637               argvec[1] = argvec[0];
1638               nargs--;
1639               argvec++;
1640             }
1641         }
1642       else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1643         {
1644           /* Pointer to member.  argvec[1] is already set up.  */
1645           argvec[0] = arg1;
1646         }
1647       else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))
1648         {
1649           /* Non-member function being called.  */
1650           /* fn: This can only be done for C++ functions.  A C-style function
1651              in a C++ program, for instance, does not have the fields that
1652              are expected here.  */
1653
1654           if (overload_resolution && (exp->language_defn->la_language
1655                                       == language_cplus))
1656             {
1657               /* Language is C++, do some overload resolution before
1658                  evaluation.  */
1659               struct symbol *symp;
1660               int no_adl = 0;
1661
1662               /* If a scope has been specified disable ADL.  */
1663               if (op == OP_SCOPE)
1664                 no_adl = 1;
1665
1666               if (op == OP_VAR_VALUE)
1667                 function = exp->elts[save_pos1+2].symbol;
1668
1669               (void) find_overload_match (&argvec[1], nargs,
1670                                           NULL,        /* no need for name */
1671                                           NON_METHOD,  /* not method */
1672                                           NULL, function, /* the function */
1673                                           NULL, &symp, NULL, no_adl, noside);
1674
1675               if (op == OP_VAR_VALUE)
1676                 {
1677                   /* Now fix the expression being evaluated.  */
1678                   exp->elts[save_pos1+2].symbol = symp;
1679                   argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
1680                                                              noside);
1681                 }
1682               else
1683                 argvec[0] = value_of_variable (symp, get_selected_block (0));
1684             }
1685           else
1686             {
1687               /* Not C++, or no overload resolution allowed.  */
1688               /* Nothing to be done; argvec already correctly set up.  */
1689             }
1690         }
1691       else
1692         {
1693           /* It is probably a C-style function.  */
1694           /* Nothing to be done; argvec already correctly set up.  */
1695         }
1696
1697     do_call_it:
1698
1699       if (noside == EVAL_SKIP)
1700         goto nosideret;
1701       if (argvec[0] == NULL)
1702         error (_("Cannot evaluate function -- may be inlined"));
1703       if (noside == EVAL_AVOID_SIDE_EFFECTS)
1704         {
1705           /* If the return type doesn't look like a function type, call an
1706              error.  This can happen if somebody tries to turn a variable into
1707              a function call.  This is here because people often want to
1708              call, eg, strcmp, which gdb doesn't know is a function.  If
1709              gdb isn't asked for it's opinion (ie. through "whatis"),
1710              it won't offer it.  */
1711
1712           struct type *ftype = value_type (argvec[0]);
1713
1714           if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
1715             {
1716               /* We don't know anything about what the internal
1717                  function might return, but we have to return
1718                  something.  */
1719               return value_zero (builtin_type (exp->gdbarch)->builtin_int,
1720                                  not_lval);
1721             }
1722           else if (TYPE_GNU_IFUNC (ftype))
1723             return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype)));
1724           else if (TYPE_TARGET_TYPE (ftype))
1725             return allocate_value (TYPE_TARGET_TYPE (ftype));
1726           else
1727             error (_("Expression of type other than "
1728                      "\"Function returning ...\" used as function"));
1729         }
1730       switch (TYPE_CODE (value_type (argvec[0])))
1731         {
1732         case TYPE_CODE_INTERNAL_FUNCTION:
1733           return call_internal_function (exp->gdbarch, exp->language_defn,
1734                                          argvec[0], nargs, argvec + 1);
1735         case TYPE_CODE_XMETHOD:
1736           return call_xmethod (argvec[0], nargs, argvec + 1);
1737         default:
1738           return call_function_by_hand (argvec[0], nargs, argvec + 1);
1739         }
1740       /* pai: FIXME save value from call_function_by_hand, then adjust
1741          pc by adjust_fn_pc if +ve.  */
1742
1743     case OP_F77_UNDETERMINED_ARGLIST:
1744
1745       /* Remember that in F77, functions, substring ops and
1746          array subscript operations cannot be disambiguated
1747          at parse time.  We have made all array subscript operations,
1748          substring operations as well as function calls  come here
1749          and we now have to discover what the heck this thing actually was.
1750          If it is a function, we process just as if we got an OP_FUNCALL.  */
1751
1752       nargs = longest_to_int (exp->elts[pc + 1].longconst);
1753       (*pos) += 2;
1754
1755       /* First determine the type code we are dealing with.  */
1756       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1757       type = check_typedef (value_type (arg1));
1758       code = TYPE_CODE (type);
1759
1760       if (code == TYPE_CODE_PTR)
1761         {
1762           /* Fortran always passes variable to subroutines as pointer.
1763              So we need to look into its target type to see if it is
1764              array, string or function.  If it is, we need to switch
1765              to the target value the original one points to.  */
1766           struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1767
1768           if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1769               || TYPE_CODE (target_type) == TYPE_CODE_STRING
1770               || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1771             {
1772               arg1 = value_ind (arg1);
1773               type = check_typedef (value_type (arg1));
1774               code = TYPE_CODE (type);
1775             }
1776         }
1777
1778       switch (code)
1779         {
1780         case TYPE_CODE_ARRAY:
1781           if (exp->elts[*pos].opcode == OP_F90_RANGE)
1782             return value_f90_subarray (arg1, exp, pos, noside);
1783           else
1784             goto multi_f77_subscript;
1785
1786         case TYPE_CODE_STRING:
1787           if (exp->elts[*pos].opcode == OP_F90_RANGE)
1788             return value_f90_subarray (arg1, exp, pos, noside);
1789           else
1790             {
1791               arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1792               return value_subscript (arg1, value_as_long (arg2));
1793             }
1794
1795         case TYPE_CODE_PTR:
1796         case TYPE_CODE_FUNC:
1797           /* It's a function call.  */
1798           /* Allocate arg vector, including space for the function to be
1799              called in argvec[0] and a terminating NULL.  */
1800           argvec = (struct value **)
1801             alloca (sizeof (struct value *) * (nargs + 2));
1802           argvec[0] = arg1;
1803           tem = 1;
1804           for (; tem <= nargs; tem++)
1805             argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1806           argvec[tem] = 0;      /* signal end of arglist */
1807           goto do_call_it;
1808
1809         default:
1810           error (_("Cannot perform substring on this type"));
1811         }
1812
1813     case OP_COMPLEX:
1814       /* We have a complex number, There should be 2 floating
1815          point numbers that compose it.  */
1816       (*pos) += 2;
1817       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1818       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1819
1820       return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1821
1822     case STRUCTOP_STRUCT:
1823       tem = longest_to_int (exp->elts[pc + 1].longconst);
1824       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1825       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1826       if (noside == EVAL_SKIP)
1827         goto nosideret;
1828       arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1829                                NULL, "structure");
1830       if (noside == EVAL_AVOID_SIDE_EFFECTS)
1831         arg3 = value_zero (value_type (arg3), not_lval);
1832       return arg3;
1833
1834     case STRUCTOP_PTR:
1835       tem = longest_to_int (exp->elts[pc + 1].longconst);
1836       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1837       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1838       if (noside == EVAL_SKIP)
1839         goto nosideret;
1840
1841       /* Check to see if operator '->' has been overloaded.  If so replace
1842          arg1 with the value returned by evaluating operator->().  */
1843       while (unop_user_defined_p (op, arg1))
1844         {
1845           volatile struct gdb_exception except;
1846           struct value *value = NULL;
1847           TRY_CATCH (except, RETURN_MASK_ERROR)
1848             {
1849               value = value_x_unop (arg1, op, noside);
1850             }
1851
1852           if (except.reason < 0)
1853             {
1854               if (except.error == NOT_FOUND_ERROR)
1855                 break;
1856               else
1857                 throw_exception (except);
1858             }
1859           arg1 = value;
1860         }
1861
1862       /* JYG: if print object is on we need to replace the base type
1863          with rtti type in order to continue on with successful
1864          lookup of member / method only available in the rtti type.  */
1865       {
1866         struct type *type = value_type (arg1);
1867         struct type *real_type;
1868         int full, top, using_enc;
1869         struct value_print_options opts;
1870
1871         get_user_print_options (&opts);
1872         if (opts.objectprint && TYPE_TARGET_TYPE(type)
1873             && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
1874           {
1875             real_type = value_rtti_indirect_type (arg1, &full, &top,
1876                                                   &using_enc);
1877             if (real_type)
1878                 arg1 = value_cast (real_type, arg1);
1879           }
1880       }
1881
1882       arg3 = value_struct_elt (&arg1, NULL, &exp->elts[pc + 2].string,
1883                                NULL, "structure pointer");
1884       if (noside == EVAL_AVOID_SIDE_EFFECTS)
1885         arg3 = value_zero (value_type (arg3), not_lval);
1886       return arg3;
1887
1888     case STRUCTOP_MEMBER:
1889     case STRUCTOP_MPTR:
1890       if (op == STRUCTOP_MEMBER)
1891         arg1 = evaluate_subexp_for_address (exp, pos, noside);
1892       else
1893         arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1894
1895       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1896
1897       if (noside == EVAL_SKIP)
1898         goto nosideret;
1899
1900       type = check_typedef (value_type (arg2));
1901       switch (TYPE_CODE (type))
1902         {
1903         case TYPE_CODE_METHODPTR:
1904           if (noside == EVAL_AVOID_SIDE_EFFECTS)
1905             return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1906           else
1907             {
1908               arg2 = cplus_method_ptr_to_value (&arg1, arg2);
1909               gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
1910               return value_ind (arg2);
1911             }
1912
1913         case TYPE_CODE_MEMBERPTR:
1914           /* Now, convert these values to an address.  */
1915           arg1 = value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
1916                                       arg1, 1);
1917
1918           mem_offset = value_as_long (arg2);
1919
1920           arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1921                                      value_as_long (arg1) + mem_offset);
1922           return value_ind (arg3);
1923
1924         default:
1925           error (_("non-pointer-to-member value used "
1926                    "in pointer-to-member construct"));
1927         }
1928
1929     case TYPE_INSTANCE:
1930       nargs = longest_to_int (exp->elts[pc + 1].longconst);
1931       arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
1932       for (ix = 0; ix < nargs; ++ix)
1933         arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
1934
1935       expect_type = make_params (nargs, arg_types);
1936       *(pos) += 3 + nargs;
1937       arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
1938       xfree (TYPE_FIELDS (expect_type));
1939       xfree (TYPE_MAIN_TYPE (expect_type));
1940       xfree (expect_type);
1941       return arg1;
1942
1943     case BINOP_CONCAT:
1944       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1945       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1946       if (noside == EVAL_SKIP)
1947         goto nosideret;
1948       if (binop_user_defined_p (op, arg1, arg2))
1949         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1950       else
1951         return value_concat (arg1, arg2);
1952
1953     case BINOP_ASSIGN:
1954       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1955       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1956
1957       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1958         return arg1;
1959       if (binop_user_defined_p (op, arg1, arg2))
1960         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1961       else
1962         return value_assign (arg1, arg2);
1963
1964     case BINOP_ASSIGN_MODIFY:
1965       (*pos) += 2;
1966       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1967       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1968       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1969         return arg1;
1970       op = exp->elts[pc + 1].opcode;
1971       if (binop_user_defined_p (op, arg1, arg2))
1972         return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
1973       else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
1974                                                   value_type (arg1))
1975                && is_integral_type (value_type (arg2)))
1976         arg2 = value_ptradd (arg1, value_as_long (arg2));
1977       else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
1978                                                   value_type (arg1))
1979                && is_integral_type (value_type (arg2)))
1980         arg2 = value_ptradd (arg1, - value_as_long (arg2));
1981       else
1982         {
1983           struct value *tmp = arg1;
1984
1985           /* For shift and integer exponentiation operations,
1986              only promote the first argument.  */
1987           if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
1988               && is_integral_type (value_type (arg2)))
1989             unop_promote (exp->language_defn, exp->gdbarch, &tmp);
1990           else
1991             binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
1992
1993           arg2 = value_binop (tmp, arg2, op);
1994         }
1995       return value_assign (arg1, arg2);
1996
1997     case BINOP_ADD:
1998       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1999       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2000       if (noside == EVAL_SKIP)
2001         goto nosideret;
2002       if (binop_user_defined_p (op, arg1, arg2))
2003         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2004       else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2005                && is_integral_type (value_type (arg2)))
2006         return value_ptradd (arg1, value_as_long (arg2));
2007       else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
2008                && is_integral_type (value_type (arg1)))
2009         return value_ptradd (arg2, value_as_long (arg1));
2010       else
2011         {
2012           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2013           return value_binop (arg1, arg2, BINOP_ADD);
2014         }
2015
2016     case BINOP_SUB:
2017       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2018       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2019       if (noside == EVAL_SKIP)
2020         goto nosideret;
2021       if (binop_user_defined_p (op, arg1, arg2))
2022         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2023       else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2024                && ptrmath_type_p (exp->language_defn, value_type (arg2)))
2025         {
2026           /* FIXME -- should be ptrdiff_t */
2027           type = builtin_type (exp->gdbarch)->builtin_long;
2028           return value_from_longest (type, value_ptrdiff (arg1, arg2));
2029         }
2030       else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
2031                && is_integral_type (value_type (arg2)))
2032         return value_ptradd (arg1, - value_as_long (arg2));
2033       else
2034         {
2035           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2036           return value_binop (arg1, arg2, BINOP_SUB);
2037         }
2038
2039     case BINOP_EXP:
2040     case BINOP_MUL:
2041     case BINOP_DIV:
2042     case BINOP_INTDIV:
2043     case BINOP_REM:
2044     case BINOP_MOD:
2045     case BINOP_LSH:
2046     case BINOP_RSH:
2047     case BINOP_BITWISE_AND:
2048     case BINOP_BITWISE_IOR:
2049     case BINOP_BITWISE_XOR:
2050       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2051       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2052       if (noside == EVAL_SKIP)
2053         goto nosideret;
2054       if (binop_user_defined_p (op, arg1, arg2))
2055         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2056       else
2057         {
2058           /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
2059              fudge arg2 to avoid division-by-zero, the caller is
2060              (theoretically) only looking for the type of the result.  */
2061           if (noside == EVAL_AVOID_SIDE_EFFECTS
2062               /* ??? Do we really want to test for BINOP_MOD here?
2063                  The implementation of value_binop gives it a well-defined
2064                  value.  */
2065               && (op == BINOP_DIV
2066                   || op == BINOP_INTDIV
2067                   || op == BINOP_REM
2068                   || op == BINOP_MOD)
2069               && value_logical_not (arg2))
2070             {
2071               struct value *v_one, *retval;
2072
2073               v_one = value_one (value_type (arg2));
2074               binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
2075               retval = value_binop (arg1, v_one, op);
2076               return retval;
2077             }
2078           else
2079             {
2080               /* For shift and integer exponentiation operations,
2081                  only promote the first argument.  */
2082               if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
2083                   && is_integral_type (value_type (arg2)))
2084                 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2085               else
2086                 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2087
2088               return value_binop (arg1, arg2, op);
2089             }
2090         }
2091
2092     case BINOP_SUBSCRIPT:
2093       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2094       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2095       if (noside == EVAL_SKIP)
2096         goto nosideret;
2097       if (binop_user_defined_p (op, arg1, arg2))
2098         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2099       else
2100         {
2101           /* If the user attempts to subscript something that is not an
2102              array or pointer type (like a plain int variable for example),
2103              then report this as an error.  */
2104
2105           arg1 = coerce_ref (arg1);
2106           type = check_typedef (value_type (arg1));
2107           if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2108               && TYPE_CODE (type) != TYPE_CODE_PTR)
2109             {
2110               if (TYPE_NAME (type))
2111                 error (_("cannot subscript something of type `%s'"),
2112                        TYPE_NAME (type));
2113               else
2114                 error (_("cannot subscript requested type"));
2115             }
2116
2117           if (noside == EVAL_AVOID_SIDE_EFFECTS)
2118             return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
2119           else
2120             return value_subscript (arg1, value_as_long (arg2));
2121         }
2122     case MULTI_SUBSCRIPT:
2123       (*pos) += 2;
2124       nargs = longest_to_int (exp->elts[pc + 1].longconst);
2125       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
2126       while (nargs-- > 0)
2127         {
2128           arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2129           /* FIXME:  EVAL_SKIP handling may not be correct.  */
2130           if (noside == EVAL_SKIP)
2131             {
2132               if (nargs > 0)
2133                 {
2134                   continue;
2135                 }
2136               else
2137                 {
2138                   goto nosideret;
2139                 }
2140             }
2141           /* FIXME:  EVAL_AVOID_SIDE_EFFECTS handling may not be correct.  */
2142           if (noside == EVAL_AVOID_SIDE_EFFECTS)
2143             {
2144               /* If the user attempts to subscript something that has no target
2145                  type (like a plain int variable for example), then report this
2146                  as an error.  */
2147
2148               type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
2149               if (type != NULL)
2150                 {
2151                   arg1 = value_zero (type, VALUE_LVAL (arg1));
2152                   noside = EVAL_SKIP;
2153                   continue;
2154                 }
2155               else
2156                 {
2157                   error (_("cannot subscript something of type `%s'"),
2158                          TYPE_NAME (value_type (arg1)));
2159                 }
2160             }
2161
2162           if (binop_user_defined_p (op, arg1, arg2))
2163             {
2164               arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
2165             }
2166           else
2167             {
2168               arg1 = coerce_ref (arg1);
2169               type = check_typedef (value_type (arg1));
2170
2171               switch (TYPE_CODE (type))
2172                 {
2173                 case TYPE_CODE_PTR:
2174                 case TYPE_CODE_ARRAY:
2175                 case TYPE_CODE_STRING:
2176                   arg1 = value_subscript (arg1, value_as_long (arg2));
2177                   break;
2178
2179                 default:
2180                   if (TYPE_NAME (type))
2181                     error (_("cannot subscript something of type `%s'"),
2182                            TYPE_NAME (type));
2183                   else
2184                     error (_("cannot subscript requested type"));
2185                 }
2186             }
2187         }
2188       return (arg1);
2189
2190     multi_f77_subscript:
2191       {
2192         LONGEST subscript_array[MAX_FORTRAN_DIMS];
2193         int ndimensions = 1, i;
2194         struct value *array = arg1;
2195
2196         if (nargs > MAX_FORTRAN_DIMS)
2197           error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
2198
2199         ndimensions = calc_f77_array_dims (type);
2200
2201         if (nargs != ndimensions)
2202           error (_("Wrong number of subscripts"));
2203
2204         gdb_assert (nargs > 0);
2205
2206         /* Now that we know we have a legal array subscript expression
2207            let us actually find out where this element exists in the array.  */
2208
2209         /* Take array indices left to right.  */
2210         for (i = 0; i < nargs; i++)
2211           {
2212             /* Evaluate each subscript; it must be a legal integer in F77.  */
2213             arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
2214
2215             /* Fill in the subscript array.  */
2216
2217             subscript_array[i] = value_as_long (arg2);
2218           }
2219
2220         /* Internal type of array is arranged right to left.  */
2221         for (i = nargs; i > 0; i--)
2222           {
2223             struct type *array_type = check_typedef (value_type (array));
2224             LONGEST index = subscript_array[i - 1];
2225
2226             array = value_subscripted_rvalue (array, index,
2227                                               f77_get_lowerbound (array_type));
2228           }
2229
2230         return array;
2231       }
2232
2233     case BINOP_LOGICAL_AND:
2234       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2235       if (noside == EVAL_SKIP)
2236         {
2237           evaluate_subexp (NULL_TYPE, exp, pos, noside);
2238           goto nosideret;
2239         }
2240
2241       oldpos = *pos;
2242       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2243       *pos = oldpos;
2244
2245       if (binop_user_defined_p (op, arg1, arg2))
2246         {
2247           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2248           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2249         }
2250       else
2251         {
2252           tem = value_logical_not (arg1);
2253           arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2254                                   (tem ? EVAL_SKIP : noside));
2255           type = language_bool_type (exp->language_defn, exp->gdbarch);
2256           return value_from_longest (type,
2257                              (LONGEST) (!tem && !value_logical_not (arg2)));
2258         }
2259
2260     case BINOP_LOGICAL_OR:
2261       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2262       if (noside == EVAL_SKIP)
2263         {
2264           evaluate_subexp (NULL_TYPE, exp, pos, noside);
2265           goto nosideret;
2266         }
2267
2268       oldpos = *pos;
2269       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2270       *pos = oldpos;
2271
2272       if (binop_user_defined_p (op, arg1, arg2))
2273         {
2274           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2275           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2276         }
2277       else
2278         {
2279           tem = value_logical_not (arg1);
2280           arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2281                                   (!tem ? EVAL_SKIP : noside));
2282           type = language_bool_type (exp->language_defn, exp->gdbarch);
2283           return value_from_longest (type,
2284                              (LONGEST) (!tem || !value_logical_not (arg2)));
2285         }
2286
2287     case BINOP_EQUAL:
2288       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2289       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2290       if (noside == EVAL_SKIP)
2291         goto nosideret;
2292       if (binop_user_defined_p (op, arg1, arg2))
2293         {
2294           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2295         }
2296       else
2297         {
2298           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2299           tem = value_equal (arg1, arg2);
2300           type = language_bool_type (exp->language_defn, exp->gdbarch);
2301           return value_from_longest (type, (LONGEST) tem);
2302         }
2303
2304     case BINOP_NOTEQUAL:
2305       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2306       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2307       if (noside == EVAL_SKIP)
2308         goto nosideret;
2309       if (binop_user_defined_p (op, arg1, arg2))
2310         {
2311           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2312         }
2313       else
2314         {
2315           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2316           tem = value_equal (arg1, arg2);
2317           type = language_bool_type (exp->language_defn, exp->gdbarch);
2318           return value_from_longest (type, (LONGEST) ! tem);
2319         }
2320
2321     case BINOP_LESS:
2322       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2323       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2324       if (noside == EVAL_SKIP)
2325         goto nosideret;
2326       if (binop_user_defined_p (op, arg1, arg2))
2327         {
2328           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2329         }
2330       else
2331         {
2332           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2333           tem = value_less (arg1, arg2);
2334           type = language_bool_type (exp->language_defn, exp->gdbarch);
2335           return value_from_longest (type, (LONGEST) tem);
2336         }
2337
2338     case BINOP_GTR:
2339       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2340       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2341       if (noside == EVAL_SKIP)
2342         goto nosideret;
2343       if (binop_user_defined_p (op, arg1, arg2))
2344         {
2345           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2346         }
2347       else
2348         {
2349           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2350           tem = value_less (arg2, arg1);
2351           type = language_bool_type (exp->language_defn, exp->gdbarch);
2352           return value_from_longest (type, (LONGEST) tem);
2353         }
2354
2355     case BINOP_GEQ:
2356       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2357       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2358       if (noside == EVAL_SKIP)
2359         goto nosideret;
2360       if (binop_user_defined_p (op, arg1, arg2))
2361         {
2362           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2363         }
2364       else
2365         {
2366           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2367           tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2368           type = language_bool_type (exp->language_defn, exp->gdbarch);
2369           return value_from_longest (type, (LONGEST) tem);
2370         }
2371
2372     case BINOP_LEQ:
2373       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2374       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2375       if (noside == EVAL_SKIP)
2376         goto nosideret;
2377       if (binop_user_defined_p (op, arg1, arg2))
2378         {
2379           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2380         }
2381       else
2382         {
2383           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2384           tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2385           type = language_bool_type (exp->language_defn, exp->gdbarch);
2386           return value_from_longest (type, (LONGEST) tem);
2387         }
2388
2389     case BINOP_REPEAT:
2390       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2391       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2392       if (noside == EVAL_SKIP)
2393         goto nosideret;
2394       type = check_typedef (value_type (arg2));
2395       if (TYPE_CODE (type) != TYPE_CODE_INT)
2396         error (_("Non-integral right operand for \"@\" operator."));
2397       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2398         {
2399           return allocate_repeat_value (value_type (arg1),
2400                                      longest_to_int (value_as_long (arg2)));
2401         }
2402       else
2403         return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2404
2405     case BINOP_COMMA:
2406       evaluate_subexp (NULL_TYPE, exp, pos, noside);
2407       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2408
2409     case UNOP_PLUS:
2410       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2411       if (noside == EVAL_SKIP)
2412         goto nosideret;
2413       if (unop_user_defined_p (op, arg1))
2414         return value_x_unop (arg1, op, noside);
2415       else
2416         {
2417           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2418           return value_pos (arg1);
2419         }
2420
2421     case UNOP_NEG:
2422       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2423       if (noside == EVAL_SKIP)
2424         goto nosideret;
2425       if (unop_user_defined_p (op, arg1))
2426         return value_x_unop (arg1, op, noside);
2427       else
2428         {
2429           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2430           return value_neg (arg1);
2431         }
2432
2433     case UNOP_COMPLEMENT:
2434       /* C++: check for and handle destructor names.  */
2435       op = exp->elts[*pos].opcode;
2436
2437       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2438       if (noside == EVAL_SKIP)
2439         goto nosideret;
2440       if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2441         return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2442       else
2443         {
2444           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2445           return value_complement (arg1);
2446         }
2447
2448     case UNOP_LOGICAL_NOT:
2449       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2450       if (noside == EVAL_SKIP)
2451         goto nosideret;
2452       if (unop_user_defined_p (op, arg1))
2453         return value_x_unop (arg1, op, noside);
2454       else
2455         {
2456           type = language_bool_type (exp->language_defn, exp->gdbarch);
2457           return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2458         }
2459
2460     case UNOP_IND:
2461       if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2462         expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2463       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2464       type = check_typedef (value_type (arg1));
2465       if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2466           || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2467         error (_("Attempt to dereference pointer "
2468                  "to member without an object"));
2469       if (noside == EVAL_SKIP)
2470         goto nosideret;
2471       if (unop_user_defined_p (op, arg1))
2472         return value_x_unop (arg1, op, noside);
2473       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2474         {
2475           type = check_typedef (value_type (arg1));
2476           if (TYPE_CODE (type) == TYPE_CODE_PTR
2477               || TYPE_CODE (type) == TYPE_CODE_REF
2478           /* In C you can dereference an array to get the 1st elt.  */
2479               || TYPE_CODE (type) == TYPE_CODE_ARRAY
2480             )
2481             return value_zero (TYPE_TARGET_TYPE (type),
2482                                lval_memory);
2483           else if (TYPE_CODE (type) == TYPE_CODE_INT)
2484             /* GDB allows dereferencing an int.  */
2485             return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2486                                lval_memory);
2487           else
2488             error (_("Attempt to take contents of a non-pointer value."));
2489         }
2490
2491       /* Allow * on an integer so we can cast it to whatever we want.
2492          This returns an int, which seems like the most C-like thing to
2493          do.  "long long" variables are rare enough that
2494          BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
2495       if (TYPE_CODE (type) == TYPE_CODE_INT)
2496         return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2497                               (CORE_ADDR) value_as_address (arg1));
2498       return value_ind (arg1);
2499
2500     case UNOP_ADDR:
2501       /* C++: check for and handle pointer to members.  */
2502
2503       op = exp->elts[*pos].opcode;
2504
2505       if (noside == EVAL_SKIP)
2506         {
2507           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2508           goto nosideret;
2509         }
2510       else
2511         {
2512           struct value *retvalp = evaluate_subexp_for_address (exp, pos,
2513                                                                noside);
2514
2515           return retvalp;
2516         }
2517
2518     case UNOP_SIZEOF:
2519       if (noside == EVAL_SKIP)
2520         {
2521           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2522           goto nosideret;
2523         }
2524       return evaluate_subexp_for_sizeof (exp, pos, noside);
2525
2526     case UNOP_CAST:
2527       (*pos) += 2;
2528       type = exp->elts[pc + 1].type;
2529       arg1 = evaluate_subexp (type, exp, pos, noside);
2530       if (noside == EVAL_SKIP)
2531         goto nosideret;
2532       if (type != value_type (arg1))
2533         arg1 = value_cast (type, arg1);
2534       return arg1;
2535
2536     case UNOP_CAST_TYPE:
2537       arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2538       type = value_type (arg1);
2539       arg1 = evaluate_subexp (type, exp, pos, noside);
2540       if (noside == EVAL_SKIP)
2541         goto nosideret;
2542       if (type != value_type (arg1))
2543         arg1 = value_cast (type, arg1);
2544       return arg1;
2545
2546     case UNOP_DYNAMIC_CAST:
2547       arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2548       type = value_type (arg1);
2549       arg1 = evaluate_subexp (type, exp, pos, noside);
2550       if (noside == EVAL_SKIP)
2551         goto nosideret;
2552       return value_dynamic_cast (type, arg1);
2553
2554     case UNOP_REINTERPRET_CAST:
2555       arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2556       type = value_type (arg1);
2557       arg1 = evaluate_subexp (type, exp, pos, noside);
2558       if (noside == EVAL_SKIP)
2559         goto nosideret;
2560       return value_reinterpret_cast (type, arg1);
2561
2562     case UNOP_MEMVAL:
2563       (*pos) += 2;
2564       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2565       if (noside == EVAL_SKIP)
2566         goto nosideret;
2567       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2568         return value_zero (exp->elts[pc + 1].type, lval_memory);
2569       else
2570         return value_at_lazy (exp->elts[pc + 1].type,
2571                               value_as_address (arg1));
2572
2573     case UNOP_MEMVAL_TYPE:
2574       arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2575       type = value_type (arg1);
2576       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2577       if (noside == EVAL_SKIP)
2578         goto nosideret;
2579       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2580         return value_zero (type, lval_memory);
2581       else
2582         return value_at_lazy (type, value_as_address (arg1));
2583
2584     case UNOP_MEMVAL_TLS:
2585       (*pos) += 3;
2586       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2587       if (noside == EVAL_SKIP)
2588         goto nosideret;
2589       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2590         return value_zero (exp->elts[pc + 2].type, lval_memory);
2591       else
2592         {
2593           CORE_ADDR tls_addr;
2594
2595           tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2596                                                    value_as_address (arg1));
2597           return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
2598         }
2599
2600     case UNOP_PREINCREMENT:
2601       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2602       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2603         return arg1;
2604       else if (unop_user_defined_p (op, arg1))
2605         {
2606           return value_x_unop (arg1, op, noside);
2607         }
2608       else
2609         {
2610           if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2611             arg2 = value_ptradd (arg1, 1);
2612           else
2613             {
2614               struct value *tmp = arg1;
2615
2616               arg2 = value_one (value_type (arg1));
2617               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2618               arg2 = value_binop (tmp, arg2, BINOP_ADD);
2619             }
2620
2621           return value_assign (arg1, arg2);
2622         }
2623
2624     case UNOP_PREDECREMENT:
2625       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2626       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2627         return arg1;
2628       else if (unop_user_defined_p (op, arg1))
2629         {
2630           return value_x_unop (arg1, op, noside);
2631         }
2632       else
2633         {
2634           if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2635             arg2 = value_ptradd (arg1, -1);
2636           else
2637             {
2638               struct value *tmp = arg1;
2639
2640               arg2 = value_one (value_type (arg1));
2641               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2642               arg2 = value_binop (tmp, arg2, BINOP_SUB);
2643             }
2644
2645           return value_assign (arg1, arg2);
2646         }
2647
2648     case UNOP_POSTINCREMENT:
2649       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2650       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2651         return arg1;
2652       else if (unop_user_defined_p (op, arg1))
2653         {
2654           return value_x_unop (arg1, op, noside);
2655         }
2656       else
2657         {
2658           arg3 = value_non_lval (arg1);
2659
2660           if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2661             arg2 = value_ptradd (arg1, 1);
2662           else
2663             {
2664               struct value *tmp = arg1;
2665
2666               arg2 = value_one (value_type (arg1));
2667               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2668               arg2 = value_binop (tmp, arg2, BINOP_ADD);
2669             }
2670
2671           value_assign (arg1, arg2);
2672           return arg3;
2673         }
2674
2675     case UNOP_POSTDECREMENT:
2676       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2677       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2678         return arg1;
2679       else if (unop_user_defined_p (op, arg1))
2680         {
2681           return value_x_unop (arg1, op, noside);
2682         }
2683       else
2684         {
2685           arg3 = value_non_lval (arg1);
2686
2687           if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
2688             arg2 = value_ptradd (arg1, -1);
2689           else
2690             {
2691               struct value *tmp = arg1;
2692
2693               arg2 = value_one (value_type (arg1));
2694               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2695               arg2 = value_binop (tmp, arg2, BINOP_SUB);
2696             }
2697
2698           value_assign (arg1, arg2);
2699           return arg3;
2700         }
2701
2702     case OP_THIS:
2703       (*pos) += 1;
2704       return value_of_this (exp->language_defn);
2705
2706     case OP_TYPE:
2707       /* The value is not supposed to be used.  This is here to make it
2708          easier to accommodate expressions that contain types.  */
2709       (*pos) += 2;
2710       if (noside == EVAL_SKIP)
2711         goto nosideret;
2712       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2713         {
2714           struct type *type = exp->elts[pc + 1].type;
2715
2716           /* If this is a typedef, then find its immediate target.  We
2717              use check_typedef to resolve stubs, but we ignore its
2718              result because we do not want to dig past all
2719              typedefs.  */
2720           check_typedef (type);
2721           if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
2722             type = TYPE_TARGET_TYPE (type);
2723           return allocate_value (type);
2724         }
2725       else
2726         error (_("Attempt to use a type name as an expression"));
2727
2728     case OP_TYPEOF:
2729     case OP_DECLTYPE:
2730       if (noside == EVAL_SKIP)
2731         {
2732           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2733           goto nosideret;
2734         }
2735       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2736         {
2737           enum exp_opcode sub_op = exp->elts[*pos].opcode;
2738           struct value *result;
2739
2740           result = evaluate_subexp (NULL_TYPE, exp, pos,
2741                                     EVAL_AVOID_SIDE_EFFECTS);
2742
2743           /* 'decltype' has special semantics for lvalues.  */
2744           if (op == OP_DECLTYPE
2745               && (sub_op == BINOP_SUBSCRIPT
2746                   || sub_op == STRUCTOP_MEMBER
2747                   || sub_op == STRUCTOP_MPTR
2748                   || sub_op == UNOP_IND
2749                   || sub_op == STRUCTOP_STRUCT
2750                   || sub_op == STRUCTOP_PTR
2751                   || sub_op == OP_SCOPE))
2752             {
2753               struct type *type = value_type (result);
2754
2755               if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF)
2756                 {
2757                   type = lookup_reference_type (type);
2758                   result = allocate_value (type);
2759                 }
2760             }
2761
2762           return result;
2763         }
2764       else
2765         error (_("Attempt to use a type as an expression"));
2766
2767     case OP_TYPEID:
2768       {
2769         struct value *result;
2770         enum exp_opcode sub_op = exp->elts[*pos].opcode;
2771
2772         if (sub_op == OP_TYPE || sub_op == OP_DECLTYPE || sub_op == OP_TYPEOF)
2773           result = evaluate_subexp (NULL_TYPE, exp, pos,
2774                                     EVAL_AVOID_SIDE_EFFECTS);
2775         else
2776           result = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2777
2778         if (noside != EVAL_NORMAL)
2779           return allocate_value (cplus_typeid_type (exp->gdbarch));
2780
2781         return cplus_typeid (result);
2782       }
2783
2784     default:
2785       /* Removing this case and compiling with gcc -Wall reveals that
2786          a lot of cases are hitting this case.  Some of these should
2787          probably be removed from expression.h; others are legitimate
2788          expressions which are (apparently) not fully implemented.
2789
2790          If there are any cases landing here which mean a user error,
2791          then they should be separate cases, with more descriptive
2792          error messages.  */
2793
2794       error (_("GDB does not (yet) know how to "
2795                "evaluate that kind of expression"));
2796     }
2797
2798 nosideret:
2799   return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
2800 }
2801 \f
2802 /* Evaluate a subexpression of EXP, at index *POS,
2803    and return the address of that subexpression.
2804    Advance *POS over the subexpression.
2805    If the subexpression isn't an lvalue, get an error.
2806    NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2807    then only the type of the result need be correct.  */
2808
2809 static struct value *
2810 evaluate_subexp_for_address (struct expression *exp, int *pos,
2811                              enum noside noside)
2812 {
2813   enum exp_opcode op;
2814   int pc;
2815   struct symbol *var;
2816   struct value *x;
2817   int tem;
2818
2819   pc = (*pos);
2820   op = exp->elts[pc].opcode;
2821
2822   switch (op)
2823     {
2824     case UNOP_IND:
2825       (*pos)++;
2826       x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2827
2828       /* We can't optimize out "&*" if there's a user-defined operator*.  */
2829       if (unop_user_defined_p (op, x))
2830         {
2831           x = value_x_unop (x, op, noside);
2832           goto default_case_after_eval;
2833         }
2834
2835       return coerce_array (x);
2836
2837     case UNOP_MEMVAL:
2838       (*pos) += 3;
2839       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2840                          evaluate_subexp (NULL_TYPE, exp, pos, noside));
2841
2842     case UNOP_MEMVAL_TYPE:
2843       {
2844         struct type *type;
2845
2846         (*pos) += 1;
2847         x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2848         type = value_type (x);
2849         return value_cast (lookup_pointer_type (type),
2850                            evaluate_subexp (NULL_TYPE, exp, pos, noside));
2851       }
2852
2853     case OP_VAR_VALUE:
2854       var = exp->elts[pc + 2].symbol;
2855
2856       /* C++: The "address" of a reference should yield the address
2857        * of the object pointed to.  Let value_addr() deal with it.  */
2858       if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
2859         goto default_case;
2860
2861       (*pos) += 4;
2862       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2863         {
2864           struct type *type =
2865             lookup_pointer_type (SYMBOL_TYPE (var));
2866           enum address_class sym_class = SYMBOL_CLASS (var);
2867
2868           if (sym_class == LOC_CONST
2869               || sym_class == LOC_CONST_BYTES
2870               || sym_class == LOC_REGISTER)
2871             error (_("Attempt to take address of register or constant."));
2872
2873           return
2874             value_zero (type, not_lval);
2875         }
2876       else
2877         return address_of_variable (var, exp->elts[pc + 1].block);
2878
2879     case OP_SCOPE:
2880       tem = longest_to_int (exp->elts[pc + 2].longconst);
2881       (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2882       x = value_aggregate_elt (exp->elts[pc + 1].type,
2883                                &exp->elts[pc + 3].string,
2884                                NULL, 1, noside);
2885       if (x == NULL)
2886         error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2887       return x;
2888
2889     default:
2890     default_case:
2891       x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2892     default_case_after_eval:
2893       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2894         {
2895           struct type *type = check_typedef (value_type (x));
2896
2897           if (TYPE_CODE (type) == TYPE_CODE_REF)
2898             return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2899                                not_lval);
2900           else if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2901             return value_zero (lookup_pointer_type (value_type (x)),
2902                                not_lval);
2903           else
2904             error (_("Attempt to take address of "
2905                      "value not located in memory."));
2906         }
2907       return value_addr (x);
2908     }
2909 }
2910
2911 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2912    When used in contexts where arrays will be coerced anyway, this is
2913    equivalent to `evaluate_subexp' but much faster because it avoids
2914    actually fetching array contents (perhaps obsolete now that we have
2915    value_lazy()).
2916
2917    Note that we currently only do the coercion for C expressions, where
2918    arrays are zero based and the coercion is correct.  For other languages,
2919    with nonzero based arrays, coercion loses.  Use CAST_IS_CONVERSION
2920    to decide if coercion is appropriate.  */
2921
2922 struct value *
2923 evaluate_subexp_with_coercion (struct expression *exp,
2924                                int *pos, enum noside noside)
2925 {
2926   enum exp_opcode op;
2927   int pc;
2928   struct value *val;
2929   struct symbol *var;
2930   struct type *type;
2931
2932   pc = (*pos);
2933   op = exp->elts[pc].opcode;
2934
2935   switch (op)
2936     {
2937     case OP_VAR_VALUE:
2938       var = exp->elts[pc + 2].symbol;
2939       type = check_typedef (SYMBOL_TYPE (var));
2940       if (TYPE_CODE (type) == TYPE_CODE_ARRAY
2941           && !TYPE_VECTOR (type)
2942           && CAST_IS_CONVERSION (exp->language_defn))
2943         {
2944           (*pos) += 4;
2945           val = address_of_variable (var, exp->elts[pc + 1].block);
2946           return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2947                              val);
2948         }
2949       /* FALLTHROUGH */
2950
2951     default:
2952       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2953     }
2954 }
2955
2956 /* Evaluate a subexpression of EXP, at index *POS,
2957    and return a value for the size of that subexpression.
2958    Advance *POS over the subexpression.  If NOSIDE is EVAL_NORMAL
2959    we allow side-effects on the operand if its type is a variable
2960    length array.   */
2961
2962 static struct value *
2963 evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
2964                             enum noside noside)
2965 {
2966   /* FIXME: This should be size_t.  */
2967   struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
2968   enum exp_opcode op;
2969   int pc;
2970   struct type *type;
2971   struct value *val;
2972
2973   pc = (*pos);
2974   op = exp->elts[pc].opcode;
2975
2976   switch (op)
2977     {
2978       /* This case is handled specially
2979          so that we avoid creating a value for the result type.
2980          If the result type is very big, it's desirable not to
2981          create a value unnecessarily.  */
2982     case UNOP_IND:
2983       (*pos)++;
2984       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2985       type = check_typedef (value_type (val));
2986       if (TYPE_CODE (type) != TYPE_CODE_PTR
2987           && TYPE_CODE (type) != TYPE_CODE_REF
2988           && TYPE_CODE (type) != TYPE_CODE_ARRAY)
2989         error (_("Attempt to take contents of a non-pointer value."));
2990       type = TYPE_TARGET_TYPE (type);
2991       if (is_dynamic_type (type))
2992         type = value_type (value_ind (val));
2993       return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
2994
2995     case UNOP_MEMVAL:
2996       (*pos) += 3;
2997       type = exp->elts[pc + 1].type;
2998       break;
2999
3000     case UNOP_MEMVAL_TYPE:
3001       (*pos) += 1;
3002       val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3003       type = value_type (val);
3004       break;
3005
3006     case OP_VAR_VALUE:
3007       type = SYMBOL_TYPE (exp->elts[pc + 2].symbol);
3008       if (is_dynamic_type (type))
3009         {
3010           val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3011           type = value_type (val);
3012         }
3013       else
3014         (*pos) += 4;
3015       break;
3016
3017       /* Deal with the special case if NOSIDE is EVAL_NORMAL and the resulting
3018          type of the subscript is a variable length array type. In this case we
3019          must re-evaluate the right hand side of the subcription to allow
3020          side-effects. */
3021     case BINOP_SUBSCRIPT:
3022       if (noside == EVAL_NORMAL)
3023         {
3024           int pc = (*pos) + 1;
3025
3026           val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
3027           type = check_typedef (value_type (val));
3028           if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3029             {
3030               type = check_typedef (TYPE_TARGET_TYPE (type));
3031               if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
3032                 {
3033                   type = TYPE_INDEX_TYPE (type);
3034                   /* Only re-evaluate the right hand side if the resulting type
3035                      is a variable length type.  */
3036                   if (TYPE_RANGE_DATA (type)->flag_bound_evaluated)
3037                     {
3038                       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
3039                       return value_from_longest
3040                         (size_type, (LONGEST) TYPE_LENGTH (value_type (val)));
3041                     }
3042                 }
3043             }
3044         }
3045
3046       /* Fall through.  */
3047
3048     default:
3049       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
3050       type = value_type (val);
3051       break;
3052     }
3053
3054   /* $5.3.3/2 of the C++ Standard (n3290 draft) says of sizeof:
3055      "When applied to a reference or a reference type, the result is
3056      the size of the referenced type."  */
3057   CHECK_TYPEDEF (type);
3058   if (exp->language_defn->la_language == language_cplus
3059       && TYPE_CODE (type) == TYPE_CODE_REF)
3060     type = check_typedef (TYPE_TARGET_TYPE (type));
3061   return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
3062 }
3063
3064 /* Parse a type expression in the string [P..P+LENGTH).  */
3065
3066 struct type *
3067 parse_and_eval_type (char *p, int length)
3068 {
3069   char *tmp = (char *) alloca (length + 4);
3070   struct expression *expr;
3071
3072   tmp[0] = '(';
3073   memcpy (tmp + 1, p, length);
3074   tmp[length + 1] = ')';
3075   tmp[length + 2] = '0';
3076   tmp[length + 3] = '\0';
3077   expr = parse_expression (tmp);
3078   if (expr->elts[0].opcode != UNOP_CAST)
3079     error (_("Internal error in eval_type."));
3080   return expr->elts[1].type;
3081 }
3082
3083 int
3084 calc_f77_array_dims (struct type *array_type)
3085 {
3086   int ndimen = 1;
3087   struct type *tmp_type;
3088
3089   if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
3090     error (_("Can't get dimensions for a non-array type"));
3091
3092   tmp_type = array_type;
3093
3094   while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
3095     {
3096       if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)
3097         ++ndimen;
3098     }
3099   return ndimen;
3100 }