1 /* Support for debug methods in Python.
3 Copyright (C) 2013-2019 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/>. */
21 #include "arch-utils.h"
22 #include "extension-priv.h"
28 #include "python-internal.h"
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";
37 static PyObject
*py_match_method_name
= NULL
;
38 static PyObject
*py_get_arg_types_method_name
= NULL
;
40 struct python_xmethod_worker
: xmethod_worker
42 python_xmethod_worker (PyObject
*worker
, PyObject
*this_type
);
43 ~python_xmethod_worker ();
45 DISABLE_COPY_AND_ASSIGN (python_xmethod_worker
);
47 /* Implementation of xmethod_worker::invoke for Python. */
49 value
*invoke (value
*obj
, gdb::array_view
<value
*> args
) override
;
51 /* Implementation of xmethod_worker::do_get_arg_types for Python. */
53 ext_lang_rc
do_get_arg_types (std::vector
<type
*> *type_args
) override
;
55 /* Implementation of xmethod_worker::do_get_result_type for Python.
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. */
61 ext_lang_rc
do_get_result_type (value
*obj
, gdb::array_view
<value
*> args
,
62 type
**result_type_ptr
) override
;
66 PyObject
*m_py_worker
;
67 PyObject
*m_this_type
;
70 python_xmethod_worker::~python_xmethod_worker ()
72 /* We don't do much here, but we still need the GIL. */
73 gdbpy_enter
enter_py (get_current_arch (), current_language
);
75 Py_DECREF (m_py_worker
);
76 Py_DECREF (m_this_type
);
79 /* Invoke the "match" method of the MATCHER and return a new reference
80 to the result. Returns NULL on error. */
83 invoke_match_method (PyObject
*matcher
, PyObject
*py_obj_type
,
84 const char *xmethod_name
)
88 gdbpy_ref
<> enabled_field (PyObject_GetAttrString (matcher
,
90 if (enabled_field
== NULL
)
93 enabled
= PyObject_IsTrue (enabled_field
.get ());
98 /* Return 'None' if the matcher is not enabled. */
102 gdbpy_ref
<> match_method (PyObject_GetAttrString (matcher
,
104 if (match_method
== NULL
)
107 gdbpy_ref
<> py_xmethod_name (PyString_FromString (xmethod_name
));
108 if (py_xmethod_name
== NULL
)
111 return PyObject_CallMethodObjArgs (matcher
, py_match_method_name
,
112 py_obj_type
, py_xmethod_name
.get (),
116 /* Implementation of get_matching_xmethod_workers for Python. */
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
)
124 gdb_assert (obj_type
!= NULL
&& method_name
!= NULL
);
126 gdbpy_enter
enter_py (get_current_arch (), current_language
);
128 gdbpy_ref
<> py_type (type_to_type_object (obj_type
));
131 gdbpy_print_stack ();
132 return EXT_LANG_RC_ERROR
;
135 /* Create an empty list of debug methods. */
136 gdbpy_ref
<> py_xmethod_matcher_list (PyList_New (0));
137 if (py_xmethod_matcher_list
== NULL
)
139 gdbpy_print_stack ();
140 return EXT_LANG_RC_ERROR
;
143 /* Gather debug method matchers registered with the object files.
144 This could be done differently by iterating over each objfile's matcher
145 list individually, but there's no data yet to show it's needed. */
146 for (objfile
*objfile
: all_objfiles (current_program_space
))
148 gdbpy_ref
<> py_objfile
= objfile_to_objfile_object (objfile
);
150 if (py_objfile
== NULL
)
152 gdbpy_print_stack ();
153 return EXT_LANG_RC_ERROR
;
156 gdbpy_ref
<> objfile_matchers (objfpy_get_xmethods (py_objfile
.get (),
158 gdbpy_ref
<> temp (PySequence_Concat (py_xmethod_matcher_list
.get (),
159 objfile_matchers
.get ()));
162 gdbpy_print_stack ();
163 return EXT_LANG_RC_ERROR
;
166 py_xmethod_matcher_list
= std::move (temp
);
169 /* Gather debug methods matchers registered with the current program
171 gdbpy_ref
<> py_progspace
= pspace_to_pspace_object (current_program_space
);
172 if (py_progspace
!= NULL
)
174 gdbpy_ref
<> pspace_matchers (pspy_get_xmethods (py_progspace
.get (),
177 gdbpy_ref
<> temp (PySequence_Concat (py_xmethod_matcher_list
.get (),
178 pspace_matchers
.get ()));
181 gdbpy_print_stack ();
182 return EXT_LANG_RC_ERROR
;
185 py_xmethod_matcher_list
= std::move (temp
);
189 gdbpy_print_stack ();
190 return EXT_LANG_RC_ERROR
;
193 /* Gather debug method matchers registered globally. */
194 if (gdb_python_module
!= NULL
195 && PyObject_HasAttrString (gdb_python_module
, matchers_attr_str
))
197 gdbpy_ref
<> gdb_matchers (PyObject_GetAttrString (gdb_python_module
,
199 if (gdb_matchers
!= NULL
)
201 gdbpy_ref
<> temp (PySequence_Concat (py_xmethod_matcher_list
.get (),
202 gdb_matchers
.get ()));
205 gdbpy_print_stack ();
206 return EXT_LANG_RC_ERROR
;
209 py_xmethod_matcher_list
= std::move (temp
);
213 gdbpy_print_stack ();
214 return EXT_LANG_RC_ERROR
;
218 gdbpy_ref
<> list_iter (PyObject_GetIter (py_xmethod_matcher_list
.get ()));
219 if (list_iter
== NULL
)
221 gdbpy_print_stack ();
222 return EXT_LANG_RC_ERROR
;
226 gdbpy_ref
<> matcher (PyIter_Next (list_iter
.get ()));
229 if (PyErr_Occurred ())
231 gdbpy_print_stack ();
232 return EXT_LANG_RC_ERROR
;
237 gdbpy_ref
<> match_result (invoke_match_method (matcher
.get (),
241 if (match_result
== NULL
)
243 gdbpy_print_stack ();
244 return EXT_LANG_RC_ERROR
;
246 if (match_result
== Py_None
)
247 ; /* This means there was no match. */
248 else if (PySequence_Check (match_result
.get ()))
250 gdbpy_ref
<> iter (PyObject_GetIter (match_result
.get ()));
254 gdbpy_print_stack ();
255 return EXT_LANG_RC_ERROR
;
259 struct xmethod_worker
*worker
;
261 gdbpy_ref
<> py_worker (PyIter_Next (iter
.get ()));
262 if (py_worker
== NULL
)
264 if (PyErr_Occurred ())
266 gdbpy_print_stack ();
267 return EXT_LANG_RC_ERROR
;
272 worker
= new python_xmethod_worker (py_worker
.get (),
275 dm_vec
->emplace_back (worker
);
280 struct xmethod_worker
*worker
;
282 worker
= new python_xmethod_worker (match_result
.get (),
284 dm_vec
->emplace_back (worker
);
288 return EXT_LANG_RC_OK
;
291 /* See declaration. */
294 python_xmethod_worker::do_get_arg_types (std::vector
<type
*> *arg_types
)
296 /* The gdbpy_enter object needs to be placed first, so that it's the last to
298 gdbpy_enter
enter_py (get_current_arch (), current_language
);
299 struct type
*obj_type
;
300 int i
= 1, arg_count
;
301 gdbpy_ref
<> list_iter
;
303 gdbpy_ref
<> get_arg_types_method
304 (PyObject_GetAttrString (m_py_worker
, get_arg_types_method_name
));
305 if (get_arg_types_method
== NULL
)
307 gdbpy_print_stack ();
308 return EXT_LANG_RC_ERROR
;
311 gdbpy_ref
<> py_argtype_list
312 (PyObject_CallMethodObjArgs (m_py_worker
, py_get_arg_types_method_name
,
314 if (py_argtype_list
== NULL
)
316 gdbpy_print_stack ();
317 return EXT_LANG_RC_ERROR
;
320 if (py_argtype_list
== Py_None
)
322 else if (PySequence_Check (py_argtype_list
.get ()))
324 arg_count
= PySequence_Size (py_argtype_list
.get ());
327 gdbpy_print_stack ();
328 return EXT_LANG_RC_ERROR
;
331 list_iter
.reset (PyObject_GetIter (py_argtype_list
.get ()));
332 if (list_iter
== NULL
)
334 gdbpy_print_stack ();
335 return EXT_LANG_RC_ERROR
;
341 /* Include the 'this' argument in the size. */
342 arg_types
->resize (arg_count
+ 1);
344 if (list_iter
!= NULL
)
348 gdbpy_ref
<> item (PyIter_Next (list_iter
.get ()));
351 if (PyErr_Occurred ())
353 gdbpy_print_stack ();
354 return EXT_LANG_RC_ERROR
;
359 struct type
*arg_type
= type_object_to_type (item
.get ());
360 if (arg_type
== NULL
)
362 PyErr_SetString (PyExc_TypeError
,
363 _("Arg type returned by the get_arg_types "
364 "method of a debug method worker object is "
365 "not a gdb.Type object."));
366 return EXT_LANG_RC_ERROR
;
369 (*arg_types
)[i
] = arg_type
;
373 else if (arg_count
== 1)
375 /* py_argtype_list is not actually a list but a single gdb.Type
377 struct type
*arg_type
= type_object_to_type (py_argtype_list
.get ());
379 if (arg_type
== NULL
)
381 PyErr_SetString (PyExc_TypeError
,
382 _("Arg type returned by the get_arg_types method "
383 "of an xmethod worker object is not a gdb.Type "
385 return EXT_LANG_RC_ERROR
;
389 (*arg_types
)[i
] = arg_type
;
394 /* Add the type of 'this' as the first argument. The 'this' pointer should
395 be a 'const' value. Hence, create a 'const' variant of the 'this' pointer
397 obj_type
= type_object_to_type (m_this_type
);
398 (*arg_types
)[0] = make_cv_type (1, 0, lookup_pointer_type (obj_type
),
401 return EXT_LANG_RC_OK
;
404 /* See declaration. */
407 python_xmethod_worker::do_get_result_type (value
*obj
,
408 gdb::array_view
<value
*> args
,
409 type
**result_type_ptr
)
411 struct type
*obj_type
, *this_type
;
414 gdbpy_enter
enter_py (get_current_arch (), current_language
);
416 /* First see if there is a get_result_type method.
417 If not this could be an old xmethod (pre 7.9.1). */
418 gdbpy_ref
<> get_result_type_method
419 (PyObject_GetAttrString (m_py_worker
, get_result_type_method_name
));
420 if (get_result_type_method
== NULL
)
423 *result_type_ptr
= NULL
;
424 return EXT_LANG_RC_OK
;
427 obj_type
= check_typedef (value_type (obj
));
428 this_type
= check_typedef (type_object_to_type (m_this_type
));
429 if (TYPE_CODE (obj_type
) == TYPE_CODE_PTR
)
431 struct type
*this_ptr
= lookup_pointer_type (this_type
);
433 if (!types_equal (obj_type
, this_ptr
))
434 obj
= value_cast (this_ptr
, obj
);
436 else if (TYPE_IS_REFERENCE (obj_type
))
438 struct type
*this_ref
439 = lookup_reference_type (this_type
, TYPE_CODE (obj_type
));
441 if (!types_equal (obj_type
, this_ref
))
442 obj
= value_cast (this_ref
, obj
);
446 if (!types_equal (obj_type
, this_type
))
447 obj
= value_cast (this_type
, obj
);
449 gdbpy_ref
<> py_value_obj (value_to_value_object (obj
));
450 if (py_value_obj
== NULL
)
452 gdbpy_print_stack ();
453 return EXT_LANG_RC_ERROR
;
456 gdbpy_ref
<> py_arg_tuple (PyTuple_New (args
.size () + 1));
457 if (py_arg_tuple
== NULL
)
459 gdbpy_print_stack ();
460 return EXT_LANG_RC_ERROR
;
463 /* PyTuple_SET_ITEM steals the reference of the element, hence the
465 PyTuple_SET_ITEM (py_arg_tuple
.get (), 0, py_value_obj
.release ());
467 for (i
= 0; i
< args
.size (); i
++)
469 PyObject
*py_value_arg
= value_to_value_object (args
[i
]);
471 if (py_value_arg
== NULL
)
473 gdbpy_print_stack ();
474 return EXT_LANG_RC_ERROR
;
476 PyTuple_SET_ITEM (py_arg_tuple
.get (), i
+ 1, py_value_arg
);
479 gdbpy_ref
<> py_result_type
480 (PyObject_CallObject (get_result_type_method
.get (), py_arg_tuple
.get ()));
481 if (py_result_type
== NULL
)
483 gdbpy_print_stack ();
484 return EXT_LANG_RC_ERROR
;
487 *result_type_ptr
= type_object_to_type (py_result_type
.get ());
488 if (*result_type_ptr
== NULL
)
490 PyErr_SetString (PyExc_TypeError
,
491 _("Type returned by the get_result_type method of an"
492 " xmethod worker object is not a gdb.Type object."));
493 gdbpy_print_stack ();
494 return EXT_LANG_RC_ERROR
;
497 return EXT_LANG_RC_OK
;
500 /* See declaration. */
503 python_xmethod_worker::invoke (struct value
*obj
,
504 gdb::array_view
<value
*> args
)
506 gdbpy_enter
enter_py (get_current_arch (), current_language
);
509 struct type
*obj_type
, *this_type
;
510 struct value
*res
= NULL
;
512 obj_type
= check_typedef (value_type (obj
));
513 this_type
= check_typedef (type_object_to_type (m_this_type
));
514 if (TYPE_CODE (obj_type
) == TYPE_CODE_PTR
)
516 struct type
*this_ptr
= lookup_pointer_type (this_type
);
518 if (!types_equal (obj_type
, this_ptr
))
519 obj
= value_cast (this_ptr
, obj
);
521 else if (TYPE_IS_REFERENCE (obj_type
))
523 struct type
*this_ref
524 = lookup_reference_type (this_type
, TYPE_CODE (obj_type
));
526 if (!types_equal (obj_type
, this_ref
))
527 obj
= value_cast (this_ref
, obj
);
531 if (!types_equal (obj_type
, this_type
))
532 obj
= value_cast (this_type
, obj
);
534 gdbpy_ref
<> py_value_obj (value_to_value_object (obj
));
535 if (py_value_obj
== NULL
)
537 gdbpy_print_stack ();
538 error (_("Error while executing Python code."));
541 gdbpy_ref
<> py_arg_tuple (PyTuple_New (args
.size () + 1));
542 if (py_arg_tuple
== NULL
)
544 gdbpy_print_stack ();
545 error (_("Error while executing Python code."));
548 /* PyTuple_SET_ITEM steals the reference of the element, hence the
550 PyTuple_SET_ITEM (py_arg_tuple
.get (), 0, py_value_obj
.release ());
552 for (i
= 0; i
< args
.size (); i
++)
554 PyObject
*py_value_arg
= value_to_value_object (args
[i
]);
556 if (py_value_arg
== NULL
)
558 gdbpy_print_stack ();
559 error (_("Error while executing Python code."));
562 PyTuple_SET_ITEM (py_arg_tuple
.get (), i
+ 1, py_value_arg
);
565 gdbpy_ref
<> py_result (PyObject_CallObject (m_py_worker
,
566 py_arg_tuple
.get ()));
567 if (py_result
== NULL
)
569 gdbpy_print_stack ();
570 error (_("Error while executing Python code."));
573 if (py_result
!= Py_None
)
575 res
= convert_value_from_python (py_result
.get ());
578 gdbpy_print_stack ();
579 error (_("Error while executing Python code."));
584 res
= allocate_value (lookup_typename (python_language
, python_gdbarch
,
591 python_xmethod_worker::python_xmethod_worker (PyObject
*py_worker
,
593 : xmethod_worker (&extension_language_python
),
594 m_py_worker (py_worker
), m_this_type (this_type
)
596 gdb_assert (m_py_worker
!= NULL
&& m_this_type
!= NULL
);
598 Py_INCREF (py_worker
);
599 Py_INCREF (this_type
);
603 gdbpy_initialize_xmethods (void)
605 py_match_method_name
= PyString_FromString (match_method_name
);
606 if (py_match_method_name
== NULL
)
609 py_get_arg_types_method_name
610 = PyString_FromString (get_arg_types_method_name
);
611 if (py_get_arg_types_method_name
== NULL
)