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
  44 #include "gdb_assert.h"
  45
  46 /* This is defined in valops.c */
  47 extern int overload_resolution;
  48
  49 /* Prototypes for local functions. */
  50
  51 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
  52
  53 static struct value *evaluate_subexp_for_address (struct expression *,
  54                                                   int *, enum noside);
  55
  56 static struct value *evaluate_subexp (struct type *, 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 static 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 (current_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 (current_gdbarch)
 766                + gdbarch_num_pseudo_regs (current_gdbarch))
 767           val = value_zero (register_type (current_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       return value_string (&exp->elts[pc + 2].string, tem);
 790
 791     case OP_OBJC_NSSTRING:              /* Objective C Foundation Class NSString constant.  */
 792       tem = longest_to_int (exp->elts[pc + 1].longconst);
 793       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
 794       if (noside == EVAL_SKIP)
 795         {
 796           goto nosideret;
 797         }
 798       return (struct value *) value_nsstring (&exp->elts[pc + 2].string, tem + 1);
 799
 800     case OP_BITSTRING:
 801       tem = longest_to_int (exp->elts[pc + 1].longconst);
 802       (*pos)
 803         += 3 + BYTES_TO_EXP_ELEM ((tem + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
 804       if (noside == EVAL_SKIP)
 805         goto nosideret;
 806       return value_bitstring (&exp->elts[pc + 2].string, tem);
 807       break;
 808
 809     case OP_ARRAY:
 810       (*pos) += 3;
 811       tem2 = longest_to_int (exp->elts[pc + 1].longconst);
 812       tem3 = longest_to_int (exp->elts[pc + 2].longconst);
 813       nargs = tem3 - tem2 + 1;
 814       type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
 815
 816       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
 817           && TYPE_CODE (type) == TYPE_CODE_STRUCT)
 818         {
 819           struct value *rec = allocate_value (expect_type);
 820           memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
 821           return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
 822         }
 823
 824       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
 825           && TYPE_CODE (type) == TYPE_CODE_ARRAY)
 826         {
 827           struct type *range_type = TYPE_INDEX_TYPE (type);
 828           struct type *element_type = TYPE_TARGET_TYPE (type);
 829           struct value *array = allocate_value (expect_type);
 830           int element_size = TYPE_LENGTH (check_typedef (element_type));
 831           LONGEST low_bound, high_bound, index;
 832           if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
 833             {
 834               low_bound = 0;
 835               high_bound = (TYPE_LENGTH (type) / element_size) - 1;
 836             }
 837           index = low_bound;
 838           memset (value_contents_raw (array), 0, TYPE_LENGTH (expect_type));
 839           for (tem = nargs; --nargs >= 0;)
 840             {
 841               struct value *element;
 842               int index_pc = 0;
 843               if (exp->elts[*pos].opcode == BINOP_RANGE)
 844                 {
 845                   index_pc = ++(*pos);
 846                   evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
 847                 }
 848               element = evaluate_subexp (element_type, exp, pos, noside);
 849               if (value_type (element) != element_type)
 850                 element = value_cast (element_type, element);
 851               if (index_pc)
 852                 {
 853                   int continue_pc = *pos;
 854                   *pos = index_pc;
 855                   index = init_array_element (array, element, exp, pos, noside,
 856                                               low_bound, high_bound);
 857                   *pos = continue_pc;
 858                 }
 859               else
 860                 {
 861                   if (index > high_bound)
 862                     /* to avoid memory corruption */
 863                     error (_("Too many array elements"));
 864                   memcpy (value_contents_raw (array)
 865                           + (index - low_bound) * element_size,
 866                           value_contents (element),
 867                           element_size);
 868                 }
 869               index++;
 870             }
 871           return array;
 872         }
 873
 874       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
 875           && TYPE_CODE (type) == TYPE_CODE_SET)
 876         {
 877           struct value *set = allocate_value (expect_type);
 878           gdb_byte *valaddr = value_contents_raw (set);
 879           struct type *element_type = TYPE_INDEX_TYPE (type);
 880           struct type *check_type = element_type;
 881           LONGEST low_bound, high_bound;
 882
 883           /* get targettype of elementtype */
 884           while (TYPE_CODE (check_type) == TYPE_CODE_RANGE ||
 885                  TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
 886             check_type = TYPE_TARGET_TYPE (check_type);
 887
 888           if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
 889             error (_("(power)set type with unknown size"));
 890           memset (valaddr, '\0', TYPE_LENGTH (type));
 891           for (tem = 0; tem < nargs; tem++)
 892             {
 893               LONGEST range_low, range_high;
 894               struct type *range_low_type, *range_high_type;
 895               struct value *elem_val;
 896               if (exp->elts[*pos].opcode == BINOP_RANGE)
 897                 {
 898                   (*pos)++;
 899                   elem_val = evaluate_subexp (element_type, exp, pos, noside);
 900                   range_low_type = value_type (elem_val);
 901                   range_low = value_as_long (elem_val);
 902                   elem_val = evaluate_subexp (element_type, exp, pos, noside);
 903                   range_high_type = value_type (elem_val);
 904                   range_high = value_as_long (elem_val);
 905                 }
 906               else
 907                 {
 908                   elem_val = evaluate_subexp (element_type, exp, pos, noside);
 909                   range_low_type = range_high_type = value_type (elem_val);
 910                   range_low = range_high = value_as_long (elem_val);
 911                 }
 912               /* check types of elements to avoid mixture of elements from
 913                  different types. Also check if type of element is "compatible"
 914                  with element type of powerset */
 915               if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
 916                 range_low_type = TYPE_TARGET_TYPE (range_low_type);
 917               if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
 918                 range_high_type = TYPE_TARGET_TYPE (range_high_type);
 919               if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type)) ||
 920                   (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM &&
 921                    (range_low_type != range_high_type)))
 922                 /* different element modes */
 923                 error (_("POWERSET tuple elements of different mode"));
 924               if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) ||
 925                   (TYPE_CODE (check_type) == TYPE_CODE_ENUM &&
 926                    range_low_type != check_type))
 927                 error (_("incompatible POWERSET tuple elements"));
 928               if (range_low > range_high)
 929                 {
 930                   warning (_("empty POWERSET tuple range"));
 931                   continue;
 932                 }
 933               if (range_low < low_bound || range_high > high_bound)
 934                 error (_("POWERSET tuple element out of range"));
 935               range_low -= low_bound;
 936               range_high -= low_bound;
 937               for (; range_low <= range_high; range_low++)
 938                 {
 939                   int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
 940                   if (gdbarch_bits_big_endian (current_gdbarch))
 941                     bit_index = TARGET_CHAR_BIT - 1 - bit_index;
 942                   valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
 943                     |= 1 << bit_index;
 944                 }
 945             }
 946           return set;
 947         }
 948
 949       argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
 950       for (tem = 0; tem < nargs; tem++)
 951         {
 952           /* Ensure that array expressions are coerced into pointer objects. */
 953           argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
 954         }
 955       if (noside == EVAL_SKIP)
 956         goto nosideret;
 957       return value_array (tem2, tem3, argvec);
 958
 959     case TERNOP_SLICE:
 960       {
 961         struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 962         int lowbound
 963         = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 964         int upper
 965         = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 966         if (noside == EVAL_SKIP)
 967           goto nosideret;
 968         return value_slice (array, lowbound, upper - lowbound + 1);
 969       }
 970
 971     case TERNOP_SLICE_COUNT:
 972       {
 973         struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 974         int lowbound
 975         = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 976         int length
 977         = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
 978         return value_slice (array, lowbound, length);
 979       }
 980
 981     case TERNOP_COND:
 982       /* Skip third and second args to evaluate the first one.  */
 983       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 984       if (value_logical_not (arg1))
 985         {
 986           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
 987           return evaluate_subexp (NULL_TYPE, exp, pos, noside);
 988         }
 989       else
 990         {
 991           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
 992           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
 993           return arg2;
 994         }
 995
 996     case OP_OBJC_SELECTOR:
 997       {                         /* Objective C @selector operator.  */
 998         char *sel = &exp->elts[pc + 2].string;
 999         int len = longest_to_int (exp->elts[pc + 1].longconst);
1000         struct type *selector_type;
1001
1002         (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
1003         if (noside == EVAL_SKIP)
1004           goto nosideret;
1005
1006         if (sel[len] != 0)
1007           sel[len] = 0;         /* Make sure it's terminated.  */
1008
1009         selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1010         return value_from_longest (selector_type, lookup_child_selector (sel));
1011       }
1012
1013     case OP_OBJC_MSGCALL:
1014       {                         /* Objective C message (method) call.  */
1015
1016         static CORE_ADDR responds_selector = 0;
1017         static CORE_ADDR method_selector = 0;
1018
1019         CORE_ADDR selector = 0;
1020
1021         int struct_return = 0;
1022         int sub_no_side = 0;
1023
1024         static struct value *msg_send = NULL;
1025         static struct value *msg_send_stret = NULL;
1026         static int gnu_runtime = 0;
1027
1028         struct value *target = NULL;
1029         struct value *method = NULL;
1030         struct value *called_method = NULL;
1031
1032         struct type *selector_type = NULL;
1033         struct type *long_type;
1034
1035         struct value *ret = NULL;
1036         CORE_ADDR addr = 0;
1037
1038         selector = exp->elts[pc + 1].longconst;
1039         nargs = exp->elts[pc + 2].longconst;
1040         argvec = (struct value **) alloca (sizeof (struct value *)
1041                                            * (nargs + 5));
1042
1043         (*pos) += 3;
1044
1045         long_type = builtin_type (exp->gdbarch)->builtin_long;
1046         selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
1047
1048         if (noside == EVAL_AVOID_SIDE_EFFECTS)
1049           sub_no_side = EVAL_NORMAL;
1050         else
1051           sub_no_side = noside;
1052
1053         target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
1054
1055         if (value_as_long (target) == 0)
1056           return value_from_longest (long_type, 0);
1057
1058         if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
1059           gnu_runtime = 1;
1060
1061         /* Find the method dispatch (Apple runtime) or method lookup
1062            (GNU runtime) function for Objective-C.  These will be used
1063            to lookup the symbol information for the method.  If we
1064            can't find any symbol information, then we'll use these to
1065            call the method, otherwise we can call the method
1066            directly. The msg_send_stret function is used in the special
1067            case of a method that returns a structure (Apple runtime
1068            only).  */
1069         if (gnu_runtime)
1070           {
1071             struct type *type = selector_type;
1072             type = lookup_function_type (type);
1073             type = lookup_pointer_type (type);
1074             type = lookup_function_type (type);
1075             type = lookup_pointer_type (type);
1076
1077             msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
1078             msg_send_stret
1079               = find_function_in_inferior ("objc_msg_lookup", NULL);
1080
1081             msg_send = value_from_pointer (type, value_as_address (msg_send));
1082             msg_send_stret = value_from_pointer (type,
1083                                         value_as_address (msg_send_stret));
1084           }
1085         else
1086           {
1087             msg_send = find_function_in_inferior ("objc_msgSend", NULL);
1088             /* Special dispatcher for methods returning structs */
1089             msg_send_stret
1090               = find_function_in_inferior ("objc_msgSend_stret", NULL);
1091           }
1092
1093         /* Verify the target object responds to this method. The
1094            standard top-level 'Object' class uses a different name for
1095            the verification method than the non-standard, but more
1096            often used, 'NSObject' class. Make sure we check for both. */
1097
1098         responds_selector = lookup_child_selector ("respondsToSelector:");
1099         if (responds_selector == 0)
1100           responds_selector = lookup_child_selector ("respondsTo:");
1101
1102         if (responds_selector == 0)
1103           error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
1104
1105         method_selector = lookup_child_selector ("methodForSelector:");
1106         if (method_selector == 0)
1107           method_selector = lookup_child_selector ("methodFor:");
1108
1109         if (method_selector == 0)
1110           error (_("no 'methodFor:' or 'methodForSelector:' method"));
1111
1112         /* Call the verification method, to make sure that the target
1113          class implements the desired method. */
1114
1115         argvec[0] = msg_send;
1116         argvec[1] = target;
1117         argvec[2] = value_from_longest (long_type, responds_selector);
1118         argvec[3] = value_from_longest (long_type, selector);
1119         argvec[4] = 0;
1120
1121         ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1122         if (gnu_runtime)
1123           {
1124             /* Function objc_msg_lookup returns a pointer.  */
1125             argvec[0] = ret;
1126             ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1127           }
1128         if (value_as_long (ret) == 0)
1129           error (_("Target does not respond to this message selector."));
1130
1131         /* Call "methodForSelector:" method, to get the address of a
1132            function method that implements this selector for this
1133            class.  If we can find a symbol at that address, then we
1134            know the return type, parameter types etc.  (that's a good
1135            thing). */
1136
1137         argvec[0] = msg_send;
1138         argvec[1] = target;
1139         argvec[2] = value_from_longest (long_type, method_selector);
1140         argvec[3] = value_from_longest (long_type, selector);
1141         argvec[4] = 0;
1142
1143         ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1144         if (gnu_runtime)
1145           {
1146             argvec[0] = ret;
1147             ret = call_function_by_hand (argvec[0], 3, argvec + 1);
1148           }
1149
1150         /* ret should now be the selector.  */
1151
1152         addr = value_as_long (ret);
1153         if (addr)
1154           {
1155             struct symbol *sym = NULL;
1156             /* Is it a high_level symbol?  */
1157
1158             sym = find_pc_function (addr);
1159             if (sym != NULL)
1160               method = value_of_variable (sym, 0);
1161           }
1162
1163         /* If we found a method with symbol information, check to see
1164            if it returns a struct.  Otherwise assume it doesn't.  */
1165
1166         if (method)
1167           {
1168             struct block *b;
1169             CORE_ADDR funaddr;
1170             struct type *val_type;
1171
1172             funaddr = find_function_addr (method, &val_type);
1173
1174             b = block_for_pc (funaddr);
1175
1176             CHECK_TYPEDEF (val_type);
1177
1178             if ((val_type == NULL)
1179                 || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
1180               {
1181                 if (expect_type != NULL)
1182                   val_type = expect_type;
1183               }
1184
1185             struct_return = using_struct_return (value_type (method), val_type);
1186           }
1187         else if (expect_type != NULL)
1188           {
1189             struct_return = using_struct_return (NULL,
1190                                                  check_typedef (expect_type));
1191           }
1192
1193         /* Found a function symbol.  Now we will substitute its
1194            value in place of the message dispatcher (obj_msgSend),
1195            so that we call the method directly instead of thru
1196            the dispatcher.  The main reason for doing this is that
1197            we can now evaluate the return value and parameter values
1198            according to their known data types, in case we need to
1199            do things like promotion, dereferencing, special handling
1200            of structs and doubles, etc.
1201
1202            We want to use the type signature of 'method', but still
1203            jump to objc_msgSend() or objc_msgSend_stret() to better
1204            mimic the behavior of the runtime.  */
1205
1206         if (method)
1207           {
1208             if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
1209               error (_("method address has symbol information with non-function type; skipping"));
1210             if (struct_return)
1211               VALUE_ADDRESS (method) = value_as_address (msg_send_stret);
1212             else
1213               VALUE_ADDRESS (method) = value_as_address (msg_send);
1214             called_method = method;
1215           }
1216         else
1217           {
1218             if (struct_return)
1219               called_method = msg_send_stret;
1220             else
1221               called_method = msg_send;
1222           }
1223
1224         if (noside == EVAL_SKIP)
1225           goto nosideret;
1226
1227         if (noside == EVAL_AVOID_SIDE_EFFECTS)
1228           {
1229             /* If the return type doesn't look like a function type,
1230                call an error.  This can happen if somebody tries to
1231                turn a variable into a function call. This is here
1232                because people often want to call, eg, strcmp, which
1233                gdb doesn't know is a function.  If gdb isn't asked for
1234                it's opinion (ie. through "whatis"), it won't offer
1235                it. */
1236
1237             struct type *type = value_type (called_method);
1238             if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1239               type = TYPE_TARGET_TYPE (type);
1240             type = TYPE_TARGET_TYPE (type);
1241
1242             if (type)
1243             {
1244               if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
1245                 return allocate_value (expect_type);
1246               else
1247                 return allocate_value (type);
1248             }
1249             else
1250               error (_("Expression of type other than \"method returning ...\" used as a method"));
1251           }
1252
1253         /* Now depending on whether we found a symbol for the method,
1254            we will either call the runtime dispatcher or the method
1255            directly.  */
1256
1257         argvec[0] = called_method;
1258         argvec[1] = target;
1259         argvec[2] = value_from_longest (long_type, selector);
1260         /* User-supplied arguments.  */
1261         for (tem = 0; tem < nargs; tem++)
1262           argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
1263         argvec[tem + 3] = 0;
1264
1265         if (gnu_runtime && (method != NULL))
1266           {
1267             /* Function objc_msg_lookup returns a pointer.  */
1268             deprecated_set_value_type (argvec[0],
1269                                        lookup_function_type (lookup_pointer_type (value_type (argvec[0]))));
1270             argvec[0] = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1271           }
1272
1273         ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
1274         return ret;
1275       }
1276       break;
1277
1278     case OP_FUNCALL:
1279       (*pos) += 2;
1280       op = exp->elts[*pos].opcode;
1281       nargs = longest_to_int (exp->elts[pc + 1].longconst);
1282       /* Allocate arg vector, including space for the function to be
1283          called in argvec[0] and a terminating NULL */
1284       argvec = (struct value **) alloca (sizeof (struct value *) * (nargs + 3));
1285       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1286         {
1287           nargs++;
1288           /* First, evaluate the structure into arg2 */
1289           pc2 = (*pos)++;
1290
1291           if (noside == EVAL_SKIP)
1292             goto nosideret;
1293
1294           if (op == STRUCTOP_MEMBER)
1295             {
1296               arg2 = evaluate_subexp_for_address (exp, pos, noside);
1297             }
1298           else
1299             {
1300               arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1301             }
1302
1303           /* If the function is a virtual function, then the
1304              aggregate value (providing the structure) plays
1305              its part by providing the vtable.  Otherwise,
1306              it is just along for the ride: call the function
1307              directly.  */
1308
1309           arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1310
1311           if (TYPE_CODE (check_typedef (value_type (arg1)))
1312               != TYPE_CODE_METHODPTR)
1313             error (_("Non-pointer-to-member value used in pointer-to-member "
1314                      "construct"));
1315
1316           if (noside == EVAL_AVOID_SIDE_EFFECTS)
1317             {
1318               struct type *method_type = check_typedef (value_type (arg1));
1319               arg1 = value_zero (method_type, not_lval);
1320             }
1321           else
1322             arg1 = cplus_method_ptr_to_value (&arg2, arg1);
1323
1324           /* Now, say which argument to start evaluating from */
1325           tem = 2;
1326         }
1327       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1328         {
1329           /* Hair for method invocations */
1330           int tem2;
1331
1332           nargs++;
1333           /* First, evaluate the structure into arg2 */
1334           pc2 = (*pos)++;
1335           tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
1336           *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
1337           if (noside == EVAL_SKIP)
1338             goto nosideret;
1339
1340           if (op == STRUCTOP_STRUCT)
1341             {
1342               /* If v is a variable in a register, and the user types
1343                  v.method (), this will produce an error, because v has
1344                  no address.
1345
1346                  A possible way around this would be to allocate a
1347                  copy of the variable on the stack, copy in the
1348                  contents, call the function, and copy out the
1349                  contents.  I.e. convert this from call by reference
1350                  to call by copy-return (or whatever it's called).
1351                  However, this does not work because it is not the
1352                  same: the method being called could stash a copy of
1353                  the address, and then future uses through that address
1354                  (after the method returns) would be expected to
1355                  use the variable itself, not some copy of it.  */
1356               arg2 = evaluate_subexp_for_address (exp, pos, noside);
1357             }
1358           else
1359             {
1360               arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1361             }
1362           /* Now, say which argument to start evaluating from */
1363           tem = 2;
1364         }
1365       else
1366         {
1367           /* Non-method function call */
1368           save_pos1 = *pos;
1369           argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
1370           tem = 1;
1371           type = value_type (argvec[0]);
1372           if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
1373             type = TYPE_TARGET_TYPE (type);
1374           if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
1375             {
1376               for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
1377                 {
1378                   /* pai: FIXME This seems to be coercing arguments before
1379                    * overload resolution has been done! */
1380                   argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type, tem - 1),
1381                                                  exp, pos, noside);
1382                 }
1383             }
1384         }
1385
1386       /* Evaluate arguments */
1387       for (; tem <= nargs; tem++)
1388         {
1389           /* Ensure that array expressions are coerced into pointer objects. */
1390           argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1391         }
1392
1393       /* signal end of arglist */
1394       argvec[tem] = 0;
1395
1396       if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
1397         {
1398           int static_memfuncp;
1399           char tstr[256];
1400
1401           /* Method invocation : stuff "this" as first parameter */
1402           argvec[1] = arg2;
1403           /* Name of method from expression */
1404           strcpy (tstr, &exp->elts[pc2 + 2].string);
1405
1406           if (overload_resolution && (exp->language_defn->la_language == language_cplus))
1407             {
1408               /* Language is C++, do some overload resolution before evaluation */
1409               struct value *valp = NULL;
1410
1411               /* Prepare list of argument types for overload resolution */
1412               arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
1413               for (ix = 1; ix <= nargs; ix++)
1414                 arg_types[ix - 1] = value_type (argvec[ix]);
1415
1416               (void) find_overload_match (arg_types, nargs, tstr,
1417                                      1 /* method */ , 0 /* strict match */ ,
1418                                           &arg2 /* the object */ , NULL,
1419                                           &valp, NULL, &static_memfuncp);
1420
1421
1422               argvec[1] = arg2; /* the ``this'' pointer */
1423               argvec[0] = valp; /* use the method found after overload resolution */
1424             }
1425           else
1426             /* Non-C++ case -- or no overload resolution */
1427             {
1428               struct value *temp = arg2;
1429               argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
1430                                             &static_memfuncp,
1431                                             op == STRUCTOP_STRUCT
1432                                        ? "structure" : "structure pointer");
1433               /* value_struct_elt updates temp with the correct value
1434                  of the ``this'' pointer if necessary, so modify argvec[1] to
1435                  reflect any ``this'' changes.  */
1436               arg2 = value_from_longest (lookup_pointer_type(value_type (temp)),
1437                                          VALUE_ADDRESS (temp) + value_offset (temp)
1438                                          + value_embedded_offset (temp));
1439               argvec[1] = arg2; /* the ``this'' pointer */
1440             }
1441
1442           if (static_memfuncp)
1443             {
1444               argvec[1] = argvec[0];
1445               nargs--;
1446               argvec++;
1447             }
1448         }
1449       else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
1450         {
1451           argvec[1] = arg2;
1452           argvec[0] = arg1;
1453         }
1454       else if (op == OP_VAR_VALUE)
1455         {
1456           /* Non-member function being called */
1457           /* fn: This can only be done for C++ functions.  A C-style function
1458              in a C++ program, for instance, does not have the fields that
1459              are expected here */
1460
1461           if (overload_resolution && (exp->language_defn->la_language == language_cplus))
1462             {
1463               /* Language is C++, do some overload resolution before evaluation */
1464               struct symbol *symp;
1465
1466               /* Prepare list of argument types for overload resolution */
1467               arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
1468               for (ix = 1; ix <= nargs; ix++)
1469                 arg_types[ix - 1] = value_type (argvec[ix]);
1470
1471               (void) find_overload_match (arg_types, nargs, NULL /* no need for name */ ,
1472                                  0 /* not method */ , 0 /* strict match */ ,
1473                       NULL, exp->elts[save_pos1+2].symbol /* the function */ ,
1474                                           NULL, &symp, NULL);
1475
1476               /* Now fix the expression being evaluated */
1477               exp->elts[save_pos1+2].symbol = symp;
1478               argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
1479             }
1480           else
1481             {
1482               /* Not C++, or no overload resolution allowed */
1483               /* nothing to be done; argvec already correctly set up */
1484             }
1485         }
1486       else
1487         {
1488           /* It is probably a C-style function */
1489           /* nothing to be done; argvec already correctly set up */
1490         }
1491
1492     do_call_it:
1493
1494       if (noside == EVAL_SKIP)
1495         goto nosideret;
1496       if (argvec[0] == NULL)
1497         error (_("Cannot evaluate function -- may be inlined"));
1498       if (noside == EVAL_AVOID_SIDE_EFFECTS)
1499         {
1500           /* If the return type doesn't look like a function type, call an
1501              error.  This can happen if somebody tries to turn a variable into
1502              a function call. This is here because people often want to
1503              call, eg, strcmp, which gdb doesn't know is a function.  If
1504              gdb isn't asked for it's opinion (ie. through "whatis"),
1505              it won't offer it. */
1506
1507           struct type *ftype =
1508           TYPE_TARGET_TYPE (value_type (argvec[0]));
1509
1510           if (ftype)
1511             return allocate_value (TYPE_TARGET_TYPE (value_type (argvec[0])));
1512           else
1513             error (_("Expression of type other than \"Function returning ...\" used as function"));
1514         }
1515       return call_function_by_hand (argvec[0], nargs, argvec + 1);
1516       /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve  */
1517
1518     case OP_F77_UNDETERMINED_ARGLIST:
1519
1520       /* Remember that in F77, functions, substring ops and
1521          array subscript operations cannot be disambiguated
1522          at parse time.  We have made all array subscript operations,
1523          substring operations as well as function calls  come here
1524          and we now have to discover what the heck this thing actually was.
1525          If it is a function, we process just as if we got an OP_FUNCALL. */
1526
1527       nargs = longest_to_int (exp->elts[pc + 1].longconst);
1528       (*pos) += 2;
1529
1530       /* First determine the type code we are dealing with.  */
1531       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1532       type = check_typedef (value_type (arg1));
1533       code = TYPE_CODE (type);
1534
1535       if (code == TYPE_CODE_PTR)
1536         {
1537           /* Fortran always passes variable to subroutines as pointer.
1538              So we need to look into its target type to see if it is
1539              array, string or function.  If it is, we need to switch
1540              to the target value the original one points to.  */
1541           struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
1542
1543           if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
1544               || TYPE_CODE (target_type) == TYPE_CODE_STRING
1545               || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
1546             {
1547               arg1 = value_ind (arg1);
1548               type = check_typedef (value_type (arg1));
1549               code = TYPE_CODE (type);
1550             }
1551         }
1552
1553       switch (code)
1554         {
1555         case TYPE_CODE_ARRAY:
1556           if (exp->elts[*pos].opcode == OP_F90_RANGE)
1557             return value_f90_subarray (arg1, exp, pos, noside);
1558           else
1559             goto multi_f77_subscript;
1560
1561         case TYPE_CODE_STRING:
1562           if (exp->elts[*pos].opcode == OP_F90_RANGE)
1563             return value_f90_subarray (arg1, exp, pos, noside);
1564           else
1565             {
1566               arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1567               return value_subscript (arg1, arg2);
1568             }
1569
1570         case TYPE_CODE_PTR:
1571         case TYPE_CODE_FUNC:
1572           /* It's a function call. */
1573           /* Allocate arg vector, including space for the function to be
1574              called in argvec[0] and a terminating NULL */
1575           argvec = (struct value **) alloca (sizeof (struct value *) * (nargs + 2));
1576           argvec[0] = arg1;
1577           tem = 1;
1578           for (; tem <= nargs; tem++)
1579             argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
1580           argvec[tem] = 0;      /* signal end of arglist */
1581           goto do_call_it;
1582
1583         default:
1584           error (_("Cannot perform substring on this type"));
1585         }
1586
1587     case OP_COMPLEX:
1588       /* We have a complex number, There should be 2 floating
1589          point numbers that compose it */
1590       (*pos) += 2;
1591       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1592       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1593
1594       return value_literal_complex (arg1, arg2, exp->elts[pc + 1].type);
1595
1596     case STRUCTOP_STRUCT:
1597       tem = longest_to_int (exp->elts[pc + 1].longconst);
1598       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1599       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1600       if (noside == EVAL_SKIP)
1601         goto nosideret;
1602       if (noside == EVAL_AVOID_SIDE_EFFECTS)
1603         return value_zero (lookup_struct_elt_type (value_type (arg1),
1604                                                    &exp->elts[pc + 2].string,
1605                                                    0),
1606                            lval_memory);
1607       else
1608         {
1609           struct value *temp = arg1;
1610           return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
1611                                    NULL, "structure");
1612         }
1613
1614     case STRUCTOP_PTR:
1615       tem = longest_to_int (exp->elts[pc + 1].longconst);
1616       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1617       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1618       if (noside == EVAL_SKIP)
1619         goto nosideret;
1620
1621       /* JYG: if print object is on we need to replace the base type
1622          with rtti type in order to continue on with successful
1623          lookup of member / method only available in the rtti type. */
1624       {
1625         struct type *type = value_type (arg1);
1626         struct type *real_type;
1627         int full, top, using_enc;
1628         struct value_print_options opts;
1629
1630         get_user_print_options (&opts);
1631         if (opts.objectprint && TYPE_TARGET_TYPE(type) &&
1632             (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
1633           {
1634             real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
1635             if (real_type)
1636               {
1637                 if (TYPE_CODE (type) == TYPE_CODE_PTR)
1638                   real_type = lookup_pointer_type (real_type);
1639                 else
1640                   real_type = lookup_reference_type (real_type);
1641
1642                 arg1 = value_cast (real_type, arg1);
1643               }
1644           }
1645       }
1646
1647       if (noside == EVAL_AVOID_SIDE_EFFECTS)
1648         return value_zero (lookup_struct_elt_type (value_type (arg1),
1649                                                    &exp->elts[pc + 2].string,
1650                                                    0),
1651                            lval_memory);
1652       else
1653         {
1654           struct value *temp = arg1;
1655           return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
1656                                    NULL, "structure pointer");
1657         }
1658
1659     case STRUCTOP_MEMBER:
1660     case STRUCTOP_MPTR:
1661       if (op == STRUCTOP_MEMBER)
1662         arg1 = evaluate_subexp_for_address (exp, pos, noside);
1663       else
1664         arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1665
1666       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1667
1668       if (noside == EVAL_SKIP)
1669         goto nosideret;
1670
1671       type = check_typedef (value_type (arg2));
1672       switch (TYPE_CODE (type))
1673         {
1674         case TYPE_CODE_METHODPTR:
1675           if (noside == EVAL_AVOID_SIDE_EFFECTS)
1676             return value_zero (TYPE_TARGET_TYPE (type), not_lval);
1677           else
1678             {
1679               arg2 = cplus_method_ptr_to_value (&arg1, arg2);
1680               gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
1681               return value_ind (arg2);
1682             }
1683
1684         case TYPE_CODE_MEMBERPTR:
1685           /* Now, convert these values to an address.  */
1686           arg1 = value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
1687                              arg1);
1688
1689           mem_offset = value_as_long (arg2);
1690
1691           arg3 = value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1692                                      value_as_long (arg1) + mem_offset);
1693           return value_ind (arg3);
1694
1695         default:
1696           error (_("non-pointer-to-member value used in pointer-to-member construct"));
1697         }
1698
1699     case BINOP_CONCAT:
1700       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1701       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1702       if (noside == EVAL_SKIP)
1703         goto nosideret;
1704       if (binop_user_defined_p (op, arg1, arg2))
1705         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1706       else
1707         return value_concat (arg1, arg2);
1708
1709     case BINOP_ASSIGN:
1710       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1711       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1712
1713       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1714         return arg1;
1715       if (binop_user_defined_p (op, arg1, arg2))
1716         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1717       else
1718         return value_assign (arg1, arg2);
1719
1720     case BINOP_ASSIGN_MODIFY:
1721       (*pos) += 2;
1722       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1723       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
1724       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
1725         return arg1;
1726       op = exp->elts[pc + 1].opcode;
1727       if (binop_user_defined_p (op, arg1, arg2))
1728         return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
1729       else if (op == BINOP_ADD && ptrmath_type_p (value_type (arg1)))
1730         arg2 = value_ptradd (arg1, arg2);
1731       else if (op == BINOP_SUB && ptrmath_type_p (value_type (arg1)))
1732         arg2 = value_ptrsub (arg1, arg2);
1733       else
1734         {
1735           struct value *tmp = arg1;
1736
1737           /* For shift and integer exponentiation operations,
1738              only promote the first argument.  */
1739           if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
1740               && is_integral_type (value_type (arg2)))
1741             unop_promote (exp->language_defn, exp->gdbarch, &tmp);
1742           else
1743             binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
1744
1745           arg2 = value_binop (tmp, arg2, op);
1746         }
1747       return value_assign (arg1, arg2);
1748
1749     case BINOP_ADD:
1750       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1751       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1752       if (noside == EVAL_SKIP)
1753         goto nosideret;
1754       if (binop_user_defined_p (op, arg1, arg2))
1755         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1756       else if (ptrmath_type_p (value_type (arg1)))
1757         return value_ptradd (arg1, arg2);
1758       else if (ptrmath_type_p (value_type (arg2)))
1759         return value_ptradd (arg2, arg1);
1760       else
1761         {
1762           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
1763           return value_binop (arg1, arg2, BINOP_ADD);
1764         }
1765
1766     case BINOP_SUB:
1767       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1768       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1769       if (noside == EVAL_SKIP)
1770         goto nosideret;
1771       if (binop_user_defined_p (op, arg1, arg2))
1772         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1773       else if (ptrmath_type_p (value_type (arg1)))
1774         {
1775           if (ptrmath_type_p (value_type (arg2)))
1776             {
1777               /* FIXME -- should be ptrdiff_t */
1778               type = builtin_type (exp->gdbarch)->builtin_long;
1779               return value_from_longest (type, value_ptrdiff (arg1, arg2));
1780             }
1781           else
1782             return value_ptrsub (arg1, arg2);
1783         }
1784       else
1785         {
1786           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
1787           return value_binop (arg1, arg2, BINOP_SUB);
1788         }
1789
1790     case BINOP_EXP:
1791     case BINOP_MUL:
1792     case BINOP_DIV:
1793     case BINOP_INTDIV:
1794     case BINOP_REM:
1795     case BINOP_MOD:
1796     case BINOP_LSH:
1797     case BINOP_RSH:
1798     case BINOP_BITWISE_AND:
1799     case BINOP_BITWISE_IOR:
1800     case BINOP_BITWISE_XOR:
1801       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1802       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1803       if (noside == EVAL_SKIP)
1804         goto nosideret;
1805       if (binop_user_defined_p (op, arg1, arg2))
1806         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1807       else
1808         {
1809           /* If EVAL_AVOID_SIDE_EFFECTS and we're dividing by zero,
1810              fudge arg2 to avoid division-by-zero, the caller is
1811              (theoretically) only looking for the type of the result.  */
1812           if (noside == EVAL_AVOID_SIDE_EFFECTS
1813               /* ??? Do we really want to test for BINOP_MOD here?
1814                  The implementation of value_binop gives it a well-defined
1815                  value.  */
1816               && (op == BINOP_DIV
1817                   || op == BINOP_INTDIV
1818                   || op == BINOP_REM
1819                   || op == BINOP_MOD)
1820               && value_logical_not (arg2))
1821             {
1822               struct value *v_one, *retval;
1823
1824               v_one = value_one (value_type (arg2), not_lval);
1825               binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
1826               retval = value_binop (arg1, v_one, op);
1827               return retval;
1828             }
1829           else
1830             {
1831               /* For shift and integer exponentiation operations,
1832                  only promote the first argument.  */
1833               if ((op == BINOP_LSH || op == BINOP_RSH || op == BINOP_EXP)
1834                   && is_integral_type (value_type (arg2)))
1835                 unop_promote (exp->language_defn, exp->gdbarch, &arg1);
1836               else
1837                 binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
1838
1839               return value_binop (arg1, arg2, op);
1840             }
1841         }
1842
1843     case BINOP_RANGE:
1844       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1845       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
1846       if (noside == EVAL_SKIP)
1847         goto nosideret;
1848       error (_("':' operator used in invalid context"));
1849
1850     case BINOP_SUBSCRIPT:
1851       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1852       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1853       if (noside == EVAL_SKIP)
1854         goto nosideret;
1855       if (binop_user_defined_p (op, arg1, arg2))
1856         return value_x_binop (arg1, arg2, op, OP_NULL, noside);
1857       else
1858         {
1859           /* If the user attempts to subscript something that is not an
1860              array or pointer type (like a plain int variable for example),
1861              then report this as an error. */
1862
1863           arg1 = coerce_ref (arg1);
1864           type = check_typedef (value_type (arg1));
1865           if (TYPE_CODE (type) != TYPE_CODE_ARRAY
1866               && TYPE_CODE (type) != TYPE_CODE_PTR)
1867             {
1868               if (TYPE_NAME (type))
1869                 error (_("cannot subscript something of type `%s'"),
1870                        TYPE_NAME (type));
1871               else
1872                 error (_("cannot subscript requested type"));
1873             }
1874
1875           if (noside == EVAL_AVOID_SIDE_EFFECTS)
1876             return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
1877           else
1878             return value_subscript (arg1, arg2);
1879         }
1880
1881     case BINOP_IN:
1882       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1883       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1884       if (noside == EVAL_SKIP)
1885         goto nosideret;
1886       type = language_bool_type (exp->language_defn, exp->gdbarch);
1887       return value_from_longest (type, (LONGEST) value_in (arg1, arg2));
1888
1889     case MULTI_SUBSCRIPT:
1890       (*pos) += 2;
1891       nargs = longest_to_int (exp->elts[pc + 1].longconst);
1892       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
1893       while (nargs-- > 0)
1894         {
1895           arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1896           /* FIXME:  EVAL_SKIP handling may not be correct. */
1897           if (noside == EVAL_SKIP)
1898             {
1899               if (nargs > 0)
1900                 {
1901                   continue;
1902                 }
1903               else
1904                 {
1905                   goto nosideret;
1906                 }
1907             }
1908           /* FIXME:  EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
1909           if (noside == EVAL_AVOID_SIDE_EFFECTS)
1910             {
1911               /* If the user attempts to subscript something that has no target
1912                  type (like a plain int variable for example), then report this
1913                  as an error. */
1914
1915               type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
1916               if (type != NULL)
1917                 {
1918                   arg1 = value_zero (type, VALUE_LVAL (arg1));
1919                   noside = EVAL_SKIP;
1920                   continue;
1921                 }
1922               else
1923                 {
1924                   error (_("cannot subscript something of type `%s'"),
1925                          TYPE_NAME (value_type (arg1)));
1926                 }
1927             }
1928
1929           if (binop_user_defined_p (op, arg1, arg2))
1930             {
1931               arg1 = value_x_binop (arg1, arg2, op, OP_NULL, noside);
1932             }
1933           else
1934             {
1935               arg1 = coerce_ref (arg1);
1936               type = check_typedef (value_type (arg1));
1937
1938               switch (TYPE_CODE (type))
1939                 {
1940                 case TYPE_CODE_PTR:
1941                 case TYPE_CODE_ARRAY:
1942                 case TYPE_CODE_STRING:
1943                   arg1 = value_subscript (arg1, arg2);
1944                   break;
1945
1946                 case TYPE_CODE_BITSTRING:
1947                   type = language_bool_type (exp->language_defn, exp->gdbarch);
1948                   arg1 = value_bitstring_subscript (type, arg1, arg2);
1949                   break;
1950
1951                 default:
1952                   if (TYPE_NAME (type))
1953                     error (_("cannot subscript something of type `%s'"),
1954                            TYPE_NAME (type));
1955                   else
1956                     error (_("cannot subscript requested type"));
1957                 }
1958             }
1959         }
1960       return (arg1);
1961
1962     multi_f77_subscript:
1963       {
1964         int subscript_array[MAX_FORTRAN_DIMS];
1965         int array_size_array[MAX_FORTRAN_DIMS];
1966         int ndimensions = 1, i;
1967         struct type *tmp_type;
1968         int offset_item;        /* The array offset where the item lives */
1969
1970         if (nargs > MAX_FORTRAN_DIMS)
1971           error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
1972
1973         tmp_type = check_typedef (value_type (arg1));
1974         ndimensions = calc_f77_array_dims (type);
1975
1976         if (nargs != ndimensions)
1977           error (_("Wrong number of subscripts"));
1978
1979         gdb_assert (nargs > 0);
1980
1981         /* Now that we know we have a legal array subscript expression
1982            let us actually find out where this element exists in the array. */
1983
1984         offset_item = 0;
1985         /* Take array indices left to right */
1986         for (i = 0; i < nargs; i++)
1987           {
1988             /* Evaluate each subscript, It must be a legal integer in F77 */
1989             arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
1990
1991             /* Fill in the subscript and array size arrays */
1992
1993             subscript_array[i] = value_as_long (arg2);
1994           }
1995
1996         /* Internal type of array is arranged right to left */
1997         for (i = 0; i < nargs; i++)
1998           {
1999             upper = f77_get_upperbound (tmp_type);
2000             lower = f77_get_lowerbound (tmp_type);
2001
2002             array_size_array[nargs - i - 1] = upper - lower + 1;
2003
2004             /* Zero-normalize subscripts so that offsetting will work. */
2005
2006             subscript_array[nargs - i - 1] -= lower;
2007
2008             /* If we are at the bottom of a multidimensional
2009                array type then keep a ptr to the last ARRAY
2010                type around for use when calling value_subscript()
2011                below. This is done because we pretend to value_subscript
2012                that we actually have a one-dimensional array
2013                of base element type that we apply a simple
2014                offset to. */
2015
2016             if (i < nargs - 1)
2017               tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
2018           }
2019
2020         /* Now let us calculate the offset for this item */
2021
2022         offset_item = subscript_array[ndimensions - 1];
2023
2024         for (i = ndimensions - 1; i > 0; --i)
2025           offset_item =
2026             array_size_array[i - 1] * offset_item + subscript_array[i - 1];
2027
2028         /* Construct a value node with the value of the offset */
2029
2030         arg2 = value_from_longest (builtin_type_int32, offset_item);
2031
2032         /* Let us now play a dirty trick: we will take arg1
2033            which is a value node pointing to the topmost level
2034            of the multidimensional array-set and pretend
2035            that it is actually a array of the final element
2036            type, this will ensure that value_subscript()
2037            returns the correct type value */
2038
2039         deprecated_set_value_type (arg1, tmp_type);
2040         return value_subscripted_rvalue (arg1, arg2, 0);
2041       }
2042
2043     case BINOP_LOGICAL_AND:
2044       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2045       if (noside == EVAL_SKIP)
2046         {
2047           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2048           goto nosideret;
2049         }
2050
2051       oldpos = *pos;
2052       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2053       *pos = oldpos;
2054
2055       if (binop_user_defined_p (op, arg1, arg2))
2056         {
2057           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2058           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2059         }
2060       else
2061         {
2062           tem = value_logical_not (arg1);
2063           arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2064                                   (tem ? EVAL_SKIP : noside));
2065           type = language_bool_type (exp->language_defn, exp->gdbarch);
2066           return value_from_longest (type,
2067                              (LONGEST) (!tem && !value_logical_not (arg2)));
2068         }
2069
2070     case BINOP_LOGICAL_OR:
2071       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2072       if (noside == EVAL_SKIP)
2073         {
2074           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2075           goto nosideret;
2076         }
2077
2078       oldpos = *pos;
2079       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2080       *pos = oldpos;
2081
2082       if (binop_user_defined_p (op, arg1, arg2))
2083         {
2084           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2085           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2086         }
2087       else
2088         {
2089           tem = value_logical_not (arg1);
2090           arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
2091                                   (!tem ? EVAL_SKIP : noside));
2092           type = language_bool_type (exp->language_defn, exp->gdbarch);
2093           return value_from_longest (type,
2094                              (LONGEST) (!tem || !value_logical_not (arg2)));
2095         }
2096
2097     case BINOP_EQUAL:
2098       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2099       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2100       if (noside == EVAL_SKIP)
2101         goto nosideret;
2102       if (binop_user_defined_p (op, arg1, arg2))
2103         {
2104           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2105         }
2106       else
2107         {
2108           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2109           tem = value_equal (arg1, arg2);
2110           type = language_bool_type (exp->language_defn, exp->gdbarch);
2111           return value_from_longest (type, (LONGEST) tem);
2112         }
2113
2114     case BINOP_NOTEQUAL:
2115       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2116       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2117       if (noside == EVAL_SKIP)
2118         goto nosideret;
2119       if (binop_user_defined_p (op, arg1, arg2))
2120         {
2121           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2122         }
2123       else
2124         {
2125           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2126           tem = value_equal (arg1, arg2);
2127           type = language_bool_type (exp->language_defn, exp->gdbarch);
2128           return value_from_longest (type, (LONGEST) ! tem);
2129         }
2130
2131     case BINOP_LESS:
2132       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2133       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2134       if (noside == EVAL_SKIP)
2135         goto nosideret;
2136       if (binop_user_defined_p (op, arg1, arg2))
2137         {
2138           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2139         }
2140       else
2141         {
2142           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2143           tem = value_less (arg1, arg2);
2144           type = language_bool_type (exp->language_defn, exp->gdbarch);
2145           return value_from_longest (type, (LONGEST) tem);
2146         }
2147
2148     case BINOP_GTR:
2149       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2150       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2151       if (noside == EVAL_SKIP)
2152         goto nosideret;
2153       if (binop_user_defined_p (op, arg1, arg2))
2154         {
2155           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2156         }
2157       else
2158         {
2159           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2160           tem = value_less (arg2, arg1);
2161           type = language_bool_type (exp->language_defn, exp->gdbarch);
2162           return value_from_longest (type, (LONGEST) tem);
2163         }
2164
2165     case BINOP_GEQ:
2166       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2167       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2168       if (noside == EVAL_SKIP)
2169         goto nosideret;
2170       if (binop_user_defined_p (op, arg1, arg2))
2171         {
2172           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2173         }
2174       else
2175         {
2176           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2177           tem = value_less (arg2, arg1) || value_equal (arg1, arg2);
2178           type = language_bool_type (exp->language_defn, exp->gdbarch);
2179           return value_from_longest (type, (LONGEST) tem);
2180         }
2181
2182     case BINOP_LEQ:
2183       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2184       arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
2185       if (noside == EVAL_SKIP)
2186         goto nosideret;
2187       if (binop_user_defined_p (op, arg1, arg2))
2188         {
2189           return value_x_binop (arg1, arg2, op, OP_NULL, noside);
2190         }
2191       else
2192         {
2193           binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
2194           tem = value_less (arg1, arg2) || value_equal (arg1, arg2);
2195           type = language_bool_type (exp->language_defn, exp->gdbarch);
2196           return value_from_longest (type, (LONGEST) tem);
2197         }
2198
2199     case BINOP_REPEAT:
2200       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2201       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2202       if (noside == EVAL_SKIP)
2203         goto nosideret;
2204       type = check_typedef (value_type (arg2));
2205       if (TYPE_CODE (type) != TYPE_CODE_INT)
2206         error (_("Non-integral right operand for \"@\" operator."));
2207       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2208         {
2209           return allocate_repeat_value (value_type (arg1),
2210                                      longest_to_int (value_as_long (arg2)));
2211         }
2212       else
2213         return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
2214
2215     case BINOP_COMMA:
2216       evaluate_subexp (NULL_TYPE, exp, pos, noside);
2217       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2218
2219     case UNOP_PLUS:
2220       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2221       if (noside == EVAL_SKIP)
2222         goto nosideret;
2223       if (unop_user_defined_p (op, arg1))
2224         return value_x_unop (arg1, op, noside);
2225       else
2226         {
2227           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2228           return value_pos (arg1);
2229         }
2230
2231     case UNOP_NEG:
2232       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2233       if (noside == EVAL_SKIP)
2234         goto nosideret;
2235       if (unop_user_defined_p (op, arg1))
2236         return value_x_unop (arg1, op, noside);
2237       else
2238         {
2239           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2240           return value_neg (arg1);
2241         }
2242
2243     case UNOP_COMPLEMENT:
2244       /* C++: check for and handle destructor names.  */
2245       op = exp->elts[*pos].opcode;
2246
2247       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2248       if (noside == EVAL_SKIP)
2249         goto nosideret;
2250       if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
2251         return value_x_unop (arg1, UNOP_COMPLEMENT, noside);
2252       else
2253         {
2254           unop_promote (exp->language_defn, exp->gdbarch, &arg1);
2255           return value_complement (arg1);
2256         }
2257
2258     case UNOP_LOGICAL_NOT:
2259       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2260       if (noside == EVAL_SKIP)
2261         goto nosideret;
2262       if (unop_user_defined_p (op, arg1))
2263         return value_x_unop (arg1, op, noside);
2264       else
2265         {
2266           type = language_bool_type (exp->language_defn, exp->gdbarch);
2267           return value_from_longest (type, (LONGEST) value_logical_not (arg1));
2268         }
2269
2270     case UNOP_IND:
2271       if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
2272         expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
2273       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2274       type = check_typedef (value_type (arg1));
2275       if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
2276           || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
2277         error (_("Attempt to dereference pointer to member without an object"));
2278       if (noside == EVAL_SKIP)
2279         goto nosideret;
2280       if (unop_user_defined_p (op, arg1))
2281         return value_x_unop (arg1, op, noside);
2282       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2283         {
2284           type = check_typedef (value_type (arg1));
2285           if (TYPE_CODE (type) == TYPE_CODE_PTR
2286               || TYPE_CODE (type) == TYPE_CODE_REF
2287           /* In C you can dereference an array to get the 1st elt.  */
2288               || TYPE_CODE (type) == TYPE_CODE_ARRAY
2289             )
2290             return value_zero (TYPE_TARGET_TYPE (type),
2291                                lval_memory);
2292           else if (TYPE_CODE (type) == TYPE_CODE_INT)
2293             /* GDB allows dereferencing an int.  */
2294             return value_zero (builtin_type (exp->gdbarch)->builtin_int,
2295                                lval_memory);
2296           else
2297             error (_("Attempt to take contents of a non-pointer value."));
2298         }
2299
2300       /* Allow * on an integer so we can cast it to whatever we want.
2301          This returns an int, which seems like the most C-like thing to
2302          do.  "long long" variables are rare enough that
2303          BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
2304       if (TYPE_CODE (type) == TYPE_CODE_INT)
2305         return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
2306                               (CORE_ADDR) value_as_address (arg1));
2307       return value_ind (arg1);
2308
2309     case UNOP_ADDR:
2310       /* C++: check for and handle pointer to members.  */
2311
2312       op = exp->elts[*pos].opcode;
2313
2314       if (noside == EVAL_SKIP)
2315         {
2316           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2317           goto nosideret;
2318         }
2319       else
2320         {
2321           struct value *retvalp = evaluate_subexp_for_address (exp, pos, noside);
2322           return retvalp;
2323         }
2324
2325     case UNOP_SIZEOF:
2326       if (noside == EVAL_SKIP)
2327         {
2328           evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
2329           goto nosideret;
2330         }
2331       return evaluate_subexp_for_sizeof (exp, pos);
2332
2333     case UNOP_CAST:
2334       (*pos) += 2;
2335       type = exp->elts[pc + 1].type;
2336       arg1 = evaluate_subexp (type, exp, pos, noside);
2337       if (noside == EVAL_SKIP)
2338         goto nosideret;
2339       if (type != value_type (arg1))
2340         arg1 = value_cast (type, arg1);
2341       return arg1;
2342
2343     case UNOP_MEMVAL:
2344       (*pos) += 2;
2345       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2346       if (noside == EVAL_SKIP)
2347         goto nosideret;
2348       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2349         return value_zero (exp->elts[pc + 1].type, lval_memory);
2350       else
2351         return value_at_lazy (exp->elts[pc + 1].type,
2352                               value_as_address (arg1));
2353
2354     case UNOP_MEMVAL_TLS:
2355       (*pos) += 3;
2356       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2357       if (noside == EVAL_SKIP)
2358         goto nosideret;
2359       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2360         return value_zero (exp->elts[pc + 2].type, lval_memory);
2361       else
2362         {
2363           CORE_ADDR tls_addr;
2364           tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
2365                                                    value_as_address (arg1));
2366           return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
2367         }
2368
2369     case UNOP_PREINCREMENT:
2370       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2371       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2372         return arg1;
2373       else if (unop_user_defined_p (op, arg1))
2374         {
2375           return value_x_unop (arg1, op, noside);
2376         }
2377       else
2378         {
2379           arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
2380           if (ptrmath_type_p (value_type (arg1)))
2381             arg2 = value_ptradd (arg1, arg2);
2382           else
2383             {
2384               struct value *tmp = arg1;
2385               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2386               arg2 = value_binop (tmp, arg2, BINOP_ADD);
2387             }
2388
2389           return value_assign (arg1, arg2);
2390         }
2391
2392     case UNOP_PREDECREMENT:
2393       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2394       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2395         return arg1;
2396       else if (unop_user_defined_p (op, arg1))
2397         {
2398           return value_x_unop (arg1, op, noside);
2399         }
2400       else
2401         {
2402           arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
2403           if (ptrmath_type_p (value_type (arg1)))
2404             arg2 = value_ptrsub (arg1, arg2);
2405           else
2406             {
2407               struct value *tmp = arg1;
2408               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2409               arg2 = value_binop (tmp, arg2, BINOP_SUB);
2410             }
2411
2412           return value_assign (arg1, arg2);
2413         }
2414
2415     case UNOP_POSTINCREMENT:
2416       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2417       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2418         return arg1;
2419       else if (unop_user_defined_p (op, arg1))
2420         {
2421           return value_x_unop (arg1, op, noside);
2422         }
2423       else
2424         {
2425           arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
2426           if (ptrmath_type_p (value_type (arg1)))
2427             arg2 = value_ptradd (arg1, arg2);
2428           else
2429             {
2430               struct value *tmp = arg1;
2431               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2432               arg2 = value_binop (tmp, arg2, BINOP_ADD);
2433             }
2434
2435           value_assign (arg1, arg2);
2436           return arg1;
2437         }
2438
2439     case UNOP_POSTDECREMENT:
2440       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
2441       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
2442         return arg1;
2443       else if (unop_user_defined_p (op, arg1))
2444         {
2445           return value_x_unop (arg1, op, noside);
2446         }
2447       else
2448         {
2449           arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
2450           if (ptrmath_type_p (value_type (arg1)))
2451             arg2 = value_ptrsub (arg1, arg2);
2452           else
2453             {
2454               struct value *tmp = arg1;
2455               binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
2456               arg2 = value_binop (tmp, arg2, BINOP_SUB);
2457             }
2458
2459           value_assign (arg1, arg2);
2460           return arg1;
2461         }
2462
2463     case OP_THIS:
2464       (*pos) += 1;
2465       return value_of_this (1);
2466
2467     case OP_OBJC_SELF:
2468       (*pos) += 1;
2469       return value_of_local ("self", 1);
2470
2471     case OP_TYPE:
2472       /* The value is not supposed to be used.  This is here to make it
2473          easier to accommodate expressions that contain types.  */
2474       (*pos) += 2;
2475       if (noside == EVAL_SKIP)
2476         goto nosideret;
2477       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
2478         return allocate_value (exp->elts[pc + 1].type);
2479       else
2480         error (_("Attempt to use a type name as an expression"));
2481
2482     default:
2483       /* Removing this case and compiling with gcc -Wall reveals that
2484          a lot of cases are hitting this case.  Some of these should
2485          probably be removed from expression.h; others are legitimate
2486          expressions which are (apparently) not fully implemented.
2487
2488          If there are any cases landing here which mean a user error,
2489          then they should be separate cases, with more descriptive
2490          error messages.  */
2491
2492       error (_("\
2493 GDB does not (yet) know how to evaluate that kind of expression"));
2494     }
2495
2496 nosideret:
2497   return value_from_longest (builtin_type_int8, (LONGEST) 1);
2498 }
2499 \f
2500 /* Evaluate a subexpression of EXP, at index *POS,
2501    and return the address of that subexpression.
2502    Advance *POS over the subexpression.
2503    If the subexpression isn't an lvalue, get an error.
2504    NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
2505    then only the type of the result need be correct.  */
2506
2507 static struct value *
2508 evaluate_subexp_for_address (struct expression *exp, int *pos,
2509                              enum noside noside)
2510 {
2511   enum exp_opcode op;
2512   int pc;
2513   struct symbol *var;
2514   struct value *x;
2515   int tem;
2516
2517   pc = (*pos);
2518   op = exp->elts[pc].opcode;
2519
2520   switch (op)
2521     {
2522     case UNOP_IND:
2523       (*pos)++;
2524       x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2525
2526       /* We can't optimize out "&*" if there's a user-defined operator*.  */
2527       if (unop_user_defined_p (op, x))
2528         {
2529           x = value_x_unop (x, op, noside);
2530           goto default_case_after_eval;
2531         }
2532
2533       return x;
2534
2535     case UNOP_MEMVAL:
2536       (*pos) += 3;
2537       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
2538                          evaluate_subexp (NULL_TYPE, exp, pos, noside));
2539
2540     case OP_VAR_VALUE:
2541       var = exp->elts[pc + 2].symbol;
2542
2543       /* C++: The "address" of a reference should yield the address
2544        * of the object pointed to. Let value_addr() deal with it. */
2545       if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
2546         goto default_case;
2547
2548       (*pos) += 4;
2549       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2550         {
2551           struct type *type =
2552           lookup_pointer_type (SYMBOL_TYPE (var));
2553           enum address_class sym_class = SYMBOL_CLASS (var);
2554
2555           if (sym_class == LOC_CONST
2556               || sym_class == LOC_CONST_BYTES
2557               || sym_class == LOC_REGISTER)
2558             error (_("Attempt to take address of register or constant."));
2559
2560           return
2561             value_zero (type, not_lval);
2562         }
2563       else
2564         return address_of_variable (var, exp->elts[pc + 1].block);
2565
2566     case OP_SCOPE:
2567       tem = longest_to_int (exp->elts[pc + 2].longconst);
2568       (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
2569       x = value_aggregate_elt (exp->elts[pc + 1].type,
2570                                &exp->elts[pc + 3].string,
2571                                1, noside);
2572       if (x == NULL)
2573         error (_("There is no field named %s"), &exp->elts[pc + 3].string);
2574       return x;
2575
2576     default:
2577     default_case:
2578       x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
2579     default_case_after_eval:
2580       if (noside == EVAL_AVOID_SIDE_EFFECTS)
2581         {
2582           struct type *type = check_typedef (value_type (x));
2583
2584           if (VALUE_LVAL (x) == lval_memory || value_must_coerce_to_target (x))
2585             return value_zero (lookup_pointer_type (value_type (x)),
2586                                not_lval);
2587           else if (TYPE_CODE (type) == TYPE_CODE_REF)
2588             return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2589                                not_lval);
2590           else
2591             error (_("Attempt to take address of value not located in memory."));
2592         }
2593       return value_addr (x);
2594     }
2595 }
2596
2597 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
2598    When used in contexts where arrays will be coerced anyway, this is
2599    equivalent to `evaluate_subexp' but much faster because it avoids
2600    actually fetching array contents (perhaps obsolete now that we have
2601    value_lazy()).
2602
2603    Note that we currently only do the coercion for C expressions, where
2604    arrays are zero based and the coercion is correct.  For other languages,
2605    with nonzero based arrays, coercion loses.  Use CAST_IS_CONVERSION
2606    to decide if coercion is appropriate.
2607
2608  */
2609
2610 struct value *
2611 evaluate_subexp_with_coercion (struct expression *exp,
2612                                int *pos, enum noside noside)
2613 {
2614   enum exp_opcode op;
2615   int pc;
2616   struct value *val;
2617   struct symbol *var;
2618   struct type *type;
2619
2620   pc = (*pos);
2621   op = exp->elts[pc].opcode;
2622
2623   switch (op)
2624     {
2625     case OP_VAR_VALUE:
2626       var = exp->elts[pc + 2].symbol;
2627       type = check_typedef (SYMBOL_TYPE (var));
2628       if (TYPE_CODE (type) == TYPE_CODE_ARRAY
2629           && CAST_IS_CONVERSION)
2630         {
2631           (*pos) += 4;
2632           val = address_of_variable (var, exp->elts[pc + 1].block);
2633           return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
2634                              val);
2635         }
2636       /* FALLTHROUGH */
2637
2638     default:
2639       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
2640     }
2641 }
2642
2643 /* Evaluate a subexpression of EXP, at index *POS,
2644    and return a value for the size of that subexpression.
2645    Advance *POS over the subexpression.  */
2646
2647 static struct value *
2648 evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
2649 {
2650   /* FIXME: This should be size_t.  */
2651   struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
2652   enum exp_opcode op;
2653   int pc;
2654   struct type *type;
2655   struct value *val;
2656
2657   pc = (*pos);
2658   op = exp->elts[pc].opcode;
2659
2660   switch (op)
2661     {
2662       /* This case is handled specially
2663          so that we avoid creating a value for the result type.
2664          If the result type is very big, it's desirable not to
2665          create a value unnecessarily.  */
2666     case UNOP_IND:
2667       (*pos)++;
2668       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2669       type = check_typedef (value_type (val));
2670       if (TYPE_CODE (type) != TYPE_CODE_PTR
2671           && TYPE_CODE (type) != TYPE_CODE_REF
2672           && TYPE_CODE (type) != TYPE_CODE_ARRAY)
2673         error (_("Attempt to take contents of a non-pointer value."));
2674       type = check_typedef (TYPE_TARGET_TYPE (type));
2675       return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
2676
2677     case UNOP_MEMVAL:
2678       (*pos) += 3;
2679       type = check_typedef (exp->elts[pc + 1].type);
2680       return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
2681
2682     case OP_VAR_VALUE:
2683       (*pos) += 4;
2684       type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
2685       return
2686         value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
2687
2688     default:
2689       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
2690       return value_from_longest (size_type,
2691                                  (LONGEST) TYPE_LENGTH (value_type (val)));
2692     }
2693 }
2694
2695 /* Parse a type expression in the string [P..P+LENGTH). */
2696
2697 struct type *
2698 parse_and_eval_type (char *p, int length)
2699 {
2700   char *tmp = (char *) alloca (length + 4);
2701   struct expression *expr;
2702   tmp[0] = '(';
2703   memcpy (tmp + 1, p, length);
2704   tmp[length + 1] = ')';
2705   tmp[length + 2] = '0';
2706   tmp[length + 3] = '\0';
2707   expr = parse_expression (tmp);
2708   if (expr->elts[0].opcode != UNOP_CAST)
2709     error (_("Internal error in eval_type."));
2710   return expr->elts[1].type;
2711 }
2712
2713 int
2714 calc_f77_array_dims (struct type *array_type)
2715 {
2716   int ndimen = 1;
2717   struct type *tmp_type;
2718
2719   if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
2720     error (_("Can't get dimensions for a non-array type"));
2721
2722   tmp_type = array_type;
2723
2724   while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
2725     {
2726       if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)
2727         ++ndimen;
2728     }
2729   return ndimen;
2730 }