gdb/eval.c

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