gdb/eval.c

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