gdb/python/py-objfile.c

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