2011-03-18 Phil Muldoon <pmuldoon@redhat.com>

[deliverable/binutils-gdb.git] / gdb / eval.c

diff --git a/gdb/eval.c b/gdb/eval.c
index c7698729861451dd308d77e050a3fe3ef19a62a6..09b41a0fbc2fe6a633d9a63cbaa7c77bdd6bed4b 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -2,7 +2,7 @@
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008,
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008,

-   2009 Free Software Foundation, Inc.
+   2009, 2010, 2011 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -27,8 +27,8 @@
 #include "expression.h"
 #include "target.h"
 #include "frame.h"
 #include "expression.h"
 #include "target.h"
 #include "frame.h"

-#include "language.h"          /* For CAST_IS_CONVERSION */
-#include "f-lang.h"            /* for array bound stuff */
+#include "language.h"          /* For CAST_IS_CONVERSION.  */
+#include "f-lang.h"            /* For array bound stuff.  */

 #include "cp-abi.h"
 #include "infcall.h"
 #include "objc-lang.h"
 #include "cp-abi.h"
 #include "infcall.h"
 #include "objc-lang.h"


@@ -40,7 +40,10 @@
 #include "regcache.h"
 #include "user-regs.h"
 #include "valprint.h"
 #include "regcache.h"
 #include "user-regs.h"
 #include "valprint.h"

+#include "gdb_obstack.h"
+#include "objfiles.h"

 #include "python/python.h"
 #include "python/python.h"

+#include "wrapper.h"

 
 #include "gdb_assert.h"
 
 
 #include "gdb_assert.h"
 


@@ -49,7 +52,7 @@
 /* This is defined in valops.c */
 extern int overload_resolution;
 
 /* This is defined in valops.c */
 extern int overload_resolution;
 

-/* Prototypes for local functions. */
+/* Prototypes for local functions.  */

 
 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
 
 
 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
 


@@ -90,24 +93,8 @@ parse_and_eval_address (char *exp)
   return addr;
 }
 
   return addr;
 }
 

-/* Like parse_and_eval_address but takes a pointer to a char * variable
-   and advanced that variable across the characters parsed.  */
-
-CORE_ADDR
-parse_and_eval_address_1 (char **expptr)
-{
-  struct expression *expr = parse_exp_1 (expptr, (struct block *) 0, 0);
-  CORE_ADDR addr;
-  struct cleanup *old_chain =
-    make_cleanup (free_current_contents, &expr);
-
-  addr = value_as_address (evaluate_expression (expr));
-  do_cleanups (old_chain);
-  return addr;
-}
-

 /* Like parse_and_eval_address, but treats the value of the expression
 /* Like parse_and_eval_address, but treats the value of the expression

-   as an integer, not an address, returns a LONGEST, not a CORE_ADDR */
+   as an integer, not an address, returns a LONGEST, not a CORE_ADDR.  */

 LONGEST
 parse_and_eval_long (char *exp)
 {
 LONGEST
 parse_and_eval_long (char *exp)
 {


@@ -160,6 +147,7 @@ struct value *
 evaluate_expression (struct expression *exp)
 {
   int pc = 0;
 evaluate_expression (struct expression *exp)
 {
   int pc = 0;

+

   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
 }
 
   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
 }
 


@@ -170,6 +158,7 @@ struct value *
 evaluate_type (struct expression *exp)
 {
   int pc = 0;
 evaluate_type (struct expression *exp)
 {
   int pc = 0;

+

   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
 }
 
   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
 }
 


@@ -182,6 +171,84 @@ evaluate_subexpression_type (struct expression *exp, int subexp)
   return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
 }
 
   return evaluate_subexp (NULL_TYPE, exp, &subexp, EVAL_AVOID_SIDE_EFFECTS);
 }
 

+/* Find the current value of a watchpoint on EXP.  Return the value in
+   *VALP and *RESULTP and the chain of intermediate and final values
+   in *VAL_CHAIN.  RESULTP and VAL_CHAIN may be NULL if the caller does
+   not need them.
+
+   If a memory error occurs while evaluating the expression, *RESULTP will
+   be set to NULL.  *RESULTP may be a lazy value, if the result could
+   not be read from memory.  It is used to determine whether a value
+   is user-specified (we should watch the whole value) or intermediate
+   (we should watch only the bit used to locate the final value).
+
+   If the final value, or any intermediate value, could not be read
+   from memory, *VALP will be set to NULL.  *VAL_CHAIN will still be
+   set to any referenced values.  *VALP will never be a lazy value.
+   This is the value which we store in struct breakpoint.
+
+   If VAL_CHAIN is non-NULL, *VAL_CHAIN will be released from the
+   value chain.  The caller must free the values individually.  If
+   VAL_CHAIN is NULL, all generated values will be left on the value
+   chain.  */
+
+void
+fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
+                   struct value **resultp, struct value **val_chain)
+{
+  struct value *mark, *new_mark, *result;
+  volatile struct gdb_exception ex;
+
+  *valp = NULL;
+  if (resultp)
+    *resultp = NULL;
+  if (val_chain)
+    *val_chain = NULL;
+
+  /* Evaluate the expression.  */
+  mark = value_mark ();
+  result = NULL;
+
+  TRY_CATCH (ex, RETURN_MASK_ALL)
+    {
+      result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
+    }
+  if (ex.reason < 0)
+    {
+      /* Ignore memory errors, we want watchpoints pointing at
+        inaccessible memory to still be created; otherwise, throw the
+        error to some higher catcher.  */
+      switch (ex.error)
+       {
+       case MEMORY_ERROR:
+         break;
+       default:
+         throw_exception (ex);
+         break;
+       }
+    }
+
+  new_mark = value_mark ();
+  if (mark == new_mark)
+    return;
+  if (resultp)
+    *resultp = result;
+
+  /* Make sure it's not lazy, so that after the target stops again we
+     have a non-lazy previous value to compare with.  */
+  if (result != NULL
+      && (!value_lazy (result) || gdb_value_fetch_lazy (result)))
+    *valp = result;
+
+  if (val_chain)
+    {
+      /* Return the chain of intermediate values.  We use this to
+        decide which addresses to watch.  */
+      *val_chain = new_mark;
+      value_release_to_mark (mark);
+    }
+}
+

 /* Extract a field operation from an expression.  If the subexpression
    of EXP starting at *SUBEXP is not a structure dereference
    operation, return NULL.  Otherwise, return the name of the
 /* Extract a field operation from an expression.  If the subexpression
    of EXP starting at *SUBEXP is not a structure dereference
    operation, return NULL.  Otherwise, return the name of the


@@ -194,6 +261,7 @@ extract_field_op (struct expression *exp, int *subexp)
 {
   int tem;
   char *result;
 {
   int tem;
   char *result;

+

   if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
       && exp->elts[*subexp].opcode != STRUCTOP_PTR)
     return NULL;
   if (exp->elts[*subexp].opcode != STRUCTOP_STRUCT
       && exp->elts[*subexp].opcode != STRUCTOP_PTR)
     return NULL;


@@ -204,7 +272,7 @@ extract_field_op (struct expression *exp, int *subexp)
 }
 
 /* If the next expression is an OP_LABELED, skips past it,
 }
 
 /* If the next expression is an OP_LABELED, skips past it,

-   returning the label.  Otherwise, does nothing and returns NULL. */
+   returning the label.  Otherwise, does nothing and returns NULL.  */

 
 static char *
 get_label (struct expression *exp, int *pos)
 
 static char *
 get_label (struct expression *exp, int *pos)


@@ -214,6 +282,7 @@ get_label (struct expression *exp, int *pos)
       int pc = (*pos)++;
       char *name = &exp->elts[pc + 2].string;
       int tem = longest_to_int (exp->elts[pc + 1].longconst);
       int pc = (*pos)++;
       char *name = &exp->elts[pc + 2].string;
       int tem = longest_to_int (exp->elts[pc + 1].longconst);

+

       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
       return name;
     }
       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
       return name;
     }


@@ -235,6 +304,7 @@ evaluate_struct_tuple (struct value *struct_val,
   int fieldno = -1;
   int variantno = -1;
   int subfieldno = -1;
   int fieldno = -1;
   int variantno = -1;
   int subfieldno = -1;

+

   while (--nargs >= 0)
     {
       int pc = *pos;
   while (--nargs >= 0)
     {
       int pc = *pos;


@@ -243,19 +313,21 @@ evaluate_struct_tuple (struct value *struct_val,
       int bitpos, bitsize;
       bfd_byte *addr;
 
       int bitpos, bitsize;
       bfd_byte *addr;
 

-      /* Skip past the labels, and count them. */
+      /* Skip past the labels, and count them.  */

       while (get_label (exp, pos) != NULL)
        nlabels++;
 
       do
        {
          char *label = get_label (exp, &pc);
       while (get_label (exp, pos) != NULL)
        nlabels++;
 
       do
        {
          char *label = get_label (exp, &pc);

+

          if (label)
            {
              for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type);
                   fieldno++)
                {
                  char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
          if (label)
            {
              for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type);
                   fieldno++)
                {
                  char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);

+

                  if (field_name != NULL && strcmp (field_name, label) == 0)
                    {
                      variantno = -1;
                  if (field_name != NULL && strcmp (field_name, label) == 0)
                    {
                      variantno = -1;


@@ -268,6 +340,7 @@ evaluate_struct_tuple (struct value *struct_val,
                   fieldno++)
                {
                  char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
                   fieldno++)
                {
                  char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);

+

                  field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
                  if ((field_name == 0 || *field_name == '\0')
                      && TYPE_CODE (field_type) == TYPE_CODE_UNION)
                  field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
                  if ((field_name == 0 || *field_name == '\0')
                      && TYPE_CODE (field_type) == TYPE_CODE_UNION)


@@ -301,7 +374,7 @@ evaluate_struct_tuple (struct value *struct_val,
            }
          else
            {
            }
          else
            {

-             /* Unlabelled tuple element - go to next field. */
+             /* Unlabelled tuple element - go to next field.  */

              if (variantno >= 0)
                {
                  subfieldno++;
              if (variantno >= 0)
                {
                  subfieldno++;


@@ -336,15 +409,15 @@ evaluate_struct_tuple (struct value *struct_val,
             The value fieldno is the index of the top-level (normal or
             anonymous union) field in struct_field, while the value
             subfieldno is the index of the actual real (named inner) field
             The value fieldno is the index of the top-level (normal or
             anonymous union) field in struct_field, while the value
             subfieldno is the index of the actual real (named inner) field

-            in substruct_type. */
+            in substruct_type.  */

 
          field_type = TYPE_FIELD_TYPE (substruct_type, subfieldno);
          if (val == 0)
            val = evaluate_subexp (field_type, exp, pos, noside);
 
 
          field_type = TYPE_FIELD_TYPE (substruct_type, subfieldno);
          if (val == 0)
            val = evaluate_subexp (field_type, exp, pos, noside);
 

-         /* Now actually set the field in struct_val. */
+         /* Now actually set the field in struct_val.  */

 
 

-         /* Assign val to field fieldno. */
+         /* Assign val to field fieldno.  */

          if (value_type (val) != field_type)
            val = value_cast (field_type, val);
 
          if (value_type (val) != field_type)
            val = value_cast (field_type, val);
 


@@ -354,8 +427,8 @@ evaluate_struct_tuple (struct value *struct_val,
            bitpos += TYPE_FIELD_BITPOS (substruct_type, subfieldno);
          addr = value_contents_writeable (struct_val) + bitpos / 8;
          if (bitsize)
            bitpos += TYPE_FIELD_BITPOS (substruct_type, subfieldno);
          addr = value_contents_writeable (struct_val) + bitpos / 8;
          if (bitsize)

-           modify_field (addr, value_as_long (val),
-                         bitpos % 8, bitsize);
+           modify_field (struct_type, addr,
+                         value_as_long (val), bitpos % 8, bitsize);

          else
            memcpy (addr, value_contents (val),
                    TYPE_LENGTH (value_type (val)));
          else
            memcpy (addr, value_contents (val),
                    TYPE_LENGTH (value_type (val)));


@@ -379,6 +452,7 @@ init_array_element (struct value *array, struct value *element,
 {
   LONGEST index;
   int element_size = TYPE_LENGTH (value_type (element));
 {
   LONGEST index;
   int element_size = TYPE_LENGTH (value_type (element));

+

   if (exp->elts[*pos].opcode == BINOP_COMMA)
     {
       (*pos)++;
   if (exp->elts[*pos].opcode == BINOP_COMMA)
     {
       (*pos)++;


@@ -390,6 +464,7 @@ init_array_element (struct value *array, struct value *element,
   else if (exp->elts[*pos].opcode == BINOP_RANGE)
     {
       LONGEST low, high;
   else if (exp->elts[*pos].opcode == BINOP_RANGE)
     {
       LONGEST low, high;

+

       (*pos)++;
       low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
       high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
       (*pos)++;
       low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
       high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));


@@ -462,6 +537,7 @@ unop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
             it needs to modify this function.  */
          {
            struct type *builtin_int = builtin_type (gdbarch)->builtin_int;
             it needs to modify this function.  */
          {
            struct type *builtin_int = builtin_type (gdbarch)->builtin_int;

+

            if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
              *arg1 = value_cast (builtin_int, *arg1);
          }
            if (TYPE_LENGTH (type1) < TYPE_LENGTH (builtin_int))
              *arg1 = value_cast (builtin_int, *arg1);
          }


@@ -511,6 +587,7 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
        case language_cplus:
        case language_asm:
        case language_objc:
        case language_cplus:
        case language_asm:
        case language_objc:

+       case language_opencl:

          /* No promotion required.  */
          break;
 
          /* No promotion required.  */
          break;
 


@@ -598,7 +675,24 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
                               : builtin->builtin_long_long);
            }
          break;
                               : builtin->builtin_long_long);
            }
          break;

-
+       case language_opencl:
+         if (result_len <= TYPE_LENGTH (lookup_signed_typename
+                                        (language, gdbarch, "int")))
+           {
+             promoted_type =
+               (unsigned_operation
+                ? lookup_unsigned_typename (language, gdbarch, "int")
+                : lookup_signed_typename (language, gdbarch, "int"));
+           }
+         else if (result_len <= TYPE_LENGTH (lookup_signed_typename
+                                             (language, gdbarch, "long")))
+           {
+             promoted_type =
+               (unsigned_operation
+                ? lookup_unsigned_typename (language, gdbarch, "long")
+                : lookup_signed_typename (language, gdbarch,"long"));
+           }
+         break;

        default:
          /* For other languages the result type is unchanged from gdb
             version 6.7 for backward compatibility.
        default:
          /* For other languages the result type is unchanged from gdb
             version 6.7 for backward compatibility.


@@ -631,7 +725,7 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
 }
 
 static int
 }
 
 static int

-ptrmath_type_p (struct type *type)
+ptrmath_type_p (const struct language_defn *lang, struct type *type)

 {
   type = check_typedef (type);
   if (TYPE_CODE (type) == TYPE_CODE_REF)
 {
   type = check_typedef (type);
   if (TYPE_CODE (type) == TYPE_CODE_REF)


@@ -644,13 +738,36 @@ ptrmath_type_p (struct type *type)
       return 1;
 
     case TYPE_CODE_ARRAY:
       return 1;
 
     case TYPE_CODE_ARRAY:

-      return current_language->c_style_arrays;
+      return TYPE_VECTOR (type) ? 0 : lang->c_style_arrays;

 
     default:
       return 0;
     }
 }
 
 
     default:
       return 0;
     }
 }
 

+/* Constructs a fake method with the given parameter types.
+   This function is used by the parser to construct an "expected"
+   type for method overload resolution.  */
+
+static struct type *
+make_params (int num_types, struct type **param_types)
+{
+  struct type *type = XZALLOC (struct type);
+  TYPE_MAIN_TYPE (type) = XZALLOC (struct main_type);
+  TYPE_LENGTH (type) = 1;
+  TYPE_CODE (type) = TYPE_CODE_METHOD;
+  TYPE_VPTR_FIELDNO (type) = -1;
+  TYPE_CHAIN (type) = type;
+  TYPE_NFIELDS (type) = num_types;
+  TYPE_FIELDS (type) = (struct field *)
+    TYPE_ZALLOC (type, sizeof (struct field) * num_types);
+
+  while (num_types-- > 0)
+    TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
+
+  return type;
+}
+

 struct value *
 evaluate_subexp_standard (struct type *expect_type,
                          struct expression *exp, int *pos,
 struct value *
 evaluate_subexp_standard (struct type *expect_type,
                          struct expression *exp, int *pos,


@@ -665,12 +782,14 @@ evaluate_subexp_standard (struct type *expect_type,
   struct type *type;
   int nargs;
   struct value **argvec;
   struct type *type;
   int nargs;
   struct value **argvec;

-  int upper, lower, retcode;
+  int upper, lower;

   int code;
   int ix;
   long mem_offset;
   struct type **arg_types;
   int save_pos1;
   int code;
   int ix;
   long mem_offset;
   struct type **arg_types;
   int save_pos1;

+  struct symbol *function = NULL;
+  char *function_name = NULL;

 
   pc = (*pos)++;
   op = exp->elts[pc].opcode;
 
   pc = (*pos)++;
   op = exp->elts[pc].opcode;


@@ -684,7 +803,7 @@ evaluate_subexp_standard (struct type *expect_type,
        goto nosideret;
       arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
                                  &exp->elts[pc + 3].string,
        goto nosideret;
       arg1 = value_aggregate_elt (exp->elts[pc + 1].type,
                                  &exp->elts[pc + 3].string,

-                                 0, noside);
+                                 expect_type, 0, noside);

       if (arg1 == NULL)
        error (_("There is no field named %s"), &exp->elts[pc + 3].string);
       return arg1;
       if (arg1 == NULL)
        error (_("There is no field named %s"), &exp->elts[pc + 3].string);
       return arg1;


@@ -704,6 +823,7 @@ evaluate_subexp_standard (struct type *expect_type,
       return value_from_decfloat (exp->elts[pc + 1].type,
                                  exp->elts[pc + 2].decfloatconst);
 
       return value_from_decfloat (exp->elts[pc + 1].type,
                                  exp->elts[pc + 2].decfloatconst);
 

+    case OP_ADL_FUNC:

     case OP_VAR_VALUE:
       (*pos) += 3;
       if (noside == EVAL_SKIP)
     case OP_VAR_VALUE:
       (*pos) += 3;
       if (noside == EVAL_SKIP)


@@ -716,7 +836,7 @@ evaluate_subexp_standard (struct type *expect_type,
         We need a full value object returned here for whatis_exp ()
         to call evaluate_type () and then pass the full value to
         value_rtti_target_type () if we are dealing with a pointer
         We need a full value object returned here for whatis_exp ()
         to call evaluate_type () and then pass the full value to
         value_rtti_target_type () if we are dealing with a pointer

-        or reference to a base class and print object is on. */
+        or reference to a base class and print object is on.  */

 
       {
        volatile struct gdb_exception except;
 
       {
        volatile struct gdb_exception except;


@@ -731,7 +851,8 @@ evaluate_subexp_standard (struct type *expect_type,
        if (except.reason < 0)
          {
            if (noside == EVAL_AVOID_SIDE_EFFECTS)
        if (except.reason < 0)
          {
            if (noside == EVAL_AVOID_SIDE_EFFECTS)

-             ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol), not_lval);
+             ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
+                               not_lval);

            else
              throw_exception (except);
          }
            else
              throw_exception (except);
          }


@@ -779,7 +900,8 @@ evaluate_subexp_standard (struct type *expect_type,
 
     case OP_INTERNALVAR:
       (*pos) += 2;
 
     case OP_INTERNALVAR:
       (*pos) += 2;

-      return value_of_internalvar (exp->elts[pc + 1].internalvar);
+      return value_of_internalvar (exp->gdbarch,
+                                  exp->elts[pc + 1].internalvar);

 
     case OP_STRING:
       tem = longest_to_int (exp->elts[pc + 1].longconst);
 
     case OP_STRING:
       tem = longest_to_int (exp->elts[pc + 1].longconst);


@@ -789,7 +911,8 @@ evaluate_subexp_standard (struct type *expect_type,
       type = language_string_char_type (exp->language_defn, exp->gdbarch);
       return value_string (&exp->elts[pc + 2].string, tem, type);
 
       type = language_string_char_type (exp->language_defn, exp->gdbarch);
       return value_string (&exp->elts[pc + 2].string, tem, type);
 

-    case OP_OBJC_NSSTRING:             /* Objective C Foundation Class NSString constant.  */
+    case OP_OBJC_NSSTRING:             /* Objective C Foundation Class
+                                          NSString constant.  */

       tem = longest_to_int (exp->elts[pc + 1].longconst);
       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
       if (noside == EVAL_SKIP)
       tem = longest_to_int (exp->elts[pc + 1].longconst);
       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
       if (noside == EVAL_SKIP)


@@ -804,7 +927,8 @@ evaluate_subexp_standard (struct type *expect_type,
        += 3 + BYTES_TO_EXP_ELEM ((tem + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
       if (noside == EVAL_SKIP)
        goto nosideret;
        += 3 + BYTES_TO_EXP_ELEM ((tem + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
       if (noside == EVAL_SKIP)
        goto nosideret;

-      return value_bitstring (&exp->elts[pc + 2].string, tem);
+      return value_bitstring (&exp->elts[pc + 2].string, tem,
+                             builtin_type (exp->gdbarch)->builtin_int);

       break;
 
     case OP_ARRAY:
       break;
 
     case OP_ARRAY:


@@ -818,6 +942,7 @@ evaluate_subexp_standard (struct type *expect_type,
          && TYPE_CODE (type) == TYPE_CODE_STRUCT)
        {
          struct value *rec = allocate_value (expect_type);
          && TYPE_CODE (type) == TYPE_CODE_STRUCT)
        {
          struct value *rec = allocate_value (expect_type);

+

          memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
          return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
        }
          memset (value_contents_raw (rec), '\0', TYPE_LENGTH (type));
          return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
        }


@@ -830,6 +955,7 @@ evaluate_subexp_standard (struct type *expect_type,
          struct value *array = allocate_value (expect_type);
          int element_size = TYPE_LENGTH (check_typedef (element_type));
          LONGEST low_bound, high_bound, index;
          struct value *array = allocate_value (expect_type);
          int element_size = TYPE_LENGTH (check_typedef (element_type));
          LONGEST low_bound, high_bound, index;

+

          if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
            {
              low_bound = 0;
          if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
            {
              low_bound = 0;


@@ -841,6 +967,7 @@ evaluate_subexp_standard (struct type *expect_type,
            {
              struct value *element;
              int index_pc = 0;
            {
              struct value *element;
              int index_pc = 0;

+

              if (exp->elts[*pos].opcode == BINOP_RANGE)
                {
                  index_pc = ++(*pos);
              if (exp->elts[*pos].opcode == BINOP_RANGE)
                {
                  index_pc = ++(*pos);


@@ -852,6 +979,7 @@ evaluate_subexp_standard (struct type *expect_type,
              if (index_pc)
                {
                  int continue_pc = *pos;
              if (index_pc)
                {
                  int continue_pc = *pos;

+

                  *pos = index_pc;
                  index = init_array_element (array, element, exp, pos, noside,
                                              low_bound, high_bound);
                  *pos = index_pc;
                  index = init_array_element (array, element, exp, pos, noside,
                                              low_bound, high_bound);


@@ -860,7 +988,7 @@ evaluate_subexp_standard (struct type *expect_type,
              else
                {
                  if (index > high_bound)
              else
                {
                  if (index > high_bound)

-                   /* to avoid memory corruption */
+                   /* To avoid memory corruption.  */

                    error (_("Too many array elements"));
                  memcpy (value_contents_raw (array)
                          + (index - low_bound) * element_size,
                    error (_("Too many array elements"));
                  memcpy (value_contents_raw (array)
                          + (index - low_bound) * element_size,


@@ -881,9 +1009,9 @@ evaluate_subexp_standard (struct type *expect_type,
          struct type *check_type = element_type;
          LONGEST low_bound, high_bound;
 
          struct type *check_type = element_type;
          LONGEST low_bound, high_bound;
 

-         /* get targettype of elementtype */
-         while (TYPE_CODE (check_type) == TYPE_CODE_RANGE ||
-                TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
+         /* Get targettype of elementtype.  */
+         while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
+                || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)

            check_type = TYPE_TARGET_TYPE (check_type);
 
          if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
            check_type = TYPE_TARGET_TYPE (check_type);
 
          if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)


@@ -894,6 +1022,7 @@ evaluate_subexp_standard (struct type *expect_type,
              LONGEST range_low, range_high;
              struct type *range_low_type, *range_high_type;
              struct value *elem_val;
              LONGEST range_low, range_high;
              struct type *range_low_type, *range_high_type;
              struct value *elem_val;

+

              if (exp->elts[*pos].opcode == BINOP_RANGE)
                {
                  (*pos)++;
              if (exp->elts[*pos].opcode == BINOP_RANGE)
                {
                  (*pos)++;


@@ -910,21 +1039,21 @@ evaluate_subexp_standard (struct type *expect_type,
                  range_low_type = range_high_type = value_type (elem_val);
                  range_low = range_high = value_as_long (elem_val);
                }
                  range_low_type = range_high_type = value_type (elem_val);
                  range_low = range_high = value_as_long (elem_val);
                }

-             /* check types of elements to avoid mixture of elements from
+             /* Check types of elements to avoid mixture of elements from

                 different types. Also check if type of element is "compatible"
                 different types. Also check if type of element is "compatible"

-                with element type of powerset */
+                with element type of powerset.  */

              if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
                range_low_type = TYPE_TARGET_TYPE (range_low_type);
              if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
                range_high_type = TYPE_TARGET_TYPE (range_high_type);
              if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
                range_low_type = TYPE_TARGET_TYPE (range_low_type);
              if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
                range_high_type = TYPE_TARGET_TYPE (range_high_type);

-             if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type)) ||
-                 (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM &&
-                  (range_low_type != range_high_type)))
-               /* different element modes */
+             if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
+                 || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
+                     && (range_low_type != range_high_type)))
+               /* different element modes.  */

                error (_("POWERSET tuple elements of different mode"));
                error (_("POWERSET tuple elements of different mode"));

-             if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type)) ||
-                 (TYPE_CODE (check_type) == TYPE_CODE_ENUM &&
-                  range_low_type != check_type))
+             if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
+                 || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
+                     && range_low_type != check_type))

                error (_("incompatible POWERSET tuple elements"));
              if (range_low > range_high)
                {
                error (_("incompatible POWERSET tuple elements"));
              if (range_low > range_high)
                {


@@ -938,7 +1067,8 @@ evaluate_subexp_standard (struct type *expect_type,
              for (; range_low <= range_high; range_low++)
                {
                  int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
              for (; range_low <= range_high; range_low++)
                {
                  int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;

-                 if (gdbarch_bits_big_endian (current_gdbarch))
+
+                 if (gdbarch_bits_big_endian (exp->gdbarch))

                    bit_index = TARGET_CHAR_BIT - 1 - bit_index;
                  valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
                    |= 1 << bit_index;
                    bit_index = TARGET_CHAR_BIT - 1 - bit_index;
                  valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
                    |= 1 << bit_index;


@@ -950,7 +1080,8 @@ evaluate_subexp_standard (struct type *expect_type,
       argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
       for (tem = 0; tem < nargs; tem++)
        {
       argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
       for (tem = 0; tem < nargs; tem++)
        {

-         /* Ensure that array expressions are coerced into pointer objects. */
+         /* Ensure that array expressions are coerced into pointer
+            objects.  */

          argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
        }
       if (noside == EVAL_SKIP)
          argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
        }
       if (noside == EVAL_SKIP)


@@ -961,9 +1092,10 @@ evaluate_subexp_standard (struct type *expect_type,
       {
        struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
        int lowbound
       {
        struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
        int lowbound

-       = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+         = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));

        int upper
        int upper

-       = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+         = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+

        if (noside == EVAL_SKIP)
          goto nosideret;
        return value_slice (array, lowbound, upper - lowbound + 1);
        if (noside == EVAL_SKIP)
          goto nosideret;
        return value_slice (array, lowbound, upper - lowbound + 1);


@@ -973,9 +1105,10 @@ evaluate_subexp_standard (struct type *expect_type,
       {
        struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
        int lowbound
       {
        struct value *array = evaluate_subexp (NULL_TYPE, exp, pos, noside);
        int lowbound

-       = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+         = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));

        int length
        int length

-       = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+         = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
+

        return value_slice (array, lowbound, length);
       }
 
        return value_slice (array, lowbound, length);
       }
 


@@ -1065,12 +1198,13 @@ evaluate_subexp_standard (struct type *expect_type,
           to lookup the symbol information for the method.  If we
           can't find any symbol information, then we'll use these to
           call the method, otherwise we can call the method
           to lookup the symbol information for the method.  If we
           can't find any symbol information, then we'll use these to
           call the method, otherwise we can call the method

-          directly. The msg_send_stret function is used in the special
+          directly.  The msg_send_stret function is used in the special

           case of a method that returns a structure (Apple runtime 
           only).  */
        if (gnu_runtime)
          {
            struct type *type = selector_type;
           case of a method that returns a structure (Apple runtime 
           only).  */
        if (gnu_runtime)
          {
            struct type *type = selector_type;

+

            type = lookup_function_type (type);
            type = lookup_pointer_type (type);
            type = lookup_function_type (type);
            type = lookup_function_type (type);
            type = lookup_pointer_type (type);
            type = lookup_function_type (type);


@@ -1087,15 +1221,15 @@ evaluate_subexp_standard (struct type *expect_type,
        else
          {
            msg_send = find_function_in_inferior ("objc_msgSend", NULL);
        else
          {
            msg_send = find_function_in_inferior ("objc_msgSend", NULL);

-           /* Special dispatcher for methods returning structs */
+           /* Special dispatcher for methods returning structs.  */

            msg_send_stret
              = find_function_in_inferior ("objc_msgSend_stret", NULL);
          }
 
            msg_send_stret
              = find_function_in_inferior ("objc_msgSend_stret", NULL);
          }
 

-       /* Verify the target object responds to this method. The
+       /* Verify the target object responds to this method.  The

           standard top-level 'Object' class uses a different name for
           the verification method than the non-standard, but more
           standard top-level 'Object' class uses a different name for
           the verification method than the non-standard, but more

-          often used, 'NSObject' class. Make sure we check for both. */
+          often used, 'NSObject' class.  Make sure we check for both.  */

 
        responds_selector
          = lookup_child_selector (exp->gdbarch, "respondsToSelector:");
 
        responds_selector
          = lookup_child_selector (exp->gdbarch, "respondsToSelector:");


@@ -1116,7 +1250,7 @@ evaluate_subexp_standard (struct type *expect_type,
          error (_("no 'methodFor:' or 'methodForSelector:' method"));
 
        /* Call the verification method, to make sure that the target
          error (_("no 'methodFor:' or 'methodForSelector:' method"));
 
        /* Call the verification method, to make sure that the target

-        class implements the desired method. */
+        class implements the desired method.  */

 
        argvec[0] = msg_send;
        argvec[1] = target;
 
        argvec[0] = msg_send;
        argvec[1] = target;


@@ -1138,7 +1272,7 @@ evaluate_subexp_standard (struct type *expect_type,
           function method that implements this selector for this
           class.  If we can find a symbol at that address, then we
           know the return type, parameter types etc.  (that's a good
           function method that implements this selector for this
           class.  If we can find a symbol at that address, then we
           know the return type, parameter types etc.  (that's a good

-          thing). */
+          thing).  */

 
        argvec[0] = msg_send;
        argvec[1] = target;
 
        argvec[0] = msg_send;
        argvec[1] = target;


@@ -1159,8 +1293,13 @@ evaluate_subexp_standard (struct type *expect_type,
        if (addr)
          {
            struct symbol *sym = NULL;
        if (addr)
          {
            struct symbol *sym = NULL;

-           /* Is it a high_level symbol?  */

 
 

+           /* The address might point to a function descriptor;
+              resolve it to the actual code address instead.  */
+           addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
+                                                      &current_target);
+
+           /* Is it a high_level symbol?  */

            sym = find_pc_function (addr);
            if (sym != NULL) 
              method = value_of_variable (sym, 0);
            sym = find_pc_function (addr);
            if (sym != NULL) 
              method = value_of_variable (sym, 0);


@@ -1171,13 +1310,12 @@ evaluate_subexp_standard (struct type *expect_type,
 
        if (method)
          {
 
        if (method)
          {

-           struct block *b;

            CORE_ADDR funaddr;
            struct type *val_type;
 
            funaddr = find_function_addr (method, &val_type);
 
            CORE_ADDR funaddr;
            struct type *val_type;
 
            funaddr = find_function_addr (method, &val_type);
 

-           b = block_for_pc (funaddr);
+           block_for_pc (funaddr);

 
            CHECK_TYPEDEF (val_type);
          
 
            CHECK_TYPEDEF (val_type);
          


@@ -1189,7 +1327,8 @@ evaluate_subexp_standard (struct type *expect_type,
              }
 
            struct_return = using_struct_return (exp->gdbarch,
              }
 
            struct_return = using_struct_return (exp->gdbarch,

-                                                value_type (method), val_type);
+                                                value_type (method),
+                                                val_type);

          }
        else if (expect_type != NULL)
          {
          }
        else if (expect_type != NULL)
          {


@@ -1213,12 +1352,23 @@ evaluate_subexp_standard (struct type *expect_type,
        if (method)
          {
            if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
        if (method)
          {
            if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)

-             error (_("method address has symbol information with non-function type; skipping"));
+             error (_("method address has symbol information "
+                      "with non-function type; skipping"));
+
+           /* Create a function pointer of the appropriate type, and
+              replace its value with the value of msg_send or
+              msg_send_stret.  We must use a pointer here, as
+              msg_send and msg_send_stret are of pointer type, and
+              the representation may be different on systems that use
+              function descriptors.  */

            if (struct_return)
            if (struct_return)

-             set_value_address (method, value_as_address (msg_send_stret));
+             called_method
+               = value_from_pointer (lookup_pointer_type (value_type (method)),
+                                     value_as_address (msg_send_stret));

            else
            else

-             set_value_address (method, value_as_address (msg_send));
-           called_method = method;
+             called_method
+               = value_from_pointer (lookup_pointer_type (value_type (method)),
+                                     value_as_address (msg_send));

          }
        else
          {
          }
        else
          {


@@ -1235,13 +1385,14 @@ evaluate_subexp_standard (struct type *expect_type,
          {
            /* If the return type doesn't look like a function type,
               call an error.  This can happen if somebody tries to
          {
            /* If the return type doesn't look like a function type,
               call an error.  This can happen if somebody tries to

-              turn a variable into a function call. This is here
+              turn a variable into a function call.  This is here

               because people often want to call, eg, strcmp, which
               gdb doesn't know is a function.  If gdb isn't asked for
               it's opinion (ie. through "whatis"), it won't offer
               because people often want to call, eg, strcmp, which
               gdb doesn't know is a function.  If gdb isn't asked for
               it's opinion (ie. through "whatis"), it won't offer

-              it. */
+              it.  */

 
            struct type *type = value_type (called_method);
 
            struct type *type = value_type (called_method);

+

            if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
              type = TYPE_TARGET_TYPE (type);
            type = TYPE_TARGET_TYPE (type);
            if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
              type = TYPE_TARGET_TYPE (type);
            type = TYPE_TARGET_TYPE (type);


@@ -1254,7 +1405,8 @@ evaluate_subexp_standard (struct type *expect_type,
                return allocate_value (type);
            }
            else
                return allocate_value (type);
            }
            else

-             error (_("Expression of type other than \"method returning ...\" used as a method"));
+             error (_("Expression of type other than "
+                      "\"method returning ...\" used as a method"));

          }
 
        /* Now depending on whether we found a symbol for the method,
          }
 
        /* Now depending on whether we found a symbol for the method,


@@ -1273,8 +1425,9 @@ evaluate_subexp_standard (struct type *expect_type,
          {
            /* Function objc_msg_lookup returns a pointer.  */
            deprecated_set_value_type (argvec[0],
          {
            /* Function objc_msg_lookup returns a pointer.  */
            deprecated_set_value_type (argvec[0],

-                                      lookup_function_type (lookup_pointer_type (value_type (argvec[0]))));
-           argvec[0] = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
+                                      lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
+           argvec[0]
+             = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);

          }
 
        ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);
          }
 
        ret = call_function_by_hand (argvec[0], nargs + 2, argvec + 1);


@@ -1287,12 +1440,13 @@ evaluate_subexp_standard (struct type *expect_type,
       op = exp->elts[*pos].opcode;
       nargs = longest_to_int (exp->elts[pc + 1].longconst);
       /* Allocate arg vector, including space for the function to be
       op = exp->elts[*pos].opcode;
       nargs = longest_to_int (exp->elts[pc + 1].longconst);
       /* Allocate arg vector, including space for the function to be

-         called in argvec[0] and a terminating NULL */
-      argvec = (struct value **) alloca (sizeof (struct value *) * (nargs + 3));
+         called in argvec[0] and a terminating NULL.  */
+      argvec = (struct value **)
+       alloca (sizeof (struct value *) * (nargs + 3));

       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
        {
          nargs++;
       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
        {
          nargs++;

-         /* First, evaluate the structure into arg2 */
+         /* First, evaluate the structure into arg2.  */

          pc2 = (*pos)++;
 
          if (noside == EVAL_SKIP)
          pc2 = (*pos)++;
 
          if (noside == EVAL_SKIP)


@@ -1323,21 +1477,22 @@ evaluate_subexp_standard (struct type *expect_type,
          if (noside == EVAL_AVOID_SIDE_EFFECTS)
            {
              struct type *method_type = check_typedef (value_type (arg1));
          if (noside == EVAL_AVOID_SIDE_EFFECTS)
            {
              struct type *method_type = check_typedef (value_type (arg1));

+

              arg1 = value_zero (method_type, not_lval);
            }
          else
            arg1 = cplus_method_ptr_to_value (&arg2, arg1);
 
              arg1 = value_zero (method_type, not_lval);
            }
          else
            arg1 = cplus_method_ptr_to_value (&arg2, arg1);
 

-         /* Now, say which argument to start evaluating from */
+         /* Now, say which argument to start evaluating from.  */

          tem = 2;
        }
       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
        {
          tem = 2;
        }
       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
        {

-         /* Hair for method invocations */
+         /* Hair for method invocations.  */

          int tem2;
 
          nargs++;
          int tem2;
 
          nargs++;

-         /* First, evaluate the structure into arg2 */
+         /* First, evaluate the structure into arg2.  */

          pc2 = (*pos)++;
          tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
          *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);
          pc2 = (*pos)++;
          tem2 = longest_to_int (exp->elts[pc2 + 1].longconst);
          *pos += 3 + BYTES_TO_EXP_ELEM (tem2 + 1);


@@ -1365,74 +1520,210 @@ evaluate_subexp_standard (struct type *expect_type,
          else
            {
              arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
          else
            {
              arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

+
+             /* Check to see if the operator '->' has been
+                overloaded.  If the operator has been overloaded
+                replace arg2 with the value returned by the custom
+                operator and continue evaluation.  */
+             while (unop_user_defined_p (op, arg2))
+               {
+                 volatile struct gdb_exception except;
+                 struct value *value = NULL;
+                 TRY_CATCH (except, RETURN_MASK_ERROR)
+                   {
+                     value = value_x_unop (arg2, op, noside);
+                   }
+
+                 if (except.reason < 0)
+                   {
+                     if (except.error == NOT_FOUND_ERROR)
+                       break;
+                     else
+                       throw_exception (except);
+                   }
+                 arg2 = value;
+               }

            }
            }

-         /* Now, say which argument to start evaluating from */
+         /* Now, say which argument to start evaluating from.  */

          tem = 2;
        }
          tem = 2;
        }

+      else if (op == OP_SCOPE
+              && overload_resolution
+              && (exp->language_defn->la_language == language_cplus))
+       {
+         /* Unpack it locally so we can properly handle overload
+            resolution.  */
+         char *name;
+         int local_tem;
+
+         pc2 = (*pos)++;
+         local_tem = longest_to_int (exp->elts[pc2 + 2].longconst);
+         (*pos) += 4 + BYTES_TO_EXP_ELEM (local_tem + 1);
+         type = exp->elts[pc2 + 1].type;
+         name = &exp->elts[pc2 + 3].string;
+
+         function = NULL;
+         function_name = NULL;
+         if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
+           {
+             function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
+                                                    name,
+                                                    get_selected_block (0),
+                                                    VAR_DOMAIN);
+             if (function == NULL)
+               error (_("No symbol \"%s\" in namespace \"%s\"."), 
+                      name, TYPE_TAG_NAME (type));
+
+             tem = 1;
+           }
+         else
+           {
+             gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
+                         || TYPE_CODE (type) == TYPE_CODE_UNION);
+             function_name = name;
+
+             arg2 = value_zero (type, lval_memory);
+             ++nargs;
+             tem = 2;
+           }
+       }
+      else if (op == OP_ADL_FUNC)
+        {
+          /* Save the function position and move pos so that the arguments
+             can be evaluated.  */
+          int func_name_len;
+
+          save_pos1 = *pos;
+          tem = 1;
+
+          func_name_len = longest_to_int (exp->elts[save_pos1 + 3].longconst);
+          (*pos) += 6 + BYTES_TO_EXP_ELEM (func_name_len + 1);
+        }

       else
        {
       else
        {

-         /* Non-method function call */
+         /* Non-method function call.  */

          save_pos1 = *pos;
          save_pos1 = *pos;

-         argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);

          tem = 1;
          tem = 1;

-         type = value_type (argvec[0]);
-         if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
-           type = TYPE_TARGET_TYPE (type);
-         if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
+
+         /* If this is a C++ function wait until overload resolution.  */
+         if (op == OP_VAR_VALUE
+             && overload_resolution
+             && (exp->language_defn->la_language == language_cplus))

            {
            {

-             for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
+             (*pos) += 4; /* Skip the evaluation of the symbol.  */
+             argvec[0] = NULL;
+           }
+         else
+           {
+             argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
+             type = value_type (argvec[0]);
+             if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
+               type = TYPE_TARGET_TYPE (type);
+             if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)

                {
                {

-                 /* pai: FIXME This seems to be coercing arguments before
-                  * overload resolution has been done! */
-                 argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type, tem - 1),
-                                                exp, pos, noside);
+                 for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
+                   {
+                     argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
+                                                                     tem - 1),
+                                                    exp, pos, noside);
+                   }

                }
            }
        }
 
                }
            }
        }
 

-      /* Evaluate arguments */
+      /* Evaluate arguments.  */

       for (; tem <= nargs; tem++)
        {
       for (; tem <= nargs; tem++)
        {

-         /* Ensure that array expressions are coerced into pointer objects. */
+         /* Ensure that array expressions are coerced into pointer
+            objects.  */

          argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
        }
 
          argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
        }
 

-      /* signal end of arglist */
+      /* Signal end of arglist.  */

       argvec[tem] = 0;
       argvec[tem] = 0;

-
-      if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
+      if (op == OP_ADL_FUNC)
+        {
+          struct symbol *symp;
+          char *func_name;
+          int  name_len;
+          int string_pc = save_pos1 + 3;
+
+          /* Extract the function name.  */
+          name_len = longest_to_int (exp->elts[string_pc].longconst);
+          func_name = (char *) alloca (name_len + 1);
+          strcpy (func_name, &exp->elts[string_pc + 1].string);
+
+          /* Prepare list of argument types for overload resolution.  */
+          arg_types = (struct type **)
+           alloca (nargs * (sizeof (struct type *)));
+          for (ix = 1; ix <= nargs; ix++)
+            arg_types[ix - 1] = value_type (argvec[ix]);
+
+          find_overload_match (arg_types, nargs, func_name,
+                               NON_METHOD, /* not method */
+                              0,          /* strict match */
+                               NULL, NULL, /* pass NULL symbol since
+                                             symbol is unknown */
+                               NULL, &symp, NULL, 0);
+
+          /* Now fix the expression being evaluated.  */
+          exp->elts[save_pos1 + 2].symbol = symp;
+          argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
+        }
+
+      if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR
+         || (op == OP_SCOPE && function_name != NULL))

        {
          int static_memfuncp;
        {
          int static_memfuncp;

-         char tstr[256];
+         char *tstr;

 
 

-         /* Method invocation : stuff "this" as first parameter */
+         /* Method invocation : stuff "this" as first parameter.  */

          argvec[1] = arg2;
          argvec[1] = arg2;

-         /* Name of method from expression */
-         strcpy (tstr, &exp->elts[pc2 + 2].string);

 
 

-         if (overload_resolution && (exp->language_defn->la_language == language_cplus))
+         if (op != OP_SCOPE)

            {
            {

-             /* Language is C++, do some overload resolution before evaluation */
+             /* Name of method from expression.  */
+             tstr = &exp->elts[pc2 + 2].string;
+           }
+         else
+           tstr = function_name;
+
+         if (overload_resolution && (exp->language_defn->la_language
+                                     == language_cplus))
+           {
+             /* Language is C++, do some overload resolution before
+                evaluation.  */

              struct value *valp = NULL;
 
              struct value *valp = NULL;
 

-             /* Prepare list of argument types for overload resolution */
-             arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
+             /* Prepare list of argument types for overload resolution.  */
+             arg_types = (struct type **)
+               alloca (nargs * (sizeof (struct type *)));

              for (ix = 1; ix <= nargs; ix++)
                arg_types[ix - 1] = value_type (argvec[ix]);
 
              (void) find_overload_match (arg_types, nargs, tstr,
              for (ix = 1; ix <= nargs; ix++)
                arg_types[ix - 1] = value_type (argvec[ix]);
 
              (void) find_overload_match (arg_types, nargs, tstr,

-                                    1 /* method */ , 0 /* strict match */ ,
-                                         &arg2 /* the object */ , NULL,
-                                         &valp, NULL, &static_memfuncp);
-
+                                         METHOD, /* method */
+                                         0,      /* strict match */
+                                         &arg2,  /* the object */
+                                         NULL, &valp, NULL,
+                                         &static_memfuncp, 0);

 
 

+             if (op == OP_SCOPE && !static_memfuncp)
+               {
+                 /* For the time being, we don't handle this.  */
+                 error (_("Call to overloaded function %s requires "
+                          "`this' pointer"),
+                        function_name);
+               }

              argvec[1] = arg2; /* the ``this'' pointer */
              argvec[1] = arg2; /* the ``this'' pointer */

-             argvec[0] = valp; /* use the method found after overload resolution */
+             argvec[0] = valp; /* Use the method found after overload
+                                  resolution.  */

            }
          else
            }
          else

-           /* Non-C++ case -- or no overload resolution */
+           /* Non-C++ case -- or no overload resolution.  */

            {
              struct value *temp = arg2;
            {
              struct value *temp = arg2;

+

              argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
                                            &static_memfuncp,
                                            op == STRUCTOP_STRUCT
              argvec[0] = value_struct_elt (&temp, argvec + 1, tstr,
                                            &static_memfuncp,
                                            op == STRUCTOP_STRUCT


@@ -1440,9 +1731,10 @@ evaluate_subexp_standard (struct type *expect_type,
              /* value_struct_elt updates temp with the correct value
                 of the ``this'' pointer if necessary, so modify argvec[1] to
                 reflect any ``this'' changes.  */
              /* value_struct_elt updates temp with the correct value
                 of the ``this'' pointer if necessary, so modify argvec[1] to
                 reflect any ``this'' changes.  */

-             arg2 = value_from_longest (lookup_pointer_type(value_type (temp)),
-                                        value_address (temp)
-                                        + value_embedded_offset (temp));
+             arg2
+               = value_from_longest (lookup_pointer_type(value_type (temp)),
+                                     value_address (temp)
+                                     + value_embedded_offset (temp));

              argvec[1] = arg2; /* the ``this'' pointer */
            }
 
              argvec[1] = arg2; /* the ``this'' pointer */
            }
 


@@ -1458,42 +1750,61 @@ evaluate_subexp_standard (struct type *expect_type,
          argvec[1] = arg2;
          argvec[0] = arg1;
        }
          argvec[1] = arg2;
          argvec[0] = arg1;
        }

-      else if (op == OP_VAR_VALUE)
+      else if (op == OP_VAR_VALUE || (op == OP_SCOPE && function != NULL))

        {
        {

-         /* Non-member function being called */
+         /* Non-member function being called.  */

           /* fn: This can only be done for C++ functions.  A C-style function
              in a C++ program, for instance, does not have the fields that 
           /* fn: This can only be done for C++ functions.  A C-style function
              in a C++ program, for instance, does not have the fields that 

-             are expected here */
+             are expected here.  */

 
 

-         if (overload_resolution && (exp->language_defn->la_language == language_cplus))
+         if (overload_resolution && (exp->language_defn->la_language
+                                     == language_cplus))

            {
            {

-             /* Language is C++, do some overload resolution before evaluation */
+             /* Language is C++, do some overload resolution before
+                evaluation.  */

              struct symbol *symp;
              struct symbol *symp;

+             int no_adl = 0;
+
+             /* If a scope has been specified disable ADL.  */
+             if (op == OP_SCOPE)
+               no_adl = 1;

 
 

-             /* Prepare list of argument types for overload resolution */
-             arg_types = (struct type **) alloca (nargs * (sizeof (struct type *)));
+             if (op == OP_VAR_VALUE)
+               function = exp->elts[save_pos1+2].symbol;
+
+             /* Prepare list of argument types for overload resolution.  */
+             arg_types = (struct type **)
+               alloca (nargs * (sizeof (struct type *)));

              for (ix = 1; ix <= nargs; ix++)
                arg_types[ix - 1] = value_type (argvec[ix]);
 
              for (ix = 1; ix <= nargs; ix++)
                arg_types[ix - 1] = value_type (argvec[ix]);
 

-             (void) find_overload_match (arg_types, nargs, NULL /* no need for name */ ,
-                                0 /* not method */ , 0 /* strict match */ ,
-                     NULL, exp->elts[save_pos1+2].symbol /* the function */ ,
-                                         NULL, &symp, NULL);
+             (void) find_overload_match (arg_types, nargs,
+                                         NULL,        /* no need for name */
+                                         NON_METHOD,  /* not method */
+                                         0,           /* strict match */
+                                         NULL, function, /* the function */
+                                         NULL, &symp, NULL, no_adl);

 
 

-             /* Now fix the expression being evaluated */
-             exp->elts[save_pos1+2].symbol = symp;
-             argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1, noside);
+             if (op == OP_VAR_VALUE)
+               {
+                 /* Now fix the expression being evaluated.  */
+                 exp->elts[save_pos1+2].symbol = symp;
+                 argvec[0] = evaluate_subexp_with_coercion (exp, &save_pos1,
+                                                            noside);
+               }
+             else
+               argvec[0] = value_of_variable (symp, get_selected_block (0));

            }
          else
            {
            }
          else
            {

-             /* Not C++, or no overload resolution allowed */
-             /* nothing to be done; argvec already correctly set up */
+             /* Not C++, or no overload resolution allowed.  */
+             /* Nothing to be done; argvec already correctly set up.  */

            }
        }
       else
        {
            }
        }
       else
        {

-         /* It is probably a C-style function */
-         /* nothing to be done; argvec already correctly set up */
+         /* It is probably a C-style function.  */
+         /* Nothing to be done; argvec already correctly set up.  */

        }
 
     do_call_it:
        }
 
     do_call_it:


@@ -1506,24 +1817,34 @@ evaluate_subexp_standard (struct type *expect_type,
        {
          /* If the return type doesn't look like a function type, call an
             error.  This can happen if somebody tries to turn a variable into
        {
          /* If the return type doesn't look like a function type, call an
             error.  This can happen if somebody tries to turn a variable into

-            a function call. This is here because people often want to
+            a function call.  This is here because people often want to

             call, eg, strcmp, which gdb doesn't know is a function.  If
             gdb isn't asked for it's opinion (ie. through "whatis"),
             call, eg, strcmp, which gdb doesn't know is a function.  If
             gdb isn't asked for it's opinion (ie. through "whatis"),

-            it won't offer it. */
+            it won't offer it.  */

 
 

-         struct type *ftype =
-         TYPE_TARGET_TYPE (value_type (argvec[0]));
+         struct type *ftype = value_type (argvec[0]);

 
 

-         if (ftype)
-           return allocate_value (TYPE_TARGET_TYPE (value_type (argvec[0])));
+         if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
+           {
+             /* We don't know anything about what the internal
+                function might return, but we have to return
+                something.  */
+             return value_zero (builtin_type (exp->gdbarch)->builtin_int,
+                                not_lval);
+           }
+         else if (TYPE_TARGET_TYPE (ftype))
+           return allocate_value (TYPE_TARGET_TYPE (ftype));

          else
          else

-           error (_("Expression of type other than \"Function returning ...\" used as function"));
+           error (_("Expression of type other than "
+                    "\"Function returning ...\" used as function"));

        }
       if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_INTERNAL_FUNCTION)
        }
       if (TYPE_CODE (value_type (argvec[0])) == TYPE_CODE_INTERNAL_FUNCTION)

-       return call_internal_function (argvec[0], nargs, argvec + 1);
+       return call_internal_function (exp->gdbarch, exp->language_defn,
+                                      argvec[0], nargs, argvec + 1);

 
       return call_function_by_hand (argvec[0], nargs, argvec + 1);
 
       return call_function_by_hand (argvec[0], nargs, argvec + 1);

-      /* pai: FIXME save value from call_function_by_hand, then adjust pc by adjust_fn_pc if +ve  */
+      /* pai: FIXME save value from call_function_by_hand, then adjust
+        pc by adjust_fn_pc if +ve.  */

 
     case OP_F77_UNDETERMINED_ARGLIST:
 
 
     case OP_F77_UNDETERMINED_ARGLIST:
 


@@ -1531,8 +1852,8 @@ evaluate_subexp_standard (struct type *expect_type,
          array subscript operations cannot be disambiguated 
          at parse time.  We have made all array subscript operations, 
          substring operations as well as function calls  come here 
          array subscript operations cannot be disambiguated 
          at parse time.  We have made all array subscript operations, 
          substring operations as well as function calls  come here 

-         and we now have to discover what the heck this thing actually was.  
-         If it is a function, we process just as if we got an OP_FUNCALL. */
+         and we now have to discover what the heck this thing actually was.
+         If it is a function, we process just as if we got an OP_FUNCALL.  */

 
       nargs = longest_to_int (exp->elts[pc + 1].longconst);
       (*pos) += 2;
 
       nargs = longest_to_int (exp->elts[pc + 1].longconst);
       (*pos) += 2;


@@ -1574,15 +1895,16 @@ evaluate_subexp_standard (struct type *expect_type,
          else
            {
              arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
          else
            {
              arg2 = evaluate_subexp_with_coercion (exp, pos, noside);

-             return value_subscript (arg1, arg2);
+             return value_subscript (arg1, value_as_long (arg2));

            }
 
        case TYPE_CODE_PTR:
        case TYPE_CODE_FUNC:
            }
 
        case TYPE_CODE_PTR:
        case TYPE_CODE_FUNC:

-         /* It's a function call. */
+         /* It's a function call.  */

          /* Allocate arg vector, including space for the function to be
          /* Allocate arg vector, including space for the function to be

-            called in argvec[0] and a terminating NULL */
-         argvec = (struct value **) alloca (sizeof (struct value *) * (nargs + 2));
+            called in argvec[0] and a terminating NULL.  */
+         argvec = (struct value **)
+           alloca (sizeof (struct value *) * (nargs + 2));

          argvec[0] = arg1;
          tem = 1;
          for (; tem <= nargs; tem++)
          argvec[0] = arg1;
          tem = 1;
          for (; tem <= nargs; tem++)


@@ -1596,7 +1918,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
     case OP_COMPLEX:
       /* We have a complex number, There should be 2 floating 
 
     case OP_COMPLEX:
       /* We have a complex number, There should be 2 floating 

-         point numbers that compose it */
+         point numbers that compose it.  */

       (*pos) += 2;
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       (*pos) += 2;
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);


@@ -1617,6 +1939,7 @@ evaluate_subexp_standard (struct type *expect_type,
       else
        {
          struct value *temp = arg1;
       else
        {
          struct value *temp = arg1;

+

          return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
                                   NULL, "structure");
        }
          return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
                                   NULL, "structure");
        }


@@ -1628,9 +1951,30 @@ evaluate_subexp_standard (struct type *expect_type,
       if (noside == EVAL_SKIP)
        goto nosideret;
 
       if (noside == EVAL_SKIP)
        goto nosideret;
 

+      /* Check to see if operator '->' has been overloaded.  If so replace
+         arg1 with the value returned by evaluating operator->().  */
+      while (unop_user_defined_p (op, arg1))
+       {
+         volatile struct gdb_exception except;
+         struct value *value = NULL;
+         TRY_CATCH (except, RETURN_MASK_ERROR)
+           {
+             value = value_x_unop (arg1, op, noside);
+           }
+
+         if (except.reason < 0)
+           {
+             if (except.error == NOT_FOUND_ERROR)
+               break;
+             else
+               throw_exception (except);
+           }
+         arg1 = value;
+       }
+

       /* JYG: if print object is on we need to replace the base type
         with rtti type in order to continue on with successful
       /* JYG: if print object is on we need to replace the base type
         with rtti type in order to continue on with successful

-        lookup of member / method only available in the rtti type. */
+        lookup of member / method only available in the rtti type.  */

       {
         struct type *type = value_type (arg1);
         struct type *real_type;
       {
         struct type *type = value_type (arg1);
         struct type *real_type;


@@ -1638,8 +1982,8 @@ evaluate_subexp_standard (struct type *expect_type,
        struct value_print_options opts;
 
        get_user_print_options (&opts);
        struct value_print_options opts;
 
        get_user_print_options (&opts);

-        if (opts.objectprint && TYPE_TARGET_TYPE(type) &&
-            (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
+        if (opts.objectprint && TYPE_TARGET_TYPE(type)
+            && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))

           {
             real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
             if (real_type)
           {
             real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
             if (real_type)


@@ -1662,6 +2006,7 @@ evaluate_subexp_standard (struct type *expect_type,
       else
        {
          struct value *temp = arg1;
       else
        {
          struct value *temp = arg1;

+

          return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
                                   NULL, "structure pointer");
        }
          return value_struct_elt (&temp, NULL, &exp->elts[pc + 2].string,
                                   NULL, "structure pointer");
        }


@@ -1703,9 +2048,24 @@ evaluate_subexp_standard (struct type *expect_type,
          return value_ind (arg3);
 
        default:
          return value_ind (arg3);
 
        default:

-         error (_("non-pointer-to-member value used in pointer-to-member construct"));
+         error (_("non-pointer-to-member value used "
+                  "in pointer-to-member construct"));

        }
 
        }
 

+    case TYPE_INSTANCE:
+      nargs = longest_to_int (exp->elts[pc + 1].longconst);
+      arg_types = (struct type **) alloca (nargs * sizeof (struct type *));
+      for (ix = 0; ix < nargs; ++ix)
+       arg_types[ix] = exp->elts[pc + 1 + ix + 1].type;
+
+      expect_type = make_params (nargs, arg_types);
+      *(pos) += 3 + nargs;
+      arg1 = evaluate_subexp_standard (expect_type, exp, pos, noside);
+      xfree (TYPE_FIELDS (expect_type));
+      xfree (TYPE_MAIN_TYPE (expect_type));
+      xfree (expect_type);
+      return arg1;
+

     case BINOP_CONCAT:
       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
     case BINOP_CONCAT:
       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);


@@ -1736,10 +2096,14 @@ evaluate_subexp_standard (struct type *expect_type,
       op = exp->elts[pc + 1].opcode;
       if (binop_user_defined_p (op, arg1, arg2))
        return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);
       op = exp->elts[pc + 1].opcode;
       if (binop_user_defined_p (op, arg1, arg2))
        return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op, noside);

-      else if (op == BINOP_ADD && ptrmath_type_p (value_type (arg1)))
-       arg2 = value_ptradd (arg1, arg2);
-      else if (op == BINOP_SUB && ptrmath_type_p (value_type (arg1)))
-       arg2 = value_ptrsub (arg1, arg2);
+      else if (op == BINOP_ADD && ptrmath_type_p (exp->language_defn,
+                                                 value_type (arg1))
+              && is_integral_type (value_type (arg2)))
+       arg2 = value_ptradd (arg1, value_as_long (arg2));
+      else if (op == BINOP_SUB && ptrmath_type_p (exp->language_defn,
+                                                 value_type (arg1))
+              && is_integral_type (value_type (arg2)))
+       arg2 = value_ptradd (arg1, - value_as_long (arg2));

       else
        {
          struct value *tmp = arg1;
       else
        {
          struct value *tmp = arg1;


@@ -1763,10 +2127,12 @@ evaluate_subexp_standard (struct type *expect_type,
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        return value_x_binop (arg1, arg2, op, OP_NULL, noside);
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        return value_x_binop (arg1, arg2, op, OP_NULL, noside);

-      else if (ptrmath_type_p (value_type (arg1)))
-       return value_ptradd (arg1, arg2);
-      else if (ptrmath_type_p (value_type (arg2)))
-       return value_ptradd (arg2, arg1);
+      else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
+              && is_integral_type (value_type (arg2)))
+       return value_ptradd (arg1, value_as_long (arg2));
+      else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
+              && is_integral_type (value_type (arg1)))
+       return value_ptradd (arg2, value_as_long (arg1));

       else
        {
          binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
       else
        {
          binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);


@@ -1780,17 +2146,16 @@ evaluate_subexp_standard (struct type *expect_type,
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        return value_x_binop (arg1, arg2, op, OP_NULL, noside);
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
        return value_x_binop (arg1, arg2, op, OP_NULL, noside);

-      else if (ptrmath_type_p (value_type (arg1)))
+      else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
+              && ptrmath_type_p (exp->language_defn, value_type (arg2)))

        {
        {

-         if (ptrmath_type_p (value_type (arg2)))
-           {
-             /* FIXME -- should be ptrdiff_t */
-             type = builtin_type (exp->gdbarch)->builtin_long;
-             return value_from_longest (type, value_ptrdiff (arg1, arg2));
-           }
-         else
-           return value_ptrsub (arg1, arg2);
+         /* FIXME -- should be ptrdiff_t */
+         type = builtin_type (exp->gdbarch)->builtin_long;
+         return value_from_longest (type, value_ptrdiff (arg1, arg2));

        }
        }

+      else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
+              && is_integral_type (value_type (arg2)))
+       return value_ptradd (arg1, - value_as_long (arg2));

       else
        {
          binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);
       else
        {
          binop_promote (exp->language_defn, exp->gdbarch, &arg1, &arg2);


@@ -1851,15 +2216,15 @@ evaluate_subexp_standard (struct type *expect_type,
        }
 
     case BINOP_RANGE:
        }
 
     case BINOP_RANGE:

-      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
-      arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      evaluate_subexp (NULL_TYPE, exp, pos, noside);

       if (noside == EVAL_SKIP)
        goto nosideret;
       error (_("':' operator used in invalid context"));
 
     case BINOP_SUBSCRIPT:
       if (noside == EVAL_SKIP)
        goto nosideret;
       error (_("':' operator used in invalid context"));
 
     case BINOP_SUBSCRIPT:

-      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
-      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
+      arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+      arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (binop_user_defined_p (op, arg1, arg2))


@@ -1868,7 +2233,7 @@ evaluate_subexp_standard (struct type *expect_type,
        {
          /* If the user attempts to subscript something that is not an
             array or pointer type (like a plain int variable for example),
        {
          /* If the user attempts to subscript something that is not an
             array or pointer type (like a plain int variable for example),

-            then report this as an error. */
+            then report this as an error.  */

 
          arg1 = coerce_ref (arg1);
          type = check_typedef (value_type (arg1));
 
          arg1 = coerce_ref (arg1);
          type = check_typedef (value_type (arg1));


@@ -1885,7 +2250,7 @@ evaluate_subexp_standard (struct type *expect_type,
          if (noside == EVAL_AVOID_SIDE_EFFECTS)
            return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
          else
          if (noside == EVAL_AVOID_SIDE_EFFECTS)
            return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
          else

-           return value_subscript (arg1, arg2);
+           return value_subscript (arg1, value_as_long (arg2));

        }
 
     case BINOP_IN:
        }
 
     case BINOP_IN:


@@ -1903,7 +2268,7 @@ evaluate_subexp_standard (struct type *expect_type,
       while (nargs-- > 0)
        {
          arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
       while (nargs-- > 0)
        {
          arg2 = evaluate_subexp_with_coercion (exp, pos, noside);

-         /* FIXME:  EVAL_SKIP handling may not be correct. */
+         /* FIXME:  EVAL_SKIP handling may not be correct.  */

          if (noside == EVAL_SKIP)
            {
              if (nargs > 0)
          if (noside == EVAL_SKIP)
            {
              if (nargs > 0)


@@ -1915,12 +2280,12 @@ evaluate_subexp_standard (struct type *expect_type,
                  goto nosideret;
                }
            }
                  goto nosideret;
                }
            }

-         /* FIXME:  EVAL_AVOID_SIDE_EFFECTS handling may not be correct. */
+         /* FIXME:  EVAL_AVOID_SIDE_EFFECTS handling may not be correct.  */

          if (noside == EVAL_AVOID_SIDE_EFFECTS)
            {
              /* If the user attempts to subscript something that has no target
                 type (like a plain int variable for example), then report this
          if (noside == EVAL_AVOID_SIDE_EFFECTS)
            {
              /* If the user attempts to subscript something that has no target
                 type (like a plain int variable for example), then report this

-                as an error. */
+                as an error.  */

 
              type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
              if (type != NULL)
 
              type = TYPE_TARGET_TYPE (check_typedef (value_type (arg1)));
              if (type != NULL)


@@ -1950,12 +2315,13 @@ evaluate_subexp_standard (struct type *expect_type,
                case TYPE_CODE_PTR:
                case TYPE_CODE_ARRAY:
                case TYPE_CODE_STRING:
                case TYPE_CODE_PTR:
                case TYPE_CODE_ARRAY:
                case TYPE_CODE_STRING:

-                 arg1 = value_subscript (arg1, arg2);
+                 arg1 = value_subscript (arg1, value_as_long (arg2));

                  break;
 
                case TYPE_CODE_BITSTRING:
                  type = language_bool_type (exp->language_defn, exp->gdbarch);
                  break;
 
                case TYPE_CODE_BITSTRING:
                  type = language_bool_type (exp->language_defn, exp->gdbarch);

-                 arg1 = value_bitstring_subscript (type, arg1, arg2);
+                 arg1 = value_bitstring_subscript (type, arg1,
+                                                   value_as_long (arg2));

                  break;
 
                default:
                  break;
 
                default:


@@ -1971,16 +2337,13 @@ evaluate_subexp_standard (struct type *expect_type,
 
     multi_f77_subscript:
       {
 
     multi_f77_subscript:
       {

-       int subscript_array[MAX_FORTRAN_DIMS];
-       int array_size_array[MAX_FORTRAN_DIMS];
+       LONGEST subscript_array[MAX_FORTRAN_DIMS];

        int ndimensions = 1, i;
        int ndimensions = 1, i;

-       struct type *tmp_type;
-       int offset_item;        /* The array offset where the item lives */
+       struct value *array = arg1;

 
        if (nargs > MAX_FORTRAN_DIMS)
          error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
 
 
        if (nargs > MAX_FORTRAN_DIMS)
          error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);
 

-       tmp_type = check_typedef (value_type (arg1));

        ndimensions = calc_f77_array_dims (type);
 
        if (nargs != ndimensions)
        ndimensions = calc_f77_array_dims (type);
 
        if (nargs != ndimensions)


@@ -1989,72 +2352,37 @@ evaluate_subexp_standard (struct type *expect_type,
        gdb_assert (nargs > 0);
 
        /* Now that we know we have a legal array subscript expression 
        gdb_assert (nargs > 0);
 
        /* Now that we know we have a legal array subscript expression 

-          let us actually find out where this element exists in the array. */
+          let us actually find out where this element exists in the array.  */

 
 

-       offset_item = 0;
-       /* Take array indices left to right */
+       /* Take array indices left to right.  */

        for (i = 0; i < nargs; i++)
          {
        for (i = 0; i < nargs; i++)
          {

-           /* Evaluate each subscript, It must be a legal integer in F77 */
+           /* Evaluate each subscript; it must be a legal integer in F77.  */

            arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 
            arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 

-           /* Fill in the subscript and array size arrays */
+           /* Fill in the subscript array.  */

 
            subscript_array[i] = value_as_long (arg2);
          }
 
 
            subscript_array[i] = value_as_long (arg2);
          }
 

-       /* Internal type of array is arranged right to left */
-       for (i = 0; i < nargs; i++)
+       /* Internal type of array is arranged right to left.  */
+       for (i = nargs; i > 0; i--)

          {
          {

-           upper = f77_get_upperbound (tmp_type);
-           lower = f77_get_lowerbound (tmp_type);
-
-           array_size_array[nargs - i - 1] = upper - lower + 1;
-
-           /* Zero-normalize subscripts so that offsetting will work. */
-
-           subscript_array[nargs - i - 1] -= lower;
+           struct type *array_type = check_typedef (value_type (array));
+           LONGEST index = subscript_array[i - 1];

 
 

-           /* If we are at the bottom of a multidimensional 
-              array type then keep a ptr to the last ARRAY
-              type around for use when calling value_subscript()
-              below. This is done because we pretend to value_subscript
-              that we actually have a one-dimensional array 
-              of base element type that we apply a simple 
-              offset to. */
-
-           if (i < nargs - 1)
-             tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
+           lower = f77_get_lowerbound (array_type);
+           array = value_subscripted_rvalue (array, index, lower);

          }
 
          }
 

-       /* Now let us calculate the offset for this item */
-
-       offset_item = subscript_array[ndimensions - 1];
-
-       for (i = ndimensions - 1; i > 0; --i)
-         offset_item =
-           array_size_array[i - 1] * offset_item + subscript_array[i - 1];
-
-       /* Construct a value node with the value of the offset */
-
-       arg2 = value_from_longest (builtin_type_int32, offset_item);
-
-       /* Let us now play a dirty trick: we will take arg1 
-          which is a value node pointing to the topmost level
-          of the multidimensional array-set and pretend
-          that it is actually a array of the final element 
-          type, this will ensure that value_subscript()
-          returns the correct type value */
-
-       deprecated_set_value_type (arg1, tmp_type);
-       return value_subscripted_rvalue (arg1, arg2, 0);
+       return array;

       }
 
     case BINOP_LOGICAL_AND:
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
        {
       }
 
     case BINOP_LOGICAL_AND:
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
        {

-         arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+         evaluate_subexp (NULL_TYPE, exp, pos, noside);

          goto nosideret;
        }
 
          goto nosideret;
        }
 


@@ -2081,7 +2409,7 @@ evaluate_subexp_standard (struct type *expect_type,
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
        {
       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
       if (noside == EVAL_SKIP)
        {

-         arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
+         evaluate_subexp (NULL_TYPE, exp, pos, noside);

          goto nosideret;
        }
 
          goto nosideret;
        }
 


@@ -2284,7 +2612,8 @@ evaluate_subexp_standard (struct type *expect_type,
       type = check_typedef (value_type (arg1));
       if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
          || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
       type = check_typedef (value_type (arg1));
       if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
          || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)

-       error (_("Attempt to dereference pointer to member without an object"));
+       error (_("Attempt to dereference pointer "
+                "to member without an object"));

       if (noside == EVAL_SKIP)
        goto nosideret;
       if (unop_user_defined_p (op, arg1))
       if (noside == EVAL_SKIP)
        goto nosideret;
       if (unop_user_defined_p (op, arg1))


@@ -2328,7 +2657,9 @@ evaluate_subexp_standard (struct type *expect_type,
        }
       else
        {
        }
       else
        {

-         struct value *retvalp = evaluate_subexp_for_address (exp, pos, noside);
+         struct value *retvalp = evaluate_subexp_for_address (exp, pos,
+                                                              noside);
+

          return retvalp;
        }
 
          return retvalp;
        }
 


@@ -2350,6 +2681,22 @@ evaluate_subexp_standard (struct type *expect_type,
        arg1 = value_cast (type, arg1);
       return arg1;
 
        arg1 = value_cast (type, arg1);
       return arg1;
 

+    case UNOP_DYNAMIC_CAST:
+      (*pos) += 2;
+      type = exp->elts[pc + 1].type;
+      arg1 = evaluate_subexp (type, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+       goto nosideret;
+      return value_dynamic_cast (type, arg1);
+
+    case UNOP_REINTERPRET_CAST:
+      (*pos) += 2;
+      type = exp->elts[pc + 1].type;
+      arg1 = evaluate_subexp (type, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+       goto nosideret;
+      return value_reinterpret_cast (type, arg1);
+

     case UNOP_MEMVAL:
       (*pos) += 2;
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
     case UNOP_MEMVAL:
       (*pos) += 2;
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);


@@ -2371,6 +2718,7 @@ evaluate_subexp_standard (struct type *expect_type,
       else
        {
          CORE_ADDR tls_addr;
       else
        {
          CORE_ADDR tls_addr;

+

          tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
                                                   value_as_address (arg1));
          return value_at_lazy (exp->elts[pc + 2].type, tls_addr);
          tls_addr = target_translate_tls_address (exp->elts[pc + 1].objfile,
                                                   value_as_address (arg1));
          return value_at_lazy (exp->elts[pc + 2].type, tls_addr);


@@ -2386,12 +2734,13 @@ evaluate_subexp_standard (struct type *expect_type,
        }
       else
        {
        }
       else
        {

-         arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
-         if (ptrmath_type_p (value_type (arg1)))
-           arg2 = value_ptradd (arg1, arg2);
+         if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+           arg2 = value_ptradd (arg1, 1);

          else
            {
              struct value *tmp = arg1;
          else
            {
              struct value *tmp = arg1;

+
+             arg2 = value_one (value_type (arg1), not_lval);

              binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
              arg2 = value_binop (tmp, arg2, BINOP_ADD);
            }
              binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
              arg2 = value_binop (tmp, arg2, BINOP_ADD);
            }


@@ -2409,12 +2758,13 @@ evaluate_subexp_standard (struct type *expect_type,
        }
       else
        {
        }
       else
        {

-         arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
-         if (ptrmath_type_p (value_type (arg1)))
-           arg2 = value_ptrsub (arg1, arg2);
+         if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+           arg2 = value_ptradd (arg1, -1);

          else
            {
              struct value *tmp = arg1;
          else
            {
              struct value *tmp = arg1;

+
+             arg2 = value_one (value_type (arg1), not_lval);

              binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
              arg2 = value_binop (tmp, arg2, BINOP_SUB);
            }
              binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
              arg2 = value_binop (tmp, arg2, BINOP_SUB);
            }


@@ -2432,18 +2782,21 @@ evaluate_subexp_standard (struct type *expect_type,
        }
       else
        {
        }
       else
        {

-         arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
-         if (ptrmath_type_p (value_type (arg1)))
-           arg2 = value_ptradd (arg1, arg2);
+         arg3 = value_non_lval (arg1);
+
+         if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+           arg2 = value_ptradd (arg1, 1);

          else
            {
              struct value *tmp = arg1;
          else
            {
              struct value *tmp = arg1;

+
+             arg2 = value_one (value_type (arg1), not_lval);

              binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
              arg2 = value_binop (tmp, arg2, BINOP_ADD);
            }
 
          value_assign (arg1, arg2);
              binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
              arg2 = value_binop (tmp, arg2, BINOP_ADD);
            }
 
          value_assign (arg1, arg2);

-         return arg1;
+         return arg3;

        }
 
     case UNOP_POSTDECREMENT:
        }
 
     case UNOP_POSTDECREMENT:


@@ -2456,18 +2809,21 @@ evaluate_subexp_standard (struct type *expect_type,
        }
       else
        {
        }
       else
        {

-         arg2 = value_from_longest (builtin_type_uint8, (LONGEST) 1);
-         if (ptrmath_type_p (value_type (arg1)))
-           arg2 = value_ptrsub (arg1, arg2);
+         arg3 = value_non_lval (arg1);
+
+         if (ptrmath_type_p (exp->language_defn, value_type (arg1)))
+           arg2 = value_ptradd (arg1, -1);

          else
            {
              struct value *tmp = arg1;
          else
            {
              struct value *tmp = arg1;

+
+             arg2 = value_one (value_type (arg1), not_lval);

              binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
              arg2 = value_binop (tmp, arg2, BINOP_SUB);
            }
 
          value_assign (arg1, arg2);
              binop_promote (exp->language_defn, exp->gdbarch, &tmp, &arg2);
              arg2 = value_binop (tmp, arg2, BINOP_SUB);
            }
 
          value_assign (arg1, arg2);

-         return arg1;
+         return arg3;

        }
 
     case OP_THIS:
        }
 
     case OP_THIS:


@@ -2487,6 +2843,7 @@ evaluate_subexp_standard (struct type *expect_type,
       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *type = exp->elts[pc + 1].type;
       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *type = exp->elts[pc + 1].type;

+

          /* If this is a typedef, then find its immediate target.  We
             use check_typedef to resolve stubs, but we ignore its
             result because we do not want to dig past all
          /* If this is a typedef, then find its immediate target.  We
             use check_typedef to resolve stubs, but we ignore its
             result because we do not want to dig past all


@@ -2509,12 +2866,12 @@ evaluate_subexp_standard (struct type *expect_type,
          then they should be separate cases, with more descriptive
          error messages.  */
 
          then they should be separate cases, with more descriptive
          error messages.  */
 

-      error (_("\
-GDB does not (yet) know how to evaluate that kind of expression"));
+      error (_("GDB does not (yet) know how to "
+              "evaluate that kind of expression"));

     }
 
 nosideret:
     }
 
 nosideret:

-  return value_from_longest (builtin_type_int8, (LONGEST) 1);
+  return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);

 }
 \f
 /* Evaluate a subexpression of EXP, at index *POS,
 }
 \f
 /* Evaluate a subexpression of EXP, at index *POS,


@@ -2550,7 +2907,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
          goto default_case_after_eval;
        }
 
          goto default_case_after_eval;
        }
 

-      return x;
+      return coerce_array (x);

 
     case UNOP_MEMVAL:
       (*pos) += 3;
 
     case UNOP_MEMVAL:
       (*pos) += 3;


@@ -2561,7 +2918,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
       var = exp->elts[pc + 2].symbol;
 
       /* C++: The "address" of a reference should yield the address
       var = exp->elts[pc + 2].symbol;
 
       /* C++: The "address" of a reference should yield the address

-       * of the object pointed to. Let value_addr() deal with it. */
+       * of the object pointed to.  Let value_addr() deal with it.  */

       if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
        goto default_case;
 
       if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_REF)
        goto default_case;
 


@@ -2569,7 +2926,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *type =
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
        {
          struct type *type =

-         lookup_pointer_type (SYMBOL_TYPE (var));
+           lookup_pointer_type (SYMBOL_TYPE (var));

          enum address_class sym_class = SYMBOL_CLASS (var);
 
          if (sym_class == LOC_CONST
          enum address_class sym_class = SYMBOL_CLASS (var);
 
          if (sym_class == LOC_CONST


@@ -2588,7 +2945,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
       (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
       x = value_aggregate_elt (exp->elts[pc + 1].type,
                               &exp->elts[pc + 3].string,
       (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
       x = value_aggregate_elt (exp->elts[pc + 1].type,
                               &exp->elts[pc + 3].string,

-                              1, noside);
+                              NULL, 1, noside);

       if (x == NULL)
        error (_("There is no field named %s"), &exp->elts[pc + 3].string);
       return x;
       if (x == NULL)
        error (_("There is no field named %s"), &exp->elts[pc + 3].string);
       return x;


@@ -2608,7 +2965,8 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
            return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
                               not_lval);
          else
            return value_zero (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
                               not_lval);
          else

-           error (_("Attempt to take address of value not located in memory."));
+           error (_("Attempt to take address of "
+                    "value not located in memory."));

        }
       return value_addr (x);
     }
        }
       return value_addr (x);
     }


@@ -2623,9 +2981,7 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
    Note that we currently only do the coercion for C expressions, where
    arrays are zero based and the coercion is correct.  For other languages,
    with nonzero based arrays, coercion loses.  Use CAST_IS_CONVERSION
    Note that we currently only do the coercion for C expressions, where
    arrays are zero based and the coercion is correct.  For other languages,
    with nonzero based arrays, coercion loses.  Use CAST_IS_CONVERSION

-   to decide if coercion is appropriate.
-
- */
+   to decide if coercion is appropriate.  */

 
 struct value *
 evaluate_subexp_with_coercion (struct expression *exp,
 
 struct value *
 evaluate_subexp_with_coercion (struct expression *exp,


@@ -2646,7 +3002,8 @@ evaluate_subexp_with_coercion (struct expression *exp,
       var = exp->elts[pc + 2].symbol;
       type = check_typedef (SYMBOL_TYPE (var));
       if (TYPE_CODE (type) == TYPE_CODE_ARRAY
       var = exp->elts[pc + 2].symbol;
       type = check_typedef (SYMBOL_TYPE (var));
       if (TYPE_CODE (type) == TYPE_CODE_ARRAY

-         && CAST_IS_CONVERSION)
+         && !TYPE_VECTOR (type)
+         && CAST_IS_CONVERSION (exp->language_defn))

        {
          (*pos) += 4;
          val = address_of_variable (var, exp->elts[pc + 1].block);
        {
          (*pos) += 4;
          val = address_of_variable (var, exp->elts[pc + 1].block);


@@ -2712,13 +3069,14 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
     }
 }
 
     }
 }
 

-/* Parse a type expression in the string [P..P+LENGTH). */
+/* Parse a type expression in the string [P..P+LENGTH).  */

 
 struct type *
 parse_and_eval_type (char *p, int length)
 {
   char *tmp = (char *) alloca (length + 4);
   struct expression *expr;
 
 struct type *
 parse_and_eval_type (char *p, int length)
 {
   char *tmp = (char *) alloca (length + 4);
   struct expression *expr;

+

   tmp[0] = '(';
   memcpy (tmp + 1, p, length);
   tmp[length + 1] = ')';
   tmp[0] = '(';
   memcpy (tmp + 1, p, length);
   tmp[length + 1] = ')';