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