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