Merge GDB 7.5.1

gdb/python/py-inferior.c

 /* Python interface to inferiors.
 
    Copyright (C) 2009-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.
@@ skipping 63 matching lines @@
         PyErr_SetString (PyExc_RuntimeError,                    \
                          _("Inferior no longer exists."));      \
         return NULL;                                            \
       }                                                         \
   } while (0)
 
 static void
 python_on_normal_stop (struct bpstats *bs, int print_frame)
 {
   struct cleanup *cleanup;
-  enum target_signal stop_signal;
+  enum gdb_signal stop_signal;
 
   if (!find_thread_ptid (inferior_ptid))
       return;
 
   stop_signal = inferior_thread ()->suspend.stop_signal;
 
   cleanup = ensure_python_env (get_current_arch (), current_language);
 
   if (emit_stop_event (bs, stop_signal) < 0)
     gdbpy_print_stack ();
@@ skipping 78 matching lines @@
 
   return (PyObject *) inf_obj;
 }
 
 /* Finds the Python Inferior object for the given PID.  Returns a
    reference, or NULL if PID does not match any inferior object. */
 
 PyObject *
 find_inferior_object (int pid)
 {
-  struct inflist_entry *p;
   struct inferior *inf = find_inferior_pid (pid);
 
   if (inf)
     return inferior_to_inferior_object (inf);
 
   return NULL;
 }
 
 thread_object *
 find_thread_object (ptid_t ptid)
@@ skipping 56 matching lines @@
   inf_obj->nthreads++;
 
   do_cleanups (cleanup);
 }
 
 static void
 delete_thread_object (struct thread_info *tp, int ignore)
 {
   struct cleanup *cleanup;
   inferior_object *inf_obj;
-  thread_object *thread_obj;
   struct threadlist_entry **entry, *tmp;
   
   cleanup = ensure_python_env (python_gdbarch, python_language);
 
   inf_obj = (inferior_object *) find_inferior_object (PIDGET(tp->ptid));
   if (!inf_obj)
     {
       do_cleanups (cleanup);
       return;
     }
@@ skipping 116 matching lines @@
     }
 
   tuple = PyList_AsTuple (list);
   Py_DECREF (list);
 
   return tuple;
 }
 
 /* Membuf and memory manipulation.  */
 
-/* Implementation of gdb.read_memory (address, length).
+/* Implementation of Inferior.read_memory (address, length).
    Returns a Python buffer object with LENGTH bytes of the inferior's
    memory at ADDRESS.  Both arguments are integers.  Returns NULL on error,
    with a python exception set.  */
 static PyObject *
 infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
 {
   int error = 0;
   CORE_ADDR addr, length;
   void *buffer = NULL;
   membuf_object *membuf_obj;
-  PyObject *addr_obj, *length_obj;
-  struct cleanup *cleanups;
+  PyObject *addr_obj, *length_obj, *result;
   volatile struct gdb_exception except;
   static char *keywords[] = { "address", "length", NULL };
 
   if (! PyArg_ParseTupleAndKeywords (args, kw, "OO", keywords,
                                      &addr_obj, &length_obj))
     return NULL;
 
-  cleanups = make_cleanup (null_cleanup, NULL);
-
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       if (!get_addr_from_python (addr_obj, &addr)
           || !get_addr_from_python (length_obj, &length))
         {
           error = 1;
           break;
         }
 
       buffer = xmalloc (length);
-      make_cleanup (xfree, buffer);
 
       read_memory (addr, buffer, length);
     }
   if (except.reason < 0)
     {
-      do_cleanups (cleanups);
+      xfree (buffer);
       GDB_PY_HANDLE_EXCEPTION (except);
     }
 
   if (error)
     {
-      do_cleanups (cleanups);
+      xfree (buffer);
       return NULL;
     }
 
   membuf_obj = PyObject_New (membuf_object, &membuf_object_type);
   if (membuf_obj == NULL)
     {
+      xfree (buffer);
       PyErr_SetString (PyExc_MemoryError,
                        _("Could not allocate memory buffer object."));
-      do_cleanups (cleanups);
       return NULL;
     }
 
-  discard_cleanups (cleanups);
-
   membuf_obj->buffer = buffer;
   membuf_obj->addr = addr;
   membuf_obj->length = length;
 
-  return PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj, 0,
-                                       Py_END_OF_BUFFER);
+  result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj, 0,
+                                         Py_END_OF_BUFFER);
+  Py_DECREF (membuf_obj);
+  return result;
 }
 
-/* Implementation of gdb.write_memory (address, buffer [, length]).
+/* Implementation of Inferior.write_memory (address, buffer [, length]).
    Writes the contents of BUFFER (a Python object supporting the read
    buffer protocol) at ADDRESS in the inferior's memory.  Write LENGTH
    bytes from BUFFER, or its entire contents if the argument is not
    provided.  The function returns nothing.  Returns NULL on error, with
    a python exception set.  */
 static PyObject *
 infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
 {
   Py_ssize_t buf_len;
   int error = 0;
@@ skipping 17 matching lines @@
           break;
         }
 
       if (!length_obj)
         length = buf_len;
       else if (!get_addr_from_python (length_obj, &length))
         {
           error = 1;
           break;
         }
-      write_memory (addr, buffer, length);
+      write_memory_with_notification (addr, buffer, length);
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
   if (error)
     return NULL;
 
   Py_RETURN_NONE;
 }
 
 /* Destructor of Membuf objects.  */
@@ skipping 354 matching lines @@
   0,                              /* tp_members */
   0,                              /* tp_getset */
   0,                              /* tp_base */
   0,                              /* tp_dict */
   0,                              /* tp_descr_get */
   0,                              /* tp_descr_set */
   0,                              /* tp_dictoffset */
   0,                              /* tp_init */
   0,                              /* tp_alloc */
 };