/* Python interface to symbol tables.
- Copyright (C) 2008-2012 Free Software Foundation, Inc.
+ Copyright (C) 2008-2020 Free Software Foundation, Inc.
This file is part of GDB.
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
typedef struct salpy_sal_object {
PyObject_HEAD
/* The GDB Symbol table structure. */
- symtab_object *symtab;
+ PyObject *symtab;
/* The GDB Symbol table and line structure. */
struct symtab_and_line *sal;
/* A Symtab and line object is associated with an objfile, so keep
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 *
fullname = symtab_to_fullname (symtab);
- return PyString_Decode (fullname, strlen (fullname), host_charset (), NULL);
+ return host_string_to_python_string (fullname).release ();
}
/* Implementation of gdb.Symtab.is_valid (self) -> Boolean.
stpy_global_block (PyObject *self, PyObject *args)
{
struct symtab *symtab = NULL;
- struct block *block = NULL;
- struct blockvector *blockvector;
+ const struct block *block = NULL;
+ const struct blockvector *blockvector;
STPY_REQUIRE_VALID (self, symtab);
- blockvector = BLOCKVECTOR (symtab);
+ blockvector = SYMTAB_BLOCKVECTOR (symtab);
block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
- return block_to_block_object (block, symtab->objfile);
+ return block_to_block_object (block, SYMTAB_OBJFILE (symtab));
}
/* Return the STATIC_BLOCK of the underlying symtab. */
stpy_static_block (PyObject *self, PyObject *args)
{
struct symtab *symtab = NULL;
- struct block *block = NULL;
- struct blockvector *blockvector;
+ const struct block *block = NULL;
+ const struct blockvector *blockvector;
STPY_REQUIRE_VALID (self, symtab);
- blockvector = BLOCKVECTOR (symtab);
+ blockvector = SYMTAB_BLOCKVECTOR (symtab);
block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
- return block_to_block_object (block, symtab->objfile);
+ 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;
-
- s = xstrprintf ("symbol and line for %s, line %d", filename,
- sal->line);
-
- result = PyString_FromString (s);
- xfree (s);
+ if (sal_obj->symtab == Py_None)
+ filename = "<unknown>";
+ else
+ {
+ symtab *symtab = symtab_object_to_symtab (sal_obj->symtab);
+ filename = symtab_to_filename_for_display (symtab);
+ }
- 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)
symtab->next->prev = symtab->prev;
symtab->symtab = NULL;
+ Py_TYPE (obj)->tp_free (obj);
}
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,
- salpy_objfile_data_key, self_sal->next);
+ else if (self_sal->symtab != Py_None)
+ set_objfile_data
+ (SYMTAB_OBJFILE (symtab_object_to_symtab (self_sal->symtab)),
+ salpy_objfile_data_key, self_sal->next);
if (self_sal->next)
self_sal->next->prev = self_sal->prev;
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
- NULL. */
-static int
+ 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;
+ PyObject *symtab_obj;
if (sal.symtab)
{
- symtab_obj = (symtab_object *) symtab_to_symtab_object (sal.symtab);
+ symtab_obj = symtab_to_symtab_object (sal.symtab);
/* If a symtab existed in the sal, but it cannot be duplicated,
we exit. */
if (symtab_obj == NULL)
- return 0;
+ return -1;
}
else
{
- symtab_obj = (symtab_object *) Py_None;
+ symtab_obj = Py_None;
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;
/* If the SAL does not have a symtab, we do not add it to the
objfile cleanup observer linked list. */
- if (sal_obj->symtab != (symtab_object *)Py_None)
+ if (sal_obj->symtab != Py_None)
{
- sal_obj->next = objfile_data (sal_obj->symtab->symtab->objfile,
- salpy_objfile_data_key);
+ symtab *symtab = symtab_object_to_symtab (sal_obj->symtab);
+
+ sal_obj->next
+ = ((struct salpy_sal_object *) objfile_data (SYMTAB_OBJFILE (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 (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
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;
- Py_DECREF (obj->symtab);
- obj->symtab = (symtab_object *) Py_None;
+ gdbpy_ref<> tmp (obj->symtab);
+ obj->symtab = Py_None;
Py_INCREF (Py_None);
obj->next = NULL;
}
}
-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_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 = {
+PyTypeObject symtab_object_type = {
PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Symtab", /*tp_name*/
sizeof (symtab_object), /*tp_basicsize*/
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,
{NULL} /* Sentinel */
};
-static PyTypeObject sal_object_type = {
+PyTypeObject sal_object_type = {
PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Symtab_and_line", /*tp_name*/
sizeof (sal_object), /*tp_basicsize*/
projects / deliverable / binutils-gdb.git / blobdiff