gdb/python/py-objfile.c

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