gdb/python/py-xmethods.c

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