gdb/eval.c

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