Merge GDB 7.5.1

gdb/python/py-value.c

 /* Python interface to values.
 
-   Copyright (C) 2008-2012 Free Software Foundation, Inc.
+   Copyright (C) 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "gdb_assert.h"
 #include "charset.h"
 #include "value.h"
 #include "exceptions.h"
 #include "language.h"
 #include "dfp.h"
 #include "valprint.h"
 #include "infcall.h"
 #include "expression.h"
 #include "cp-abi.h"
+#include "python.h"
 
 #ifdef HAVE_PYTHON
 
 #include "python-internal.h"
 
 /* Even though Python scalar types directly map to host types, we use
    target types here to remain consistent with the values system in
    GDB (which uses target arithmetic).  */
 
 /* Python's integer type corresponds to C's long type.  */
@@ skipping 102 matching lines @@
     }
 
   value = convert_value_from_python (PyTuple_GetItem (args, 0));
   if (value == NULL)
     {
       subtype->tp_free (value_obj);
       return NULL;
     }
 
   value_obj->value = value;
-  value_incref (value);
+  release_value_or_incref (value);
   value_obj->address = NULL;
   value_obj->type = NULL;
   value_obj->dynamic_type = NULL;
   note_value (value_obj);
 
   return (PyObject *) value_obj;
 }
 
 /* Iterate over all the Value objects, calling preserve_one_value on
    each.  */
 void
 preserve_python_values (struct objfile *objfile, htab_t copied_types)
 {
   value_object *iter;
 
   for (iter = values_in_python; iter; iter = iter->next)
     preserve_one_value (iter->value, objfile, copied_types);
 }
 
 /* Given a value of a pointer type, apply the C unary * operator to it.  */
 static PyObject *
 valpy_dereference (PyObject *self, PyObject *args)
 {
-  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
   volatile struct gdb_exception except;
+  PyObject *result = NULL;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
+      struct value *res_val;
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
       res_val = value_ind (((value_object *) self)->value);
+      result = value_to_value_object (res_val);
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
-  return value_to_value_object (res_val);
+  return result;
+}
+
+/* Given a value of a pointer type or a reference type, return the value
+   referenced. The difference between this function and valpy_dereference is
+   that the latter applies * unary operator to a value, which need not always
+   result in the value referenced. For example, for a value which is a reference
+   to an 'int' pointer ('int *'), valpy_dereference will result in a value of
+   type 'int' while valpy_referenced_value will result in a value of type
+   'int *'.  */
+
+static PyObject *
+valpy_referenced_value (PyObject *self, PyObject *args)
+{
+  volatile struct gdb_exception except;
+  PyObject *result = NULL;
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      struct value *self_val, *res_val;
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
+      self_val = ((value_object *) self)->value;
+      switch (TYPE_CODE (check_typedef (value_type (self_val))))
+        {
+        case TYPE_CODE_PTR:
+          res_val = value_ind (self_val);
+          break;
+        case TYPE_CODE_REF:
+          res_val = coerce_ref (self_val);
+          break;
+        default:
+          error(_("Trying to get the referenced value from a value which is "
+                  "neither a pointer nor a reference."));
+        }
+
+      result = value_to_value_object (res_val);
+      do_cleanups (cleanup);
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  return result;
 }
 
 /* Return "&value".  */
 static PyObject *
 valpy_get_address (PyObject *self, void *closure)
 {
-  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
   value_object *val_obj = (value_object *) self;
   volatile struct gdb_exception except;
 
   if (!val_obj->address)
     {
       TRY_CATCH (except, RETURN_MASK_ALL)
         {
+          struct value *res_val;
+          struct cleanup *cleanup
+            = make_cleanup_value_free_to_mark (value_mark ());
+
           res_val = value_addr (val_obj->value);
+          val_obj->address = value_to_value_object (res_val);
+          do_cleanups (cleanup);
         }
       if (except.reason < 0)
         {
           val_obj->address = Py_None;
           Py_INCREF (Py_None);
         }
-      else
-        val_obj->address = value_to_value_object (res_val);
     }
 
   Py_XINCREF (val_obj->address);
 
   return val_obj->address;
 }
 
 /* Return type of the value.  */
 static PyObject *
 valpy_get_type (PyObject *self, void *closure)
@@ skipping 21 matching lines @@
 
   if (obj->dynamic_type != NULL)
     {
       Py_INCREF (obj->dynamic_type);
       return obj->dynamic_type;
     }
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       struct value *val = obj->value;
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 
       type = value_type (val);
       CHECK_TYPEDEF (type);
 
       if (((TYPE_CODE (type) == TYPE_CODE_PTR)
            || (TYPE_CODE (type) == TYPE_CODE_REF))
           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
         {
           struct value *target;
           int was_pointer = TYPE_CODE (type) == TYPE_CODE_PTR;
 
           target = value_ind (val);
           type = value_rtti_type (target, NULL, NULL, NULL);
 
           if (type)
             {
               if (was_pointer)
                 type = lookup_pointer_type (type);
               else
                 type = lookup_reference_type (type);
             }
         }
       else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
         type = value_rtti_type (val, NULL, NULL, NULL);
       else
         {
           /* Re-use object's static type.  */
           type = NULL;
         }
+
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
   if (type == NULL)
     {
       /* Ensure that the TYPE field is ready.  */
       if (!valpy_get_type (self, NULL))
         return NULL;
       /* We don't need to incref here, because valpy_get_type already
          did it for us.  */
@@ skipping 14 matching lines @@
    the string is not encoded.  If LENGTH is provided then the length
    parameter is set to LENGTH, otherwise length will be set to -1 (first
    null of appropriate with).  */
 static PyObject *
 valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
 {
   gdb_py_longest length = -1;
   struct value *value = ((value_object *) self)->value;
   const char *user_encoding = NULL;
   static char *keywords[] = { "encoding", "length", NULL };
-  PyObject *str_obj;
+  PyObject *str_obj = NULL;
   volatile struct gdb_exception except;
 
   if (!PyArg_ParseTupleAndKeywords (args, kw, "|s" GDB_PY_LL_ARG, keywords,
                                     &user_encoding, &length))
     return NULL;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
       if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR)
         value = value_ind (value);
+
+      str_obj = gdbpy_create_lazy_string_object (value_address (value), length,
+                                                 user_encoding,
+                                                 value_type (value));
+
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
-  str_obj = gdbpy_create_lazy_string_object (value_address (value), length,
-                                             user_encoding,
-                                             value_type (value));
-
-  return (PyObject *) str_obj;
+  return str_obj;
 }
 
 /* Implementation of gdb.Value.string ([encoding] [, errors]
    [, length]) -> string.  Return Unicode string with value contents.
    If ENCODING is not given, the string is assumed to be encoded in
    the target's charset.  If LENGTH is provided, only fetch string to
    the length provided.  */
 
 static PyObject *
 valpy_string (PyObject *self, PyObject *args, PyObject *kw)
@@ skipping 26 matching lines @@
   xfree (buffer);
 
   return unicode;
 }
 
 /* A helper function that implements the various cast operators.  */
 
 static PyObject *
 valpy_do_cast (PyObject *self, PyObject *args, enum exp_opcode op)
 {
-  PyObject *type_obj;
+  PyObject *type_obj, *result = NULL;
   struct type *type;
-  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
   volatile struct gdb_exception except;
 
   if (! PyArg_ParseTuple (args, "O", &type_obj))
     return NULL;
 
   type = type_object_to_type (type_obj);
   if (! type)
     {
       PyErr_SetString (PyExc_RuntimeError, 
                        _("Argument must be a type."));
       return NULL;
     }
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       struct value *val = ((value_object *) self)->value;
+      struct value *res_val;
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
 
       if (op == UNOP_DYNAMIC_CAST)
         res_val = value_dynamic_cast (type, val);
       else if (op == UNOP_REINTERPRET_CAST)
         res_val = value_reinterpret_cast (type, val);
       else
         {
           gdb_assert (op == UNOP_CAST);
           res_val = value_cast (type, val);
         }
+
+      result = value_to_value_object (res_val);
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
-  return value_to_value_object (res_val);
+  return result;
 }
 
 /* Implementation of the "cast" method.  */
 
 static PyObject *
 valpy_cast (PyObject *self, PyObject *args)
 {
   return valpy_do_cast (self, args, UNOP_CAST);
 }
 
@@ skipping 22 matching lines @@
   return -1;
 }
 
 /* Given string name of an element inside structure, return its value
    object.  Returns NULL on error, with a python exception set.  */
 static PyObject *
 valpy_getitem (PyObject *self, PyObject *key)
 {
   value_object *self_value = (value_object *) self;
   char *field = NULL;
-  struct value *res_val = NULL;
   volatile struct gdb_exception except;
+  PyObject *result = NULL;
 
   if (gdbpy_is_string (key))
     {  
       field = python_string_to_host_string (key);
       if (field == NULL)
         return NULL;
     }
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       struct value *tmp = self_value->value;
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+      struct value *res_val = NULL;
 
       if (field)
         res_val = value_struct_elt (&tmp, NULL, field, 0, NULL);
       else
         {
           /* Assume we are attempting an array access, and let the
              value code throw an exception if the index has an invalid
              type.  */
           struct value *idx = convert_value_from_python (key);
 
           if (idx != NULL)
             {
               /* Check the value's type is something that can be accessed via
                  a subscript.  */
               struct type *type;
 
               tmp = coerce_ref (tmp);
               type = check_typedef (value_type (tmp));
               if (TYPE_CODE (type) != TYPE_CODE_ARRAY
                   && TYPE_CODE (type) != TYPE_CODE_PTR)
                   error (_("Cannot subscript requested type."));
               else
                 res_val = value_subscript (tmp, value_as_long (idx));
             }
         }
+
+      if (res_val)
+        result = value_to_value_object (res_val);
+      do_cleanups (cleanup);
     }
 
   xfree (field);
   GDB_PY_HANDLE_EXCEPTION (except);
 
-  return res_val ? value_to_value_object (res_val) : NULL;
+  return result;
 }
 
 static int
 valpy_setitem (PyObject *self, PyObject *key, PyObject *value)
 {
   PyErr_Format (PyExc_NotImplementedError,
                 _("Setting of struct elements is not currently supported."));
   return -1;
 }
 
 /* Called by the Python interpreter to perform an inferior function
    call on the value.  Returns NULL on error, with a python exception set.  */
 static PyObject *
 valpy_call (PyObject *self, PyObject *args, PyObject *keywords)
 {
-  struct value *return_value = NULL;
   Py_ssize_t args_count;
   volatile struct gdb_exception except;
   struct value *function = ((value_object *) self)->value;
   struct value **vargs = NULL;
   struct type *ftype = NULL;
+  struct value *mark = value_mark ();
+  PyObject *result = NULL;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       ftype = check_typedef (value_type (function));
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
   if (TYPE_CODE (ftype) != TYPE_CODE_FUNC)
     {
       PyErr_SetString (PyExc_RuntimeError,
@@ skipping 22 matching lines @@
             return NULL;
 
           vargs[i] = convert_value_from_python (item);
           if (vargs[i] == NULL)
             return NULL;
         }
     }
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (mark);
+      struct value *return_value;
+
       return_value = call_function_by_hand (function, args_count, vargs);
+      result = value_to_value_object (return_value);
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
-  return value_to_value_object (return_value);
+  return result;
 }
 
 /* Called by the Python interpreter to obtain string representation
    of the object.  */
 static PyObject *
 valpy_str (PyObject *self)
 {
   char *s = NULL;
   PyObject *result;
   struct value_print_options opts;
@@ skipping 104 matching lines @@
 /* If TYPE is a reference, return the target; otherwise return TYPE.  */
 #define STRIP_REFERENCE(TYPE) \
   ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
 
 /* Returns a value object which is the result of applying the operation
    specified by OPCODE to the given arguments.  Returns NULL on error, with
    a python exception set.  */
 static PyObject *
 valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
 {
-  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
   volatile struct gdb_exception except;
+  PyObject *result = NULL;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       struct value *arg1, *arg2;
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+      struct value *res_val = NULL;
 
       /* If the gdb.Value object is the second operand, then it will be passed
          to us as the OTHER argument, and SELF will be an entirely different
          kind of object, altogether.  Because of this, we can't assume self is
          a gdb.Value object and need to convert it from python as well.  */
       arg1 = convert_value_from_python (self);
       if (arg1 == NULL)
         break;
 
       arg2 = convert_value_from_python (other);
@@ skipping 65 matching lines @@
         case VALPY_BITAND:
           res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND);
           break;
         case VALPY_BITOR:
           res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR);
           break;
         case VALPY_BITXOR:
           res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR);
           break;
         }
+
+      if (res_val)
+        result = value_to_value_object (res_val);
+
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
-  return res_val ? value_to_value_object (res_val) : NULL;
+  return result;
 }
 
 static PyObject *
 valpy_add (PyObject *self, PyObject *other)
 {
   return valpy_binop (VALPY_ADD, self, other);
 }
 
 static PyObject *
 valpy_subtract (PyObject *self, PyObject *other)
@@ skipping 31 matching lines @@
                        "Invalid operation on gdb.Value.");
       return NULL;
     }
 
   return valpy_binop (VALPY_POW, self, other);
 }
 
 static PyObject *
 valpy_negative (PyObject *self)
 {
-  struct value *val = NULL;
   volatile struct gdb_exception except;
+  PyObject *result = NULL;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
+      /* Perhaps overkill, but consistency has some virtue.  */
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+      struct value *val;
+
       val = value_neg (((value_object *) self)->value);
+      result = value_to_value_object (val);
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
-  return value_to_value_object (val);
+  return result;
 }
 
 static PyObject *
 valpy_positive (PyObject *self)
 {
   return value_to_value_object (((value_object *) self)->value);
 }
 
 static PyObject *
 valpy_absolute (PyObject *self)
 {
   struct value *value = ((value_object *) self)->value;
   volatile struct gdb_exception except;
   int isabs = 1;
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
+      struct cleanup *cleanup = make_cleanup_value_free_to_mark (value_mark ());
+
       if (value_less (value, value_zero (value_type (value), not_lval)))
         isabs = 0;
+
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
   if (isabs)
     return valpy_positive (self);
   else
     return valpy_negative (self);
 }
 
 /* Implements boolean evaluation of gdb.Value.  */
@@ skipping 79 matching lines @@
 {
   return valpy_binop (VALPY_BITXOR, self, other);
 }
 
 /* Implements comparison operations for value objects.  Returns NULL on error,
    with a python exception set.  */
 static PyObject *
 valpy_richcompare (PyObject *self, PyObject *other, int op)
 {
   int result = 0;
-  struct value *value_other;
   volatile struct gdb_exception except;
 
   if (other == Py_None)
     /* Comparing with None is special.  From what I can tell, in Python
        None is smaller than anything else.  */
     switch (op) {
       case Py_LT:
       case Py_LE:
       case Py_EQ:
         Py_RETURN_FALSE;
       case Py_NE:
       case Py_GT:
       case Py_GE:
         Py_RETURN_TRUE;
       default:
         /* Can't happen.  */
         PyErr_SetString (PyExc_NotImplementedError,
                          _("Invalid operation on gdb.Value."));
         return NULL;
     }
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
+      struct value *value_other, *mark = value_mark ();
+      struct cleanup *cleanup;
+
       value_other = convert_value_from_python (other);
       if (value_other == NULL)
         {
           result = -1;
           break;
         }
 
+      cleanup = make_cleanup_value_free_to_mark (mark);
+
       switch (op) {
         case Py_LT:
           result = value_less (((value_object *) self)->value, value_other);
           break;
         case Py_LE:
           result = value_less (((value_object *) self)->value, value_other)
             || value_equal (((value_object *) self)->value, value_other);
           break;
         case Py_EQ:
           result = value_equal (((value_object *) self)->value, value_other);
           break;
         case Py_NE:
           result = !value_equal (((value_object *) self)->value, value_other);
           break;
         case Py_GT:
           result = value_less (value_other, ((value_object *) self)->value);
           break;
         case Py_GE:
           result = value_less (value_other, ((value_object *) self)->value)
             || value_equal (((value_object *) self)->value, value_other);
           break;
         default:
           /* Can't happen.  */
           PyErr_SetString (PyExc_NotImplementedError,
                            _("Invalid operation on gdb.Value."));
           result = -1;
           break;
       }
+
+      do_cleanups (cleanup);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
   /* In this case, the Python exception has already been set.  */
   if (result < 0)
     return NULL;
 
   if (result == 1)
     Py_RETURN_TRUE;
 
@@ skipping 83 matching lines @@
    so its lifetime is not bound to the execution of a command.  */
 PyObject *
 value_to_value_object (struct value *val)
 {
   value_object *val_obj;
 
   val_obj = PyObject_New (value_object, &value_object_type);
   if (val_obj != NULL)
     {
       val_obj->value = val;
-      value_incref (val);
+      release_value_or_incref (val);
       val_obj->address = NULL;
       val_obj->type = NULL;
       val_obj->dynamic_type = NULL;
       note_value (val_obj);
     }
 
   return (PyObject *) val_obj;
 }
 
 /* Returns a borrowed reference to the struct value corresponding to
@@ skipping 10 matching lines @@
 }
 
 /* Try to convert a Python value to a gdb value.  If the value cannot
    be converted, set a Python exception and return NULL.  Returns a
    reference to a new value on the all_values chain.  */
 
 struct value *
 convert_value_from_python (PyObject *obj)
 {
   struct value *value = NULL; /* -Wall */
-  struct cleanup *old;
   volatile struct gdb_exception except;
   int cmp;
 
   gdb_assert (obj != NULL);
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       if (PyBool_Check (obj)) 
         {
           cmp = PyObject_IsTrue (obj);
@@ skipping 48 matching lines @@
           if (! PyErr_Occurred ())
             value = value_from_double (builtin_type_pyfloat, d);
         }
       else if (gdbpy_is_string (obj))
         {
           char *s;
 
           s = python_string_to_target_string (obj);
           if (s != NULL)
             {
+              struct cleanup *old;
+
               old = make_cleanup (xfree, s);
               value = value_cstring (s, strlen (s), builtin_type_pychar);
               do_cleanups (old);
             }
         }
       else if (PyObject_TypeCheck (obj, &value_object_type))
         value = value_copy (((value_object *) obj)->value);
       else if (gdbpy_is_lazy_string (obj))
         {
           PyObject *result;
@@ skipping 78 matching lines @@
 };
 
 static PyMethodDef value_object_methods[] = {
   { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." },
   { "dynamic_cast", valpy_dynamic_cast, METH_VARARGS,
     "dynamic_cast (gdb.Type) -> gdb.Value\n\
 Cast the value to the supplied type, as if by the C++ dynamic_cast operator."
   },
   { "reinterpret_cast", valpy_reinterpret_cast, METH_VARARGS,
     "reinterpret_cast (gdb.Type) -> gdb.Value\n\