+2010-06-28 Phil Muldoon <pmuldoon@redhat.com>
+ Tom Tromey <tromey@redhat.com>
+ Thiago Jung Bauermann <bauerman@br.ibm.com>
+
+ * value.c (pack_unsigned_long): New function.
+ (value_from_ulongest): New function.
+ * value.h (value_from_ulongest): Declare.
+ * python/python.c (_initialize_python): Call
+ gdbpy_initialize_thread and gdbpy_initialize_inferior.
+ * python/python-internal.h: Define thread_object.
+ (gdbpy_inferiors, gdbpy_selected_thread)
+ (frame_info_to_frame_object, create_thread_object)
+ (find_thread_object, find_inferior_object)
+ (gdbpy_initialize_thread, gdbpy_initialize_inferiors)
+ (gdbpy_is_value_object, get_addr_from_python): Declare.
+ * python/py-value.c (builtin_type_upylong): Define.
+ (convert_value_from_python): Add logic for ulongest.
+ (gdbpy_is_value_object): New function.
+ * python/py-utils.c (get_addr_from_python): New function.
+ * python/py-frame.c (frame_info_to_frame_object): Return a PyObject.
+ (gdbpy_selected_frame): Use PyObject over frame_info.
+ * Makefile.in (SUBDIR_PYTHON_OBS): Add py-inferior and
+ py-infthread.
+ (SUBDIR_PYTHON_SRCS): Likewise.
+ (py-inferior.o): New Rule.
+ (py-infthread.o): New Rule.
+ * python/py-inferior.c: New File.
+ * python/py-infthread.c: New File.
+
+
+
2010-06-28 Jan Kratochvil <jan.kratochvil@redhat.com>
* c-typeprint.c (c_type_print_base): For no fields check include also
* top.c (print_gdb_version): Update copyright year.
-2010-01-01 Joel Brobecker <brobecker@adacore.com>
+2010-01-01, 10 Joel Brobecker <brobecker@adacore.com>
Fix break *FUN'address thread NUM.
* ada-lex.l (task): Expand rule to also match the thread keyword.
py-cmd.o \
py-frame.o \
py-function.o \
+ py-inferior.o \
+ py-infthread.o \
py-lazy-string.o \
py-objfile.o \
py-param.o \
python/py-cmd.c \
python/py-frame.c \
python/py-function.c \
+ python/py-inferior.c \
+ python/py-infthread.c \
python/py-lazy-string.c \
python/py-objfile.c \
python/py-param.c \
$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-function.c
$(POSTCOMPILE)
+py-inferior.o: $(srcdir)/python/py-inferior.c
+ $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-inferior.c
+ $(POSTCOMPILE)
+
+py-infthread.o: $(srcdir)/python/py-infthread.c
+ $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-infthread.c
+ $(POSTCOMPILE)
+
py-lazy-string.o: $(srcdir)/python/py-lazy-string.c
$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-lazy-string.c
$(POSTCOMPILE)
GDB using Python' in the manual.
** The GDB Python API now has access to breakpoints, symbols, symbol
- tables, program spaces, and frame's code blocks. Additionally, GDB
- Parameters can now be created from the API, and manipulated via
- set/show in the CLI.
+ tables, program spaces, inferiors, threads and frame's code blocks.
+ Additionally, GDB Parameters can now be created from the API, and
+ manipulated via set/show in the CLI.
** New functions gdb.target_charset, gdb.target_wide_charset,
gdb.progspaces, gdb.current_progspace, and gdb.string_to_argv.
+2010-06-28 Phil Muldoon <pmuldoon@redhat.com>
+ Tom Tromey <tromey@redhat.com>
+ Thiago Jung Bauermann <bauerman@br.ibm.com>
+
+ * gdb.texinfo (Inferiors In Python): New node.
+ * gdb.texinfo (Threads In Python): New node.
+
2010-06-28 Joel Brobecker <brobecker@adacore.com>
* gdb.texinfo (Python): Document what the python directory is
* Pretty Printing API:: Pretty-printing values.
* Selecting Pretty-Printers:: How GDB chooses a pretty-printer.
* Disabling Pretty-Printers:: Disabling broken printers.
+* Inferiors In Python:: Python representation of inferiors (processes)
+* Threads In Python:: Accessing inferior threads from Python.
* Commands In Python:: Implementing new commands in Python.
* Parameters In Python:: Adding new @value{GDBN} parameters.
* Functions In Python:: Writing new convenience functions.
is present and its value is @code{False}, the printer is disabled, otherwise
the printer is enabled.
+@node Inferiors In Python
+@subsubsection Inferiors In Python
+@cindex inferiors in python
+
+@findex gdb.Inferior
+Programs which are being run under @value{GDBN} are called inferiors
+(@pxref{Inferiors and Programs}). Python scripts can access
+information about and manipulate inferiors controlled by @value{GDBN}
+via objects of the @code{gdb.Inferior} class.
+
+The following inferior-related functions are available in the @code{gdb}
+module:
+
+@defun inferiors
+Return a tuple containing all inferior objects.
+@end defun
+
+A @code{gdb.Inferior} object has the following attributes:
+
+@table @code
+@defivar Inferior num
+ID of inferior, as assigned by GDB.
+@end defivar
+
+@defivar Inferior pid
+Process ID of the inferior, as assigned by the underlying operating
+system.
+@end defivar
+
+@defivar Inferior was_attached
+Boolean signaling whether the inferior was created using `attach', or
+started by @value{GDBN} itself.
+@end defivar
+@end table
+
+A @code{gdb.Inferior} object has the following methods:
+
+@table @code
+@defmethod Inferior threads
+This method returns a tuple holding all the threads which are valid
+when it is called. If there are no valid threads, the method will
+return an empty tuple.
+@end defmethod
+
+@findex gdb.read_memory
+@defmethod Inferior read_memory address length
+Read @var{length} bytes of memory from the inferior, starting at
+@var{address}. Returns a buffer object, which behaves much like an array
+or a string. It can be modified and given to the @code{gdb.write_memory}
+function.
+@end defmethod
+
+@findex gdb.write_memory
+@defmethod Inferior write_memory address buffer @r{[}length@r{]}
+Write the contents of @var{buffer} to the inferior, starting at
+@var{address}. The @var{buffer} parameter must be a Python object
+which supports the buffer protocol, i.e., a string, an array or the
+object returned from @code{gdb.read_memory}. If given, @var{length}
+determines the number of bytes from @var{buffer} to be written.
+@end defmethod
+
+@findex gdb.search_memory
+@defmethod Inferior search_memory address length pattern
+Search a region of the inferior memory starting at @var{address} with
+the given @var{length} using the search pattern supplied in
+@var{pattern}. The @var{pattern} parameter must be a Python object
+which supports the buffer protocol, i.e., a string, an array or the
+object returned from @code{gdb.read_memory}. Returns a Python @code{Long}
+containing the address where the pattern was found, or @code{None} if
+the pattern could not be found.
+@end defmethod
+@end table
+
+@node Threads In Python
+@subsubsection Threads In Python
+@cindex threads in python
+
+@findex gdb.InferiorThread
+Python scripts can access information about, and manipulate inferior threads
+controlled by @value{GDBN}, via objects of the @code{gdb.InferiorThread} class.
+
+The following thread-related functions are available in the @code{gdb}
+module:
+
+@findex gdb.selected_thread
+@defun selected_thread
+This function returns the thread object for the selected thread. If there
+is no selected thread, this will return @code{None}.
+@end defun
+
+A @code{gdb.InferiorThread} object has the following attributes:
+
+@table @code
+@defivar InferiorThread num
+ID of the thread, as assigned by GDB.
+@end defivar
+
+@defivar InferiorThread ptid
+ID of the thread, as assigned by the operating system. This attribute is a
+tuple containing three integers. The first is the Process ID (PID); the second
+is the Lightweight Process ID (LWPID), and the third is the Thread ID (TID).
+Either the LWPID or TID may be 0, which indicates that the operating system
+does not use that identifier.
+@end defivar
+@end table
+
+A @code{gdb.InferiorThread} object has the following methods:
+
+@defmethod InferiorThread switch
+This changes @value{GDBN}'s currently selected thread to the one represented
+by this object.
+@end defmethod
+
+@defmethod InferiorThread is_stopped
+Return a Boolean indicating whether the thread is stopped.
+@end defmethod
+
+@defmethod InferiorThread is_running
+Return a Boolean indicating whether the thread is running.
+@end defmethod
+
+@defmethod InferiorThread is_exited
+Return a Boolean indicating whether the thread is exited.
+@end defmethod
+@end table
+
@node Commands In Python
@subsubsection Commands In Python
/* Convert a frame_info struct to a Python Frame object.
Sets a Python exception and returns NULL on error. */
-static frame_object *
+PyObject *
frame_info_to_frame_object (struct frame_info *frame)
{
frame_object *frame_obj;
frame_obj->gdbarch = get_frame_arch (frame);
- return frame_obj;
+ return (PyObject *) frame_obj;
}
/* Implementation of gdb.Frame.older (self) -> gdb.Frame.
gdbpy_selected_frame (PyObject *self, PyObject *args)
{
struct frame_info *frame;
- frame_object *frame_obj = NULL; /* Initialize to appease gcc warning. */
+ PyObject *frame_obj = NULL; /* Initialize to appease gcc warning. */
volatile struct gdb_exception except;
TRY_CATCH (except, RETURN_MASK_ALL)
}
GDB_PY_HANDLE_EXCEPTION (except);
- return (PyObject *) frame_obj;
+ return frame_obj;
}
/* Implementation of gdb.stop_reason_string (Integer) -> String.
--- /dev/null
+/* Python interface to inferiors.
+
+ Copyright (C) 2009, 2010 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 "exceptions.h"
+#include "gdbcore.h"
+#include "gdbthread.h"
+#include "inferior.h"
+#include "observer.h"
+#include "python-internal.h"
+#include "arch-utils.h"
+#include "language.h"
+
+struct threadlist_entry {
+ thread_object *thread_obj;
+ struct threadlist_entry *next;
+};
+
+typedef struct
+{
+ PyObject_HEAD
+
+ /* The inferior we represent. */
+ struct inferior *inferior;
+
+ /* thread_object instances under this inferior. This list owns a
+ reference to each object it contains. */
+ struct threadlist_entry *threads;
+
+ /* Number of threads in the list. */
+ int nthreads;
+} inferior_object;
+
+static PyTypeObject inferior_object_type;
+
+static const struct inferior_data *infpy_inf_data_key;
+
+typedef struct {
+ PyObject_HEAD
+ void *buffer;
+
+ /* These are kept just for mbpy_str. */
+ CORE_ADDR addr;
+ CORE_ADDR length;
+} membuf_object;
+
+static PyTypeObject membuf_object_type;
+
+/* Require that INFERIOR be a valid inferior ID. */
+#define INFPY_REQUIRE_VALID(Inferior) \
+ do { \
+ if (!Inferior->inferior) \
+ { \
+ PyErr_SetString (PyExc_RuntimeError, \
+ _("Inferior no longer exists.")); \
+ return NULL; \
+ } \
+ } while (0)
+
+/* Return a borrowed reference to the Python object of type Inferior
+ representing INFERIOR. If the object has already been created,
+ return it, otherwise, create it. Return NULL on failure. */
+PyObject *
+inferior_to_inferior_object (struct inferior *inferior)
+{
+ inferior_object *inf_obj;
+
+ inf_obj = inferior_data (inferior, infpy_inf_data_key);
+ if (!inf_obj)
+ {
+ struct cleanup *cleanup;
+ cleanup = ensure_python_env (python_gdbarch, python_language);
+
+ inf_obj = PyObject_New (inferior_object, &inferior_object_type);
+ if (!inf_obj)
+ {
+ do_cleanups (cleanup);
+ return NULL;
+ }
+
+ inf_obj->inferior = inferior;
+ inf_obj->threads = NULL;
+ inf_obj->nthreads = 0;
+
+ set_inferior_data (inferior, infpy_inf_data_key, inf_obj);
+
+ do_cleanups (cleanup);
+ }
+
+ return (PyObject *) inf_obj;
+}
+
+/* Finds the Python Inferior object for the given PID. Returns a
+ borrowed reference, or NULL if PID does not match any inferior
+ obect.
+ */
+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)
+{
+ int pid;
+ struct threadlist_entry *thread;
+ PyObject *inf_obj;
+
+ pid = PIDGET (ptid);
+ inf_obj = find_inferior_object (pid);
+
+ if (inf_obj)
+ for (thread = ((inferior_object *)inf_obj)->threads; thread;
+ thread = thread->next)
+ if (ptid_equal (thread->thread_obj->thread->ptid, ptid))
+ return thread->thread_obj;
+
+ return NULL;
+}
+
+static void
+add_thread_object (struct thread_info *tp)
+{
+ struct cleanup *cleanup;
+ thread_object *thread_obj;
+ inferior_object *inf_obj;
+ struct threadlist_entry *entry;
+
+ cleanup = ensure_python_env (python_gdbarch, python_language);
+
+ thread_obj = create_thread_object (tp);
+ if (!thread_obj)
+ {
+ gdbpy_print_stack ();
+ do_cleanups (cleanup);
+ return;
+ }
+
+ inf_obj = (inferior_object *) thread_obj->inf_obj;
+
+ entry = xmalloc (sizeof (struct threadlist_entry));
+ entry->thread_obj = thread_obj;
+ entry->next = inf_obj->threads;
+
+ inf_obj->threads = entry;
+ 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;
+
+ inf_obj = (inferior_object *) find_inferior_object (PIDGET(tp->ptid));
+ if (!inf_obj)
+ return;
+
+ /* Find thread entry in its inferior's thread_list. */
+ for (entry = &inf_obj->threads; *entry != NULL; entry =
+ &(*entry)->next)
+ if ((*entry)->thread_obj->thread == tp)
+ break;
+
+ if (!*entry)
+ return;
+
+ cleanup = ensure_python_env (python_gdbarch, python_language);
+
+ tmp = *entry;
+ tmp->thread_obj->thread = NULL;
+
+ *entry = (*entry)->next;
+ inf_obj->nthreads--;
+
+ Py_DECREF (tmp->thread_obj);
+ xfree (tmp);
+
+ do_cleanups (cleanup);
+}
+
+static PyObject *
+infpy_threads (PyObject *self, PyObject *args)
+{
+ int i;
+ struct threadlist_entry *entry;
+ inferior_object *inf_obj = (inferior_object *) self;
+ PyObject *tuple;
+
+ INFPY_REQUIRE_VALID (inf_obj);
+
+ tuple = PyTuple_New (inf_obj->nthreads);
+ if (!tuple)
+ return NULL;
+
+ for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
+ i++, entry = entry->next)
+ {
+ Py_INCREF (entry->thread_obj);
+ PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
+ }
+
+ return tuple;
+}
+
+static PyObject *
+infpy_get_num (PyObject *self, void *closure)
+{
+ inferior_object *inf = (inferior_object *) self;
+
+ INFPY_REQUIRE_VALID (inf);
+
+ return PyLong_FromLong (inf->inferior->num);
+}
+
+static PyObject *
+infpy_get_pid (PyObject *self, void *closure)
+{
+ inferior_object *inf = (inferior_object *) self;
+
+ INFPY_REQUIRE_VALID (inf);
+
+ return PyLong_FromLong (inf->inferior->pid);
+}
+
+static PyObject *
+infpy_get_was_attached (PyObject *self, void *closure)
+{
+ inferior_object *inf = (inferior_object *) self;
+
+ INFPY_REQUIRE_VALID (inf);
+ if (inf->inferior->attach_flag)
+ Py_RETURN_TRUE;
+ Py_RETURN_FALSE;
+}
+
+static int
+build_inferior_list (struct inferior *inf, void *arg)
+{
+ PyObject *list = arg;
+ PyObject *inferior = inferior_to_inferior_object (inf);
+
+ PyList_Append (list, inferior);
+ return 0;
+}
+
+/* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
+ Returns a tuple of all inferiors. */
+PyObject *
+gdbpy_inferiors (PyObject *unused, PyObject *unused2)
+{
+ int i = 0;
+ PyObject *list, *inferior;
+ struct inferior *inf;
+
+ list = PyList_New (0);
+ if (!list)
+ return NULL;
+
+ iterate_over_inferiors (build_inferior_list, list);
+
+ return PyList_AsTuple (list);
+}
+
+/* Membuf and memory manipulation. */
+
+/* Implementation of gdb.read_memory (address, length).
+ Returns a Python buffer object with LENGTH bytes of the inferior's
+ memory at ADDRESS. Both arguments are integers. */
+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;
+ 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);
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+
+ if (error)
+ {
+ do_cleanups (cleanups);
+ return NULL;
+ }
+
+ membuf_obj = PyObject_New (membuf_object, &membuf_object_type);
+ if (membuf_obj == NULL)
+ {
+ 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);
+}
+
+/* Implementation of gdb.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. */
+static PyObject *
+infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
+{
+ int buf_len, error = 0;
+ const char *buffer;
+ CORE_ADDR addr, length;
+ PyObject *addr_obj, *length_obj = NULL;
+ volatile struct gdb_exception except;
+ static char *keywords[] = { "address", "buffer", "length", NULL };
+
+
+ if (! PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
+ &addr_obj, &buffer, &buf_len,
+ &length_obj))
+ return NULL;
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ if (!get_addr_from_python (addr_obj, &addr))
+ {
+ error = 1;
+ break;
+ }
+
+ if (!length_obj)
+ length = buf_len;
+ else if (!get_addr_from_python (length_obj, &length))
+ {
+ error = 1;
+ break;
+ }
+ write_memory (addr, buffer, length);
+ }
+ GDB_PY_HANDLE_EXCEPTION (except);
+
+ if (error)
+ return NULL;
+
+ Py_RETURN_NONE;
+}
+
+/* Destructor of Membuf objects. */
+static void
+mbpy_dealloc (PyObject *self)
+{
+ xfree (((membuf_object *) self)->buffer);
+ self->ob_type->tp_free (self);
+}
+
+/* Return a description of the Membuf object. */
+static PyObject *
+mbpy_str (PyObject *self)
+{
+ membuf_object *membuf_obj = (membuf_object *) self;
+
+ return PyString_FromFormat (_("Memory buffer for address %s, \
+which is %s bytes long."),
+ paddress (python_gdbarch, membuf_obj->addr),
+ pulongest (membuf_obj->length));
+}
+
+static Py_ssize_t
+get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
+{
+ membuf_object *membuf_obj = (membuf_object *) self;
+
+ if (segment)
+ {
+ PyErr_SetString (PyExc_SystemError,
+ _("The memory buffer supports only one segment."));
+ return -1;
+ }
+
+ *ptrptr = membuf_obj->buffer;
+
+ return membuf_obj->length;
+}
+
+static Py_ssize_t
+get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
+{
+ return get_read_buffer (self, segment, ptrptr);
+}
+
+static Py_ssize_t
+get_seg_count (PyObject *self, Py_ssize_t *lenp)
+{
+ if (lenp)
+ *lenp = ((membuf_object *) self)->length;
+
+ return 1;
+}
+
+static Py_ssize_t
+get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
+{
+ void *ptr = NULL;
+ Py_ssize_t ret;
+
+ ret = get_read_buffer (self, segment, &ptr);
+ *ptrptr = (char *) ptr;
+
+ return ret;
+}
+
+/* Implementation of
+ gdb.search_memory (address, length, pattern). ADDRESS is the
+ address to start the search. LENGTH specifies the scope of the
+ search from ADDRESS. PATTERN is the pattern to search for (and
+ must be a Python object supporting the buffer protocol).
+ Returns a Python Long object holding the address where the pattern
+ was located, or if the pattern was not found, returns None. */
+static PyObject *
+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;
+ volatile struct gdb_exception except;
+ Py_ssize_t pattern_size;
+ const void *buffer;
+ CORE_ADDR found_addr;
+ int found = 0;
+
+ if (! PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
+ &start_addr_obj, &length_obj,
+ &pattern))
+ return NULL;
+
+ if (get_addr_from_python (start_addr_obj, &start_addr)
+ && get_addr_from_python (length_obj, &length))
+ {
+ if (!length)
+ {
+ PyErr_SetString (PyExc_ValueError,
+ _("Search range is empty."));
+ return NULL;
+ }
+ /* Watch for overflows. */
+ else if (length > CORE_ADDR_MAX
+ || (start_addr + length - 1) < start_addr)
+ {
+ PyErr_SetString (PyExc_ValueError,
+ _("The search range is too large."));
+
+ return NULL;
+ }
+ }
+ else
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Cannot get search address/range from Python."));
+
+ 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,
+ buffer, pattern_size,
+ &found_addr);
+ }
+ GDB_PY_HANDLE_EXCEPTION (except);
+
+ if (found)
+ return PyLong_FromLong (found_addr);
+ else
+ Py_RETURN_NONE;
+}
+
+
+/* Clear the INFERIOR pointer in an Inferior object and clear the
+ thread list. */
+static void
+py_free_inferior (struct inferior *inf, void *datum)
+{
+
+ struct cleanup *cleanup;
+ inferior_object *inf_obj = datum;
+ struct threadlist_entry *th_entry, *th_tmp;
+
+ cleanup = ensure_python_env (python_gdbarch, python_language);
+
+ inf_obj->inferior = NULL;
+
+ /* Deallocate threads list. */
+ for (th_entry = inf_obj->threads; th_entry != NULL;)
+ {
+ Py_DECREF (th_entry->thread_obj);
+
+ th_tmp = th_entry;
+ th_entry = th_entry->next;
+ xfree (th_tmp);
+ }
+
+ inf_obj->nthreads = 0;
+
+ Py_DECREF ((PyObject *) inf_obj);
+ do_cleanups (cleanup);
+}
+
+void
+gdbpy_initialize_inferior (void)
+{
+ if (PyType_Ready (&inferior_object_type) < 0)
+ return;
+
+ Py_INCREF (&inferior_object_type);
+ PyModule_AddObject (gdb_module, "Inferior",
+ (PyObject *) &inferior_object_type);
+
+ infpy_inf_data_key =
+ register_inferior_data_with_cleanup (py_free_inferior);
+
+ observer_attach_new_thread (add_thread_object);
+ observer_attach_thread_exit (delete_thread_object);
+
+ if (PyType_Ready (&membuf_object_type) < 0)
+ return;
+
+ Py_INCREF (&membuf_object_type);
+ PyModule_AddObject (gdb_module, "Membuf", (PyObject *)
+ &membuf_object_type);
+}
+
+static PyGetSetDef inferior_object_getset[] =
+{
+ { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
+ { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
+ NULL },
+ { "was_attached", infpy_get_was_attached, NULL,
+ "True if the inferior was created using 'attach'.", NULL },
+ { NULL }
+};
+
+static PyMethodDef inferior_object_methods[] =
+{
+ { "threads", infpy_threads, METH_NOARGS,
+ "Return all the threads of this inferior." },
+ { "read_memory", (PyCFunction) infpy_read_memory,
+ METH_VARARGS | METH_KEYWORDS,
+ "read_memory (address, length) -> buffer\n\
+Return a buffer object for reading from the inferior's memory." },
+ { "write_memory", (PyCFunction) infpy_write_memory,
+ METH_VARARGS | METH_KEYWORDS,
+ "write_memory (address, buffer [, length])\n\
+Write the given buffer object to the inferior's memory." },
+ { "search_memory", (PyCFunction) infpy_search_memory,
+ METH_VARARGS | METH_KEYWORDS,
+ "search_memory (address, length, pattern) -> long\n\
+Return a long with the address of a match, or None." },
+ { NULL }
+};
+
+static PyTypeObject inferior_object_type =
+{
+ PyObject_HEAD_INIT (NULL)
+ 0, /* ob_size */
+ "gdb.Inferior", /* tp_name */
+ sizeof (inferior_object), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /* tp_flags */
+ "GDB inferior object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ inferior_object_methods, /* tp_methods */
+ 0, /* tp_members */
+ inferior_object_getset, /* 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 */
+};
+
+/* Python doesn't provide a decent way to get compatibility here. */
+#if HAVE_LIBPYTHON2_4
+#define CHARBUFFERPROC_NAME getcharbufferproc
+#else
+#define CHARBUFFERPROC_NAME charbufferproc
+#endif
+
+static PyBufferProcs buffer_procs = {
+ get_read_buffer,
+ get_write_buffer,
+ get_seg_count,
+ /* The cast here works around a difference between Python 2.4 and
+ Python 2.5. */
+ (CHARBUFFERPROC_NAME) get_char_buffer
+};
+
+static PyTypeObject membuf_object_type = {
+ PyObject_HEAD_INIT (NULL)
+ 0, /*ob_size*/
+ "gdb.Membuf", /*tp_name*/
+ sizeof (membuf_object), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ mbpy_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash */
+ 0, /*tp_call*/
+ mbpy_str, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ &buffer_procs, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT, /*tp_flags*/
+ "GDB memory buffer object", /*tp_doc*/
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ 0, /* tp_methods */
+ 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 */
+ PyType_GenericNew /* tp_new */
+};
--- /dev/null
+/* Python interface to inferior threads.
+
+ Copyright (C) 2009, 2010 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 "exceptions.h"
+#include "gdbthread.h"
+#include "inferior.h"
+#include "python-internal.h"
+
+static PyTypeObject thread_object_type;
+
+/* Require that INFERIOR be a valid inferior ID. */
+#define THPY_REQUIRE_VALID(Thread) \
+ do { \
+ if (!Thread->thread) \
+ { \
+ PyErr_SetString (PyExc_RuntimeError, \
+ _("Thread no longer exists.")); \
+ return NULL; \
+ } \
+ } while (0)
+
+
+
+thread_object *
+create_thread_object (struct thread_info *tp)
+{
+ thread_object *thread_obj;
+
+ thread_obj = PyObject_New (thread_object, &thread_object_type);
+ if (!thread_obj)
+ return NULL;
+
+ thread_obj->thread = tp;
+ thread_obj->inf_obj = find_inferior_object (PIDGET (tp->ptid));
+ Py_INCREF (thread_obj->inf_obj);
+
+ return thread_obj;
+}
+
+
+
+static void
+thpy_dealloc (PyObject *self)
+{
+ Py_DECREF (((thread_object *) self)->inf_obj);
+ self->ob_type->tp_free (self);
+}
+
+static PyObject *
+thpy_get_num (PyObject *self, void *closure)
+{
+ thread_object *thread_obj = (thread_object *) self;
+
+ THPY_REQUIRE_VALID (thread_obj);
+
+ return PyLong_FromLong (thread_obj->thread->num);
+}
+
+/* Getter for InferiorThread.ptid -> (pid, lwp, tid).
+ Returns a tuple with the thread's ptid components. */
+static PyObject *
+thpy_get_ptid (PyObject *self, void *closure)
+{
+ int pid;
+ long tid, lwp;
+ thread_object *thread_obj = (thread_object *) self;
+ PyObject *ret;
+
+ THPY_REQUIRE_VALID (thread_obj);
+
+ ret = PyTuple_New (3);
+ if (!ret)
+ return NULL;
+
+ pid = ptid_get_pid (thread_obj->thread->ptid);
+ lwp = ptid_get_lwp (thread_obj->thread->ptid);
+ tid = ptid_get_tid (thread_obj->thread->ptid);
+
+ PyTuple_SET_ITEM (ret, 0, PyInt_FromLong (pid));
+ PyTuple_SET_ITEM (ret, 1, PyInt_FromLong (lwp));
+ PyTuple_SET_ITEM (ret, 2, PyInt_FromLong (tid));
+
+ return ret;
+}
+
+/* Implementation of InferiorThread.switch ().
+ Makes this the GDB selected thread. */
+static PyObject *
+thpy_switch (PyObject *self, PyObject *args)
+{
+ thread_object *thread_obj = (thread_object *) self;
+ struct cleanup *cleanup;
+ volatile struct gdb_exception except;
+
+ THPY_REQUIRE_VALID (thread_obj);
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ switch_to_thread (thread_obj->thread->ptid);
+ }
+ GDB_PY_HANDLE_EXCEPTION (except);
+
+ Py_RETURN_NONE;
+}
+
+/* Implementation of InferiorThread.is_stopped () -> Boolean.
+ Return whether the thread is stopped. */
+static PyObject *
+thpy_is_stopped (PyObject *self, PyObject *args)
+{
+ thread_object *thread_obj = (thread_object *) self;
+
+ THPY_REQUIRE_VALID (thread_obj);
+
+ if (is_stopped (thread_obj->thread->ptid))
+ Py_RETURN_TRUE;
+
+ Py_RETURN_FALSE;
+}
+
+/* Implementation of InferiorThread.is_running () -> Boolean.
+ Return whether the thread is running. */
+static PyObject *
+thpy_is_running (PyObject *self, PyObject *args)
+{
+ thread_object *thread_obj = (thread_object *) self;
+
+ THPY_REQUIRE_VALID (thread_obj);
+
+ if (is_running (thread_obj->thread->ptid))
+ Py_RETURN_TRUE;
+
+ Py_RETURN_FALSE;
+}
+
+/* Implementation of InferiorThread.is_exited () -> Boolean.
+ Return whether the thread is exited. */
+static PyObject *
+thpy_is_exited (PyObject *self, PyObject *args)
+{
+ thread_object *thread_obj = (thread_object *) self;
+
+ THPY_REQUIRE_VALID (thread_obj);
+
+ if (is_exited (thread_obj->thread->ptid))
+ Py_RETURN_TRUE;
+
+ Py_RETURN_FALSE;
+}
+
+
+
+/* Implementation of gdb.selected_thread () -> gdb.InferiorThread.
+ Returns the selected thread object. */
+PyObject *
+gdbpy_selected_thread (PyObject *self, PyObject *args)
+{
+ PyObject *thread_obj;
+
+ thread_obj = (PyObject *) find_thread_object (inferior_ptid);
+ if (thread_obj)
+ {
+ Py_INCREF (thread_obj);
+ return thread_obj;
+ }
+
+ Py_RETURN_NONE;
+}
+
+
+
+void
+gdbpy_initialize_thread (void)
+{
+ if (PyType_Ready (&thread_object_type) < 0)
+ return;
+
+ Py_INCREF (&thread_object_type);
+ PyModule_AddObject (gdb_module, "InferiorThread",
+ (PyObject *) &thread_object_type);
+}
+
+
+
+static PyGetSetDef thread_object_getset[] =
+{
+ { "num", thpy_get_num, NULL, "ID of the thread, as assigned by GDB.", NULL },
+ { "ptid", thpy_get_ptid, NULL, "ID of the thread, as assigned by the OS.",
+ NULL },
+
+ { NULL }
+};
+
+static PyMethodDef thread_object_methods[] =
+{
+ { "switch", thpy_switch, METH_NOARGS,
+ "switch ()\n\
+Makes this the GDB selected thread." },
+ { "is_stopped", thpy_is_stopped, METH_NOARGS,
+ "is_stopped () -> Boolean\n\
+Return whether the thread is stopped." },
+ { "is_running", thpy_is_running, METH_NOARGS,
+ "is_running () -> Boolean\n\
+Return whether the thread is running." },
+ { "is_exited", thpy_is_exited, METH_NOARGS,
+ "is_exited () -> Boolean\n\
+Return whether the thread is exited." },
+
+ { NULL }
+};
+
+static PyTypeObject thread_object_type =
+{
+ PyObject_HEAD_INIT (NULL)
+ 0, /*ob_size*/
+ "gdb.InferiorThread", /*tp_name*/
+ sizeof (thread_object), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ thpy_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+ 0, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ 0, /*tp_hash */
+ 0, /*tp_call*/
+ 0, /*tp_str*/
+ 0, /*tp_getattro*/
+ 0, /*tp_setattro*/
+ 0, /*tp_as_buffer*/
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
+ "GDB thread object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ thread_object_methods, /* tp_methods */
+ 0, /* tp_members */
+ thread_object_getset, /* 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 */
+};
#include "defs.h"
#include "charset.h"
+#include "value.h"
#include "python-internal.h"
return str;
}
+
+/* Converts OBJ to a CORE_ADDR value.
+
+ Returns 1 on success or 0 on failure, with a Python exception set. This
+ function can also throw GDB exceptions.
+*/
+
+int
+get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
+{
+ if (gdbpy_is_value_object (obj))
+ *addr = value_as_address (value_object_to_value (obj));
+ else if (PyLong_Check (obj))
+ {
+ /* Assume CORE_ADDR corresponds to unsigned long. */
+ *addr = PyLong_AsUnsignedLong (obj);
+ if (PyErr_Occurred () != NULL)
+ return 0;
+ }
+ else if (PyInt_Check (obj))
+ {
+ long val;
+
+ /* Assume CORE_ADDR corresponds to unsigned long. */
+ val = PyInt_AsLong (obj);
+
+ if (val >= 0)
+ *addr = val;
+ else
+ {
+ /* If no error ocurred, VAL is indeed negative. */
+ if (PyErr_Occurred () != NULL)
+ return 0;
+
+ PyErr_SetString (PyExc_ValueError,
+ _("Supplied address is negative."));
+ return 0;
+ }
+ }
+ else
+ {
+ PyErr_SetString (PyExc_TypeError,
+ _("Invalid type for address."));
+ return 0;
+ }
+
+ return 1;
+}
/* Python's long type corresponds to C's long long type. */
#define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
+/* Python's long type corresponds to C's long long type. Unsigned version. */
+#define builtin_type_upylong builtin_type \
+ (python_gdbarch)->builtin_unsigned_long_long
+
#define builtin_type_pybool \
language_bool_type (python_language, python_gdbarch)
{
LONGEST l = PyLong_AsLongLong (obj);
- if (! PyErr_Occurred ())
+ if (PyErr_Occurred ())
+ {
+ /* If the error was an overflow, we can try converting to
+ ULONGEST instead. */
+ if (PyErr_ExceptionMatches (PyExc_OverflowError))
+ {
+ PyObject *etype, *evalue, *etraceback, *zero;
+
+ PyErr_Fetch (&etype, &evalue, &etraceback);
+ zero = PyInt_FromLong (0);
+
+ /* Check whether obj is positive. */
+ if (PyObject_RichCompareBool (obj, zero, Py_GT) > 0)
+ {
+ ULONGEST ul;
+
+ ul = PyLong_AsUnsignedLongLong (obj);
+ if (! PyErr_Occurred ())
+ value = value_from_ulongest (builtin_type_upylong, ul);
+ }
+ else
+ /* There's nothing we can do. */
+ PyErr_Restore (etype, evalue, etraceback);
+
+ Py_DECREF (zero);
+ }
+ }
+ else
value = value_from_longest (builtin_type_pylong, l);
}
else if (PyFloat_Check (obj))
return value_to_value_object (res_val);
}
+/* Returns 1 in OBJ is a gdb.Value object, 0 otherwise. */
+
+int
+gdbpy_is_value_object (PyObject *obj)
+{
+ return PyObject_TypeCheck (obj, &value_object_type);
+}
+
void
gdbpy_initialize_values (void)
{
extern PyTypeObject block_object_type;
extern PyTypeObject symbol_object_type;
+typedef struct
+{
+ PyObject_HEAD
+
+ /* The thread we represent. */
+ struct thread_info *thread;
+
+ /* The Inferior object to which this thread belongs. */
+ PyObject *inf_obj;
+} thread_object;
+
extern struct cmd_list_element *set_python_list;
extern struct cmd_list_element *show_python_list;
PyObject *gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw);
PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
const char *encoding, struct type *type);
+PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2);
+PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args);
PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args);
PyObject *gdbpy_get_hook_function (const char *);
PyObject *gdbpy_parameter (PyObject *self, PyObject *args);
PyObject *block_to_block_object (struct block *block, struct objfile *objfile);
PyObject *value_to_value_object (struct value *v);
PyObject *type_to_type_object (struct type *);
+PyObject *frame_info_to_frame_object (struct frame_info *frame);
PyObject *pspace_to_pspace_object (struct program_space *);
PyObject *pspy_get_printers (PyObject *, void *);
PyObject *objfile_to_objfile_object (struct objfile *);
PyObject *objfpy_get_printers (PyObject *, void *);
+thread_object *create_thread_object (struct thread_info *tp);
+thread_object *find_thread_object (ptid_t ptid);
+PyObject *find_inferior_object (int pid);
+
struct block *block_object_to_block (PyObject *obj);
struct symbol *symbol_object_to_symbol (PyObject *obj);
struct value *value_object_to_value (PyObject *self);
void gdbpy_initialize_breakpoints (void);
void gdbpy_initialize_lazy_string (void);
void gdbpy_initialize_parameters (void);
+void gdbpy_initialize_thread (void);
+void gdbpy_initialize_inferior (void);
struct cleanup *make_cleanup_py_decref (PyObject *py);
struct type **str_type,
long *length, char **encoding);
+int gdbpy_is_value_object (PyObject *obj);
+
/* Note that these are declared here, and not in python.h with the
other pretty-printer functions, because they refer to PyObject. */
PyObject *apply_varobj_pretty_printer (PyObject *print_obj,
extern PyObject *gdbpy_gdberror_exc;
+int get_addr_from_python (PyObject *obj, CORE_ADDR *addr);
+
#endif /* GDB_PYTHON_INTERNAL_H */
gdbpy_initialize_objfile ();
gdbpy_initialize_breakpoints ();
gdbpy_initialize_lazy_string ();
+ gdbpy_initialize_thread ();
+ gdbpy_initialize_inferior ();
PyRun_SimpleString ("import gdb");
PyRun_SimpleString ("gdb.pretty_printers = []");
"Write a string using gdb's filtered stream." },
{ "flush", gdbpy_flush, METH_NOARGS,
"Flush gdb's filtered stdout stream." },
-
+ { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
+ "selected_thread () -> gdb.InferiorThread.\n\
+Return the selected thread object." },
+ { "inferiors", gdbpy_inferiors, METH_NOARGS,
+ "inferiors () -> (gdb.Inferior, ...).\n\
+Return a tuple containing all inferiors." },
{NULL, NULL, 0, NULL}
};
+2010-06-28 Phil Muldoon <pmuldoon@redhat.com>
+ Tom Tromey <tromey@redhat.com>
+ Thiago Jung Bauermann <bauerman@br.ibm.com>
+
+ * gdb.python/py-inferior.c: New File.
+ * gdb.python/py-infthread.c: New File.
+ * gdb.python/py-inferior.exp: New File.
+ * gdb.python/py-infthread.exp: New File.
+
2010-06-28 Jan Kratochvil <jan.kratochvil@redhat.com>
* gdb.cp/namespace.exp (ptype OtherFileClass typedefs)
srcdir = @srcdir@
EXECUTABLES = py-type py-value py-prettyprint py-template py-block \
- py-symbol py-mi py-breakpoint
+ py-symbol py-mi py-breakpoint py-inferior py-infthread
all info install-info dvi install uninstall installcheck check:
@echo "Nothing to be done for $@..."
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#define CHUNK_SIZE 16000 /* same as findcmd.c's */
+#define BUF_SIZE (2 * CHUNK_SIZE) /* at least two chunks */
+
+static int8_t int8_search_buf[100];
+static int16_t int16_search_buf[100];
+static int32_t int32_search_buf[100];
+static int64_t int64_search_buf[100];
+
+static char *search_buf;
+static int search_buf_size;
+
+static int x;
+
+
+int f2 (int a)
+{
+ char *str = "hello, testsuite";
+
+ puts (str); /* Break here. */
+
+ return ++a;
+}
+
+int f1 (int a, int b)
+{
+ return f2(a) + b;
+}
+
+static void
+init_bufs ()
+{
+ search_buf_size = BUF_SIZE;
+ search_buf = malloc (search_buf_size);
+ if (search_buf == NULL)
+ exit (1);
+ memset (search_buf, 'x', search_buf_size);
+}
+
+int main (int argc, char *argv[])
+{
+ init_bufs ();
+
+ return f1 (1, 2);
+}
--- /dev/null
+# Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+
+# 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/>.
+
+# This file is part of the GDB testsuite. It tests the mechanism
+# exposing inferiors to Python.
+
+if $tracelevel then {
+ strace $tracelevel
+}
+
+# Run a command in GDB, and report a failure if a Python exception is thrown.
+# If report_pass is true, report a pass if no exception is thrown.
+proc gdb_py_test_silent_cmd {cmd name report_pass} {
+ global gdb_prompt
+
+ gdb_test_multiple $cmd $name {
+ -re "Traceback.*$gdb_prompt $" { fail $name }
+ -re "$gdb_prompt $" { if $report_pass { pass $name } }
+ }
+}
+
+set testfile "py-inferior"
+set srcfile ${testfile}.c
+if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+ return -1
+}
+
+# Start with a fresh gdb.
+clean_restart ${testfile}
+
+# Skip all tests if Python scripting is not enabled.
+if { [skip_python_tests] } { continue }
+
+# The following tests require execution.
+
+if ![runto_main] then {
+ fail "Can't run to main"
+ return 0
+}
+
+runto [gdb_get_line_number "Break here."]
+
+# Test basic gdb.Inferior attributes and methods.
+
+gdb_py_test_silent_cmd "python inferiors = gdb.inferiors ()" "get inferiors list" 1
+gdb_test "python print inferiors" "\\(<gdb.Inferior object at 0x\[\[:xdigit:\]\]+>,\\)" "verify inferiors list"
+gdb_py_test_silent_cmd "python i0 = inferiors\[0\]" "get first inferior" 0
+
+gdb_test "python print 'result =', i0 == inferiors\[0\]" " = True" "test equality comparison (true)"
+gdb_test "python print 'result =', i0.num" " = \[0-9\]+" "test Inferior.num"
+gdb_test "python print 'result =', i0.pid" " = \[0-9\]+" "test Inferior.pid"
+gdb_test "python print 'result =', i0.was_attached" " = False" "test Inferior.was_attached"
+gdb_test "python print i0.threads ()" "\\(<gdb.InferiorThread object at 0x\[\[:xdigit:\]\]+>,\\)" "test Inferior.threads"
+
+# Test memory read and write operations.
+
+gdb_py_test_silent_cmd "python addr = gdb.selected_frame ().read_var ('str')" \
+ "read str address" 0
+gdb_py_test_silent_cmd "python str = gdb.inferiors()\[0\].read_memory (addr, 5)" \
+ "read str contents" 1
+gdb_py_test_silent_cmd "python str\[1\] = 'a'" "change str" 0
+gdb_py_test_silent_cmd "python gdb.inferiors()\[0\].write_memory (addr, str)" \
+ "write str" 1
+gdb_test "print str" " = 0x\[\[:xdigit:\]\]+ \"hallo, testsuite\"" \
+ "ensure str was changed in the inferior"
+
+# Test memory search.
+
+set hex_number {0x[0-9a-fA-F][0-9a-fA-F]*}
+set dec_number {[0-9]+}
+set history_prefix {[$][0-9]* = }
+set newline {[\r\n]+}
+set pattern_not_found "${newline}.None"
+set one_pattern_found "${newline}.${dec_number}"
+
+# Test string pattern.
+
+gdb_test "set *(int32_t*) &int8_search_buf\[10\] = 0x61616161" "" ""
+gdb_test "py search_buf = gdb.selected_frame ().read_var ('int8_search_buf')" "" ""
+gdb_test "py start_addr = search_buf.address" "" ""
+gdb_test "py length = search_buf.type.sizeof" "" ""
+
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, length, 'aaa')" \
+ "${one_pattern_found}" "find string pattern"
+
+# Test not finding pattern because search range too small, with
+# potential find at the edge of the range.
+
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, 10+3, 'aaaa')" \
+ "${pattern_not_found}" "pattern not found at end of range"
+
+# Increase the search range by 1 and we should find the pattern.
+
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, 10+3+1, 'aaa')" \
+ "${one_pattern_found}" "pattern found at end of range"
+
+# Import struct to pack the following patterns.
+gdb_test "py from struct import *" "" ""
+
+# Test 16-bit pattern.
+
+gdb_test "set int16_search_buf\[10\] = 0x1234" "" ""
+gdb_test "py search_buf = gdb.selected_frame ().read_var ('int16_search_buf')" "" ""
+gdb_test "py start_addr = search_buf.address" "" ""
+gdb_test "py length = search_buf.type.sizeof" "" ""
+gdb_test "py pattern = pack('H',0x1234)" "" \
+
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, length, pattern)" \
+ "${one_pattern_found}" "find 16-bit pattern, with value pattern"
+
+# Test 32-bit pattern.
+
+gdb_test "set int32_search_buf\[10\] = 0x12345678" "" ""
+gdb_test "py search_buf = gdb.selected_frame ().read_var ('int32_search_buf')" "" ""
+gdb_test "py start_addr = search_buf.address" "" ""
+gdb_test "py length = search_buf.type.sizeof" "" ""
+gdb_test "py pattern = pack('I',0x12345678)" "" \
+
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, length, pattern)" \
+ "${one_pattern_found}" "find 32-bit pattern, with python pattern"
+
+# Test 64-bit pattern.
+
+gdb_test "set int64_search_buf\[10\] = 0xfedcba9876543210LL" "" ""
+gdb_test "py search_buf = gdb.selected_frame ().read_var ('int64_search_buf')" "" ""
+gdb_test "py start_addr = search_buf.address" "" ""
+gdb_test "py length = search_buf.type.sizeof" "" ""
+gdb_test "py pattern = pack('Q', 0xfedcba9876543210)" "" ""
+
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, length, pattern)" \
+ "${one_pattern_found}" "find 64-bit pattern, with value pattern"
+
+# Test mixed-sized patterns.
+
+gdb_test "set *(int8_t*) &search_buf\[10\] = 0x62" "" ""
+gdb_test "set *(int16_t*) &search_buf\[11\] = 0x6363" "" ""
+gdb_test "set *(int32_t*) &search_buf\[13\] = 0x64646464" "" ""
+gdb_test "py search_buf = gdb.selected_frame ().read_var ('search_buf')" "" ""
+gdb_test "py start_addr = search_buf\[0\].address" "" ""
+gdb_test "py pattern1 = pack('B', 0x62)" "" ""
+gdb_test "py pattern2 = pack('H', 0x6363)" "" ""
+gdb_test "py pattern3 = pack('I', 0x64646464)" "" ""
+
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, 100, pattern1)" \
+ "${one_pattern_found}" "find mixed-sized pattern"
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, 100, pattern2)" \
+ "${one_pattern_found}" "find mixed-sized pattern"
+gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, 100, pattern3)" \
+ "${one_pattern_found}" "find mixed-sized pattern"
+
+# Test search spanning a large range, in the particular case of native
+# targets, test the search spanning multiple chunks.
+# Remote targets may implement the search differently.
+
+set CHUNK_SIZE 16000 ;
+
+gdb_test "set *(int32_t*) &search_buf\[0*${CHUNK_SIZE}+100\] = 0x12345678" "" ""
+gdb_test "set *(int32_t*) &search_buf\[1*${CHUNK_SIZE}+100\] = 0x12345678" "" ""
+gdb_test "py start_addr = gdb.selected_frame ().read_var ('search_buf')" "" ""
+gdb_test "py length = gdb.selected_frame ().read_var ('search_buf_size')" "" ""
+gdb_test "py pattern = pack('I', 0x12345678)" "" ""
+gdb_test "py first = gdb.inferiors()\[0\].search_memory (start_addr,length, pattern)" "" ""
+gdb_test "py print first" "${one_pattern_found}" "search spanning large range 1st result"
+gdb_test "py start_addr = first + 1"
+gdb_test "py second = gdb.inferiors()\[0\].search_memory (start_addr, length, pattern)" "" ""
+gdb_test "py print second" "${one_pattern_found}" "search spanning large range 2nd result"
+gdb_test "py start_addr = second + 1"
+gdb_test "py third = gdb.inferiors()\[0\].search_memory (start_addr, length, pattern)" "" ""
+gdb_test "py print third" "${pattern_not_found}" "search spanning large range 3rd result"
+
+# For native targets, test a pattern straddling a chunk boundary.
+
+if [isnative] {
+ gdb_test "set *(int32_t*) &search_buf\[${CHUNK_SIZE}-1\] = 0xfdb97531" "" ""
+ gdb_test "py pattern = pack('I', 0xfdb97531)" "" ""
+ gdb_test "py start_addr = gdb.selected_frame ().read_var ('search_buf')" "" ""
+ gdb_test "py print gdb.inferiors()\[0\].search_memory (start_addr, length, pattern)" \
+ "${one_pattern_found}" "find pattern straddling chunk boundary"
+}
--- /dev/null
+int f2 (int a)
+{
+ return ++a;
+}
+
+int f1 (int a, int b)
+{
+ return f2(a) + b;
+}
+
+int main (int argc, char *argv[])
+{
+ return f1 (1, 2);
+}
--- /dev/null
+# Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+
+# 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/>.
+
+# This file is part of the GDB testsuite. It tests the mechanism
+# exposing inferior threads to Python.
+
+if $tracelevel then {
+ strace $tracelevel
+}
+
+set testfile "py-infthread"
+set srcfile ${testfile}.c
+if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+ return -1
+}
+
+# Start with a fresh gdb.
+clean_restart ${testfile}
+
+# Skip all tests if Python scripting is not enabled.
+if { [skip_python_tests] } { continue }
+
+# The following tests require execution.
+
+if ![runto_main] then {
+ fail "Can't run to main"
+ return 0
+}
+
+runto [gdb_get_line_number "Break here."]
+
+# Test basic gdb.Inferior attributes and methods.
+
+gdb_py_test_silent_cmd "python t0 = gdb.selected_thread ()" "test gdb.selected_thread" 1
+gdb_test "python print t0" "\\<gdb.InferiorThread object at 0x\[\[:xdigit:\]\]+>" "verify InferiorThread object"
+gdb_test "python print 'result =', t0.num" " = \[0-9\]+" "test Inferior.num"
+gdb_test "python print 'result =', t0.ptid" " = \\(\[0-9\]+, \[0-9\]+, \[0-9\]+\\)" "test InferiorThread.ptid"
+
+gdb_test "python print 'result =', t0.is_stopped ()" " = True" "test InferiorThread.is_stopped"
+gdb_test "python print 'result =', t0.is_running ()" " = False" "test InferiorThread.is_running"
+gdb_test "python print 'result =', t0.is_exited ()" " = False" "test InferiorThread.is_exited"
}
+/* Pack NUM into BUF using a target format of TYPE. */
+
+void
+pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num)
+{
+ int len;
+ enum bfd_endian byte_order;
+
+ type = check_typedef (type);
+ len = TYPE_LENGTH (type);
+ byte_order = gdbarch_byte_order (get_type_arch (type));
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_INT:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_FLAGS:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_MEMBERPTR:
+ store_unsigned_integer (buf, len, byte_order, num);
+ break;
+
+ case TYPE_CODE_REF:
+ case TYPE_CODE_PTR:
+ store_typed_address (buf, type, (CORE_ADDR) num);
+ break;
+
+ default:
+ error (_("\
+Unexpected type (%d) encountered for unsigned integer constant."),
+ TYPE_CODE (type));
+ }
+}
+
+
/* Convert C numbers into newly allocated values. */
struct value *
}
+/* Convert C unsigned numbers into newly allocated values. */
+
+struct value *
+value_from_ulongest (struct type *type, ULONGEST num)
+{
+ struct value *val = allocate_value (type);
+
+ pack_unsigned_long (value_contents_raw (val), type, num);
+
+ return val;
+}
+
+
/* Create a value representing a pointer of type TYPE to the address
ADDR. */
struct value *
extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num);
extern struct value *value_from_longest (struct type *type, LONGEST num);
+extern struct value *value_from_ulongest (struct type *type, ULONGEST num);
extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
extern struct value *value_from_double (struct type *type, DOUBLEST num);
extern struct value *value_from_decfloat (struct type *type,
projects / binutils-gdb.git / commitdiff