[spu] Don't call set_gdbarch_cannot_step_breakpoint in spu_gdbarch_init

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

diff --git a/gdb/eval.c b/gdb/eval.c
index ab431c64b7daef73f623974d1cf571de2a329908..9804a977f7bc0c48818bd662510d1361f2d8c750 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1,6 +1,6 @@
 /* Evaluate expressions for GDB.
 
-   Copyright (C) 1986-2014 Free Software Foundation, Inc.
+   Copyright (C) 1986-2015 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -24,6 +24,7 @@
 #include "expression.h"
 #include "target.h"
 #include "frame.h"
+#include "gdbthread.h"
 #include "language.h"          /* For CAST_IS_CONVERSION.  */
 #include "f-lang.h"            /* For array bound stuff.  */
 #include "cp-abi.h"
@@ -63,8 +64,29 @@ struct value *
 evaluate_subexp (struct type *expect_type, struct expression *exp,
                 int *pos, enum noside noside)
 {
-  return (*exp->language_defn->la_exp_desc->evaluate_exp) 
+  struct cleanup *cleanups;
+  struct value *retval;
+  int cleanup_temps = 0;
+
+  if (*pos == 0 && target_has_execution
+      && exp->language_defn->la_language == language_cplus
+      && !thread_stack_temporaries_enabled_p (inferior_ptid))
+    {
+      cleanups = enable_thread_stack_temporaries (inferior_ptid);
+      cleanup_temps = 1;
+    }
+
+  retval = (*exp->language_defn->la_exp_desc->evaluate_exp)
     (expect_type, exp, pos, noside);
+
+  if (cleanup_temps)
+    {
+      if (value_in_thread_stack_temporaries (retval, inferior_ptid))
+       retval = value_non_lval (retval);
+      do_cleanups (cleanups);
+    }
+
+  return retval;
 }
 \f
 /* Parse the string EXP as a C expression, evaluate it,
@@ -190,7 +212,6 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
                    int preserve_errors)
 {
   struct value *mark, *new_mark, *result;
-  volatile struct gdb_exception ex;
 
   *valp = NULL;
   if (resultp)
@@ -202,11 +223,11 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
   mark = value_mark ();
   result = NULL;
 
-  TRY_CATCH (ex, RETURN_MASK_ALL)
+  TRY
     {
       result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
     }
-  if (ex.reason < 0)
+  CATCH (ex, RETURN_MASK_ALL)
     {
       /* Ignore memory errors if we want watchpoints pointing at
         inaccessible memory to still be created; otherwise, throw the
@@ -221,6 +242,7 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
          break;
        }
     }
+  END_CATCH
 
   new_mark = value_mark ();
   if (mark == new_mark)
@@ -236,13 +258,16 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
        *valp = result;
       else
        {
-         volatile struct gdb_exception except;
 
-         TRY_CATCH (except, RETURN_MASK_ERROR)
+         TRY
            {
              value_fetch_lazy (result);
              *valp = result;
            }
+         CATCH (except, RETURN_MASK_ERROR)
+           {
+           }
+         END_CATCH
        }
     }
 
@@ -642,7 +667,6 @@ make_params (int num_types, struct type **param_types)
   TYPE_MAIN_TYPE (type) = XCNEW (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)
     {
@@ -741,16 +765,15 @@ evaluate_subexp_standard (struct type *expect_type,
         or reference to a base class and print object is on.  */
 
       {
-       volatile struct gdb_exception except;
        struct value *ret = NULL;
 
-       TRY_CATCH (except, RETURN_MASK_ERROR)
+       TRY
          {
            ret = value_of_variable (exp->elts[pc + 2].symbol,
                                     exp->elts[pc + 1].block);
          }
 
-       if (except.reason < 0)
+       CATCH (except, RETURN_MASK_ERROR)
          {
            if (noside == EVAL_AVOID_SIDE_EFFECTS)
              ret = value_zero (SYMBOL_TYPE (exp->elts[pc + 2].symbol),
@@ -758,6 +781,7 @@ evaluate_subexp_standard (struct type *expect_type,
            else
              throw_exception (except);
          }
+       END_CATCH
 
        return ret;
       }
@@ -1368,7 +1392,7 @@ evaluate_subexp_standard (struct type *expect_type,
          else if (TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
            {
              struct type *type_ptr
-               = lookup_pointer_type (TYPE_DOMAIN_TYPE (type));
+               = lookup_pointer_type (TYPE_SELF_TYPE (type));
              struct type *target_type_ptr
                = lookup_pointer_type (TYPE_TARGET_TYPE (type));
 
@@ -1425,20 +1449,21 @@ evaluate_subexp_standard (struct type *expect_type,
                 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)
+                 TRY
                    {
                      value = value_x_unop (arg2, op, noside);
                    }
 
-                 if (except.reason < 0)
+                 CATCH (except, RETURN_MASK_ERROR)
                    {
                      if (except.error == NOT_FOUND_ERROR)
                        break;
                      else
                        throw_exception (except);
                    }
+                 END_CATCH
+
                  arg2 = value;
                }
            }
@@ -1696,8 +1721,6 @@ evaluate_subexp_standard (struct type *expect_type,
 
     do_call_it:
 
-      if (noside == EVAL_SKIP)
-       goto nosideret;
       if (argvec[0] == NULL)
        error (_("Cannot evaluate function -- may be inlined"));
       if (noside == EVAL_AVOID_SIDE_EFFECTS)
@@ -1804,6 +1827,8 @@ evaluate_subexp_standard (struct type *expect_type,
          for (; tem <= nargs; tem++)
            argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
          argvec[tem] = 0;      /* signal end of arglist */
+         if (noside == EVAL_SKIP)
+           goto nosideret;
          goto do_call_it;
 
        default:
@@ -1842,20 +1867,21 @@ evaluate_subexp_standard (struct type *expect_type,
          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)
+         TRY
            {
              value = value_x_unop (arg1, op, noside);
            }
 
-         if (except.reason < 0)
+         CATCH (except, RETURN_MASK_ERROR)
            {
              if (except.error == NOT_FOUND_ERROR)
                break;
              else
                throw_exception (except);
            }
+         END_CATCH
+
          arg1 = value;
        }
 
@@ -1870,7 +1896,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
        get_user_print_options (&opts);
         if (opts.objectprint && TYPE_TARGET_TYPE(type)
-            && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
+            && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
           {
             real_type = value_rtti_indirect_type (arg1, &full, &top,
                                                  &using_enc);
@@ -1912,7 +1938,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
        case TYPE_CODE_MEMBERPTR:
          /* Now, convert these values to an address.  */
-         arg1 = value_cast_pointers (lookup_pointer_type (TYPE_DOMAIN_TYPE (type)),
+         arg1 = value_cast_pointers (lookup_pointer_type (TYPE_SELF_TYPE (type)),
                                      arg1, 1);
 
          mem_offset = value_as_long (arg2);