gdb/eval.c

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