gdb/python/py-xmethods.c

   1 /* Support for debug methods in Python.
   2
   3    Copyright (C) 2013-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 "arch-utils.h"
  22 #include "extension-priv.h"
  23 #include "objfiles.h"
  24 #include "value.h"
  25 #include "language.h"
  26
  27 #include "python.h"
  28 #include "python-internal.h"
  29 #include "py-ref.h"
  30
  31 static const char enabled_field_name[] = "enabled";
  32 static const char match_method_name[] = "match";
  33 static const char get_arg_types_method_name[] = "get_arg_types";
  34 static const char get_result_type_method_name[] = "get_result_type";
  35 static const char matchers_attr_str[] = "xmethods";
  36
  37 static PyObject *py_match_method_name = NULL;
  38 static PyObject *py_get_arg_types_method_name = NULL;
  39
  40 struct gdbpy_worker_data
  41 {
  42   PyObject *worker;
  43   PyObject *this_type;
  44 };
  45
  46 static struct xmethod_worker *new_python_xmethod_worker (PyObject *item,
  47                                                          PyObject *py_obj_type);
  48
  49 /* Implementation of free_xmethod_worker_data for Python.  */
  50
  51 void
  52 gdbpy_free_xmethod_worker_data (const struct extension_language_defn *extlang,
  53                                 void *data)
  54 {
  55   struct gdbpy_worker_data *worker_data = (struct gdbpy_worker_data *) data;
  56
  57   gdb_assert (worker_data->worker != NULL && worker_data->this_type != NULL);
  58
  59   /* We don't do much here, but we still need the GIL.  */
  60   gdbpy_enter enter_py (get_current_arch (), current_language);
  61
  62   Py_DECREF (worker_data->worker);
  63   Py_DECREF (worker_data->this_type);
  64   xfree (worker_data);
  65 }
  66
  67 /* Implementation of clone_xmethod_worker_data for Python.  */
  68
  69 void *
  70 gdbpy_clone_xmethod_worker_data (const struct extension_language_defn *extlang,
  71                                  void *data)
  72 {
  73   struct gdbpy_worker_data *worker_data
  74     = (struct gdbpy_worker_data *) data, *new_data;
  75
  76   gdb_assert (worker_data->worker != NULL && worker_data->this_type != NULL);
  77
  78   /* We don't do much here, but we still need the GIL.  */
  79   gdbpy_enter enter_py (get_current_arch (), current_language);
  80
  81   new_data = XCNEW (struct gdbpy_worker_data);
  82   new_data->worker = worker_data->worker;
  83   new_data->this_type = worker_data->this_type;
  84   Py_INCREF (new_data->worker);
  85   Py_INCREF (new_data->this_type);
  86
  87   return new_data;
  88 }
  89
  90 /* Invoke the "match" method of the MATCHER and return a new reference
  91    to the result.  Returns NULL on error.  */
  92
  93 static PyObject *
  94 invoke_match_method (PyObject *matcher, PyObject *py_obj_type,
  95                      const char *xmethod_name)
  96 {
  97   int enabled;
  98
  99   gdbpy_ref<> enabled_field (PyObject_GetAttrString (matcher,
 100                                                      enabled_field_name));
 101   if (enabled_field == NULL)
 102     return NULL;
 103
 104   enabled = PyObject_IsTrue (enabled_field.get ());
 105   if (enabled == -1)
 106     return NULL;
 107   if (enabled == 0)
 108     {
 109       /* Return 'None' if the matcher is not enabled.  */
 110       Py_RETURN_NONE;
 111     }
 112
 113   gdbpy_ref<> match_method (PyObject_GetAttrString (matcher,
 114                                                     match_method_name));
 115   if (match_method == NULL)
 116     return NULL;
 117
 118   gdbpy_ref<> py_xmethod_name (PyString_FromString (xmethod_name));
 119   if (py_xmethod_name == NULL)
 120     return NULL;
 121
 122   return PyObject_CallMethodObjArgs (matcher, py_match_method_name,
 123                                      py_obj_type, py_xmethod_name.get (),
 124                                      NULL);
 125 }
 126
 127 /* Implementation of get_matching_xmethod_workers for Python.  */
 128
 129 enum ext_lang_rc
 130 gdbpy_get_matching_xmethod_workers
 131   (const struct extension_language_defn *extlang,
 132    struct type *obj_type, const char *method_name,
 133    xmethod_worker_vec **dm_vec)
 134 {
 135   struct objfile *objfile;
 136   VEC (xmethod_worker_ptr) *worker_vec = NULL;
 137   PyObject *py_progspace;
 138
 139   gdb_assert (obj_type != NULL && method_name != NULL);
 140
 141   gdbpy_enter enter_py (get_current_arch (), current_language);
 142
 143   gdbpy_ref<> py_type (type_to_type_object (obj_type));
 144   if (py_type == NULL)
 145     {
 146       gdbpy_print_stack ();
 147       return EXT_LANG_RC_ERROR;
 148     }
 149
 150   /* Create an empty list of debug methods.  */
 151   gdbpy_ref<> py_xmethod_matcher_list (PyList_New (0));
 152   if (py_xmethod_matcher_list == NULL)
 153     {
 154       gdbpy_print_stack ();
 155       return EXT_LANG_RC_ERROR;
 156     }
 157
 158   /* Gather debug method matchers registered with the object files.
 159      This could be done differently by iterating over each objfile's matcher
 160      list individually, but there's no data yet to show it's needed.  */
 161   ALL_OBJFILES (objfile)
 162     {
 163       PyObject *py_objfile = objfile_to_objfile_object (objfile);
 164
 165       if (py_objfile == NULL)
 166         {
 167           gdbpy_print_stack ();
 168           return EXT_LANG_RC_ERROR;
 169         }
 170
 171       gdbpy_ref<> objfile_matchers (objfpy_get_xmethods (py_objfile, NULL));
 172       gdbpy_ref<> temp (PySequence_Concat (py_xmethod_matcher_list.get (),
 173                                            objfile_matchers.get ()));
 174       if (temp == NULL)
 175         {
 176           gdbpy_print_stack ();
 177           return EXT_LANG_RC_ERROR;
 178         }
 179
 180       py_xmethod_matcher_list = std::move (temp);
 181     }
 182
 183   /* Gather debug methods matchers registered with the current program
 184      space.  */
 185   py_progspace = pspace_to_pspace_object (current_program_space);
 186   if (py_progspace != NULL)
 187     {
 188       gdbpy_ref<> pspace_matchers (pspy_get_xmethods (py_progspace, NULL));
 189
 190       gdbpy_ref<> temp (PySequence_Concat (py_xmethod_matcher_list.get (),
 191                                            pspace_matchers.get ()));
 192       if (temp == NULL)
 193         {
 194           gdbpy_print_stack ();
 195           return EXT_LANG_RC_ERROR;
 196         }
 197
 198       py_xmethod_matcher_list = std::move (temp);
 199     }
 200   else
 201     {
 202       gdbpy_print_stack ();
 203       return EXT_LANG_RC_ERROR;
 204     }
 205
 206   /* Gather debug method matchers registered globally.  */
 207   if (gdb_python_module != NULL
 208       && PyObject_HasAttrString (gdb_python_module, matchers_attr_str))
 209     {
 210       gdbpy_ref<> gdb_matchers (PyObject_GetAttrString (gdb_python_module,
 211                                                         matchers_attr_str));
 212       if (gdb_matchers != NULL)
 213         {
 214           gdbpy_ref<> temp (PySequence_Concat (py_xmethod_matcher_list.get (),
 215                                                gdb_matchers.get ()));
 216           if (temp == NULL)
 217             {
 218               gdbpy_print_stack ();
 219               return EXT_LANG_RC_ERROR;
 220             }
 221
 222           py_xmethod_matcher_list = std::move (temp);
 223         }
 224       else
 225         {
 226           gdbpy_print_stack ();
 227           return EXT_LANG_RC_ERROR;
 228         }
 229     }
 230
 231   gdbpy_ref<> list_iter (PyObject_GetIter (py_xmethod_matcher_list.get ()));
 232   if (list_iter == NULL)
 233     {
 234       gdbpy_print_stack ();
 235       return EXT_LANG_RC_ERROR;
 236     }
 237   while (true)
 238     {
 239       gdbpy_ref<> matcher (PyIter_Next (list_iter.get ()));
 240       if (matcher == NULL)
 241         {
 242           if (PyErr_Occurred ())
 243             {
 244               gdbpy_print_stack ();
 245               return EXT_LANG_RC_ERROR;
 246             }
 247           break;
 248         }
 249
 250       gdbpy_ref<> match_result (invoke_match_method (matcher.get (),
 251                                                      py_type.get (),
 252                                                      method_name));
 253
 254       if (match_result == NULL)
 255         {
 256           gdbpy_print_stack ();
 257           return EXT_LANG_RC_ERROR;
 258         }
 259       if (match_result == Py_None)
 260         ; /* This means there was no match.  */
 261       else if (PySequence_Check (match_result.get ()))
 262         {
 263           gdbpy_ref<> iter (PyObject_GetIter (match_result.get ()));
 264
 265           if (iter == NULL)
 266             {
 267               gdbpy_print_stack ();
 268               return EXT_LANG_RC_ERROR;
 269             }
 270           while (true)
 271             {
 272               struct xmethod_worker *worker;
 273
 274               gdbpy_ref<> py_worker (PyIter_Next (iter.get ()));
 275               if (py_worker == NULL)
 276                 {
 277                   if (PyErr_Occurred ())
 278                     {
 279                       gdbpy_print_stack ();
 280                       return EXT_LANG_RC_ERROR;
 281                     }
 282                   break;
 283                 }
 284
 285               worker = new_python_xmethod_worker (py_worker.get (),
 286                                                   py_type.get ());
 287               VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
 288             }
 289         }
 290       else
 291         {
 292           struct xmethod_worker *worker;
 293
 294           worker = new_python_xmethod_worker (match_result.get (),
 295                                               py_type.get ());
 296           VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
 297         }
 298     }
 299
 300   *dm_vec = worker_vec;
 301
 302   return EXT_LANG_RC_OK;
 303 }
 304
 305 /* Implementation of get_xmethod_arg_types for Python.  */
 306
 307 enum ext_lang_rc
 308 gdbpy_get_xmethod_arg_types (const struct extension_language_defn *extlang,
 309                              struct xmethod_worker *worker,
 310                              int *nargs, struct type ***arg_types)
 311 {
 312   /* The gdbpy_enter object needs to be placed first, so that it's the last to
 313      be destroyed.  */
 314   gdbpy_enter enter_py (get_current_arch (), current_language);
 315   struct gdbpy_worker_data *worker_data
 316     = (struct gdbpy_worker_data *) worker->data;
 317   PyObject *py_worker = worker_data->worker;
 318   struct type *obj_type;
 319   int i = 1, arg_count;
 320   gdbpy_ref<> list_iter;
 321
 322   /* Set nargs to -1 so that any premature return from this function returns
 323      an invalid/unusable number of arg types.  */
 324   *nargs = -1;
 325
 326   gdbpy_ref<> get_arg_types_method
 327     (PyObject_GetAttrString (py_worker, get_arg_types_method_name));
 328   if (get_arg_types_method == NULL)
 329     {
 330       gdbpy_print_stack ();
 331       return EXT_LANG_RC_ERROR;
 332     }
 333
 334   gdbpy_ref<> py_argtype_list
 335     (PyObject_CallMethodObjArgs (py_worker, py_get_arg_types_method_name,
 336                                  NULL));
 337   if (py_argtype_list == NULL)
 338     {
 339       gdbpy_print_stack ();
 340       return EXT_LANG_RC_ERROR;
 341     }
 342
 343   if (py_argtype_list == Py_None)
 344     arg_count = 0;
 345   else if (PySequence_Check (py_argtype_list.get ()))
 346     {
 347       arg_count = PySequence_Size (py_argtype_list.get ());
 348       if (arg_count == -1)
 349         {
 350           gdbpy_print_stack ();
 351           return EXT_LANG_RC_ERROR;
 352         }
 353
 354       list_iter.reset (PyObject_GetIter (py_argtype_list.get ()));
 355       if (list_iter == NULL)
 356         {
 357           gdbpy_print_stack ();
 358           return EXT_LANG_RC_ERROR;
 359         }
 360     }
 361   else
 362     arg_count = 1;
 363
 364   /* Include the 'this' argument in the size.  */
 365   gdb::unique_xmalloc_ptr<struct type *> type_array
 366     (XCNEWVEC (struct type *, arg_count + 1));
 367   i = 1;
 368   if (list_iter != NULL)
 369     {
 370       while (true)
 371         {
 372           gdbpy_ref<> item (PyIter_Next (list_iter.get ()));
 373           if (item == NULL)
 374             {
 375               if (PyErr_Occurred ())
 376                 {
 377                   gdbpy_print_stack ();
 378                   return EXT_LANG_RC_ERROR;
 379                 }
 380               break;
 381             }
 382
 383           struct type *arg_type = type_object_to_type (item.get ());
 384           if (arg_type == NULL)
 385             {
 386               PyErr_SetString (PyExc_TypeError,
 387                                _("Arg type returned by the get_arg_types "
 388                                  "method of a debug method worker object is "
 389                                  "not a gdb.Type object."));
 390               return EXT_LANG_RC_ERROR;
 391             }
 392
 393           (type_array.get ())[i] = arg_type;
 394           i++;
 395         }
 396     }
 397   else if (arg_count == 1)
 398     {
 399       /* py_argtype_list is not actually a list but a single gdb.Type
 400          object.  */
 401       struct type *arg_type = type_object_to_type (py_argtype_list.get ());
 402
 403       if (arg_type == NULL)
 404         {
 405           PyErr_SetString (PyExc_TypeError,
 406                            _("Arg type returned by the get_arg_types method "
 407                              "of an xmethod worker object is not a gdb.Type "
 408                              "object."));
 409           return EXT_LANG_RC_ERROR;
 410         }
 411       else
 412         {
 413           (type_array.get ())[i] = arg_type;
 414           i++;
 415         }
 416     }
 417
 418   /* Add the type of 'this' as the first argument.  The 'this' pointer should
 419      be a 'const' value.  Hence, create a 'const' variant of the 'this' pointer
 420      type.  */
 421   obj_type = type_object_to_type (worker_data->this_type);
 422   (type_array.get ())[0] = make_cv_type (1, 0, lookup_pointer_type (obj_type),
 423                                          NULL);
 424   *nargs = i;
 425   *arg_types = type_array.release ();
 426
 427   return EXT_LANG_RC_OK;
 428 }
 429
 430 /* Implementation of get_xmethod_result_type for Python.  */
 431
 432 enum ext_lang_rc
 433 gdbpy_get_xmethod_result_type (const struct extension_language_defn *extlang,
 434                                struct xmethod_worker *worker,
 435                                struct value *obj,
 436                                struct value **args, int nargs,
 437                                struct type **result_type_ptr)
 438 {
 439   struct gdbpy_worker_data *worker_data
 440     = (struct gdbpy_worker_data *) worker->data;
 441   PyObject *py_worker = worker_data->worker;
 442   struct type *obj_type, *this_type;
 443   int i;
 444
 445   gdbpy_enter enter_py (get_current_arch (), current_language);
 446
 447   /* First see if there is a get_result_type method.
 448      If not this could be an old xmethod (pre 7.9.1).  */
 449   gdbpy_ref<> get_result_type_method
 450     (PyObject_GetAttrString (py_worker, get_result_type_method_name));
 451   if (get_result_type_method == NULL)
 452     {
 453       PyErr_Clear ();
 454       *result_type_ptr = NULL;
 455       return EXT_LANG_RC_OK;
 456     }
 457
 458   obj_type = check_typedef (value_type (obj));
 459   this_type = check_typedef (type_object_to_type (worker_data->this_type));
 460   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
 461     {
 462       struct type *this_ptr = lookup_pointer_type (this_type);
 463
 464       if (!types_equal (obj_type, this_ptr))
 465         obj = value_cast (this_ptr, obj);
 466     }
 467   else if (TYPE_IS_REFERENCE (obj_type))
 468     {
 469       struct type *this_ref
 470         = lookup_reference_type (this_type, TYPE_CODE (obj_type));
 471
 472       if (!types_equal (obj_type, this_ref))
 473         obj = value_cast (this_ref, obj);
 474     }
 475   else
 476     {
 477       if (!types_equal (obj_type, this_type))
 478         obj = value_cast (this_type, obj);
 479     }
 480   gdbpy_ref<> py_value_obj (value_to_value_object (obj));
 481   if (py_value_obj == NULL)
 482     {
 483       gdbpy_print_stack ();
 484       return EXT_LANG_RC_ERROR;
 485     }
 486
 487   gdbpy_ref<> py_arg_tuple (PyTuple_New (nargs + 1));
 488   if (py_arg_tuple == NULL)
 489     {
 490       gdbpy_print_stack ();
 491       return EXT_LANG_RC_ERROR;
 492     }
 493
 494   /* PyTuple_SET_ITEM steals the reference of the element, hence the
 495      release.  */
 496   PyTuple_SET_ITEM (py_arg_tuple.get (), 0, py_value_obj.release ());
 497
 498   for (i = 0; i < nargs; i++)
 499     {
 500       PyObject *py_value_arg = value_to_value_object (args[i]);
 501
 502       if (py_value_arg == NULL)
 503         {
 504           gdbpy_print_stack ();
 505           return EXT_LANG_RC_ERROR;
 506         }
 507       PyTuple_SET_ITEM (py_arg_tuple.get (), i + 1, py_value_arg);
 508     }
 509
 510   gdbpy_ref<> py_result_type
 511     (PyObject_CallObject (get_result_type_method.get (), py_arg_tuple.get ()));
 512   if (py_result_type == NULL)
 513     {
 514       gdbpy_print_stack ();
 515       return EXT_LANG_RC_ERROR;
 516     }
 517
 518   *result_type_ptr = type_object_to_type (py_result_type.get ());
 519   if (*result_type_ptr == NULL)
 520     {
 521       PyErr_SetString (PyExc_TypeError,
 522                        _("Type returned by the get_result_type method of an"
 523                          " xmethod worker object is not a gdb.Type object."));
 524       gdbpy_print_stack ();
 525       return EXT_LANG_RC_ERROR;
 526     }
 527
 528   return EXT_LANG_RC_OK;
 529 }
 530
 531 /* Implementation of invoke_xmethod for Python.  */
 532
 533 struct value *
 534 gdbpy_invoke_xmethod (const struct extension_language_defn *extlang,
 535                       struct xmethod_worker *worker,
 536                       struct value *obj, struct value **args, int nargs)
 537 {
 538   int i;
 539   struct type *obj_type, *this_type;
 540   struct value *res = NULL;
 541   struct gdbpy_worker_data *worker_data
 542     = (struct gdbpy_worker_data *) worker->data;
 543   PyObject *xmethod_worker = worker_data->worker;
 544
 545   gdbpy_enter enter_py (get_current_arch (), current_language);
 546
 547   obj_type = check_typedef (value_type (obj));
 548   this_type = check_typedef (type_object_to_type (worker_data->this_type));
 549   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
 550     {
 551       struct type *this_ptr = lookup_pointer_type (this_type);
 552
 553       if (!types_equal (obj_type, this_ptr))
 554         obj = value_cast (this_ptr, obj);
 555     }
 556   else if (TYPE_IS_REFERENCE (obj_type))
 557     {
 558       struct type *this_ref
 559         = lookup_reference_type (this_type, TYPE_CODE (obj_type));
 560
 561       if (!types_equal (obj_type, this_ref))
 562         obj = value_cast (this_ref, obj);
 563     }
 564   else
 565     {
 566       if (!types_equal (obj_type, this_type))
 567         obj = value_cast (this_type, obj);
 568     }
 569   gdbpy_ref<> py_value_obj (value_to_value_object (obj));
 570   if (py_value_obj == NULL)
 571     {
 572       gdbpy_print_stack ();
 573       error (_("Error while executing Python code."));
 574     }
 575
 576   gdbpy_ref<> py_arg_tuple (PyTuple_New (nargs + 1));
 577   if (py_arg_tuple == NULL)
 578     {
 579       gdbpy_print_stack ();
 580       error (_("Error while executing Python code."));
 581     }
 582
 583   /* PyTuple_SET_ITEM steals the reference of the element, hence the
 584      release.  */
 585   PyTuple_SET_ITEM (py_arg_tuple.get (), 0, py_value_obj.release ());
 586
 587   for (i = 0; i < nargs; i++)
 588     {
 589       PyObject *py_value_arg = value_to_value_object (args[i]);
 590
 591       if (py_value_arg == NULL)
 592         {
 593           gdbpy_print_stack ();
 594           error (_("Error while executing Python code."));
 595         }
 596
 597       PyTuple_SET_ITEM (py_arg_tuple.get (), i + 1, py_value_arg);
 598     }
 599
 600   gdbpy_ref<> py_result (PyObject_CallObject (xmethod_worker,
 601                                               py_arg_tuple.get ()));
 602   if (py_result == NULL)
 603     {
 604       gdbpy_print_stack ();
 605       error (_("Error while executing Python code."));
 606     }
 607
 608   if (py_result != Py_None)
 609     {
 610       res = convert_value_from_python (py_result.get ());
 611       if (res == NULL)
 612         {
 613           gdbpy_print_stack ();
 614           error (_("Error while executing Python code."));
 615         }
 616     }
 617   else
 618     {
 619       res = allocate_value (lookup_typename (python_language, python_gdbarch,
 620                                              "void", NULL, 0));
 621     }
 622
 623   return res;
 624 }
 625
 626 /* Creates a new Python xmethod_worker object.
 627    The new object has data of type 'struct gdbpy_worker_data' composed
 628    with the components PY_WORKER and THIS_TYPE.  */
 629
 630 static struct xmethod_worker *
 631 new_python_xmethod_worker (PyObject *py_worker, PyObject *this_type)
 632 {
 633   struct gdbpy_worker_data *data;
 634
 635   gdb_assert (py_worker != NULL && this_type != NULL);
 636
 637   data = XCNEW (struct gdbpy_worker_data);
 638   data->worker = py_worker;
 639   data->this_type = this_type;
 640   Py_INCREF (py_worker);
 641   Py_INCREF (this_type);
 642
 643   return new_xmethod_worker (&extension_language_python, data);
 644 }
 645
 646 int
 647 gdbpy_initialize_xmethods (void)
 648 {
 649   py_match_method_name = PyString_FromString (match_method_name);
 650   if (py_match_method_name == NULL)
 651     return -1;
 652
 653   py_get_arg_types_method_name
 654     = PyString_FromString (get_arg_types_method_name);
 655   if (py_get_arg_types_method_name == NULL)
 656     return -1;
 657
 658   return 1;
 659 }