gdb/eval.c

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