gdb/python/py-objfile.c

   1 /* Python interface to objfiles.
   2
   3    Copyright (C) 2008-2018 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "python-internal.h"
  22 #include "charset.h"
  23 #include "objfiles.h"
  24 #include "language.h"
  25 #include "build-id.h"
  26 #include "symtab.h"
  27 #include "py-ref.h"
  28
  29 typedef struct
  30 {
  31   PyObject_HEAD
  32
  33   /* The corresponding objfile.  */
  34   struct objfile *objfile;
  35
  36   /* Dictionary holding user-added attributes.
  37      This is the __dict__ attribute of the object.  */
  38   PyObject *dict;
  39
  40   /* The pretty-printer list of functions.  */
  41   PyObject *printers;
  42
  43   /* The frame filter list of functions.  */
  44   PyObject *frame_filters;
  45
  46   /* The list of frame unwinders.  */
  47   PyObject *frame_unwinders;
  48
  49   /* The type-printer list.  */
  50   PyObject *type_printers;
  51
  52   /* The debug method matcher list.  */
  53   PyObject *xmethods;
  54 } objfile_object;
  55
  56 extern PyTypeObject objfile_object_type
  57     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("objfile_object");
  58
  59 static const struct objfile_data *objfpy_objfile_data_key;
  60
  61 /* Require that OBJF be a valid objfile.  */
  62 #define OBJFPY_REQUIRE_VALID(obj)                               \
  63   do {                                                          \
  64     if (!(obj)->objfile)                                        \
  65       {                                                         \
  66         PyErr_SetString (PyExc_RuntimeError,                    \
  67                          _("Objfile no longer exists."));       \
  68         return NULL;                                            \
  69       }                                                         \
  70   } while (0)
  71
  72 \f
  73
  74 /* An Objfile method which returns the objfile's file name, or None.  */
  75
  76 static PyObject *
  77 objfpy_get_filename (PyObject *self, void *closure)
  78 {
  79   objfile_object *obj = (objfile_object *) self;
  80
  81   if (obj->objfile)
  82     return host_string_to_python_string (objfile_name (obj->objfile));
  83   Py_RETURN_NONE;
  84 }
  85
  86 /* An Objfile method which returns the objfile's file name, as specified
  87    by the user, or None.  */
  88
  89 static PyObject *
  90 objfpy_get_username (PyObject *self, void *closure)
  91 {
  92   objfile_object *obj = (objfile_object *) self;
  93
  94   if (obj->objfile)
  95     {
  96       const char *username = obj->objfile->original_name;
  97
  98       return host_string_to_python_string (username);
  99     }
 100
 101   Py_RETURN_NONE;
 102 }
 103
 104 /* If SELF is a separate debug-info file, return the "backlink" field.
 105    Otherwise return None.  */
 106
 107 static PyObject *
 108 objfpy_get_owner (PyObject *self, void *closure)
 109 {
 110   objfile_object *obj = (objfile_object *) self;
 111   struct objfile *objfile = obj->objfile;
 112   struct objfile *owner;
 113
 114   OBJFPY_REQUIRE_VALID (obj);
 115
 116   owner = objfile->separate_debug_objfile_backlink;
 117   if (owner != NULL)
 118     {
 119       PyObject *result = objfile_to_objfile_object (owner);
 120
 121       Py_XINCREF (result);
 122       return result;
 123     }
 124   Py_RETURN_NONE;
 125 }
 126
 127 /* An Objfile method which returns the objfile's build id, or None.  */
 128
 129 static PyObject *
 130 objfpy_get_build_id (PyObject *self, void *closure)
 131 {
 132   objfile_object *obj = (objfile_object *) self;
 133   struct objfile *objfile = obj->objfile;
 134   const struct bfd_build_id *build_id = NULL;
 135
 136   OBJFPY_REQUIRE_VALID (obj);
 137
 138   TRY
 139     {
 140       build_id = build_id_bfd_get (objfile->obfd);
 141     }
 142   CATCH (except, RETURN_MASK_ALL)
 143     {
 144       GDB_PY_HANDLE_EXCEPTION (except);
 145     }
 146   END_CATCH
 147
 148   if (build_id != NULL)
 149     {
 150       char *hex_form = make_hex_string (build_id->data, build_id->size);
 151       PyObject *result;
 152
 153       result = host_string_to_python_string (hex_form);
 154       xfree (hex_form);
 155       return result;
 156     }
 157
 158   Py_RETURN_NONE;
 159 }
 160
 161 /* An Objfile method which returns the objfile's progspace, or None.  */
 162
 163 static PyObject *
 164 objfpy_get_progspace (PyObject *self, void *closure)
 165 {
 166   objfile_object *obj = (objfile_object *) self;
 167
 168   if (obj->objfile)
 169     {
 170       PyObject *pspace =  pspace_to_pspace_object (obj->objfile->pspace);
 171
 172       Py_XINCREF (pspace);
 173       return pspace;
 174     }
 175
 176   Py_RETURN_NONE;
 177 }
 178
 179 static void
 180 objfpy_dealloc (PyObject *o)
 181 {
 182   objfile_object *self = (objfile_object *) o;
 183
 184   Py_XDECREF (self->dict);
 185   Py_XDECREF (self->printers);
 186   Py_XDECREF (self->frame_filters);
 187   Py_XDECREF (self->frame_unwinders);
 188   Py_XDECREF (self->type_printers);
 189   Py_XDECREF (self->xmethods);
 190   Py_TYPE (self)->tp_free (self);
 191 }
 192
 193 /* Initialize an objfile_object.
 194    The result is a boolean indicating success.  */
 195
 196 static int
 197 objfpy_initialize (objfile_object *self)
 198 {
 199   self->objfile = NULL;
 200
 201   self->dict = PyDict_New ();
 202   if (self->dict == NULL)
 203     return 0;
 204
 205   self->printers = PyList_New (0);
 206   if (self->printers == NULL)
 207     return 0;
 208
 209   self->frame_filters = PyDict_New ();
 210   if (self->frame_filters == NULL)
 211     return 0;
 212
 213   self->frame_unwinders = PyList_New (0);
 214   if (self->frame_unwinders == NULL)
 215     return 0;
 216
 217   self->type_printers = PyList_New (0);
 218   if (self->type_printers == NULL)
 219     return 0;
 220
 221   self->xmethods = PyList_New (0);
 222   if (self->xmethods == NULL)
 223     return 0;
 224
 225   return 1;
 226 }
 227
 228 static PyObject *
 229 objfpy_new (PyTypeObject *type, PyObject *args, PyObject *keywords)
 230 {
 231   gdbpy_ref<objfile_object> self ((objfile_object *) type->tp_alloc (type, 0));
 232
 233   if (self != NULL)
 234     {
 235       if (!objfpy_initialize (self.get ()))
 236         return NULL;
 237     }
 238
 239   return (PyObject *) self.release ();
 240 }
 241
 242 PyObject *
 243 objfpy_get_printers (PyObject *o, void *ignore)
 244 {
 245   objfile_object *self = (objfile_object *) o;
 246
 247   Py_INCREF (self->printers);
 248   return self->printers;
 249 }
 250
 251 static int
 252 objfpy_set_printers (PyObject *o, PyObject *value, void *ignore)
 253 {
 254   PyObject *tmp;
 255   objfile_object *self = (objfile_object *) o;
 256
 257   if (! value)
 258     {
 259       PyErr_SetString (PyExc_TypeError,
 260                        _("Cannot delete the pretty_printers attribute."));
 261       return -1;
 262     }
 263
 264   if (! PyList_Check (value))
 265     {
 266       PyErr_SetString (PyExc_TypeError,
 267                        _("The pretty_printers attribute must be a list."));
 268       return -1;
 269     }
 270
 271   /* Take care in case the LHS and RHS are related somehow.  */
 272   tmp = self->printers;
 273   Py_INCREF (value);
 274   self->printers = value;
 275   Py_XDECREF (tmp);
 276
 277   return 0;
 278 }
 279
 280 /* Return the Python dictionary attribute containing frame filters for
 281    this object file.  */
 282 PyObject *
 283 objfpy_get_frame_filters (PyObject *o, void *ignore)
 284 {
 285   objfile_object *self = (objfile_object *) o;
 286
 287   Py_INCREF (self->frame_filters);
 288   return self->frame_filters;
 289 }
 290
 291 /* Set this object file's frame filters dictionary to FILTERS.  */
 292 static int
 293 objfpy_set_frame_filters (PyObject *o, PyObject *filters, void *ignore)
 294 {
 295   PyObject *tmp;
 296   objfile_object *self = (objfile_object *) o;
 297
 298   if (! filters)
 299     {
 300       PyErr_SetString (PyExc_TypeError,
 301                        _("Cannot delete the frame filters attribute."));
 302       return -1;
 303     }
 304
 305   if (! PyDict_Check (filters))
 306     {
 307       PyErr_SetString (PyExc_TypeError,
 308                        _("The frame_filters attribute must be a dictionary."));
 309       return -1;
 310     }
 311
 312   /* Take care in case the LHS and RHS are related somehow.  */
 313   tmp = self->frame_filters;
 314   Py_INCREF (filters);
 315   self->frame_filters = filters;
 316   Py_XDECREF (tmp);
 317
 318   return 0;
 319 }
 320
 321 /* Return the frame unwinders attribute for this object file.  */
 322
 323 PyObject *
 324 objfpy_get_frame_unwinders (PyObject *o, void *ignore)
 325 {
 326   objfile_object *self = (objfile_object *) o;
 327
 328   Py_INCREF (self->frame_unwinders);
 329   return self->frame_unwinders;
 330 }
 331
 332 /* Set this object file's frame unwinders list to UNWINDERS.  */
 333
 334 static int
 335 objfpy_set_frame_unwinders (PyObject *o, PyObject *unwinders, void *ignore)
 336 {
 337   PyObject *tmp;
 338   objfile_object *self = (objfile_object *) o;
 339
 340   if (!unwinders)
 341     {
 342       PyErr_SetString (PyExc_TypeError,
 343                        _("Cannot delete the frame unwinders attribute."));
 344       return -1;
 345     }
 346
 347   if (!PyList_Check (unwinders))
 348     {
 349       PyErr_SetString (PyExc_TypeError,
 350                        _("The frame_unwinders attribute must be a list."));
 351       return -1;
 352     }
 353
 354   /* Take care in case the LHS and RHS are related somehow.  */
 355   tmp = self->frame_unwinders;
 356   Py_INCREF (unwinders);
 357   self->frame_unwinders = unwinders;
 358   Py_XDECREF (tmp);
 359
 360   return 0;
 361 }
 362
 363 /* Get the 'type_printers' attribute.  */
 364
 365 static PyObject *
 366 objfpy_get_type_printers (PyObject *o, void *ignore)
 367 {
 368   objfile_object *self = (objfile_object *) o;
 369
 370   Py_INCREF (self->type_printers);
 371   return self->type_printers;
 372 }
 373
 374 /* Get the 'xmethods' attribute.  */
 375
 376 PyObject *
 377 objfpy_get_xmethods (PyObject *o, void *ignore)
 378 {
 379   objfile_object *self = (objfile_object *) o;
 380
 381   Py_INCREF (self->xmethods);
 382   return self->xmethods;
 383 }
 384
 385 /* Set the 'type_printers' attribute.  */
 386
 387 static int
 388 objfpy_set_type_printers (PyObject *o, PyObject *value, void *ignore)
 389 {
 390   PyObject *tmp;
 391   objfile_object *self = (objfile_object *) o;
 392
 393   if (! value)
 394     {
 395       PyErr_SetString (PyExc_TypeError,
 396                        _("Cannot delete the type_printers attribute."));
 397       return -1;
 398     }
 399
 400   if (! PyList_Check (value))
 401     {
 402       PyErr_SetString (PyExc_TypeError,
 403                        _("The type_printers attribute must be a list."));
 404       return -1;
 405     }
 406
 407   /* Take care in case the LHS and RHS are related somehow.  */
 408   tmp = self->type_printers;
 409   Py_INCREF (value);
 410   self->type_printers = value;
 411   Py_XDECREF (tmp);
 412
 413   return 0;
 414 }
 415
 416 /* Implementation of gdb.Objfile.is_valid (self) -> Boolean.
 417    Returns True if this object file still exists in GDB.  */
 418
 419 static PyObject *
 420 objfpy_is_valid (PyObject *self, PyObject *args)
 421 {
 422   objfile_object *obj = (objfile_object *) self;
 423
 424   if (! obj->objfile)
 425     Py_RETURN_FALSE;
 426
 427   Py_RETURN_TRUE;
 428 }
 429
 430 /* Implementation of gdb.Objfile.add_separate_debug_file (self) -> Boolean.  */
 431
 432 static PyObject *
 433 objfpy_add_separate_debug_file (PyObject *self, PyObject *args, PyObject *kw)
 434 {
 435   static const char *keywords[] = { "file_name", NULL };
 436   objfile_object *obj = (objfile_object *) self;
 437   const char *file_name;
 438
 439   OBJFPY_REQUIRE_VALID (obj);
 440
 441   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s", keywords, &file_name))
 442     return NULL;
 443
 444   TRY
 445     {
 446       gdb_bfd_ref_ptr abfd (symfile_bfd_open (file_name));
 447
 448       symbol_file_add_separate (abfd.get (), file_name, 0, obj->objfile);
 449     }
 450   CATCH (except, RETURN_MASK_ALL)
 451     {
 452       GDB_PY_HANDLE_EXCEPTION (except);
 453     }
 454   END_CATCH
 455
 456   Py_RETURN_NONE;
 457 }
 458
 459 /* Implement repr() for gdb.Objfile.  */
 460
 461 static PyObject *
 462 objfpy_repr (PyObject *self_)
 463 {
 464   objfile_object *self = (objfile_object *) self_;
 465   objfile *obj = self->objfile;
 466
 467   if (obj == nullptr)
 468     return PyString_FromString ("<gdb.Objfile (invalid)>");
 469
 470   return PyString_FromFormat ("<gdb.Objfile filename=%s>",
 471                               objfile_filename (obj));
 472 }
 473
 474 /* Subroutine of gdbpy_lookup_objfile_by_build_id to simplify it.
 475    Return non-zero if STRING is a potentially valid build id.  */
 476
 477 static int
 478 objfpy_build_id_ok (const char *string)
 479 {
 480   size_t i, n = strlen (string);
 481
 482   if (n % 2 != 0)
 483     return 0;
 484   for (i = 0; i < n; ++i)
 485     {
 486       if (!isxdigit (string[i]))
 487         return 0;
 488     }
 489   return 1;
 490 }
 491
 492 /* Subroutine of gdbpy_lookup_objfile_by_build_id to simplify it.
 493    Returns non-zero if BUILD_ID matches STRING.
 494    It is assumed that objfpy_build_id_ok (string) returns TRUE.  */
 495
 496 static int
 497 objfpy_build_id_matches (const struct bfd_build_id *build_id,
 498                          const char *string)
 499 {
 500   size_t i;
 501
 502   if (strlen (string) != 2 * build_id->size)
 503     return 0;
 504
 505   for (i = 0; i < build_id->size; ++i)
 506     {
 507       char c1 = string[i * 2], c2 = string[i * 2 + 1];
 508       int byte = (host_hex_value (c1) << 4) | host_hex_value (c2);
 509
 510       if (byte != build_id->data[i])
 511         return 0;
 512     }
 513
 514   return 1;
 515 }
 516
 517 /* Subroutine of gdbpy_lookup_objfile to simplify it.
 518    Look up an objfile by its file name.  */
 519
 520 static struct objfile *
 521 objfpy_lookup_objfile_by_name (const char *name)
 522 {
 523   struct objfile *objfile;
 524
 525   ALL_OBJFILES (objfile)
 526     {
 527       const char *filename;
 528
 529       if ((objfile->flags & OBJF_NOT_FILENAME) != 0)
 530         continue;
 531       /* Don't return separate debug files.  */
 532       if (objfile->separate_debug_objfile_backlink != NULL)
 533         continue;
 534
 535       filename = objfile_filename (objfile);
 536       if (filename != NULL && compare_filenames_for_search (filename, name))
 537         return objfile;
 538       if (compare_filenames_for_search (objfile->original_name, name))
 539         return objfile;
 540     }
 541
 542   return NULL;
 543 }
 544
 545 /* Subroutine of gdbpy_lookup_objfile to simplify it.
 546    Look up an objfile by its build id.  */
 547
 548 static struct objfile *
 549 objfpy_lookup_objfile_by_build_id (const char *build_id)
 550 {
 551   struct objfile *objfile;
 552
 553   ALL_OBJFILES (objfile)
 554     {
 555       const struct bfd_build_id *obfd_build_id;
 556
 557       if (objfile->obfd == NULL)
 558         continue;
 559       /* Don't return separate debug files.  */
 560       if (objfile->separate_debug_objfile_backlink != NULL)
 561         continue;
 562       obfd_build_id = build_id_bfd_get (objfile->obfd);
 563       if (obfd_build_id == NULL)
 564         continue;
 565       if (objfpy_build_id_matches (obfd_build_id, build_id))
 566         return objfile;
 567     }
 568
 569   return NULL;
 570 }
 571
 572 /* Implementation of gdb.lookup_objfile.  */
 573
 574 PyObject *
 575 gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw)
 576 {
 577   static const char *keywords[] = { "name", "by_build_id", NULL };
 578   const char *name;
 579   PyObject *by_build_id_obj = NULL;
 580   int by_build_id;
 581   struct objfile *objfile;
 582
 583   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!", keywords,
 584                                         &name, &PyBool_Type, &by_build_id_obj))
 585     return NULL;
 586
 587   by_build_id = 0;
 588   if (by_build_id_obj != NULL)
 589     {
 590       int cmp = PyObject_IsTrue (by_build_id_obj);
 591
 592       if (cmp < 0)
 593         return NULL;
 594       by_build_id = cmp;
 595     }
 596
 597   if (by_build_id)
 598     {
 599       if (!objfpy_build_id_ok (name))
 600         {
 601           PyErr_SetString (PyExc_TypeError, _("Not a valid build id."));
 602           return NULL;
 603         }
 604       objfile = objfpy_lookup_objfile_by_build_id (name);
 605     }
 606   else
 607     objfile = objfpy_lookup_objfile_by_name (name);
 608
 609   if (objfile != NULL)
 610     {
 611       PyObject *result = objfile_to_objfile_object (objfile);
 612
 613       Py_XINCREF (result);
 614       return result;
 615     }
 616
 617   PyErr_SetString (PyExc_ValueError, _("Objfile not found."));
 618   return NULL;
 619 }
 620
 621 \f
 622
 623 /* Clear the OBJFILE pointer in an Objfile object and remove the
 624    reference.  */
 625 static void
 626 py_free_objfile (struct objfile *objfile, void *datum)
 627 {
 628   gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
 629   gdbpy_ref<objfile_object> object ((objfile_object *) datum);
 630   object->objfile = NULL;
 631 }
 632
 633 /* Return a borrowed reference to the Python object of type Objfile
 634    representing OBJFILE.  If the object has already been created,
 635    return it.  Otherwise, create it.  Return NULL and set the Python
 636    error on failure.  */
 637
 638 PyObject *
 639 objfile_to_objfile_object (struct objfile *objfile)
 640 {
 641   gdbpy_ref<objfile_object> object
 642     ((objfile_object *) objfile_data (objfile, objfpy_objfile_data_key));
 643   if (object == NULL)
 644     {
 645       object.reset (PyObject_New (objfile_object, &objfile_object_type));
 646       if (object != NULL)
 647         {
 648           if (!objfpy_initialize (object.get ()))
 649             return NULL;
 650
 651           object->objfile = objfile;
 652           set_objfile_data (objfile, objfpy_objfile_data_key, object.get ());
 653         }
 654     }
 655
 656   return (PyObject *) object.release ();
 657 }
 658
 659 int
 660 gdbpy_initialize_objfile (void)
 661 {
 662   objfpy_objfile_data_key
 663     = register_objfile_data_with_cleanup (NULL, py_free_objfile);
 664
 665   if (PyType_Ready (&objfile_object_type) < 0)
 666     return -1;
 667
 668   return gdb_pymodule_addobject (gdb_module, "Objfile",
 669                                  (PyObject *) &objfile_object_type);
 670 }
 671
 672 \f
 673
 674 static PyMethodDef objfile_object_methods[] =
 675 {
 676   { "is_valid", objfpy_is_valid, METH_NOARGS,
 677     "is_valid () -> Boolean.\n\
 678 Return true if this object file is valid, false if not." },
 679
 680   { "add_separate_debug_file", (PyCFunction) objfpy_add_separate_debug_file,
 681     METH_VARARGS | METH_KEYWORDS,
 682     "add_separate_debug_file (file_name).\n\
 683 Add FILE_NAME to the list of files containing debug info for the objfile." },
 684
 685   { NULL }
 686 };
 687
 688 static gdb_PyGetSetDef objfile_getset[] =
 689 {
 690   { "__dict__", gdb_py_generic_dict, NULL,
 691     "The __dict__ for this objfile.", &objfile_object_type },
 692   { "filename", objfpy_get_filename, NULL,
 693     "The objfile's filename, or None.", NULL },
 694   { "username", objfpy_get_username, NULL,
 695     "The name of the objfile as provided by the user, or None.", NULL },
 696   { "owner", objfpy_get_owner, NULL,
 697     "The objfile owner of separate debug info objfiles, or None.",
 698     NULL },
 699   { "build_id", objfpy_get_build_id, NULL,
 700     "The objfile's build id, or None.", NULL },
 701   { "progspace", objfpy_get_progspace, NULL,
 702     "The objfile's progspace, or None.", NULL },
 703   { "pretty_printers", objfpy_get_printers, objfpy_set_printers,
 704     "Pretty printers.", NULL },
 705   { "frame_filters", objfpy_get_frame_filters,
 706     objfpy_set_frame_filters, "Frame Filters.", NULL },
 707   { "frame_unwinders", objfpy_get_frame_unwinders,
 708     objfpy_set_frame_unwinders, "Frame Unwinders", NULL },
 709   { "type_printers", objfpy_get_type_printers, objfpy_set_type_printers,
 710     "Type printers.", NULL },
 711   { "xmethods", objfpy_get_xmethods, NULL,
 712     "Debug methods.", NULL },
 713   { NULL }
 714 };
 715
 716 PyTypeObject objfile_object_type =
 717 {
 718   PyVarObject_HEAD_INIT (NULL, 0)
 719   "gdb.Objfile",                  /*tp_name*/
 720   sizeof (objfile_object),        /*tp_basicsize*/
 721   0,                              /*tp_itemsize*/
 722   objfpy_dealloc,                 /*tp_dealloc*/
 723   0,                              /*tp_print*/
 724   0,                              /*tp_getattr*/
 725   0,                              /*tp_setattr*/
 726   0,                              /*tp_compare*/
 727   objfpy_repr,                    /*tp_repr*/
 728   0,                              /*tp_as_number*/
 729   0,                              /*tp_as_sequence*/
 730   0,                              /*tp_as_mapping*/
 731   0,                              /*tp_hash */
 732   0,                              /*tp_call*/
 733   0,                              /*tp_str*/
 734   0,                              /*tp_getattro*/
 735   0,                              /*tp_setattro*/
 736   0,                              /*tp_as_buffer*/
 737   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 738   "GDB objfile object",           /* tp_doc */
 739   0,                              /* tp_traverse */
 740   0,                              /* tp_clear */
 741   0,                              /* tp_richcompare */
 742   0,                              /* tp_weaklistoffset */
 743   0,                              /* tp_iter */
 744   0,                              /* tp_iternext */
 745   objfile_object_methods,         /* tp_methods */
 746   0,                              /* tp_members */
 747   objfile_getset,                 /* tp_getset */
 748   0,                              /* tp_base */
 749   0,                              /* tp_dict */
 750   0,                              /* tp_descr_get */
 751   0,                              /* tp_descr_set */
 752   offsetof (objfile_object, dict), /* tp_dictoffset */
 753   0,                              /* tp_init */
 754   0,                              /* tp_alloc */
 755   objfpy_new,                     /* tp_new */
 756 };