gdb/eval.c

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