PR exp/13206:

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

diff --git a/gdb/eval.c b/gdb/eval.c
index f4ae539b52f25c3be510c1a0d700bcb829aa98e3..4253820719c44fba3742ff5aa594fff5bc780cc7 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1,8 +1,6 @@
 /* Evaluate expressions for GDB.
 
 /* Evaluate expressions for GDB.
 

-   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
-   Free Software Foundation, Inc.
+   Copyright (C) 1986-2003, 2005-2012 Free Software Foundation, Inc.

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


@@ -27,8 +25,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"


@@ -39,26 +37,25 @@
 #include "exceptions.h"
 #include "regcache.h"
 #include "user-regs.h"
 #include "exceptions.h"
 #include "regcache.h"
 #include "user-regs.h"

+#include "valprint.h"
+#include "gdb_obstack.h"
+#include "objfiles.h"
+#include "python/python.h"

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

+#include <ctype.h>
+

 /* This is defined in valops.c */
 extern int overload_resolution;
 
 /* This is defined in valops.c */
 extern int overload_resolution;
 

-/* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
-   on with successful lookup for member/method of the rtti type. */
-extern int objectprint;
-
-/* Prototypes for local functions. */
+/* Prototypes for local functions.  */

 
 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
 
 static struct value *evaluate_subexp_for_address (struct expression *,
                                                  int *, enum noside);
 
 
 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
 
 static struct value *evaluate_subexp_for_address (struct expression *,
                                                  int *, enum noside);
 

-static struct value *evaluate_subexp (struct type *, struct expression *,
-                                     int *, enum noside);
-

 static char *get_label (struct expression *, int *);
 
 static struct value *evaluate_struct_tuple (struct value *,
 static char *get_label (struct expression *, int *);
 
 static struct value *evaluate_struct_tuple (struct value *,


@@ -69,7 +66,7 @@ static LONGEST init_array_element (struct value *, struct value *,
                                   struct expression *, int *, enum noside,
                                   LONGEST, LONGEST);
 
                                   struct expression *, int *, enum noside,
                                   LONGEST, LONGEST);
 

-static struct value *
+struct value *

 evaluate_subexp (struct type *expect_type, struct expression *exp,
                 int *pos, enum noside noside)
 {
 evaluate_subexp (struct type *expect_type, struct expression *exp,
                 int *pos, enum noside noside)
 {


@@ -93,24 +90,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)
 {


@@ -144,7 +125,7 @@ parse_and_eval (char *exp)
 struct value *
 parse_to_comma_and_eval (char **expp)
 {
 struct value *
 parse_to_comma_and_eval (char **expp)
 {

-  struct expression *expr = parse_exp_1 (expp, (struct block *) 0, 1);
+  struct expression *expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);

   struct value *val;
   struct cleanup *old_chain =
     make_cleanup (free_current_contents, &expr);
   struct value *val;
   struct cleanup *old_chain =
     make_cleanup (free_current_contents, &expr);


@@ -163,6 +144,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);
 }
 


@@ -173,6 +155,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);
 }
 


@@ -185,6 +168,96 @@ 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)
+    {
+      if (!value_lazy (result))
+       *valp = result;
+      else
+       {
+         volatile struct gdb_exception except;
+
+         TRY_CATCH (except, RETURN_MASK_ERROR)
+           {
+             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


@@ -197,6 +270,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;


@@ -207,7 +281,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)


@@ -217,6 +291,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;
     }


@@ -238,6 +313,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;


@@ -246,19 +322,22 @@ 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++)
                {
          if (label)
            {
              for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type);
                   fieldno++)
                {

-                 char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
+                 const 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;


@@ -270,7 +349,9 @@ evaluate_struct_tuple (struct value *struct_val,
              for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type);
                   fieldno++)
                {
              for (fieldno = 0; fieldno < TYPE_NFIELDS (struct_type);
                   fieldno++)
                {

-                 char *field_name = TYPE_FIELD_NAME (struct_type, fieldno);
+                 const 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)


@@ -304,7 +385,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++;


@@ -319,7 +400,8 @@ evaluate_struct_tuple (struct value *struct_val,
                  fieldno++;
                  /* Skip static fields.  */
                  while (fieldno < TYPE_NFIELDS (struct_type)
                  fieldno++;
                  /* Skip static fields.  */
                  while (fieldno < TYPE_NFIELDS (struct_type)

-                        && TYPE_FIELD_STATIC_KIND (struct_type, fieldno))
+                        && field_is_static (&TYPE_FIELD (struct_type,
+                                                         fieldno)))

                    fieldno++;
                  subfieldno = fieldno;
                  if (fieldno >= TYPE_NFIELDS (struct_type))
                    fieldno++;
                  subfieldno = fieldno;
                  if (fieldno >= TYPE_NFIELDS (struct_type))


@@ -338,15 +420,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);
 


@@ -356,8 +438,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)));


@@ -381,6 +463,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)++;


@@ -392,6 +475,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));


@@ -415,7 +499,7 @@ init_array_element (struct value *array, struct value *element,
   return index;
 }
 
   return index;
 }
 

-struct value *
+static struct value *

 value_f90_subarray (struct value *array,
                    struct expression *exp, int *pos, enum noside noside)
 {
 value_f90_subarray (struct value *array,
                    struct expression *exp, int *pos, enum noside noside)
 {


@@ -464,6 +548,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);
          }


@@ -513,6 +598,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;
 


@@ -600,7 +686,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.


@@ -633,7 +736,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)


@@ -646,13 +749,53 @@ 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;
+  if (num_types > 0)
+    {
+      if (param_types[num_types - 1] == NULL)
+       {
+         --num_types;
+         TYPE_VARARGS (type) = 1;
+       }
+      else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
+              == TYPE_CODE_VOID)
+       {
+         --num_types;
+         /* Caller should have ensured this.  */
+         gdb_assert (num_types == 0);
+         TYPE_PROTOTYPED (type) = 1;
+       }
+    }
+
+  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,


@@ -667,12 +810,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 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;


@@ -686,7 +831,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;


@@ -706,6 +851,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)


@@ -718,7 +864,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;


@@ -733,7 +879,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);
          }


@@ -741,6 +888,27 @@ evaluate_subexp_standard (struct type *expect_type,
        return ret;
       }
 
        return ret;
       }
 

+    case OP_VAR_ENTRY_VALUE:
+      (*pos) += 2;
+      if (noside == EVAL_SKIP)
+       goto nosideret;
+
+      {
+       struct symbol *sym = exp->elts[pc + 1].symbol;
+       struct frame_info *frame;
+
+       if (noside == EVAL_AVOID_SIDE_EFFECTS)
+         return value_zero (SYMBOL_TYPE (sym), not_lval);
+
+       if (SYMBOL_CLASS (sym) != LOC_COMPUTED
+           || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
+         error (_("Symbol \"%s\" does not have any specific entry value"),
+                SYMBOL_PRINT_NAME (sym));
+
+       frame = get_selected_frame (NULL);
+       return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
+      }
+

     case OP_LAST:
       (*pos) += 2;
       return
     case OP_LAST:
       (*pos) += 2;
       return


@@ -753,7 +921,7 @@ evaluate_subexp_standard (struct type *expect_type,
        struct value *val;
 
        (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
        struct value *val;
 
        (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);

-       regno = user_reg_map_name_to_regnum (current_gdbarch,
+       regno = user_reg_map_name_to_regnum (exp->gdbarch,

                                             name, strlen (name));
        if (regno == -1)
          error (_("Register $%s not available."), name);
                                             name, strlen (name));
        if (regno == -1)
          error (_("Register $%s not available."), name);


@@ -764,9 +932,9 @@ evaluate_subexp_standard (struct type *expect_type,
            So for these registers, we fetch the register value regardless
            of the evaluation mode.  */
        if (noside == EVAL_AVOID_SIDE_EFFECTS
            So for these registers, we fetch the register value regardless
            of the evaluation mode.  */
        if (noside == EVAL_AVOID_SIDE_EFFECTS

-           && regno < gdbarch_num_regs (current_gdbarch)
-              + gdbarch_num_pseudo_regs (current_gdbarch))
-         val = value_zero (register_type (current_gdbarch, regno), not_lval);
+           && regno < gdbarch_num_regs (exp->gdbarch)
+                       + gdbarch_num_pseudo_regs (exp->gdbarch))
+         val = value_zero (register_type (exp->gdbarch, regno), not_lval);

        else
          val = value_of_register (regno, get_selected_frame (NULL));
        if (val == NULL)
        else
          val = value_of_register (regno, get_selected_frame (NULL));
        if (val == NULL)


@@ -781,23 +949,26 @@ 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);
       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
       if (noside == EVAL_SKIP)
        goto nosideret;
 
     case OP_STRING:
       tem = longest_to_int (exp->elts[pc + 1].longconst);
       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
       if (noside == EVAL_SKIP)
        goto nosideret;

-      return value_string (&exp->elts[pc + 2].string, tem);
+      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)
        {
          goto nosideret;
        }
       tem = longest_to_int (exp->elts[pc + 1].longconst);
       (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
       if (noside == EVAL_SKIP)
        {
          goto nosideret;
        }

-      return (struct value *) value_nsstring (&exp->elts[pc + 2].string, tem + 1);
+      return value_nsstring (exp->gdbarch, &exp->elts[pc + 2].string, tem + 1);

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


@@ -805,7 +976,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:


@@ -819,6 +991,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);
        }


@@ -826,11 +999,12 @@ evaluate_subexp_standard (struct type *expect_type,
       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
          && TYPE_CODE (type) == TYPE_CODE_ARRAY)
        {
       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
          && TYPE_CODE (type) == TYPE_CODE_ARRAY)
        {

-         struct type *range_type = TYPE_FIELD_TYPE (type, 0);
+         struct type *range_type = TYPE_INDEX_TYPE (type);

          struct type *element_type = TYPE_TARGET_TYPE (type);
          struct value *array = allocate_value (expect_type);
          int element_size = TYPE_LENGTH (check_typedef (element_type));
          LONGEST low_bound, high_bound, index;
          struct type *element_type = TYPE_TARGET_TYPE (type);
          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;


@@ -842,6 +1016,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);


@@ -853,6 +1028,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);


@@ -861,7 +1037,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,


@@ -882,9 +1058,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)


@@ -895,6 +1071,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)++;


@@ -911,21 +1088,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)
                {


@@ -939,7 +1116,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;


@@ -951,7 +1129,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)


@@ -962,9 +1141,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);


@@ -974,9 +1154,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);
       }
 


@@ -999,6 +1180,7 @@ evaluate_subexp_standard (struct type *expect_type,
       {                                /* Objective C @selector operator.  */
        char *sel = &exp->elts[pc + 2].string;
        int len = longest_to_int (exp->elts[pc + 1].longconst);
       {                                /* Objective C @selector operator.  */
        char *sel = &exp->elts[pc + 2].string;
        int len = longest_to_int (exp->elts[pc + 1].longconst);

+       struct type *selector_type;

 
        (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
        if (noside == EVAL_SKIP)
 
        (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
        if (noside == EVAL_SKIP)


@@ -1006,30 +1188,33 @@ evaluate_subexp_standard (struct type *expect_type,
 
        if (sel[len] != 0)
          sel[len] = 0;         /* Make sure it's terminated.  */
 
        if (sel[len] != 0)
          sel[len] = 0;         /* Make sure it's terminated.  */

-       return value_from_longest (lookup_pointer_type (builtin_type_void),
-                                  lookup_child_selector (sel));
+
+       selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
+       return value_from_longest (selector_type,
+                                  lookup_child_selector (exp->gdbarch, sel));

       }
 
     case OP_OBJC_MSGCALL:
       {                                /* Objective C message (method) call.  */
 
       }
 
     case OP_OBJC_MSGCALL:
       {                                /* Objective C message (method) call.  */
 

-       static CORE_ADDR responds_selector = 0;
-       static CORE_ADDR method_selector = 0;
+       CORE_ADDR responds_selector = 0;
+       CORE_ADDR method_selector = 0;

 
        CORE_ADDR selector = 0;
 
        int struct_return = 0;
        int sub_no_side = 0;
 
 
        CORE_ADDR selector = 0;
 
        int struct_return = 0;
        int sub_no_side = 0;
 

-       static struct value *msg_send = NULL;
-       static struct value *msg_send_stret = NULL;
-       static int gnu_runtime = 0;
+       struct value *msg_send = NULL;
+       struct value *msg_send_stret = NULL;
+       int gnu_runtime = 0;

 
        struct value *target = NULL;
        struct value *method = NULL;
        struct value *called_method = NULL; 
 
        struct type *selector_type = NULL;
 
        struct value *target = NULL;
        struct value *method = NULL;
        struct value *called_method = NULL; 
 
        struct type *selector_type = NULL;

+       struct type *long_type;

 
        struct value *ret = NULL;
        CORE_ADDR addr = 0;
 
        struct value *ret = NULL;
        CORE_ADDR addr = 0;


@@ -1041,7 +1226,9 @@ evaluate_subexp_standard (struct type *expect_type,
 
        (*pos) += 3;
 
 
        (*pos) += 3;
 

-       selector_type = lookup_pointer_type (builtin_type_void);
+       long_type = builtin_type (exp->gdbarch)->builtin_long;
+       selector_type = builtin_type (exp->gdbarch)->builtin_data_ptr;
+

        if (noside == EVAL_AVOID_SIDE_EFFECTS)
          sub_no_side = EVAL_NORMAL;
        else
        if (noside == EVAL_AVOID_SIDE_EFFECTS)
          sub_no_side = EVAL_NORMAL;
        else


@@ -1050,7 +1237,7 @@ evaluate_subexp_standard (struct type *expect_type,
        target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
 
        if (value_as_long (target) == 0)
        target = evaluate_subexp (selector_type, exp, pos, sub_no_side);
 
        if (value_as_long (target) == 0)

-         return value_from_longest (builtin_type_long, 0);
+         return value_from_longest (long_type, 0);

        
        if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
          gnu_runtime = 1;
        
        if (lookup_minimal_symbol ("objc_msg_lookup", 0, 0))
          gnu_runtime = 1;


@@ -1060,20 +1247,21 @@ 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)
          {
           case of a method that returns a structure (Apple runtime 
           only).  */
        if (gnu_runtime)
          {

-           struct type *type;
-           type = lookup_pointer_type (builtin_type_void);
+           struct type *type = selector_type;
+

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

-           msg_send = find_function_in_inferior ("objc_msg_lookup");
-           msg_send_stret = find_function_in_inferior ("objc_msg_lookup");
+           msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
+           msg_send_stret
+             = find_function_in_inferior ("objc_msg_lookup", NULL);

 
            msg_send = value_from_pointer (type, value_as_address (msg_send));
            msg_send_stret = value_from_pointer (type, 
 
            msg_send = value_from_pointer (type, value_as_address (msg_send));
            msg_send_stret = value_from_pointer (type, 


@@ -1081,37 +1269,42 @@ evaluate_subexp_standard (struct type *expect_type,
          }
        else
          {
          }
        else
          {

-           msg_send = find_function_in_inferior ("objc_msgSend");
-           /* Special dispatcher for methods returning structs */
-           msg_send_stret = find_function_in_inferior ("objc_msgSend_stret");
+           msg_send = find_function_in_inferior ("objc_msgSend", NULL);
+           /* Special dispatcher for methods returning structs.  */
+           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 ("respondsToSelector:");
+       responds_selector
+         = lookup_child_selector (exp->gdbarch, "respondsToSelector:");

        if (responds_selector == 0)
        if (responds_selector == 0)

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

        
        if (responds_selector == 0)
          error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
        
        
        if (responds_selector == 0)
          error (_("no 'respondsTo:' or 'respondsToSelector:' method"));
        

-       method_selector = lookup_child_selector ("methodForSelector:");
+       method_selector
+         = lookup_child_selector (exp->gdbarch, "methodForSelector:");

        if (method_selector == 0)
        if (method_selector == 0)

-         method_selector = lookup_child_selector ("methodFor:");
+         method_selector
+           = lookup_child_selector (exp->gdbarch, "methodFor:");

        
        if (method_selector == 0)
          error (_("no 'methodFor:' or 'methodForSelector:' method"));
 
        /* Call the verification method, to make sure that the target
        
        if (method_selector == 0)
          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;

-       argvec[2] = value_from_longest (builtin_type_long, responds_selector);
-       argvec[3] = value_from_longest (builtin_type_long, selector);
+       argvec[2] = value_from_longest (long_type, responds_selector);
+       argvec[3] = value_from_longest (long_type, selector);

        argvec[4] = 0;
 
        ret = call_function_by_hand (argvec[0], 3, argvec + 1);
        argvec[4] = 0;
 
        ret = call_function_by_hand (argvec[0], 3, argvec + 1);


@@ -1128,12 +1321,12 @@ 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;

-       argvec[2] = value_from_longest (builtin_type_long, method_selector);
-       argvec[3] = value_from_longest (builtin_type_long, selector);
+       argvec[2] = value_from_longest (long_type, method_selector);
+       argvec[3] = value_from_longest (long_type, selector);

        argvec[4] = 0;
 
        ret = call_function_by_hand (argvec[0], 3, argvec + 1);
        argvec[4] = 0;
 
        ret = call_function_by_hand (argvec[0], 3, argvec + 1);


@@ -1149,8 +1342,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);


@@ -1161,13 +1359,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);
          


@@ -1178,11 +1375,12 @@ evaluate_subexp_standard (struct type *expect_type,
                  val_type = expect_type;
              }
 
                  val_type = expect_type;
              }
 

-           struct_return = using_struct_return (value_type (method), val_type);
+           struct_return = using_struct_return (exp->gdbarch, method,
+                                                val_type);

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

-           struct_return = using_struct_return (NULL,
+           struct_return = using_struct_return (exp->gdbarch, NULL,

                                                 check_typedef (expect_type));
          }
        
                                                 check_typedef (expect_type));
          }
        


@@ -1202,12 +1400,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)

-             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

-             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
          {


@@ -1224,13 +1433,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);


@@ -1243,7 +1453,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,


@@ -1252,7 +1463,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
        argvec[0] = called_method;
        argvec[1] = target;
 
        argvec[0] = called_method;
        argvec[1] = target;

-       argvec[2] = value_from_longest (builtin_type_long, selector);
+       argvec[2] = value_from_longest (long_type, selector);

        /* User-supplied arguments.  */
        for (tem = 0; tem < nargs; tem++)
          argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
        /* User-supplied arguments.  */
        for (tem = 0; tem < nargs; tem++)
          argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);


@@ -1262,8 +1473,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);


@@ -1276,12 +1488,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)


@@ -1312,21 +1525,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);


@@ -1354,74 +1568,198 @@ 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);
+
+          find_overload_match (&argvec[1], 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 */
-             struct value *valp = NULL;
-
-             /* 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]);
+             /* Name of method from expression.  */
+             tstr = &exp->elts[pc2 + 2].string;
+           }
+         else
+           tstr = function_name;

 
 

-             (void) find_overload_match (arg_types, nargs, tstr,
-                                    1 /* method */ , 0 /* strict match */ ,
-                                         &arg2 /* the object */ , NULL,
-                                         &valp, NULL, &static_memfuncp);
+         if (overload_resolution && (exp->language_defn->la_language
+                                     == language_cplus))
+           {
+             /* Language is C++, do some overload resolution before
+                evaluation.  */
+             struct value *valp = NULL;

 
 

+             (void) find_overload_match (&argvec[1], nargs, tstr,
+                                         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


@@ -1429,9 +1767,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_offset (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 */
            }
 


@@ -1447,42 +1786,55 @@ 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 *)));
-             for (ix = 1; ix <= nargs; ix++)
-               arg_types[ix - 1] = value_type (argvec[ix]);
+             if (op == OP_VAR_VALUE)
+               function = exp->elts[save_pos1+2].symbol;

 
 

-             (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 (&argvec[1], 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:


@@ -1495,21 +1847,36 @@ 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_GNU_IFUNC (ftype))
+           return allocate_value (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype)));
+         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)
+       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:
 


@@ -1517,8 +1884,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;


@@ -1560,15 +1927,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++)


@@ -1582,7 +1950,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);


@@ -1603,6 +1971,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");
        }


@@ -1614,27 +1983,44 @@ 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;
         int full, top, using_enc;
       {
         struct type *type = value_type (arg1);
         struct type *real_type;
         int full, top, using_enc;

-        
-        if (objectprint && TYPE_TARGET_TYPE(type) &&
-            (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
+       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))

           {
           {

-            real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
+            real_type = value_rtti_indirect_type (arg1, &full, &top,
+                                                 &using_enc);

             if (real_type)
             if (real_type)

-              {
-                if (TYPE_CODE (type) == TYPE_CODE_PTR)
-                  real_type = lookup_pointer_type (real_type);
-                else
-                  real_type = lookup_reference_type (real_type);
-

                 arg1 = value_cast (real_type, arg1);
                 arg1 = value_cast (real_type, arg1);

-              }

           }
       }
 
           }
       }
 


@@ -1646,6 +2032,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");
        }


@@ -1677,8 +2064,8 @@ evaluate_subexp_standard (struct type *expect_type,
 
        case TYPE_CODE_MEMBERPTR:
          /* Now, convert these values to an address.  */
 
        case TYPE_CODE_MEMBERPTR:
          /* Now, convert these values to an address.  */

-         arg1 = value_cast (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
-                            arg1);
+         arg1 = value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
+                                     arg1, 1);

 
          mem_offset = value_as_long (arg2);
 
 
          mem_offset = value_as_long (arg2);
 


@@ -1687,9 +2074,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);


@@ -1720,10 +2122,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;


@@ -1747,10 +2153,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);


@@ -1764,17 +2172,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);


@@ -1815,7 +2222,7 @@ evaluate_subexp_standard (struct type *expect_type,
            {
              struct value *v_one, *retval;
 
            {
              struct value *v_one, *retval;
 

-             v_one = value_one (value_type (arg2), not_lval);
+             v_one = value_one (value_type (arg2));

              binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
              retval = value_binop (arg1, v_one, op);
              return retval;
              binop_promote (exp->language_defn, exp->gdbarch, &arg1, &v_one);
              retval = value_binop (arg1, v_one, op);
              return retval;


@@ -1835,15 +2242,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))


@@ -1852,7 +2259,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));


@@ -1869,7 +2276,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:


@@ -1887,7 +2294,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)


@@ -1899,12 +2306,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)


@@ -1934,12 +2341,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:


@@ -1955,93 +2363,52 @@ 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)
          error (_("Wrong number of subscripts"));
 
        ndimensions = calc_f77_array_dims (type);
 
        if (nargs != ndimensions)
          error (_("Wrong number of subscripts"));
 

+       gdb_assert (nargs > 0);
+

        /* Now that we know we have a legal array subscript expression 
        /* 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--)

          {
          {

-           retcode = f77_get_dynamic_upperbound (tmp_type, &upper);
-           if (retcode == BOUND_FETCH_ERROR)
-             error (_("Cannot obtain dynamic upper bound"));
-
-           retcode = f77_get_dynamic_lowerbound (tmp_type, &lower);
-           if (retcode == BOUND_FETCH_ERROR)
-             error (_("Cannot obtain dynamic lower bound"));
-
-           array_size_array[nargs - i - 1] = upper - lower + 1;
+           struct type *array_type = check_typedef (value_type (array));
+           LONGEST index = subscript_array[i - 1];

 
 

-           /* Zero-normalize subscripts so that offsetting will work. */
-
-           subscript_array[nargs - i - 1] -= lower;
-
-           /* 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_f_integer, 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;
        }
 


@@ -2068,7 +2435,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;
        }
 


@@ -2271,7 +2638,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))


@@ -2315,7 +2683,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;
        }
 


@@ -2337,6 +2707,32 @@ evaluate_subexp_standard (struct type *expect_type,
        arg1 = value_cast (type, arg1);
       return arg1;
 
        arg1 = value_cast (type, arg1);
       return arg1;
 

+    case UNOP_CAST_TYPE:
+      arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+      type = value_type (arg1);
+      arg1 = evaluate_subexp (type, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+       goto nosideret;
+      if (type != value_type (arg1))
+       arg1 = value_cast (type, arg1);
+      return arg1;
+
+    case UNOP_DYNAMIC_CAST:
+      arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+      type = value_type (arg1);
+      arg1 = evaluate_subexp (type, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+       goto nosideret;
+      return value_dynamic_cast (type, arg1);
+
+    case UNOP_REINTERPRET_CAST:
+      arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+      type = value_type (arg1);
+      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);


@@ -2348,6 +2744,18 @@ evaluate_subexp_standard (struct type *expect_type,
        return value_at_lazy (exp->elts[pc + 1].type,
                              value_as_address (arg1));
 
        return value_at_lazy (exp->elts[pc + 1].type,
                              value_as_address (arg1));
 

+    case UNOP_MEMVAL_TYPE:
+      arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+      type = value_type (arg1);
+      arg1 = evaluate_subexp (expect_type, exp, pos, noside);
+      if (noside == EVAL_SKIP)
+       goto nosideret;
+      if (noside == EVAL_AVOID_SIDE_EFFECTS)
+       return value_zero (exp->elts[pc + 1].type, lval_memory);
+      else
+       return value_at_lazy (exp->elts[pc + 1].type,
+                             value_as_address (arg1));
+

     case UNOP_MEMVAL_TLS:
       (*pos) += 3;
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
     case UNOP_MEMVAL_TLS:
       (*pos) += 3;
       arg1 = evaluate_subexp (expect_type, exp, pos, noside);


@@ -2358,6 +2766,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);


@@ -2373,12 +2782,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));

              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);
            }


@@ -2396,12 +2806,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));

              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);
            }


@@ -2419,18 +2830,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));

              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:


@@ -2443,27 +2857,26 @@ 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));

              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:
       (*pos) += 1;
        }
 
     case OP_THIS:
       (*pos) += 1;

-      return value_of_this (1);
-
-    case OP_OBJC_SELF:
-      (*pos) += 1;
-      return value_of_local ("self", 1);
+      return value_of_this (exp->language_defn);

 
     case OP_TYPE:
       /* The value is not supposed to be used.  This is here to make it
 
     case OP_TYPE:
       /* The value is not supposed to be used.  This is here to make it


@@ -2472,10 +2885,60 @@ evaluate_subexp_standard (struct type *expect_type,
       if (noside == EVAL_SKIP)
         goto nosideret;
       else if (noside == EVAL_AVOID_SIDE_EFFECTS)
       if (noside == EVAL_SKIP)
         goto nosideret;
       else if (noside == EVAL_AVOID_SIDE_EFFECTS)

-        return allocate_value (exp->elts[pc + 1].type);
+       {
+         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
+            typedefs.  */
+         check_typedef (type);
+         if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+           type = TYPE_TARGET_TYPE (type);
+         return allocate_value (type);
+       }

       else
         error (_("Attempt to use a type name as an expression"));
 
       else
         error (_("Attempt to use a type name as an expression"));
 

+    case OP_TYPEOF:
+    case OP_DECLTYPE:
+      if (noside == EVAL_SKIP)
+       {
+         evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
+         goto nosideret;
+       }
+      else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+       {
+         enum exp_opcode sub_op = exp->elts[*pos].opcode;
+         struct value *result;
+
+         result = evaluate_subexp (NULL_TYPE, exp, pos,
+                                   EVAL_AVOID_SIDE_EFFECTS);
+
+         /* 'decltype' has special semantics for lvalues.  */
+         if (op == OP_DECLTYPE
+             && (sub_op == BINOP_SUBSCRIPT
+                 || sub_op == STRUCTOP_MEMBER
+                 || sub_op == STRUCTOP_MPTR
+                 || sub_op == UNOP_IND
+                 || sub_op == STRUCTOP_STRUCT
+                 || sub_op == STRUCTOP_PTR
+                 || sub_op == OP_SCOPE))
+           {
+             struct type *type = value_type (result);
+
+             if (TYPE_CODE (check_typedef (type)) != TYPE_CODE_REF)
+               {
+                 type = lookup_reference_type (type);
+                 result = allocate_value (type);
+               }
+           }
+
+         return result;
+       }
+      else
+        error (_("Attempt to use a type as an expression"));
+

     default:
       /* Removing this case and compiling with gcc -Wall reveals that
          a lot of cases are hitting this case.  Some of these should
     default:
       /* Removing this case and compiling with gcc -Wall reveals that
          a lot of cases are hitting this case.  Some of these should


@@ -2486,12 +2949,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,


@@ -2527,18 +2990,29 @@ 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;
       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
                         evaluate_subexp (NULL_TYPE, exp, pos, noside));
 
 
     case UNOP_MEMVAL:
       (*pos) += 3;
       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
                         evaluate_subexp (NULL_TYPE, exp, pos, noside));
 

+    case UNOP_MEMVAL_TYPE:
+      {
+       struct type *type;
+
+       (*pos) += 1;
+       x = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+       type = value_type (x);
+       return value_cast (lookup_pointer_type (type),
+                          evaluate_subexp (NULL_TYPE, exp, pos, noside));
+      }
+

     case OP_VAR_VALUE:
       var = exp->elts[pc + 2].symbol;
 
       /* C++: The "address" of a reference should yield the address
     case OP_VAR_VALUE:
       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;
 


@@ -2546,7 +3020,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


@@ -2557,20 +3031,15 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
          return
            value_zero (type, not_lval);
        }
          return
            value_zero (type, not_lval);
        }

-      else if (symbol_read_needs_frame (var))
-       return
-         locate_var_value
-         (var,
-          block_innermost_frame (exp->elts[pc + 1].block));

       else
       else

-       return locate_var_value (var, NULL);
+       return address_of_variable (var, exp->elts[pc + 1].block);

 
     case OP_SCOPE:
       tem = longest_to_int (exp->elts[pc + 2].longconst);
       (*pos) += 5 + BYTES_TO_EXP_ELEM (tem + 1);
       x = value_aggregate_elt (exp->elts[pc + 1].type,
                               &exp->elts[pc + 3].string,
 
     case OP_SCOPE:
       tem = longest_to_int (exp->elts[pc + 2].longconst);
       (*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;


@@ -2590,7 +3059,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);
     }


@@ -2605,9 +3075,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,


@@ -2617,6 +3085,7 @@ evaluate_subexp_with_coercion (struct expression *exp,
   int pc;
   struct value *val;
   struct symbol *var;
   int pc;
   struct value *val;
   struct symbol *var;

+  struct type *type;

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


@@ -2625,14 +3094,14 @@ evaluate_subexp_with_coercion (struct expression *exp,
     {
     case OP_VAR_VALUE:
       var = exp->elts[pc + 2].symbol;
     {
     case OP_VAR_VALUE:
       var = exp->elts[pc + 2].symbol;

-      if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var))) == TYPE_CODE_ARRAY
-         && CAST_IS_CONVERSION)
+      type = check_typedef (SYMBOL_TYPE (var));
+      if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+         && !TYPE_VECTOR (type)
+         && CAST_IS_CONVERSION (exp->language_defn))

        {
          (*pos) += 4;
        {
          (*pos) += 4;

-         val =
-           locate_var_value
-           (var, block_innermost_frame (exp->elts[pc + 1].block));
-         return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var)))),
+         val = address_of_variable (var, exp->elts[pc + 1].block);
+         return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),

                             val);
        }
       /* FALLTHROUGH */
                             val);
        }
       /* FALLTHROUGH */


@@ -2681,6 +3150,12 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos)
       type = check_typedef (exp->elts[pc + 1].type);
       return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
 
       type = check_typedef (exp->elts[pc + 1].type);
       return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
 

+    case UNOP_MEMVAL_TYPE:
+      (*pos) += 1;
+      val = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
+      type = check_typedef (value_type (val));
+      return value_from_longest (size_type, (LONGEST) TYPE_LENGTH (type));
+

     case OP_VAR_VALUE:
       (*pos) += 4;
       type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
     case OP_VAR_VALUE:
       (*pos) += 4;
       type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));


@@ -2694,13 +3169,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] = ')';