Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / python / py-inferior.c
index 339a221..9c84904 100644 (file)
@@ -1,6 +1,6 @@
 /* Python interface to inferiors.
 
-   Copyright (C) 2009-2012 Free Software Foundation, Inc.
+   Copyright (C) 2009-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -81,7 +81,7 @@ 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;
@@ -101,7 +101,7 @@ python_on_resume (ptid_t ptid)
 {
   struct cleanup *cleanup;
 
-  cleanup = ensure_python_env (target_gdbarch, current_language);
+  cleanup = ensure_python_env (target_gdbarch (), current_language);
 
   if (emit_continue_event (ptid) < 0)
     gdbpy_print_stack ();
@@ -115,7 +115,7 @@ python_inferior_exit (struct inferior *inf)
   struct cleanup *cleanup;
   const LONGEST *exit_code = NULL;
 
-  cleanup = ensure_python_env (target_gdbarch, current_language);
+  cleanup = ensure_python_env (target_gdbarch (), current_language);
 
   if (inf->has_exit_code)
     exit_code = &inf->exit_code;
@@ -180,7 +180,6 @@ inferior_to_inferior_object (struct inferior *inferior)
 PyObject *
 find_inferior_object (int pid)
 {
-  struct inflist_entry *p;
   struct inferior *inf = find_inferior_pid (pid);
 
   if (inf)
@@ -257,7 +256,6 @@ 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);
@@ -302,9 +300,14 @@ infpy_threads (PyObject *self, PyObject *args)
   struct threadlist_entry *entry;
   inferior_object *inf_obj = (inferior_object *) self;
   PyObject *tuple;
+  volatile struct gdb_exception except;
 
   INFPY_REQUIRE_VALID (inf_obj);
 
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    update_thread_list ();
+  GDB_PY_HANDLE_EXCEPTION (except);
+
   tuple = PyTuple_New (inf_obj->nthreads);
   if (!tuple)
     return NULL;
@@ -394,7 +397,7 @@ gdbpy_inferiors (PyObject *unused, PyObject *unused2)
 
 /* 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.  */
@@ -405,8 +408,7 @@ infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
   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 };
 
@@ -414,8 +416,6 @@ infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
                                     &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)
@@ -426,42 +426,46 @@ infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
        }
 
       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);
+#ifdef IS_PY3K
+  result = PyMemoryView_FromObject ((PyObject *) membuf_obj);
+#else
+  result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj, 0,
+                                        Py_END_OF_BUFFER);
+#endif
+  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
@@ -477,12 +481,22 @@ infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
   PyObject *addr_obj, *length_obj = NULL;
   volatile struct gdb_exception except;
   static char *keywords[] = { "address", "buffer", "length", NULL };
+#ifdef IS_PY3K
+  Py_buffer pybuf;
 
+  if (! PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
+                                    &addr_obj, &pybuf,
+                                    &length_obj))
+    return NULL;
 
+  buffer = pybuf.buf;
+  buf_len = pybuf.len;
+#else
   if (! PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
                                     &addr_obj, &buffer, &buf_len,
                                     &length_obj))
     return NULL;
+#endif
 
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
@@ -499,10 +513,14 @@ infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
          error = 1;
          break;
        }
-      write_memory (addr, buffer, length);
+      write_memory_with_notification (addr, buffer, length);
     }
+#ifdef IS_PY3K
+  PyBuffer_Release (&pybuf);
+#endif
   GDB_PY_HANDLE_EXCEPTION (except);
 
+
   if (error)
     return NULL;
 
@@ -514,7 +532,7 @@ static void
 mbpy_dealloc (PyObject *self)
 {
   xfree (((membuf_object *) self)->buffer);
-  self->ob_type->tp_free (self);
+  Py_TYPE (self)->tp_free (self);
 }
 
 /* Return a description of the Membuf object.  */
@@ -529,6 +547,24 @@ which is %s bytes long."),
                              pulongest (membuf_obj->length));
 }
 
+#ifdef IS_PY3K
+
+static int
+get_buffer (PyObject *self, Py_buffer *buf, int flags)
+{
+  membuf_object *membuf_obj = (membuf_object *) self;
+  int ret;
+  
+  ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
+                          membuf_obj->length, 0, 
+                          PyBUF_CONTIG);
+  buf->format = "c";
+
+  return ret;
+}
+
+#else
+
 static Py_ssize_t
 get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
 {
@@ -573,6 +609,8 @@ get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
   return ret;
 }
 
+#endif /* IS_PY3K */
+
 /* Implementation of
    gdb.search_memory (address, length, pattern).  ADDRESS is the
    address to start the search.  LENGTH specifies the scope of the
@@ -586,17 +624,41 @@ infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
 {
   CORE_ADDR start_addr, length;
   static char *keywords[] = { "address", "length", "pattern", NULL };
-  PyObject *pattern, *start_addr_obj, *length_obj;
+  PyObject *start_addr_obj, *length_obj;
   volatile struct gdb_exception except;
   Py_ssize_t pattern_size;
   const void *buffer;
   CORE_ADDR found_addr;
   int found = 0;
+#ifdef IS_PY3K
+  Py_buffer pybuf;
 
-  if (! PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
+  if (! PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
                                     &start_addr_obj, &length_obj,
+                                    &pybuf))
+    return NULL;
+
+  buffer = pybuf.buf;
+  pattern_size = pybuf.len;
+#else
+  PyObject *pattern;
+  
+  if (! PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
+                                    &start_addr_obj, &length_obj,
                                     &pattern))
+     return NULL;
+
+  if (!PyObject_CheckReadBuffer (pattern))
+    {
+      PyErr_SetString (PyExc_RuntimeError,
+                      _("The pattern is not a Python buffer."));
+
+      return NULL;
+    }
+
+  if (PyObject_AsReadBuffer (pattern, &buffer, &pattern_size) == -1)
     return NULL;
+#endif
 
   if (get_addr_from_python (start_addr_obj, &start_addr)
       && get_addr_from_python (length_obj, &length))
@@ -605,6 +667,10 @@ infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
        {
          PyErr_SetString (PyExc_ValueError,
                           _("Search range is empty."));
+
+#ifdef IS_PY3K
+         PyBuffer_Release (&pybuf);
+#endif
          return NULL;
        }
       /* Watch for overflows.  */
@@ -614,23 +680,15 @@ infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
          PyErr_SetString (PyExc_ValueError,
                           _("The search range is too large."));
 
+#ifdef IS_PY3K
+         PyBuffer_Release (&pybuf);
+#endif
          return NULL;
        }
     }
   else
     return NULL;
 
-  if (!PyObject_CheckReadBuffer (pattern))
-    {
-      PyErr_SetString (PyExc_RuntimeError,
-                      _("The pattern is not a Python buffer."));
-
-      return NULL;
-    }
-
-  if (PyObject_AsReadBuffer (pattern, &buffer, &pattern_size) == -1)
-    return NULL;
-
   TRY_CATCH (except, RETURN_MASK_ALL)
     {
       found = target_search_memory (start_addr, length,
@@ -639,6 +697,10 @@ infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
     }
   GDB_PY_HANDLE_EXCEPTION (except);
 
+#ifdef IS_PY3K
+  PyBuffer_Release (&pybuf);
+#endif
+
   if (found)
     return PyLong_FromLong (found_addr);
   else
@@ -726,7 +788,7 @@ gdbpy_initialize_inferior (void)
                      (PyObject *) &inferior_object_type);
 
   infpy_inf_data_key =
-    register_inferior_data_with_cleanup (py_free_inferior);
+    register_inferior_data_with_cleanup (NULL, py_free_inferior);
 
   observer_attach_new_thread (add_thread_object);
   observer_attach_thread_exit (delete_thread_object);
@@ -778,8 +840,7 @@ Return a long with the address of a match, or None." },
 
 static PyTypeObject inferior_object_type =
 {
-  PyObject_HEAD_INIT (NULL)
-  0,                             /* ob_size */
+  PyVarObject_HEAD_INIT (NULL, 0)
   "gdb.Inferior",                /* tp_name */
   sizeof (inferior_object),      /* tp_basicsize */
   0,                             /* tp_itemsize */
@@ -818,6 +879,15 @@ static PyTypeObject inferior_object_type =
   0                              /* tp_alloc */
 };
 
+#ifdef IS_PY3K
+
+static PyBufferProcs buffer_procs =
+{
+  get_buffer
+};
+
+#else
+
 /* Python doesn't provide a decent way to get compatibility here.  */
 #if HAVE_LIBPYTHON2_4
 #define CHARBUFFERPROC_NAME getcharbufferproc
@@ -833,10 +903,10 @@ static PyBufferProcs buffer_procs = {
      Python 2.5.  */
   (CHARBUFFERPROC_NAME) get_char_buffer
 };
+#endif /* IS_PY3K */
 
 static PyTypeObject membuf_object_type = {
-  PyObject_HEAD_INIT (NULL)
-  0,                             /*ob_size*/
+  PyVarObject_HEAD_INIT (NULL, 0)
   "gdb.Membuf",                          /*tp_name*/
   sizeof (membuf_object),        /*tp_basicsize*/
   0,                             /*tp_itemsize*/