gdb/eval.c

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