This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[patch][python] 1/3 Python representation of GDB line tables (Python code)


This patch series (three emails) introduces GDB line table representation
to Python.

This first email contains the GDB and Python code to represent the line
table data as Python objects.

What do you think?

Cheers,

Phil

2013-10-08  Phil Muldoon  <pmuldoon@redhat.com>

	* Makefile.in (SUBDIR_PYTHON_OBS): Add py-linetable entries.
	* python/py-linetable.c: New file.
	* python/py-symtab.c (stpy_get_linetable): New function.
	* python/python-internal.h (symtab_to_linetable_object): Declare.
	(gdbpy_initialize_linetable): Ditto.
	* python/python.c (_initialize_python): Call
	gdbpy_initialize_linetable.

---

diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 6b8927a..53ba8f9 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -296,6 +296,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 \
@@ -331,6 +332,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 \
@@ -2210,6 +2212,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/python/py-linetable.c b/gdb/python/py-linetable.c
new file mode 100644
index 0000000..c62c906
--- /dev/null
+++ b/gdb/python/py-linetable.c
@@ -0,0 +1,594 @@
+/* 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_line;
+  /* 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.  Extract from this the symtab
+     in a lazy fashion.  */
+  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;
+  volatile struct gdb_exception except;
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      vec_len = VEC_length (CORE_ADDR, vec);
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  if (vec_len < 1)
+    return Py_None;
+
+  tuple = PyTuple_New (vec_len);
+
+  if (tuple == NULL)
+    return NULL;
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+
+      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_XDECREF (tuple);
+	      tuple = NULL;
+	      break;
+	    }
+	}
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  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_LLU_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);
+
+  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_LLU_ARG, &py_line))
+    return NULL;
+
+  for (index = 0; index <= symtab->linetable->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, *line, *fset;
+  struct linetable_entry *item;
+
+  LTPY_REQUIRE_VALID (self, symtab);
+
+  source_list = PyList_New (0);
+
+  if (source_list == NULL)
+    return NULL;
+
+  for (index = 0; index <= symtab->linetable->nitems; index++)
+    {
+      item = &(symtab->linetable->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_list);
+	      return NULL;
+	    }
+
+	  if (PyList_Append (source_list, line) == -1)
+	    {
+	      Py_DECREF (line);
+	      Py_DECREF (source_list);
+	      return NULL;
+	    }
+
+	  Py_DECREF (line);
+	}
+    }
+
+  /* Return a frozen set to remove duplicated line numbers in the case
+     where a source line has more than one instruction and more than one
+     entry in the line table.  */
+  fset = PyFrozenSet_New (source_list);
+  Py_DECREF (source_list);
+
+  return fset;
+}
+
+static void
+ltpy_dealloc (PyObject *self)
+{
+  linetable_object *obj = (linetable_object *) self;
+
+  Py_DECREF (obj->symtab);
+  Py_TYPE (self)->tp_free (self);
+  return;
+}
+
+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 (&ltpy_iterator_object_type) < 0)
+    return -1;
+
+  Py_INCREF (&linetable_object_type);
+  Py_INCREF (&linetable_entry_object_type);
+  Py_INCREF (&ltpy_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 *) &ltpy_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,
+				&ltpy_iterator_object_type);
+  if (ltpy_iter_obj == NULL)
+      return NULL;
+
+  ltpy_iter_obj->current_line = 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_XDECREF (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_line >= symtab->linetable->nitems)
+    goto stop_iteration;
+
+  item = &(symtab->linetable->item[iter_obj->current_line]);
+
+  /* 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_line++;
+
+      /* Exit if the internal value is the last item in the line table.  */
+      if (iter_obj->current_line >= symtab->linetable->nitems)
+	goto stop_iteration;
+      item = &(symtab->linetable->item[iter_obj->current_line]);
+    }
+
+  obj = build_linetable_entry (item->line, item->pc);
+  iter_obj->current_line++;
+
+  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;
+
+  LTPY_REQUIRE_VALID (iter_obj->source, symtab);
+
+  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." },
+  {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..1920b59 100644
--- a/gdb/python/py-symtab.c
+++ b/gdb/python/py-symtab.c
@@ -187,6 +187,16 @@ stpy_static_block (PyObject *self, PyObject *args)
 }
 
 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)
 {
   char *s;
@@ -532,6 +542,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 00092c7..55fbdcb 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


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]