gdb/eval.c

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