/* Python interface to symbol tables.
- Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2008-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "source.h"
#include "python-internal.h"
#include "objfiles.h"
+#include "block.h"
+#include "py-ref.h"
typedef struct stpy_symtab_object {
PyObject_HEAD
struct stpy_symtab_object *next;
} symtab_object;
-static PyTypeObject symtab_object_type;
+extern PyTypeObject symtab_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symtab_object");
static const struct objfile_data *stpy_objfile_data_key;
/* Require a valid symbol table. All access to symtab_object->symtab
struct salpy_sal_object *next;
} sal_object;
-static PyTypeObject sal_object_type;
+extern PyTypeObject sal_object_type
+ CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("sal_object");
static const struct objfile_data *salpy_objfile_data_key;
/* Require a valid symbol table and line object. All access to
STPY_REQUIRE_VALID (self, symtab);
- result = PyString_FromString (symtab->filename);
+ result = PyString_FromString (symtab_to_filename_for_display (symtab));
return result;
}
{
PyObject *str_obj;
struct symtab *symtab = NULL;
+ const char *filename;
STPY_REQUIRE_VALID (self, symtab);
+ filename = symtab_to_filename_for_display (symtab);
- str_obj = PyString_Decode (symtab->filename,
- strlen (symtab->filename),
- host_charset (), NULL);
+ str_obj = host_string_to_python_string (filename).release ();
return str_obj;
}
stpy_get_objfile (PyObject *self, void *closure)
{
struct symtab *symtab = NULL;
- PyObject *result;
STPY_REQUIRE_VALID (self, symtab);
- result = objfile_to_objfile_object (symtab->objfile);
- Py_XINCREF (result);
- return result;
+ return objfile_to_objfile_object (SYMTAB_OBJFILE (symtab)).release ();
+}
+
+/* Getter function for symtab.producer. */
+
+static PyObject *
+stpy_get_producer (PyObject *self, void *closure)
+{
+ struct symtab *symtab = NULL;
+ struct compunit_symtab *cust;
+
+ STPY_REQUIRE_VALID (self, symtab);
+ cust = SYMTAB_COMPUNIT (symtab);
+ if (COMPUNIT_PRODUCER (cust) != NULL)
+ {
+ const char *producer = COMPUNIT_PRODUCER (cust);
+
+ return host_string_to_python_string (producer).release ();
+ }
+
+ Py_RETURN_NONE;
}
static PyObject *
stpy_fullname (PyObject *self, PyObject *args)
{
- char *fullname;
+ const char *fullname;
struct symtab *symtab = NULL;
STPY_REQUIRE_VALID (self, symtab);
fullname = symtab_to_fullname (symtab);
- if (fullname)
- return PyString_Decode (fullname, strlen (fullname),
- host_charset (), NULL);
- Py_RETURN_NONE;
+ return host_string_to_python_string (fullname).release ();
+}
+
+/* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
+ Returns True if this Symbol table still exists in GDB. */
+
+static PyObject *
+stpy_is_valid (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab = NULL;
+
+ symtab = symtab_object_to_symtab (self);
+ if (symtab == NULL)
+ Py_RETURN_FALSE;
+
+ Py_RETURN_TRUE;
+}
+
+/* Return the GLOBAL_BLOCK of the underlying symtab. */
+
+static PyObject *
+stpy_global_block (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab = NULL;
+ struct block *block = NULL;
+ const struct blockvector *blockvector;
+
+ STPY_REQUIRE_VALID (self, symtab);
+
+ blockvector = SYMTAB_BLOCKVECTOR (symtab);
+ block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
+ return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
+}
+
+/* Return the STATIC_BLOCK of the underlying symtab. */
+
+static PyObject *
+stpy_static_block (PyObject *self, PyObject *args)
+{
+ struct symtab *symtab = NULL;
+ struct block *block = NULL;
+ const struct blockvector *blockvector;
+
+ STPY_REQUIRE_VALID (self, symtab);
+
+ blockvector = SYMTAB_BLOCKVECTOR (symtab);
+ block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
+ return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
+}
+
+/* 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)
{
- char *s, *filename;
+ const char *filename;
sal_object *sal_obj;
- PyObject *result;
struct symtab_and_line *sal = NULL;
SALPY_REQUIRE_VALID (self, sal);
sal_obj = (sal_object *) self;
filename = (sal_obj->symtab == (symtab_object *) Py_None)
- ? "<unknown>" : sal_obj->symtab->symtab->filename;
+ ? "<unknown>" : symtab_to_filename_for_display (sal_obj->symtab->symtab);
- s = xstrprintf ("symbol and line for %s, line %d", filename,
- sal->line);
-
- result = PyString_FromString (s);
- xfree (s);
-
- return result;
+ return PyString_FromFormat ("symbol and line for %s, line %d", filename,
+ sal->line);
}
static void
symtab->prev->next = symtab->next;
else if (symtab->symtab)
{
- set_objfile_data (symtab->symtab->objfile,
+ set_objfile_data (SYMTAB_OBJFILE (symtab->symtab),
stpy_objfile_data_key, symtab->next);
}
if (symtab->next)
SALPY_REQUIRE_VALID (self, sal);
- return PyLong_FromUnsignedLongLong (sal->pc);
+ return gdb_py_long_from_ulongest (sal->pc);
+}
+
+/* Implementation of the get method for the 'last' attribute of
+ gdb.Symtab_and_line. */
+
+static PyObject *
+salpy_get_last (PyObject *self, void *closure)
+{
+ struct symtab_and_line *sal = NULL;
+
+ SALPY_REQUIRE_VALID (self, sal);
+
+ if (sal->end > 0)
+ return gdb_py_long_from_ulongest (sal->end - 1);
+ else
+ Py_RETURN_NONE;
}
static PyObject *
SALPY_REQUIRE_VALID (self, sal);
- return PyLong_FromUnsignedLongLong (sal->line);
+ return PyInt_FromLong (sal->line);
}
static PyObject *
return (PyObject *) self_sal->symtab;
}
+/* Implementation of gdb.Symtab_and_line.is_valid (self) -> Boolean.
+ Returns True if this Symbol table and line object still exists GDB. */
+
+static PyObject *
+salpy_is_valid (PyObject *self, PyObject *args)
+{
+ struct symtab_and_line *sal;
+
+ sal = sal_object_to_symtab_and_line (self);
+ if (sal == NULL)
+ Py_RETURN_FALSE;
+
+ Py_RETURN_TRUE;
+}
+
static void
salpy_dealloc (PyObject *self)
{
if (self_sal->prev)
self_sal->prev->next = self_sal->next;
else if (self_sal->symtab != (symtab_object * ) Py_None)
- set_objfile_data (self_sal->symtab->symtab->objfile,
+ set_objfile_data (SYMTAB_OBJFILE (self_sal->symtab->symtab),
salpy_objfile_data_key, self_sal->next);
if (self_sal->next)
Py_DECREF (self_sal->symtab);
xfree (self_sal->sal);
- self_sal->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
-/* Given a sal, and a sal_object that has previously been
- allocated and initialized, populate the sal_object with the
- struct sal data. Also, register the sal_object life-cycle with the
- life-cycle of the the object file associated with this sal, if
- needed. If a failure occurs during the sal population, this
- function will return NULL. */
-static int
+/* Given a sal, and a sal_object that has previously been allocated
+ and initialized, populate the sal_object with the struct sal data.
+ Also, register the sal_object life-cycle with the life-cycle of the
+ object file associated with this sal, if needed. If a failure
+ occurs during the sal population, this function will return -1. */
+static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
set_sal (sal_object *sal_obj, struct symtab_and_line sal)
{
symtab_object *symtab_obj;
/* If a symtab existed in the sal, but it cannot be duplicated,
we exit. */
if (symtab_obj == NULL)
- return 0;
+ return -1;
}
else
{
Py_INCREF (Py_None);
}
- sal_obj->sal = xmemdup (&sal, sizeof (struct symtab_and_line),
- sizeof (struct symtab_and_line));
+ sal_obj->sal = ((struct symtab_and_line *)
+ xmemdup (&sal, sizeof (struct symtab_and_line),
+ sizeof (struct symtab_and_line)));
sal_obj->symtab = symtab_obj;
sal_obj->prev = NULL;
objfile cleanup observer linked list. */
if (sal_obj->symtab != (symtab_object *)Py_None)
{
- sal_obj->next = objfile_data (sal_obj->symtab->symtab->objfile,
- salpy_objfile_data_key);
+ sal_obj->next
+ = ((struct salpy_sal_object *)
+ objfile_data (SYMTAB_OBJFILE (sal_obj->symtab->symtab),
+ salpy_objfile_data_key));
if (sal_obj->next)
sal_obj->next->prev = sal_obj;
- set_objfile_data (sal_obj->symtab->symtab->objfile,
+ set_objfile_data (SYMTAB_OBJFILE (sal_obj->symtab->symtab),
salpy_objfile_data_key, sal_obj);
}
else
sal_obj->next = NULL;
- return 1;
+ return 0;
}
/* Given a symtab, and a symtab_object that has previously been
allocated and initialized, populate the symtab_object with the
struct symtab data. Also, register the symtab_object life-cycle
- with the life-cycle of the the object file associated with this
+ with the life-cycle of the object file associated with this
symtab, if needed. */
static void
set_symtab (symtab_object *obj, struct symtab *symtab)
obj->prev = NULL;
if (symtab)
{
- obj->next = objfile_data (symtab->objfile, stpy_objfile_data_key);
+ obj->next
+ = ((struct stpy_symtab_object *)
+ objfile_data (SYMTAB_OBJFILE (symtab), stpy_objfile_data_key));
if (obj->next)
obj->next->prev = obj;
- set_objfile_data (symtab->objfile, stpy_objfile_data_key, obj);
+ set_objfile_data (SYMTAB_OBJFILE (symtab), stpy_objfile_data_key, obj);
}
else
obj->next = NULL;
that encapsulates the symtab_and_line structure from GDB. */
PyObject *
symtab_and_line_to_sal_object (struct symtab_and_line sal)
-
{
- sal_object *sal_obj;
- int success = 0;
-
- sal_obj = PyObject_New (sal_object, &sal_object_type);
- if (sal_obj)
+ gdbpy_ref<sal_object> sal_obj (PyObject_New (sal_object, &sal_object_type));
+ if (sal_obj != NULL)
{
- success = set_sal (sal_obj, sal);
- if (!success)
- {
- Py_DECREF (sal_obj);
- return NULL;
- }
+ if (set_sal (sal_obj.get (), sal) < 0)
+ return NULL;
}
- return (PyObject *) sal_obj;
+ return (PyObject *) sal_obj.release ();
}
/* Return struct symtab_and_line reference that is wrapped by this
static void
del_objfile_symtab (struct objfile *objfile, void *datum)
{
- symtab_object *obj = datum;
+ symtab_object *obj = (symtab_object *) datum;
while (obj)
{
static void
del_objfile_sal (struct objfile *objfile, void *datum)
{
- sal_object *obj = datum;
+ sal_object *obj = (sal_object *) datum;
while (obj)
{
sal_object *next = obj->next;
- obj->symtab = NULL;
+ Py_DECREF (obj->symtab);
+ obj->symtab = (symtab_object *) Py_None;
+ Py_INCREF (Py_None);
+
obj->next = NULL;
obj->prev = NULL;
xfree (obj->sal);
}
}
-void
+int
gdbpy_initialize_symtabs (void)
{
symtab_object_type.tp_new = PyType_GenericNew;
if (PyType_Ready (&symtab_object_type) < 0)
- return;
+ return -1;
sal_object_type.tp_new = PyType_GenericNew;
if (PyType_Ready (&sal_object_type) < 0)
- return;
+ return -1;
/* Register an objfile "free" callback so we can properly
invalidate symbol tables, and symbol table and line data
salpy_objfile_data_key
= register_objfile_data_with_cleanup (NULL, del_objfile_sal);
- Py_INCREF (&symtab_object_type);
- PyModule_AddObject (gdb_module, "Symtab",
- (PyObject *) &symtab_object_type);
+ if (gdb_pymodule_addobject (gdb_module, "Symtab",
+ (PyObject *) &symtab_object_type) < 0)
+ return -1;
- Py_INCREF (&sal_object_type);
- PyModule_AddObject (gdb_module, "Symtab_and_line",
- (PyObject *) &sal_object_type);
+ return gdb_pymodule_addobject (gdb_module, "Symtab_and_line",
+ (PyObject *) &sal_object_type);
}
\f
-static PyGetSetDef symtab_object_getset[] = {
+static gdb_PyGetSetDef symtab_object_getset[] = {
{ "filename", stpy_get_filename, NULL,
"The symbol table's source filename.", NULL },
{ "objfile", stpy_get_objfile, NULL, "The symtab's objfile.",
NULL },
+ { "producer", stpy_get_producer, NULL,
+ "The name/version of the program that compiled this symtab.", NULL },
{NULL} /* Sentinel */
};
static PyMethodDef symtab_object_methods[] = {
+ { "is_valid", stpy_is_valid, METH_NOARGS,
+ "is_valid () -> Boolean.\n\
+Return true if this symbol table is valid, false if not." },
{ "fullname", stpy_fullname, METH_NOARGS,
"fullname () -> String.\n\
Return the symtab's full source filename." },
+ { "global_block", stpy_global_block, METH_NOARGS,
+ "global_block () -> gdb.Block.\n\
+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 */
};
-static PyTypeObject symtab_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+PyTypeObject symtab_object_type = {
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Symtab", /*tp_name*/
sizeof (symtab_object), /*tp_basicsize*/
0, /*tp_itemsize*/
symtab_object_getset /*tp_getset */
};
-static PyGetSetDef sal_object_getset[] = {
+static gdb_PyGetSetDef sal_object_getset[] = {
{ "symtab", salpy_get_symtab, NULL, "Symtab object.", NULL },
{ "pc", salpy_get_pc, NULL, "Return the symtab_and_line's pc.", NULL },
+ { "last", salpy_get_last, NULL,
+ "Return the symtab_and_line's last address.", NULL },
{ "line", salpy_get_line, NULL,
"Return the symtab_and_line's line.", NULL },
{NULL} /* Sentinel */
};
-static PyTypeObject sal_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+static PyMethodDef sal_object_methods[] = {
+ { "is_valid", salpy_is_valid, METH_NOARGS,
+ "is_valid () -> Boolean.\n\
+Return true if this symbol table and line is valid, false if not." },
+ {NULL} /* Sentinel */
+};
+
+PyTypeObject sal_object_type = {
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Symtab_and_line", /*tp_name*/
sizeof (sal_object), /*tp_basicsize*/
0, /*tp_itemsize*/
0, /*tp_weaklistoffset */
0, /*tp_iter */
0, /*tp_iternext */
- 0, /*tp_methods */
+ sal_object_methods, /*tp_methods */
0, /*tp_members */
sal_object_getset /*tp_getset */
};
projects / deliverable / binutils-gdb.git / blobdiff