gdb/eval.c

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