gdb/python/py-xmethods.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Support for debug methods in Python.

  3.    Copyright (C) 2013-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  27. #include "python.h"
  28. #include "python-internal.h"

  30. ‌static const char enabled_field_name[] = "enabled";
  31. ‌static const char match_method_name[] = "match";
  32. ‌static const char get_arg_types_method_name[] = "get_arg_types";
  33. ‌static const char invoke_method_name[] = "invoke";
  34. ‌static const char matchers_attr_str[] = "xmethods";

  36. ‌static PyObject *py_match_method_name = NULL;
  37. ‌static PyObject *py_get_arg_types_method_name = NULL;
  38. ‌static PyObject *py_invoke_method_name = NULL;

  40. ‌struct gdbpy_worker_data
  41. {
  42.   PyObject *worker;
  43.   PyObject *this_type;
  44. };

  46. static struct xmethod_worker *new_python_xmethod_worker (PyObject *item,
  47.                                                          PyObject *py_obj_type);

  49. /* Implementation of free_xmethod_worker_data for Python.  */

  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 = data;
  56.   struct cleanup *cleanups;

  58.   gdb_assert (worker_data->worker != NULL && worker_data->this_type != NULL);

  60.   /* We don't do much here, but we still need the GIL.  */
  61.   cleanups = ensure_python_env (get_current_arch (), current_language);

  63.   Py_DECREF (worker_data->worker);
  64.   Py_DECREF (worker_data->this_type);
  65.   xfree (worker_data);

  67.   do_cleanups (cleanups);
  68. }

  70. /* Implementation of clone_xmethod_worker_data for Python.  */

  72. void *
  73. ‌gdbpy_clone_xmethod_worker_data (const struct extension_language_defn *extlang,
  74.                                  void *data)
  75. {
  76.   struct gdbpy_worker_data *worker_data = data, *new_data;
  77.   struct cleanup *cleanups;

  79.   gdb_assert (worker_data->worker != NULL && worker_data->this_type != NULL);

  81.   /* We don't do much here, but we still need the GIL.  */
  82.   cleanups = ensure_python_env (get_current_arch (), current_language);

  84.   new_data = XCNEW (struct gdbpy_worker_data);
  85.   new_data->worker = worker_data->worker;
  86.   new_data->this_type = worker_data->this_type;
  87.   Py_INCREF (new_data->worker);
  88.   Py_INCREF (new_data->this_type);

  90.   do_cleanups (cleanups);

  92.   return new_data;
  93. }

  95. /* Invoke the "match" method of the MATCHER and return a new reference
  96.    to the result.  Returns NULL on error.  */

  98. static PyObject *
  99. ‌invoke_match_method (PyObject *matcher, PyObject *py_obj_type,
  100.                      const char *xmethod_name)
  101. {
  102.   PyObject *py_xmethod_name;
  103.   PyObject *match_method, *enabled_field, *match_result;
  104.   struct cleanup *cleanups;
  105.   int enabled;

  107.   cleanups = make_cleanup (null_cleanup, NULL);

  109.   enabled_field = PyObject_GetAttrString (matcher, enabled_field_name);
  110.   if (enabled_field == NULL)
  111.     {
  112.       do_cleanups (cleanups);
  113.       return NULL;
  114.     }
  115.   make_cleanup_py_decref (enabled_field);

  117.   enabled = PyObject_IsTrue (enabled_field);
  118.   if (enabled == -1)
  119.     {
  120.       do_cleanups (cleanups);
  121.       return NULL;
  122.     }
  123.   if (enabled == 0)
  124.     {
  125.       /* Return 'None' if the matcher is not enabled.  */
  126.       do_cleanups (cleanups);
  127.       Py_RETURN_NONE;
  128.     }

  130.   match_method = PyObject_GetAttrString (matcher, match_method_name);
  131.   if (match_method == NULL)
  132.     {
  133.       do_cleanups (cleanups);
  134.       return NULL;
  135.     }
  136.   make_cleanup_py_decref (match_method);

  138.   py_xmethod_name = PyString_FromString (xmethod_name);
  139.   if (py_xmethod_name == NULL)
  140.     {
  141.       do_cleanups (cleanups);
  142.       return NULL;
  143.     }
  144.   make_cleanup_py_decref (py_xmethod_name);

  146.   match_result = PyObject_CallMethodObjArgs (matcher,
  147.                                              py_match_method_name,
  148.                                              py_obj_type,
  149.                                              py_xmethod_name,
  150.                                              NULL);

  152.   do_cleanups (cleanups);

  154.   return match_result;
  155. }

  157. /* Implementation of get_matching_xmethod_workers for Python.  */

  159. enum ext_lang_rc
  160. ‌gdbpy_get_matching_xmethod_workers
  161.   (const struct extension_language_defn *extlang,
  162.    struct type *obj_type, const char *method_name,
  163.    xmethod_worker_vec **dm_vec)
  164. {
  165.   struct cleanup *cleanups;
  166.   struct objfile *objfile;
  167.   VEC (xmethod_worker_ptr) *worker_vec = NULL;
  168.   PyObject *py_type, *py_progspace;
  169.   PyObject *py_xmethod_matcher_list = NULL, *list_iter, *matcher;

  171.   gdb_assert (obj_type != NULL && method_name != NULL);

  173.   cleanups = ensure_python_env (get_current_arch (), current_language);

  175.   py_type = type_to_type_object (obj_type);
  176.   if (py_type == NULL)
  177.     {
  178.       gdbpy_print_stack ();
  179.       do_cleanups (cleanups);

  181.       return EXT_LANG_RC_ERROR;
  182.     }
  183.   make_cleanup_py_decref (py_type);

  185.   /* Create an empty list of debug methods.  */
  186.   py_xmethod_matcher_list = PyList_New (0);
  187.   if (py_xmethod_matcher_list == NULL)
  188.     {
  189.       gdbpy_print_stack ();
  190.       do_cleanups (cleanups);

  192.       return EXT_LANG_RC_ERROR;
  193.     }

  195.   /* Gather debug method matchers registered with the object files.
  196.      This could be done differently by iterating over each objfile's matcher
  197.      list individually, but there's no data yet to show it's needed.  */
  198.   ALL_OBJFILES (objfile)
  199.     {
  200.       PyObject *py_objfile = objfile_to_objfile_object (objfile);
  201.       PyObject *objfile_matchers, *temp = py_xmethod_matcher_list;

  203.       if (py_objfile == NULL)
  204.         {
  205.           gdbpy_print_stack ();
  206.           Py_DECREF (py_xmethod_matcher_list);
  207.           do_cleanups (cleanups);

  209.           return EXT_LANG_RC_ERROR;
  210.         }

  212.       objfile_matchers = objfpy_get_xmethods (py_objfile, NULL);
  213.       py_xmethod_matcher_list = PySequence_Concat (temp, objfile_matchers);
  214.       Py_DECREF (temp);
  215.       Py_DECREF (objfile_matchers);
  216.       if (py_xmethod_matcher_list == NULL)
  217.         {
  218.           gdbpy_print_stack ();
  219.           do_cleanups (cleanups);

  221.           return EXT_LANG_RC_ERROR;
  222.         }
  223.     }

  225.   /* Gather debug methods matchers registered with the current program
  226.      space.  */
  227.   py_progspace = pspace_to_pspace_object (current_program_space);
  228.   if (py_progspace != NULL)
  229.     {
  230.       PyObject *temp = py_xmethod_matcher_list;
  231.       PyObject *pspace_matchers = pspy_get_xmethods (py_progspace, NULL);

  233.       py_xmethod_matcher_list = PySequence_Concat (temp, pspace_matchers);
  234.       Py_DECREF (temp);
  235.       Py_DECREF (pspace_matchers);
  236.       if (py_xmethod_matcher_list == NULL)
  237.         {
  238.           gdbpy_print_stack ();
  239.           do_cleanups (cleanups);

  241.           return EXT_LANG_RC_ERROR;
  242.         }
  243.     }
  244.   else
  245.     {
  246.       gdbpy_print_stack ();
  247.       Py_DECREF (py_xmethod_matcher_list);
  248.       do_cleanups (cleanups);

  250.       return EXT_LANG_RC_ERROR;
  251.     }

  253.   /* Gather debug method matchers registered globally.  */
  254.   if (gdb_python_module != NULL
  255.       && PyObject_HasAttrString (gdb_python_module, matchers_attr_str))
  256.     {
  257.       PyObject *gdb_matchers;
  258.       PyObject *temp = py_xmethod_matcher_list;

  260.       gdb_matchers = PyObject_GetAttrString (gdb_python_module,
  261.                                              matchers_attr_str);
  262.       if (gdb_matchers != NULL)
  263.         {
  264.           py_xmethod_matcher_list = PySequence_Concat (temp, gdb_matchers);
  265.           Py_DECREF (temp);
  266.           Py_DECREF (gdb_matchers);
  267.           if (py_xmethod_matcher_list == NULL)
  268.             {
  269.               gdbpy_print_stack ();
  270.               do_cleanups (cleanups);

  272.               return EXT_LANG_RC_ERROR;
  273.             }
  274.         }
  275.       else
  276.         {
  277.           gdbpy_print_stack ();
  278.           Py_DECREF (py_xmethod_matcher_list);
  279.           do_cleanups (cleanups);

  281.           return EXT_LANG_RC_ERROR;
  282.         }
  283.     }

  285.   /* Safe to make a cleanup for py_xmethod_matcher_list now as it
  286.      will not change any more.  */
  287.   make_cleanup_py_decref (py_xmethod_matcher_list);

  289.   list_iter = PyObject_GetIter (py_xmethod_matcher_list);
  290.   if (list_iter == NULL)
  291.     {
  292.       gdbpy_print_stack ();
  293.       do_cleanups (cleanups);

  295.       return EXT_LANG_RC_ERROR;
  296.     }
  297.   while ((matcher = PyIter_Next (list_iter)) != NULL)
  298.     {
  299.       PyObject *match_result = invoke_match_method (matcher, py_type,
  300.                                                     method_name);

  302.       if (match_result == NULL)
  303.         {
  304.           gdbpy_print_stack ();
  305.           Py_DECREF (matcher);
  306.           do_cleanups (cleanups);

  308.           return EXT_LANG_RC_ERROR;
  309.         }
  310.       if (match_result == Py_None)
  311.         ; /* This means there was no match.  */
  312.       else if (PySequence_Check (match_result))
  313.         {
  314.           PyObject *iter = PyObject_GetIter (match_result);
  315.           PyObject *py_worker;

  317.           if (iter == NULL)
  318.             {
  319.               gdbpy_print_stack ();
  320.               Py_DECREF (matcher);
  321.               Py_DECREF (match_result);
  322.               do_cleanups (cleanups);

  324.               return EXT_LANG_RC_ERROR;
  325.             }
  326.           while ((py_worker = PyIter_Next (iter)) != NULL)
  327.             {
  328.               struct xmethod_worker *worker;

  330.               worker = new_python_xmethod_worker (py_worker, py_type);
  331.               VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
  332.               Py_DECREF (py_worker);
  333.             }
  334.           Py_DECREF (iter);
  335.           /* Report any error that could have occurred while iterating.  */
  336.           if (PyErr_Occurred ())
  337.             {
  338.               gdbpy_print_stack ();
  339.               Py_DECREF (matcher);
  340.               Py_DECREF (match_result);
  341.               do_cleanups (cleanups);

  343.               return EXT_LANG_RC_ERROR;
  344.             }
  345.         }
  346.       else
  347.         {
  348.           struct xmethod_worker *worker;

  350.           worker = new_python_xmethod_worker (match_result, py_type);
  351.           VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
  352.         }

  354.       Py_DECREF (match_result);
  355.       Py_DECREF (matcher);
  356.     }
  357.   Py_DECREF (list_iter);
  358.   /* Report any error that could have occurred while iterating.  */
  359.   if (PyErr_Occurred ())
  360.     {
  361.       gdbpy_print_stack ();
  362.       do_cleanups (cleanups);

  364.       return EXT_LANG_RC_ERROR;
  365.     }

  367.   do_cleanups (cleanups);
  368.   *dm_vec = worker_vec;

  370.   return EXT_LANG_RC_OK;
  371. }

  373. /* Implementation of get_xmethod_arg_types for Python.  */

  375. enum ext_lang_rc
  376. ‌gdbpy_get_xmethod_arg_types (const struct extension_language_defn *extlang,
  377.                              struct xmethod_worker *worker,
  378.                              int *nargs, struct type ***arg_types)
  379. {
  380.   struct gdbpy_worker_data *worker_data = worker->data;
  381.   PyObject *py_worker = worker_data->worker;
  382.   PyObject *get_arg_types_method;
  383.   PyObject *py_argtype_list, *list_iter = NULL, *item;
  384.   struct cleanup *cleanups;
  385.   struct type **type_array, *obj_type;
  386.   int i = 1, arg_count;

  388.   /* Set nargs to -1 so that any premature return from this function returns
  389.      an invalid/unusable number of arg types.  */
  390.   *nargs = -1;

  392.   cleanups = ensure_python_env (get_current_arch (), current_language);

  394.   get_arg_types_method =  PyObject_GetAttrString (py_worker,
  395.                                                   get_arg_types_method_name);
  396.   if (get_arg_types_method == NULL)
  397.     {
  398.       gdbpy_print_stack ();
  399.       do_cleanups (cleanups);

  401.       return EXT_LANG_RC_ERROR;
  402.     }
  403.   make_cleanup_py_decref (get_arg_types_method);

  405.   py_argtype_list = PyObject_CallMethodObjArgs (py_worker,
  406.                                                 py_get_arg_types_method_name,
  407.                                                 NULL);
  408.   if (py_argtype_list == NULL)
  409.     {
  410.       gdbpy_print_stack ();
  411.       do_cleanups (cleanups);

  413.       return EXT_LANG_RC_ERROR;
  414.     }
  415.   make_cleanup_py_decref (py_argtype_list);
  416.   if (py_argtype_list == Py_None)
  417.     arg_count = 0;
  418.   else if (PySequence_Check (py_argtype_list))
  419.     {
  420.       arg_count = PySequence_Size (py_argtype_list);
  421.       if (arg_count == -1)
  422.         {
  423.           gdbpy_print_stack ();
  424.           do_cleanups (cleanups);

  426.           return EXT_LANG_RC_ERROR;
  427.         }

  429.       list_iter = PyObject_GetIter (py_argtype_list);
  430.       if (list_iter == NULL)
  431.         {
  432.           gdbpy_print_stack ();
  433.           do_cleanups (cleanups);

  435.           return EXT_LANG_RC_ERROR;
  436.         }
  437.       make_cleanup_py_decref (list_iter);
  438.     }
  439.   else
  440.     arg_count = 1;

  442.   /* Include the 'this' argument in the size.  */
  443.   type_array = XCNEWVEC (struct type *, arg_count + 1);
  444.   i = 1;
  445.   if (list_iter != NULL)
  446.     {
  447.       while ((item = PyIter_Next (list_iter)) != NULL)
  448.         {
  449.           struct type *arg_type = type_object_to_type (item);

  451.           Py_DECREF (item);
  452.           if (arg_type == NULL)
  453.             {
  454.               PyErr_SetString (PyExc_TypeError,
  455.                                _("Arg type returned by the get_arg_types "
  456.                                  "method of a debug method worker object is "
  457.                                  "not a gdb.Type object."));
  458.               break;
  459.             }

  461.           type_array[i] = arg_type;
  462.           i++;
  463.         }
  464.     }
  465.   else if (arg_count == 1)
  466.     {
  467.       /* py_argtype_list is not actually a list but a single gdb.Type
  468.          object.  */
  469.       struct type *arg_type = type_object_to_type (py_argtype_list);

  471.       if (arg_type == NULL)
  472.         {
  473.           PyErr_SetString (PyExc_TypeError,
  474.                            _("Arg type returned by the get_arg_types method "
  475.                              "of an xmethod worker object is not a gdb.Type "
  476.                              "object."));
  477.         }
  478.       else
  479.         {
  480.           type_array[i] = arg_type;
  481.           i++;
  482.         }
  483.     }
  484.   if (PyErr_Occurred ())
  485.     {
  486.       gdbpy_print_stack ();
  487.       do_cleanups (cleanups);
  488.       xfree (type_array);

  490.       return EXT_LANG_RC_ERROR;
  491.     }

  493.   /* Add the type of 'this' as the first argument.  The 'this' pointer should
  494.      be a 'const' value.  Hence, create a 'const' variant of the 'this' pointer
  495.      type.  */
  496.   obj_type = type_object_to_type (worker_data->this_type);
  497.   type_array[0] = make_cv_type (1, 0, lookup_pointer_type (obj_type), NULL);
  498.   *nargs = i;
  499.   *arg_types = type_array;
  500.   do_cleanups (cleanups);

  502.   return EXT_LANG_RC_OK;
  503. }

  505. /* Implementation of invoke_xmethod for Python.  */

  507. struct value *
  508. ‌gdbpy_invoke_xmethod (const struct extension_language_defn *extlang,
  509.                       struct xmethod_worker *worker,
  510.                       struct value *obj, struct value **args, int nargs)
  511. {
  512.   int i;
  513.   struct cleanup *cleanups;
  514.   PyObject *py_value_obj, *py_arg_tuple, *py_result;
  515.   struct type *obj_type, *this_type;
  516.   struct value *res = NULL;
  517.   struct gdbpy_worker_data *worker_data = worker->data;
  518.   PyObject *xmethod_worker = worker_data->worker;

  520.   cleanups = ensure_python_env (get_current_arch (), current_language);

  522.   obj_type = check_typedef (value_type (obj));
  523.   this_type = check_typedef (type_object_to_type (worker_data->this_type));
  524.   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
  525.     {
  526.       struct type *this_ptr = lookup_pointer_type (this_type);

  528.       if (!types_equal (obj_type, this_ptr))
  529.         obj = value_cast (this_ptr, obj);
  530.     }
  531.   else if (TYPE_CODE (obj_type) == TYPE_CODE_REF)
  532.     {
  533.       struct type *this_ref = lookup_reference_type (this_type);

  535.       if (!types_equal (obj_type, this_ref))
  536.         obj = value_cast (this_ref, obj);
  537.     }
  538.   else
  539.     {
  540.       if (!types_equal (obj_type, this_type))
  541.         obj = value_cast (this_type, obj);
  542.     }
  543.   py_value_obj = value_to_value_object (obj);
  544.   if (py_value_obj == NULL)
  545.     {
  546.       gdbpy_print_stack ();
  547.       error (_("Error while executing Python code."));
  548.     }
  549.   make_cleanup_py_decref (py_value_obj);

  551.   py_arg_tuple = PyTuple_New (nargs + 1);
  552.   if (py_arg_tuple == NULL)
  553.     {
  554.       gdbpy_print_stack ();
  555.       error (_("Error while executing Python code."));
  556.     }
  557.   make_cleanup_py_decref (py_arg_tuple);

  559.   /* PyTuple_SET_ITEM steals the reference of the element.  Hence INCREF the
  560.      reference to the 'this' object as we have a cleanup to DECREF it.  */
  561.   Py_INCREF (py_value_obj);
  562.   PyTuple_SET_ITEM (py_arg_tuple, 0, py_value_obj);

  564.   for (i = 0; i < nargs; i++)
  565.     {
  566.       PyObject *py_value_arg = value_to_value_object (args[i]);

  568.       if (py_value_arg == NULL)
  569.         {
  570.           gdbpy_print_stack ();
  571.           error (_("Error while executing Python code."));
  572.         }

  574.       PyTuple_SET_ITEM (py_arg_tuple, i + 1, py_value_arg);
  575.     }

  577.   py_result = PyObject_CallObject (xmethod_worker, py_arg_tuple);
  578.   if (py_result == NULL)
  579.     {
  580.       gdbpy_print_stack ();
  581.       error (_("Error while executing Python code."));
  582.     }
  583.   make_cleanup_py_decref (py_result);

  585.   if (py_result != Py_None)
  586.     {
  587.       res = convert_value_from_python (py_result);
  588.       if (res == NULL)
  589.         {
  590.           gdbpy_print_stack ();
  591.           error (_("Error while executing Python code."));
  592.         }
  593.     }
  594.   else
  595.     {
  596.       res = allocate_value (lookup_typename (python_language, python_gdbarch,
  597.                                              "void", NULL, 0));
  598.     }

  600.   do_cleanups (cleanups);

  602.   return res;
  603. }

  605. /* Creates a new Python xmethod_worker object.
  606.    The new object has data of type 'struct gdbpy_worker_data' composed
  607.    with the components PY_WORKER and THIS_TYPE.  */

  609. static struct xmethod_worker *
  610. ‌new_python_xmethod_worker (PyObject *py_worker, PyObject *this_type)
  611. {
  612.   struct gdbpy_worker_data *data;

  614.   gdb_assert (py_worker != NULL && this_type != NULL);

  616.   data = XCNEW (struct gdbpy_worker_data);
  617.   data->worker = py_worker;
  618.   data->this_type = this_type;
  619.   Py_INCREF (py_worker);
  620.   Py_INCREF (this_type);

  622.   return new_xmethod_worker (&extension_language_python, data);
  623. }

  625. int
  626. ‌gdbpy_initialize_xmethods (void)
  627. {
  628.   py_match_method_name = PyString_FromString (match_method_name);
  629.   if (py_match_method_name == NULL)
  630.     return -1;

  632.   py_invoke_method_name = PyString_FromString (invoke_method_name);
  633.   if (py_invoke_method_name == NULL)
  634.     return -1;

  636.   py_get_arg_types_method_name
  637.     = PyString_FromString (get_arg_types_method_name);
  638.   if (py_get_arg_types_method_name == NULL)
  639.     return -1;

  641.   return 1;
  642. }