This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Re: [patch][python] 1/3 Python representation of GDB line tables (Python code)
- From: Phil Muldoon <pmuldoon at redhat dot com>
- To: Tom Tromey <tromey at redhat dot com>
- Cc: gdb-patches at sourceware dot org
- Date: Thu, 07 Nov 2013 16:33:55 +0000
- Subject: Re: [patch][python] 1/3 Python representation of GDB line tables (Python code)
- Authentication-results: sourceware.org; auth=none
- References: <5253F4D4 dot 1050600 at redhat dot com> <87ob6fd8c7 dot fsf at fleche dot redhat dot com>
On 23/10/13 21:46, Tom Tromey wrote:
>>>>>> "Phil" == Phil Muldoon <pmuldoon@redhat.com> writes:
>
> Phil> This patch series (three emails) introduces GDB line table representation
> Phil> to Python.
>
> Phil> This first email contains the GDB and Python code to represent the line
> Phil> table data as Python objects.
>
> Phil> What do you think?
>
> Thanks, Phil.
>
> Really just nits here.
Fixed up nits.
> Phil> + /* Return a frozen set to remove duplicated line numbers in the case
> Phil> + where a source line has more than one instruction and more than one
> Phil> + entry in the line table. */
> Phil> + fset = PyFrozenSet_New (source_list);
> Phil> + Py_DECREF (source_list);
>
> PyFrozenSet_New is new in 2.5.
>
> I think it's cheaper, and no more difficult, to just build a set object
> from the start rather than make a list and the convert it. I'm not sure
> what to about Python 2.4 though.
All API access to sets is new in 2.5 (sets appeared in the Python
default library in 2.3)
I elected here just to use a dictionary to ensure unique line numbers
only.
Modified patch follows,
Cheers,
Phil
--
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index fc2a3af..85d43f9 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -299,6 +299,7 @@ SUBDIR_PYTHON_OBS = \
py-inferior.o \
py-infthread.o \
py-lazy-string.o \
+ py-linetable.o \
py-newobjfileevent.o \
py-objfile.o \
py-param.o \
@@ -334,6 +335,7 @@ SUBDIR_PYTHON_SRCS = \
python/py-inferior.c \
python/py-infthread.c \
python/py-lazy-string.c \
+ python/py-linetable.c \
python/py-newobjfileevent.c \
python/py-objfile.c \
python/py-param.c \
@@ -2219,6 +2221,10 @@ py-lazy-string.o: $(srcdir)/python/py-lazy-string.c
$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-lazy-string.c
$(POSTCOMPILE)
+py-linetable.o: $(srcdir)/python/py-linetable.c
+ $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-linetable.c
+ $(POSTCOMPILE)
+
py-newobjfileevent.o: $(srcdir)/python/py-newobjfileevent.c
$(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-newobjfileevent.c
$(POSTCOMPILE)
diff --git a/gdb/NEWS b/gdb/NEWS
index 10834df..c27b7fe 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -35,7 +35,8 @@
* Python scripting
** Frame filters and frame decorators have been added.
-
+ ** Linetable representation has been added.
+
* New targets
Nios II ELF nios2*-*-elf
diff --git a/gdb/python/py-linetable.c b/gdb/python/py-linetable.c
new file mode 100644
index 0000000..9cde481
--- /dev/null
+++ b/gdb/python/py-linetable.c
@@ -0,0 +1,621 @@
+/* Python interface to line tables.
+
+ Copyright (C) 2013 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 "python-internal.h"
+#include "exceptions.h"
+
+typedef struct {
+ PyObject_HEAD
+ /* The line table source line. */
+ gdb_py_longest line;
+ /* The pc associated with the source line. */
+ CORE_ADDR pc;
+} linetable_entry_object;
+
+static PyTypeObject linetable_entry_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("linetable_entry_object");
+
+typedef struct {
+ PyObject_HEAD
+ /* The symtab python object. We store the Python object here as the
+ underlying symtab can become invalid, and we have to run validity
+ checks on it. */
+ PyObject *symtab;
+} linetable_object;
+
+static PyTypeObject linetable_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("linetable_object");
+
+typedef struct {
+ PyObject_HEAD
+ /* The current entry in the line table for the iterator */
+ int current_index;
+ /* Pointer back to the original source line table object. Needed to
+ check if the line table is still valid, and has not been invalidated
+ when an object file has been freed. */
+ PyObject *source;
+} ltpy_iterator_object;
+
+static PyTypeObject ltpy_iterator_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("ltpy_iterator_object");
+
+/* Internal helper function to extract gdb.Symtab from a gdb.Linetable
+ object. */
+
+static PyObject *
+get_symtab (PyObject *linetable)
+{
+ linetable_object *lt = (linetable_object *) linetable;
+
+ return lt->symtab;
+}
+
+#define LTPY_REQUIRE_VALID(lt_obj, symtab) \
+ do { \
+ symtab = symtab_object_to_symtab (get_symtab (lt_obj)); \
+ if (symtab == NULL) \
+ { \
+ PyErr_SetString (PyExc_RuntimeError, \
+ _("Symbol Table in line table is invalid."));\
+ return NULL; \
+ } \
+ } while (0)
+
+
+/* Helper function to create a line table object that wraps a
+ gdb.Symtab object. */
+
+PyObject *
+symtab_to_linetable_object (PyObject *symtab)
+{
+ linetable_object *ltable;
+
+ ltable = PyObject_New (linetable_object, &linetable_object_type);
+ if (ltable != NULL)
+ {
+ ltable->symtab = symtab;
+ Py_INCREF (symtab);
+ }
+ return (PyObject *) ltable;
+}
+
+/* Internal helper function to build a line table object from a line
+ and an address. */
+
+static PyObject *
+build_linetable_entry (gdb_py_longest line, CORE_ADDR address)
+{
+ linetable_entry_object *obj;
+
+ obj = PyObject_New (linetable_entry_object,
+ &linetable_entry_object_type);
+ if (obj != NULL)
+ {
+ obj->line = line;
+ obj->pc = address;
+ }
+
+ return (PyObject *) obj;
+}
+
+/* Internal helper function to build a Python Tuple from a GDB Vector.
+ A line table entry can have multiple PCs for a given source line.
+ Construct a Tuple of all entries for the given source line, LINE
+ from the line table VEC. Construct one line table entry object per
+ address. */
+
+static PyObject *
+build_tuple_from_vector (gdb_py_longest line, VEC (CORE_ADDR) *vec)
+{
+ int vec_len = 0;
+ PyObject *tuple;
+ CORE_ADDR pc;
+ int i;
+
+ vec_len = VEC_length (CORE_ADDR, vec);
+ if (vec_len < 1)
+ Py_RETURN_NONE;
+
+ tuple = PyTuple_New (vec_len);
+
+ if (tuple == NULL)
+ return NULL;
+
+ for (i = 0; VEC_iterate (CORE_ADDR, vec, i, pc); ++i)
+ {
+ PyObject *obj = build_linetable_entry (line, pc);
+
+ if (obj == NULL)
+ {
+ Py_DECREF (tuple);
+ tuple = NULL;
+ break;
+ }
+ else if (PyTuple_SetItem (tuple, i, obj) != 0)
+ {
+ Py_DECREF (obj);
+ Py_DECREF (tuple);
+ tuple = NULL;
+ break;
+ }
+ }
+
+ return tuple;
+}
+
+/* Implementation of gdb.LineTable.line (self) -> Tuple. Returns a
+ tuple of LineTableEntry objects associated with this line from the
+ in the line table. */
+
+static PyObject *
+ltpy_get_pcs_for_line (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab;
+ gdb_py_longest py_line;
+ struct linetable_entry *best_entry = NULL;
+ linetable_entry_object *result;
+ VEC (CORE_ADDR) *pcs = NULL;
+ PyObject *tuple;
+ volatile struct gdb_exception except;
+
+ LTPY_REQUIRE_VALID (self, symtab);
+
+ if (! PyArg_ParseTuple (args, GDB_PY_LL_ARG, &py_line))
+ return NULL;
+
+ TRY_CATCH (except, RETURN_MASK_ALL)
+ {
+ pcs = find_pcs_for_symtab_line (symtab, py_line, &best_entry);
+ }
+ GDB_PY_HANDLE_EXCEPTION (except);
+
+ tuple = build_tuple_from_vector (py_line, pcs);
+ VEC_free (CORE_ADDR, pcs);
+
+ return tuple;
+}
+
+/* Implementation of gdb.LineTable.has_pcs (self, line) -> Boolean.
+ Returns a Python Boolean indicating whether a source line has any
+ line table entries corresponding to it. */
+
+static PyObject *
+ltpy_has_pcs (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab;
+ gdb_py_longest py_line;
+ int index;
+
+ LTPY_REQUIRE_VALID (self, symtab);
+
+ if (! PyArg_ParseTuple (args, GDB_PY_LL_ARG, &py_line))
+ return NULL;
+
+ if (LINETABLE (symtab) == NULL)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Linetable information not found in symbol table"));
+ return NULL;
+ }
+
+ for (index = 0; index <= LINETABLE (symtab)->nitems; index++)
+ {
+ struct linetable_entry *item = &(symtab->linetable->item[index]);
+ if (item->line == py_line)
+ Py_RETURN_TRUE;
+ }
+
+ Py_RETURN_FALSE;
+}
+
+/* Implementation of gdb.LineTable.source_lines (self) -> FrozenSet.
+ Returns a Python FrozenSet that contains source line entries in the
+ line table. This function will just return the source lines
+ without corresponding addresses. */
+
+static PyObject *
+ltpy_get_all_source_lines (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab;
+ Py_ssize_t index;
+ PyObject *source_list, *source_dict, *line;
+ struct linetable_entry *item;
+ Py_ssize_t list_size;
+
+ LTPY_REQUIRE_VALID (self, symtab);
+
+ if (LINETABLE (symtab) == NULL)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Linetable information not found in symbol table"));
+ return NULL;
+ }
+
+ source_dict = PyDict_New ();
+ if (source_dict == NULL)
+ return NULL;
+
+ for (index = 0; index <= LINETABLE (symtab)->nitems; index++)
+ {
+ item = &(LINETABLE (symtab)->item[index]);
+
+ /* 0 is used to signify end of line table information. Do not
+ include in the source set. */
+ if (item->line > 0)
+ {
+ line = PyLong_FromUnsignedLongLong (item->line);
+
+ if (line == NULL)
+ {
+ Py_DECREF (source_dict);
+ return NULL;
+ }
+
+ if (PyDict_SetItem (source_dict, line, Py_None) == -1)
+ {
+ Py_DECREF (line);
+ Py_DECREF (source_dict);
+ return NULL;
+ }
+
+ Py_DECREF (line);
+ }
+ }
+
+
+ source_list = PyDict_Keys (source_dict);
+ Py_DECREF (source_dict);
+
+ return source_list;
+}
+
+/* Implementation of gdb.Linetable.is_valid (self) -> Boolean.
+ Returns True if this line table object still exists in GDB. */
+
+static PyObject *
+ltpy_is_valid (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab = NULL;
+ linetable_object *obj = (linetable_object *) self;
+
+ symtab = symtab_object_to_symtab (get_symtab (self));
+
+ if (symtab == NULL)
+ Py_RETURN_FALSE;
+
+ Py_RETURN_TRUE;
+}
+
+/* Deconstructor for the line table object. Decrement the reference
+ to the symbol table object before calling the default free. */
+static void
+ltpy_dealloc (PyObject *self)
+{
+ linetable_object *obj = (linetable_object *) self;
+
+ Py_DECREF (obj->symtab);
+ Py_TYPE (self)->tp_free (self);
+}
+
+/* Initialize LineTable, LineTableEntry and LineTableIterator
+ objects. */
+int
+gdbpy_initialize_linetable (void)
+{
+ if (PyType_Ready (&linetable_object_type) < 0)
+ return -1;
+ if (PyType_Ready (&linetable_entry_object_type) < 0)
+ return -1;
+ if (PyType_Ready (<py_iterator_object_type) < 0)
+ return -1;
+
+ Py_INCREF (&linetable_object_type);
+ Py_INCREF (&linetable_entry_object_type);
+ Py_INCREF (<py_iterator_object_type);
+
+ if (gdb_pymodule_addobject (gdb_module, "LineTable",
+ (PyObject *) &linetable_object_type) < 0)
+ return -1;
+
+ if (gdb_pymodule_addobject (gdb_module, "LineTableEntry",
+ (PyObject *) &linetable_entry_object_type) < 0)
+ return -1;
+
+ if (gdb_pymodule_addobject (gdb_module, "LineTableIterator",
+ (PyObject *) <py_iterator_object_type) < 0)
+ return -1;
+
+ return 0;
+}
+
+/* Linetable entry object get functions. */
+
+/* Implementation of gdb.LineTableEntry.line (self) -> Unsigned Long.
+ Returns an unsigned long associated with the line table entry. */
+
+static PyObject *
+ltpy_entry_get_line (PyObject *self, void *closure)
+{
+ linetable_entry_object *obj = (linetable_entry_object *) self;
+
+ return PyLong_FromUnsignedLongLong (obj->line);
+}
+
+/* Implementation of gdb.LineTableEntry.pc (self) -> Unsigned Long.
+ Returns an unsigned long associated with the PC of the line table
+ entry. */
+
+static PyObject *
+ltpy_entry_get_pcs (PyObject *self, void *closure)
+{
+ linetable_entry_object *obj = (linetable_entry_object *) self;
+
+ return PyLong_FromUnsignedLongLong (obj->pc);
+}
+
+/* Linetable iterator functions. */
+
+/* Return a new line table iterator. */
+
+static PyObject *
+ltpy_iter (PyObject *self)
+{
+ ltpy_iterator_object *ltpy_iter_obj;
+ struct symtab *symtab = NULL;
+
+ LTPY_REQUIRE_VALID (self, symtab);
+
+ ltpy_iter_obj = PyObject_New (ltpy_iterator_object,
+ <py_iterator_object_type);
+ if (ltpy_iter_obj == NULL)
+ return NULL;
+
+ ltpy_iter_obj->current_index = 0;
+ ltpy_iter_obj->source = self;
+
+ Py_INCREF (self);
+ return (PyObject *) ltpy_iter_obj;
+}
+
+static void
+ltpy_iterator_dealloc (PyObject *obj)
+{
+ ltpy_iterator_object *iter_obj = (ltpy_iterator_object *) obj;
+
+ Py_DECREF (iter_obj->source);
+}
+
+/* Return a reference to the line table iterator. */
+
+static PyObject *
+ltpy_iterator (PyObject *self)
+{
+ ltpy_iterator_object *iter_obj = (ltpy_iterator_object *) self;
+ struct symtab *symtab;
+
+ LTPY_REQUIRE_VALID (iter_obj->source, symtab);
+
+ Py_INCREF (self);
+ return self;
+}
+
+/* Return the next line table entry in the iteration through the line
+ table data structure. */
+
+static PyObject *
+ltpy_iternext (PyObject *self)
+{
+ ltpy_iterator_object *iter_obj = (ltpy_iterator_object *) self;
+ struct symtab *symtab;
+ int index;
+ PyObject *obj;
+ struct linetable_entry *item;
+
+ LTPY_REQUIRE_VALID (iter_obj->source, symtab);
+
+ if (iter_obj->current_index >= LINETABLE (symtab)->nitems)
+ goto stop_iteration;
+
+ item = &(LINETABLE (symtab)->item[iter_obj->current_index]);
+
+ /* Skip over internal entries such as 0. 0 signifies the end of
+ line table data and is not useful to the API user. */
+ while (item->line < 1)
+ {
+ iter_obj->current_index++;
+
+ /* Exit if the internal value is the last item in the line table. */
+ if (iter_obj->current_index >= symtab->linetable->nitems)
+ goto stop_iteration;
+ item = &(symtab->linetable->item[iter_obj->current_index]);
+ }
+
+ obj = build_linetable_entry (item->line, item->pc);
+ iter_obj->current_index++;
+
+ return obj;
+
+ stop_iteration:
+ PyErr_SetNone (PyExc_StopIteration);
+ return NULL;
+}
+
+/* Implementation of gdb.LinetableIterator.is_valid (self) -> Boolean.
+ Returns True if this line table iterator object still exists in
+ GDB. */
+
+static PyObject *
+ltpy_iter_is_valid (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab = NULL;
+ ltpy_iterator_object *iter_obj = (ltpy_iterator_object *) self;
+
+ symtab = symtab_object_to_symtab (get_symtab (iter_obj->source));
+
+ if (symtab == NULL)
+ Py_RETURN_FALSE;
+
+ Py_RETURN_TRUE;
+}
+
+
+
+static PyMethodDef linetable_object_methods[] = {
+ { "line", ltpy_get_pcs_for_line, METH_VARARGS,
+ "line (lineno) -> Tuple\n\
+Return executable locations for a given source line." },
+ { "has_pcs", ltpy_has_pcs, METH_VARARGS,
+ "has_pcs (lineno) -> Boolean\n\
+Return TRUE if this line has executable information, FALSE if not." },
+ { "source_lines", ltpy_get_all_source_lines, METH_NOARGS,
+ "source_lines () -> FrozenSet\n\
+Return a frozen set of all executable source lines." },
+ { "is_valid", ltpy_is_valid, METH_NOARGS,
+ "is_valid () -> Boolean.\n\
+Return True if this Linetable is valid, False if not." },
+ {NULL} /* Sentinel */
+};
+
+static PyTypeObject linetable_object_type = {
+ PyVarObject_HEAD_INIT (NULL, 0)
+ "gdb.LineTable", /*tp_name*/
+ sizeof (linetable_object), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ ltpy_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, /*tp_flags*/
+ "GDB line table object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ ltpy_iter, /* tp_iter */
+ 0, /* tp_iternext */
+ linetable_object_methods, /* 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 */
+};
+
+static PyMethodDef ltpy_iterator_methods[] = {
+ { "is_valid", ltpy_iter_is_valid, METH_NOARGS,
+ "is_valid () -> Boolean.\n\
+Return True if this Linetable iterator is valid, False if not." },
+ {NULL} /* Sentinel */
+};
+
+static PyTypeObject ltpy_iterator_object_type = {
+ PyVarObject_HEAD_INIT (NULL, 0)
+ "gdb.LineTableIterator", /*tp_name*/
+ sizeof (ltpy_iterator_object), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ ltpy_iterator_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 line table iterator object", /*tp_doc */
+ 0, /*tp_traverse */
+ 0, /*tp_clear */
+ 0, /*tp_richcompare */
+ 0, /*tp_weaklistoffset */
+ ltpy_iterator, /*tp_iter */
+ ltpy_iternext, /*tp_iternext */
+ ltpy_iterator_methods /*tp_methods */
+};
+
+
+static PyGetSetDef linetable_entry_object_getset[] = {
+ { "line", ltpy_entry_get_line, NULL,
+ "The line number in the source file.", NULL },
+ { "pc", ltpy_entry_get_pcs, NULL,
+ "The memory address for this line number.", NULL },
+ { NULL } /* Sentinel */
+};
+
+static PyTypeObject linetable_entry_object_type = {
+ PyVarObject_HEAD_INIT (NULL, 0)
+ "gdb.LineTableEntry", /*tp_name*/
+ sizeof (linetable_entry_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, /*tp_flags*/
+ "GDB line table entry 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 */
+ linetable_entry_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 */
+};
diff --git a/gdb/python/py-symtab.c b/gdb/python/py-symtab.c
index 006946c..c4a3fea 100644
--- a/gdb/python/py-symtab.c
+++ b/gdb/python/py-symtab.c
@@ -186,6 +186,20 @@ stpy_static_block (PyObject *self, PyObject *args)
return block_to_block_object (block, symtab->objfile);
}
+/* Implementation of gdb.Symtab.linetable (self) -> gdb.Linetable.
+ Returns a gdb.Linetable object corresponding to this symbol
+ table. */
+
+static PyObject *
+stpy_get_linetable (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab = NULL;
+
+ STPY_REQUIRE_VALID (self, symtab);
+
+ return symtab_to_linetable_object (self);
+}
+
static PyObject *
salpy_str (PyObject *self)
{
@@ -532,6 +546,9 @@ Return the global block of the symbol table." },
{ "static_block", stpy_static_block, METH_NOARGS,
"static_block () -> gdb.Block.\n\
Return the static block of the symbol table." },
+ { "linetable", stpy_get_linetable, METH_NOARGS,
+ "linetable () -> gdb.Linetable.\n\
+Return the Linetable associated with this symbol table" },
{NULL} /* Sentinel */
};
diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h
index d947be6..7d8c4ad 100644
--- a/gdb/python/python-internal.h
+++ b/gdb/python/python-internal.h
@@ -311,7 +311,7 @@ PyObject *block_to_block_object (const struct block *block,
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 *symtab_to_linetable_object (PyObject *symtab);
PyObject *pspace_to_pspace_object (struct program_space *)
CPYCHECKER_RETURNS_BORROWED_REF;
PyObject *pspy_get_printers (PyObject *, void *);
@@ -371,6 +371,8 @@ int gdbpy_initialize_finishbreakpoints (void)
CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
int gdbpy_initialize_lazy_string (void)
CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_linetable (void)
+ CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
int gdbpy_initialize_parameters (void)
CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
int gdbpy_initialize_thread (void)
diff --git a/gdb/python/python.c b/gdb/python/python.c
index 542c2d1..7cdf8a7 100644
--- a/gdb/python/python.c
+++ b/gdb/python/python.c
@@ -1673,6 +1673,7 @@ message == an error message without a stack will be printed."),
|| gdbpy_initialize_breakpoints () < 0
|| gdbpy_initialize_finishbreakpoints () < 0
|| gdbpy_initialize_lazy_string () < 0
+ || gdbpy_initialize_linetable () < 0
|| gdbpy_initialize_thread () < 0
|| gdbpy_initialize_inferior () < 0
|| gdbpy_initialize_events () < 0
--
1.8.1.4