gdb/eval.c

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