GDB 7.6.50

gdb/python/py-symtab.c

 /* Python interface to symbol tables.
 
-   Copyright (C) 2008-2012 Free Software Foundation, Inc.
+   Copyright (C) 2008-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
@@ skipping 16 matching lines @@
   /* The GDB Symbol table structure.  */
   struct symtab *symtab;
   /* A symtab object is associated with an objfile, so keep track with
      a doubly-linked list, rooted in the objfile.  This allows
      invalidation of the underlying struct symtab when the objfile is
      deleted.  */
   struct stpy_symtab_object *prev;
   struct stpy_symtab_object *next;
 } symtab_object;
 
-static PyTypeObject symtab_object_type;
+static 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
    should be gated by this call.  */
 #define STPY_REQUIRE_VALID(symtab_obj, symtab)           \
   do {                                                   \
     symtab = symtab_object_to_symtab (symtab_obj);       \
     if (symtab == NULL)                                  \
       {                                                  \
         PyErr_SetString (PyExc_RuntimeError,             \
                          _("Symbol Table is invalid.")); \
         return NULL;                                     \
       }                                                  \
   } while (0)
 
 typedef struct salpy_sal_object {
   PyObject_HEAD
   /* The GDB Symbol table structure.  */
   symtab_object *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
      track with a doubly-linked list, rooted in the objfile.  This
      allows invalidation of the underlying struct symtab_and_line
      when the objfile is deleted.  */
   struct salpy_sal_object *prev;
   struct salpy_sal_object *next;
 } sal_object;
 
-static PyTypeObject sal_object_type;
+static 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
    sal_object->sal should be gated by this call.  */
 #define SALPY_REQUIRE_VALID(sal_obj, sal)                               \
   do {                                                                  \
     sal = sal_object_to_symtab_and_line (sal_obj);                      \
     if (sal == NULL)                                                    \
       {                                                                 \
           PyErr_SetString (PyExc_RuntimeError,                          \
                            _("Symbol Table and Line is invalid."));     \
           return NULL;                                                  \
         }                                                               \
   } while (0)
 
 static PyObject *
 stpy_str (PyObject *self)
 {
   PyObject *result;
   struct symtab *symtab = NULL;
 
   STPY_REQUIRE_VALID (self, symtab);
 
-  result = PyString_FromString (symtab->filename);
+  result = PyString_FromString (symtab_to_filename_for_display (symtab));
 
   return result;
 }
 
 static PyObject *
 stpy_get_filename (PyObject *self, void *closure)
 {
   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),
+  str_obj = PyString_Decode (filename, strlen (filename),
                              host_charset (), NULL);
   return str_obj;
 }
 
 static PyObject *
 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;
 }
 
 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 PyString_Decode (fullname, strlen (fullname), host_charset (), NULL);
 }
 
 /* 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;
 
@@ skipping 29 matching lines @@
   struct block *block = NULL;
   struct blockvector *blockvector;
 
   STPY_REQUIRE_VALID (self, symtab);
 
   blockvector = BLOCKVECTOR (symtab);
   block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
   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)
 {
-  char *s, *filename;
+  char *s;
+  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;
 }
 
@@ skipping 88 matching lines @@
     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);
 
   if (self_sal->next)
     self_sal->next->prev = self_sal->prev;
 
   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
    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;
 
   if (sal.symtab)
     {
       symtab_obj = (symtab_object *) 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;
       Py_INCREF (Py_None);
     }
 
   sal_obj->sal = 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)
     {
       sal_obj->next = objfile_data (sal_obj->symtab->symtab->objfile,
                                     salpy_objfile_data_key);
       if (sal_obj->next)
         sal_obj->next->prev = sal_obj;
 
       set_objfile_data (sal_obj->symtab->symtab->objfile,
                         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 object file associated with this
    symtab, if needed.  */
 static void
 set_symtab (symtab_object *obj, struct symtab *symtab)
 {
@@ skipping 21 matching lines @@
   if (symtab_obj)
     set_symtab (symtab_obj, symtab);
 
   return (PyObject *) symtab_obj;
 }
 
 /* Create a new symtab and line (gdb.Symtab_and_line) object
    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)
     {
-      success = set_sal (sal_obj, sal);
-      if (!success)
+      if (set_sal (sal_obj, sal) < 0)
         {
           Py_DECREF (sal_obj);
           return NULL;
         }
     }
 
   return (PyObject *) sal_obj;
 }
 
 /* Return struct symtab_and_line reference that is wrapped by this
@@ skipping 43 matching lines @@
    invalid symbol table and line objects.  */
 static void
 del_objfile_sal (struct objfile *objfile, void *datum)
 {
   sal_object *obj = 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);
       obj->sal = NULL;
 
       obj = next;
     }
 }
 
-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
      structures when an object file that is about to be
      deleted.  */
   stpy_objfile_data_key
     = register_objfile_data_with_cleanup (NULL, del_objfile_symtab);