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   /* The gdbpy_enter object needs to be placed first, so that it's the last to
 312      be destroyed.  */
 313   gdbpy_enter enter_py (get_current_arch (), current_language);
 314   struct gdbpy_worker_data *worker_data
 315     = (struct gdbpy_worker_data *) worker->data;
 316   PyObject *py_worker = worker_data->worker;
 317   struct type *obj_type;
 318   int i = 1, arg_count;
 319   gdbpy_ref list_iter;
 320
 321   /* Set nargs to -1 so that any premature return from this function returns
 322      an invalid/unusable number of arg types.  */
 323   *nargs = -1;
 324
 325   gdbpy_ref get_arg_types_method
 326     (PyObject_GetAttrString (py_worker, get_arg_types_method_name));
 327   if (get_arg_types_method == NULL)
 328     {
 329       gdbpy_print_stack ();
 330       return EXT_LANG_RC_ERROR;
 331     }
 332
 333   gdbpy_ref py_argtype_list
 334     (PyObject_CallMethodObjArgs (py_worker, py_get_arg_types_method_name,
 335                                  NULL));
 336   if (py_argtype_list == NULL)
 337     {
 338       gdbpy_print_stack ();
 339       return EXT_LANG_RC_ERROR;
 340     }
 341
 342   if (py_argtype_list == Py_None)
 343     arg_count = 0;
 344   else if (PySequence_Check (py_argtype_list.get ()))
 345     {
 346       arg_count = PySequence_Size (py_argtype_list.get ());
 347       if (arg_count == -1)
 348         {
 349           gdbpy_print_stack ();
 350           return EXT_LANG_RC_ERROR;
 351         }
 352
 353       list_iter.reset (PyObject_GetIter (py_argtype_list.get ()));
 354       if (list_iter == NULL)
 355         {
 356           gdbpy_print_stack ();
 357           return EXT_LANG_RC_ERROR;
 358         }
 359     }
 360   else
 361     arg_count = 1;
 362
 363   /* Include the 'this' argument in the size.  */
 364   gdb::unique_xmalloc_ptr<struct type *> type_array
 365     (XCNEWVEC (struct type *, arg_count + 1));
 366   i = 1;
 367   if (list_iter != NULL)
 368     {
 369       while (true)
 370         {
 371           gdbpy_ref item (PyIter_Next (list_iter.get ()));
 372           if (item == NULL)
 373             {
 374               if (PyErr_Occurred ())
 375                 {
 376                   gdbpy_print_stack ();
 377                   return EXT_LANG_RC_ERROR;
 378                 }
 379               break;
 380             }
 381
 382           struct type *arg_type = type_object_to_type (item.get ());
 383           if (arg_type == NULL)
 384             {
 385               PyErr_SetString (PyExc_TypeError,
 386                                _("Arg type returned by the get_arg_types "
 387                                  "method of a debug method worker object is "
 388                                  "not a gdb.Type object."));
 389               return EXT_LANG_RC_ERROR;
 390             }
 391
 392           (type_array.get ())[i] = arg_type;
 393           i++;
 394         }
 395     }
 396   else if (arg_count == 1)
 397     {
 398       /* py_argtype_list is not actually a list but a single gdb.Type
 399          object.  */
 400       struct type *arg_type = type_object_to_type (py_argtype_list.get ());
 401
 402       if (arg_type == NULL)
 403         {
 404           PyErr_SetString (PyExc_TypeError,
 405                            _("Arg type returned by the get_arg_types method "
 406                              "of an xmethod worker object is not a gdb.Type "
 407                              "object."));
 408           return EXT_LANG_RC_ERROR;
 409         }
 410       else
 411         {
 412           (type_array.get ())[i] = arg_type;
 413           i++;
 414         }
 415     }
 416
 417   /* Add the type of 'this' as the first argument.  The 'this' pointer should
 418      be a 'const' value.  Hence, create a 'const' variant of the 'this' pointer
 419      type.  */
 420   obj_type = type_object_to_type (worker_data->this_type);
 421   (type_array.get ())[0] = make_cv_type (1, 0, lookup_pointer_type (obj_type),
 422                                          NULL);
 423   *nargs = i;
 424   *arg_types = type_array.release ();
 425
 426   return EXT_LANG_RC_OK;
 427 }
 428
 429 /* Implementation of get_xmethod_result_type for Python.  */
 430
 431 enum ext_lang_rc
 432 gdbpy_get_xmethod_result_type (const struct extension_language_defn *extlang,
 433                                struct xmethod_worker *worker,
 434                                struct value *obj,
 435                                struct value **args, int nargs,
 436                                struct type **result_type_ptr)
 437 {
 438   struct gdbpy_worker_data *worker_data
 439     = (struct gdbpy_worker_data *) worker->data;
 440   PyObject *py_worker = worker_data->worker;
 441   struct type *obj_type, *this_type;
 442   int i;
 443
 444   gdbpy_enter enter_py (get_current_arch (), current_language);
 445
 446   /* First see if there is a get_result_type method.
 447      If not this could be an old xmethod (pre 7.9.1).  */
 448   gdbpy_ref get_result_type_method
 449     (PyObject_GetAttrString (py_worker, get_result_type_method_name));
 450   if (get_result_type_method == NULL)
 451     {
 452       PyErr_Clear ();
 453       *result_type_ptr = NULL;
 454       return EXT_LANG_RC_OK;
 455     }
 456
 457   obj_type = check_typedef (value_type (obj));
 458   this_type = check_typedef (type_object_to_type (worker_data->this_type));
 459   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
 460     {
 461       struct type *this_ptr = lookup_pointer_type (this_type);
 462
 463       if (!types_equal (obj_type, this_ptr))
 464         obj = value_cast (this_ptr, obj);
 465     }
 466   else if (TYPE_CODE (obj_type) == TYPE_CODE_REF)
 467     {
 468       struct type *this_ref = lookup_reference_type (this_type);
 469
 470       if (!types_equal (obj_type, this_ref))
 471         obj = value_cast (this_ref, obj);
 472     }
 473   else
 474     {
 475       if (!types_equal (obj_type, this_type))
 476         obj = value_cast (this_type, obj);
 477     }
 478   gdbpy_ref py_value_obj (value_to_value_object (obj));
 479   if (py_value_obj == NULL)
 480     {
 481       gdbpy_print_stack ();
 482       return EXT_LANG_RC_ERROR;
 483     }
 484
 485   gdbpy_ref py_arg_tuple (PyTuple_New (nargs + 1));
 486   if (py_arg_tuple == NULL)
 487     {
 488       gdbpy_print_stack ();
 489       return EXT_LANG_RC_ERROR;
 490     }
 491
 492   /* PyTuple_SET_ITEM steals the reference of the element, hence the
 493      release.  */
 494   PyTuple_SET_ITEM (py_arg_tuple.get (), 0, py_value_obj.release ());
 495
 496   for (i = 0; i < nargs; i++)
 497     {
 498       PyObject *py_value_arg = value_to_value_object (args[i]);
 499
 500       if (py_value_arg == NULL)
 501         {
 502           gdbpy_print_stack ();
 503           return EXT_LANG_RC_ERROR;
 504         }
 505       PyTuple_SET_ITEM (py_arg_tuple.get (), i + 1, py_value_arg);
 506     }
 507
 508   gdbpy_ref py_result_type
 509     (PyObject_CallObject (get_result_type_method.get (), py_arg_tuple.get ()));
 510   if (py_result_type == NULL)
 511     {
 512       gdbpy_print_stack ();
 513       return EXT_LANG_RC_ERROR;
 514     }
 515
 516   *result_type_ptr = type_object_to_type (py_result_type.get ());
 517   if (*result_type_ptr == NULL)
 518     {
 519       PyErr_SetString (PyExc_TypeError,
 520                        _("Type returned by the get_result_type method of an"
 521                          " xmethod worker object is not a gdb.Type object."));
 522       gdbpy_print_stack ();
 523       return EXT_LANG_RC_ERROR;
 524     }
 525
 526   return EXT_LANG_RC_OK;
 527 }
 528
 529 /* Implementation of invoke_xmethod for Python.  */
 530
 531 struct value *
 532 gdbpy_invoke_xmethod (const struct extension_language_defn *extlang,
 533                       struct xmethod_worker *worker,
 534                       struct value *obj, struct value **args, int nargs)
 535 {
 536   int i;
 537   struct type *obj_type, *this_type;
 538   struct value *res = NULL;
 539   struct gdbpy_worker_data *worker_data
 540     = (struct gdbpy_worker_data *) worker->data;
 541   PyObject *xmethod_worker = worker_data->worker;
 542
 543   gdbpy_enter enter_py (get_current_arch (), current_language);
 544
 545   obj_type = check_typedef (value_type (obj));
 546   this_type = check_typedef (type_object_to_type (worker_data->this_type));
 547   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
 548     {
 549       struct type *this_ptr = lookup_pointer_type (this_type);
 550
 551       if (!types_equal (obj_type, this_ptr))
 552         obj = value_cast (this_ptr, obj);
 553     }
 554   else if (TYPE_CODE (obj_type) == TYPE_CODE_REF)
 555     {
 556       struct type *this_ref = lookup_reference_type (this_type);
 557
 558       if (!types_equal (obj_type, this_ref))
 559         obj = value_cast (this_ref, obj);
 560     }
 561   else
 562     {
 563       if (!types_equal (obj_type, this_type))
 564         obj = value_cast (this_type, obj);
 565     }
 566   gdbpy_ref py_value_obj (value_to_value_object (obj));
 567   if (py_value_obj == NULL)
 568     {
 569       gdbpy_print_stack ();
 570       error (_("Error while executing Python code."));
 571     }
 572
 573   gdbpy_ref py_arg_tuple (PyTuple_New (nargs + 1));
 574   if (py_arg_tuple == NULL)
 575     {
 576       gdbpy_print_stack ();
 577       error (_("Error while executing Python code."));
 578     }
 579
 580   /* PyTuple_SET_ITEM steals the reference of the element, hence the
 581      release.  */
 582   PyTuple_SET_ITEM (py_arg_tuple.get (), 0, py_value_obj.release ());
 583
 584   for (i = 0; i < nargs; i++)
 585     {
 586       PyObject *py_value_arg = value_to_value_object (args[i]);
 587
 588       if (py_value_arg == NULL)
 589         {
 590           gdbpy_print_stack ();
 591           error (_("Error while executing Python code."));
 592         }
 593
 594       PyTuple_SET_ITEM (py_arg_tuple.get (), i + 1, py_value_arg);
 595     }
 596
 597   gdbpy_ref py_result (PyObject_CallObject (xmethod_worker,
 598                                             py_arg_tuple.get ()));
 599   if (py_result == NULL)
 600     {
 601       gdbpy_print_stack ();
 602       error (_("Error while executing Python code."));
 603     }
 604
 605   if (py_result != Py_None)
 606     {
 607       res = convert_value_from_python (py_result.get ());
 608       if (res == NULL)
 609         {
 610           gdbpy_print_stack ();
 611           error (_("Error while executing Python code."));
 612         }
 613     }
 614   else
 615     {
 616       res = allocate_value (lookup_typename (python_language, python_gdbarch,
 617                                              "void", NULL, 0));
 618     }
 619
 620   return res;
 621 }
 622
 623 /* Creates a new Python xmethod_worker object.
 624    The new object has data of type 'struct gdbpy_worker_data' composed
 625    with the components PY_WORKER and THIS_TYPE.  */
 626
 627 static struct xmethod_worker *
 628 new_python_xmethod_worker (PyObject *py_worker, PyObject *this_type)
 629 {
 630   struct gdbpy_worker_data *data;
 631
 632   gdb_assert (py_worker != NULL && this_type != NULL);
 633
 634   data = XCNEW (struct gdbpy_worker_data);
 635   data->worker = py_worker;
 636   data->this_type = this_type;
 637   Py_INCREF (py_worker);
 638   Py_INCREF (this_type);
 639
 640   return new_xmethod_worker (&extension_language_python, data);
 641 }
 642
 643 int
 644 gdbpy_initialize_xmethods (void)
 645 {
 646   py_match_method_name = PyString_FromString (match_method_name);
 647   if (py_match_method_name == NULL)
 648     return -1;
 649
 650   py_get_arg_types_method_name
 651     = PyString_FromString (get_arg_types_method_name);
 652   if (py_get_arg_types_method_name == NULL)
 653     return -1;
 654
 655   return 1;
 656 }