gdb/python/py-objfile.c

   1 /* Python interface to objfiles.
   2
   3    Copyright (C) 2008-2017 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 /* Subroutine of gdbpy_lookup_objfile_by_build_id to simplify it.
 460    Return non-zero if STRING is a potentially valid build id.  */
 461
 462 static int
 463 objfpy_build_id_ok (const char *string)
 464 {
 465   size_t i, n = strlen (string);
 466
 467   if (n % 2 != 0)
 468     return 0;
 469   for (i = 0; i < n; ++i)
 470     {
 471       if (!isxdigit (string[i]))
 472         return 0;
 473     }
 474   return 1;
 475 }
 476
 477 /* Subroutine of gdbpy_lookup_objfile_by_build_id to simplify it.
 478    Returns non-zero if BUILD_ID matches STRING.
 479    It is assumed that objfpy_build_id_ok (string) returns TRUE.  */
 480
 481 static int
 482 objfpy_build_id_matches (const struct bfd_build_id *build_id,
 483                          const char *string)
 484 {
 485   size_t i;
 486
 487   if (strlen (string) != 2 * build_id->size)
 488     return 0;
 489
 490   for (i = 0; i < build_id->size; ++i)
 491     {
 492       char c1 = string[i * 2], c2 = string[i * 2 + 1];
 493       int byte = (host_hex_value (c1) << 4) | host_hex_value (c2);
 494
 495       if (byte != build_id->data[i])
 496         return 0;
 497     }
 498
 499   return 1;
 500 }
 501
 502 /* Subroutine of gdbpy_lookup_objfile to simplify it.
 503    Look up an objfile by its file name.  */
 504
 505 static struct objfile *
 506 objfpy_lookup_objfile_by_name (const char *name)
 507 {
 508   struct objfile *objfile;
 509
 510   ALL_OBJFILES (objfile)
 511     {
 512       const char *filename;
 513
 514       if ((objfile->flags & OBJF_NOT_FILENAME) != 0)
 515         continue;
 516       /* Don't return separate debug files.  */
 517       if (objfile->separate_debug_objfile_backlink != NULL)
 518         continue;
 519
 520       filename = objfile_filename (objfile);
 521       if (filename != NULL && compare_filenames_for_search (filename, name))
 522         return objfile;
 523       if (compare_filenames_for_search (objfile->original_name, name))
 524         return objfile;
 525     }
 526
 527   return NULL;
 528 }
 529
 530 /* Subroutine of gdbpy_lookup_objfile to simplify it.
 531    Look up an objfile by its build id.  */
 532
 533 static struct objfile *
 534 objfpy_lookup_objfile_by_build_id (const char *build_id)
 535 {
 536   struct objfile *objfile;
 537
 538   ALL_OBJFILES (objfile)
 539     {
 540       const struct bfd_build_id *obfd_build_id;
 541
 542       if (objfile->obfd == NULL)
 543         continue;
 544       /* Don't return separate debug files.  */
 545       if (objfile->separate_debug_objfile_backlink != NULL)
 546         continue;
 547       obfd_build_id = build_id_bfd_get (objfile->obfd);
 548       if (obfd_build_id == NULL)
 549         continue;
 550       if (objfpy_build_id_matches (obfd_build_id, build_id))
 551         return objfile;
 552     }
 553
 554   return NULL;
 555 }
 556
 557 /* Implementation of gdb.lookup_objfile.  */
 558
 559 PyObject *
 560 gdbpy_lookup_objfile (PyObject *self, PyObject *args, PyObject *kw)
 561 {
 562   static const char *keywords[] = { "name", "by_build_id", NULL };
 563   const char *name;
 564   PyObject *by_build_id_obj = NULL;
 565   int by_build_id;
 566   struct objfile *objfile;
 567
 568   if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!", keywords,
 569                                         &name, &PyBool_Type, &by_build_id_obj))
 570     return NULL;
 571
 572   by_build_id = 0;
 573   if (by_build_id_obj != NULL)
 574     {
 575       int cmp = PyObject_IsTrue (by_build_id_obj);
 576
 577       if (cmp < 0)
 578         return NULL;
 579       by_build_id = cmp;
 580     }
 581
 582   if (by_build_id)
 583     {
 584       if (!objfpy_build_id_ok (name))
 585         {
 586           PyErr_SetString (PyExc_TypeError, _("Not a valid build id."));
 587           return NULL;
 588         }
 589       objfile = objfpy_lookup_objfile_by_build_id (name);
 590     }
 591   else
 592     objfile = objfpy_lookup_objfile_by_name (name);
 593
 594   if (objfile != NULL)
 595     {
 596       PyObject *result = objfile_to_objfile_object (objfile);
 597
 598       Py_XINCREF (result);
 599       return result;
 600     }
 601
 602   PyErr_SetString (PyExc_ValueError, _("Objfile not found."));
 603   return NULL;
 604 }
 605
 606 \f
 607
 608 /* Clear the OBJFILE pointer in an Objfile object and remove the
 609    reference.  */
 610 static void
 611 py_free_objfile (struct objfile *objfile, void *datum)
 612 {
 613   gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
 614   gdbpy_ref<objfile_object> object ((objfile_object *) datum);
 615   object->objfile = NULL;
 616 }
 617
 618 /* Return a borrowed reference to the Python object of type Objfile
 619    representing OBJFILE.  If the object has already been created,
 620    return it.  Otherwise, create it.  Return NULL and set the Python
 621    error on failure.  */
 622
 623 PyObject *
 624 objfile_to_objfile_object (struct objfile *objfile)
 625 {
 626   gdbpy_ref<objfile_object> object
 627     ((objfile_object *) objfile_data (objfile, objfpy_objfile_data_key));
 628   if (object == NULL)
 629     {
 630       object.reset (PyObject_New (objfile_object, &objfile_object_type));
 631       if (object != NULL)
 632         {
 633           if (!objfpy_initialize (object.get ()))
 634             return NULL;
 635
 636           object->objfile = objfile;
 637           set_objfile_data (objfile, objfpy_objfile_data_key, object.get ());
 638         }
 639     }
 640
 641   return (PyObject *) object.release ();
 642 }
 643
 644 int
 645 gdbpy_initialize_objfile (void)
 646 {
 647   objfpy_objfile_data_key
 648     = register_objfile_data_with_cleanup (NULL, py_free_objfile);
 649
 650   if (PyType_Ready (&objfile_object_type) < 0)
 651     return -1;
 652
 653   return gdb_pymodule_addobject (gdb_module, "Objfile",
 654                                  (PyObject *) &objfile_object_type);
 655 }
 656
 657 \f
 658
 659 static PyMethodDef objfile_object_methods[] =
 660 {
 661   { "is_valid", objfpy_is_valid, METH_NOARGS,
 662     "is_valid () -> Boolean.\n\
 663 Return true if this object file is valid, false if not." },
 664
 665   { "add_separate_debug_file", (PyCFunction) objfpy_add_separate_debug_file,
 666     METH_VARARGS | METH_KEYWORDS,
 667     "add_separate_debug_file (file_name).\n\
 668 Add FILE_NAME to the list of files containing debug info for the objfile." },
 669
 670   { NULL }
 671 };
 672
 673 static gdb_PyGetSetDef objfile_getset[] =
 674 {
 675   { "__dict__", gdb_py_generic_dict, NULL,
 676     "The __dict__ for this objfile.", &objfile_object_type },
 677   { "filename", objfpy_get_filename, NULL,
 678     "The objfile's filename, or None.", NULL },
 679   { "username", objfpy_get_username, NULL,
 680     "The name of the objfile as provided by the user, or None.", NULL },
 681   { "owner", objfpy_get_owner, NULL,
 682     "The objfile owner of separate debug info objfiles, or None.",
 683     NULL },
 684   { "build_id", objfpy_get_build_id, NULL,
 685     "The objfile's build id, or None.", NULL },
 686   { "progspace", objfpy_get_progspace, NULL,
 687     "The objfile's progspace, or None.", NULL },
 688   { "pretty_printers", objfpy_get_printers, objfpy_set_printers,
 689     "Pretty printers.", NULL },
 690   { "frame_filters", objfpy_get_frame_filters,
 691     objfpy_set_frame_filters, "Frame Filters.", NULL },
 692   { "frame_unwinders", objfpy_get_frame_unwinders,
 693     objfpy_set_frame_unwinders, "Frame Unwinders", NULL },
 694   { "type_printers", objfpy_get_type_printers, objfpy_set_type_printers,
 695     "Type printers.", NULL },
 696   { "xmethods", objfpy_get_xmethods, NULL,
 697     "Debug methods.", NULL },
 698   { NULL }
 699 };
 700
 701 PyTypeObject objfile_object_type =
 702 {
 703   PyVarObject_HEAD_INIT (NULL, 0)
 704   "gdb.Objfile",                  /*tp_name*/
 705   sizeof (objfile_object),        /*tp_basicsize*/
 706   0,                              /*tp_itemsize*/
 707   objfpy_dealloc,                 /*tp_dealloc*/
 708   0,                              /*tp_print*/
 709   0,                              /*tp_getattr*/
 710   0,                              /*tp_setattr*/
 711   0,                              /*tp_compare*/
 712   0,                              /*tp_repr*/
 713   0,                              /*tp_as_number*/
 714   0,                              /*tp_as_sequence*/
 715   0,                              /*tp_as_mapping*/
 716   0,                              /*tp_hash */
 717   0,                              /*tp_call*/
 718   0,                              /*tp_str*/
 719   0,                              /*tp_getattro*/
 720   0,                              /*tp_setattro*/
 721   0,                              /*tp_as_buffer*/
 722   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 723   "GDB objfile object",           /* tp_doc */
 724   0,                              /* tp_traverse */
 725   0,                              /* tp_clear */
 726   0,                              /* tp_richcompare */
 727   0,                              /* tp_weaklistoffset */
 728   0,                              /* tp_iter */
 729   0,                              /* tp_iternext */
 730   objfile_object_methods,         /* tp_methods */
 731   0,                              /* tp_members */
 732   objfile_getset,                 /* tp_getset */
 733   0,                              /* tp_base */
 734   0,                              /* tp_dict */
 735   0,                              /* tp_descr_get */
 736   0,                              /* tp_descr_set */
 737   offsetof (objfile_object, dict), /* tp_dictoffset */
 738   0,                              /* tp_init */
 739   0,                              /* tp_alloc */
 740   objfpy_new,                     /* tp_new */
 741 };