1 /* Support for debug methods in Python.
3 Copyright (C) 2013-2017 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 gdbpy_worker_data
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. */
52 gdbpy_free_xmethod_worker_data (const struct extension_language_defn
*extlang
,
55 struct gdbpy_worker_data
*worker_data
= (struct gdbpy_worker_data
*) data
;
57 gdb_assert (worker_data
->worker
!= NULL
&& worker_data
->this_type
!= NULL
);
59 /* We don't do much here, but we still need the GIL. */
60 gdbpy_enter
enter_py (get_current_arch (), current_language
);
62 Py_DECREF (worker_data
->worker
);
63 Py_DECREF (worker_data
->this_type
);
67 /* Implementation of clone_xmethod_worker_data for Python. */
70 gdbpy_clone_xmethod_worker_data (const struct extension_language_defn
*extlang
,
73 struct gdbpy_worker_data
*worker_data
74 = (struct gdbpy_worker_data
*) data
, *new_data
;
76 gdb_assert (worker_data
->worker
!= NULL
&& worker_data
->this_type
!= NULL
);
78 /* We don't do much here, but we still need the GIL. */
79 gdbpy_enter
enter_py (get_current_arch (), current_language
);
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
);
90 /* Invoke the "match" method of the MATCHER and return a new reference
91 to the result. Returns NULL on error. */
94 invoke_match_method (PyObject
*matcher
, PyObject
*py_obj_type
,
95 const char *xmethod_name
)
99 gdbpy_ref
enabled_field (PyObject_GetAttrString (matcher
,
100 enabled_field_name
));
101 if (enabled_field
== NULL
)
104 enabled
= PyObject_IsTrue (enabled_field
.get ());
109 /* Return 'None' if the matcher is not enabled. */
113 gdbpy_ref
match_method (PyObject_GetAttrString (matcher
, match_method_name
));
114 if (match_method
== NULL
)
117 gdbpy_ref
py_xmethod_name (PyString_FromString (xmethod_name
));
118 if (py_xmethod_name
== NULL
)
121 return PyObject_CallMethodObjArgs (matcher
, py_match_method_name
,
122 py_obj_type
, py_xmethod_name
.get (),
126 /* Implementation of get_matching_xmethod_workers for Python. */
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
)
134 struct objfile
*objfile
;
135 VEC (xmethod_worker_ptr
) *worker_vec
= NULL
;
136 PyObject
*py_progspace
;
138 gdb_assert (obj_type
!= NULL
&& method_name
!= NULL
);
140 gdbpy_enter
enter_py (get_current_arch (), current_language
);
142 gdbpy_ref
py_type (type_to_type_object (obj_type
));
145 gdbpy_print_stack ();
146 return EXT_LANG_RC_ERROR
;
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
)
153 gdbpy_print_stack ();
154 return EXT_LANG_RC_ERROR
;
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
)
162 PyObject
*py_objfile
= objfile_to_objfile_object (objfile
);
164 if (py_objfile
== NULL
)
166 gdbpy_print_stack ();
167 return EXT_LANG_RC_ERROR
;
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 ()));
175 gdbpy_print_stack ();
176 return EXT_LANG_RC_ERROR
;
179 py_xmethod_matcher_list
= std::move (temp
);
182 /* Gather debug methods matchers registered with the current program
184 py_progspace
= pspace_to_pspace_object (current_program_space
);
185 if (py_progspace
!= NULL
)
187 gdbpy_ref
pspace_matchers (pspy_get_xmethods (py_progspace
, NULL
));
189 gdbpy_ref
temp (PySequence_Concat (py_xmethod_matcher_list
.get (),
190 pspace_matchers
.get ()));
193 gdbpy_print_stack ();
194 return EXT_LANG_RC_ERROR
;
197 py_xmethod_matcher_list
= std::move (temp
);
201 gdbpy_print_stack ();
202 return EXT_LANG_RC_ERROR
;
205 /* Gather debug method matchers registered globally. */
206 if (gdb_python_module
!= NULL
207 && PyObject_HasAttrString (gdb_python_module
, matchers_attr_str
))
209 gdbpy_ref
gdb_matchers (PyObject_GetAttrString (gdb_python_module
,
211 if (gdb_matchers
!= NULL
)
213 gdbpy_ref
temp (PySequence_Concat (py_xmethod_matcher_list
.get (),
214 gdb_matchers
.get ()));
217 gdbpy_print_stack ();
218 return EXT_LANG_RC_ERROR
;
221 py_xmethod_matcher_list
= std::move (temp
);
225 gdbpy_print_stack ();
226 return EXT_LANG_RC_ERROR
;
230 gdbpy_ref
list_iter (PyObject_GetIter (py_xmethod_matcher_list
.get ()));
231 if (list_iter
== NULL
)
233 gdbpy_print_stack ();
234 return EXT_LANG_RC_ERROR
;
238 gdbpy_ref
matcher (PyIter_Next (list_iter
.get ()));
241 if (PyErr_Occurred ())
243 gdbpy_print_stack ();
244 return EXT_LANG_RC_ERROR
;
249 gdbpy_ref
match_result (invoke_match_method (matcher
.get (),
253 if (match_result
== NULL
)
255 gdbpy_print_stack ();
256 return EXT_LANG_RC_ERROR
;
258 if (match_result
== Py_None
)
259 ; /* This means there was no match. */
260 else if (PySequence_Check (match_result
.get ()))
262 gdbpy_ref
iter (PyObject_GetIter (match_result
.get ()));
266 gdbpy_print_stack ();
267 return EXT_LANG_RC_ERROR
;
271 struct xmethod_worker
*worker
;
273 gdbpy_ref
py_worker (PyIter_Next (iter
.get ()));
274 if (py_worker
== NULL
)
276 if (PyErr_Occurred ())
278 gdbpy_print_stack ();
279 return EXT_LANG_RC_ERROR
;
284 worker
= new_python_xmethod_worker (py_worker
.get (),
286 VEC_safe_push (xmethod_worker_ptr
, worker_vec
, worker
);
291 struct xmethod_worker
*worker
;
293 worker
= new_python_xmethod_worker (match_result
.get (),
295 VEC_safe_push (xmethod_worker_ptr
, worker_vec
, worker
);
299 *dm_vec
= worker_vec
;
301 return EXT_LANG_RC_OK
;
304 /* Implementation of get_xmethod_arg_types for Python. */
307 gdbpy_get_xmethod_arg_types (const struct extension_language_defn
*extlang
,
308 struct xmethod_worker
*worker
,
309 int *nargs
, struct type
***arg_types
)
311 struct gdbpy_worker_data
*worker_data
312 = (struct gdbpy_worker_data
*) worker
->data
;
313 PyObject
*py_worker
= worker_data
->worker
;
314 struct type
*obj_type
;
315 int i
= 1, arg_count
;
318 /* Set nargs to -1 so that any premature return from this function returns
319 an invalid/unusable number of arg types. */
322 gdbpy_enter
enter_py (get_current_arch (), current_language
);
324 gdbpy_ref get_arg_types_method
325 (PyObject_GetAttrString (py_worker
, get_arg_types_method_name
));
326 if (get_arg_types_method
== NULL
)
328 gdbpy_print_stack ();
329 return EXT_LANG_RC_ERROR
;
332 gdbpy_ref py_argtype_list
333 (PyObject_CallMethodObjArgs (py_worker
, py_get_arg_types_method_name
,
335 if (py_argtype_list
== NULL
)
337 gdbpy_print_stack ();
338 return EXT_LANG_RC_ERROR
;
341 if (py_argtype_list
== Py_None
)
343 else if (PySequence_Check (py_argtype_list
.get ()))
345 arg_count
= PySequence_Size (py_argtype_list
.get ());
348 gdbpy_print_stack ();
349 return EXT_LANG_RC_ERROR
;
352 list_iter
.reset (PyObject_GetIter (py_argtype_list
.get ()));
353 if (list_iter
== NULL
)
355 gdbpy_print_stack ();
356 return EXT_LANG_RC_ERROR
;
362 /* Include the 'this' argument in the size. */
363 gdb::unique_xmalloc_ptr
<struct type
*> type_array
364 (XCNEWVEC (struct type
*, arg_count
+ 1));
366 if (list_iter
!= NULL
)
370 gdbpy_ref
item (PyIter_Next (list_iter
.get ()));
373 if (PyErr_Occurred ())
375 gdbpy_print_stack ();
376 return EXT_LANG_RC_ERROR
;
381 struct type
*arg_type
= type_object_to_type (item
.get ());
382 if (arg_type
== NULL
)
384 PyErr_SetString (PyExc_TypeError
,
385 _("Arg type returned by the get_arg_types "
386 "method of a debug method worker object is "
387 "not a gdb.Type object."));
388 return EXT_LANG_RC_ERROR
;
391 (type_array
.get ())[i
] = arg_type
;
395 else if (arg_count
== 1)
397 /* py_argtype_list is not actually a list but a single gdb.Type
399 struct type
*arg_type
= type_object_to_type (py_argtype_list
.get ());
401 if (arg_type
== NULL
)
403 PyErr_SetString (PyExc_TypeError
,
404 _("Arg type returned by the get_arg_types method "
405 "of an xmethod worker object is not a gdb.Type "
407 return EXT_LANG_RC_ERROR
;
411 (type_array
.get ())[i
] = arg_type
;
416 /* Add the type of 'this' as the first argument. The 'this' pointer should
417 be a 'const' value. Hence, create a 'const' variant of the 'this' pointer
419 obj_type
= type_object_to_type (worker_data
->this_type
);
420 (type_array
.get ())[0] = make_cv_type (1, 0, lookup_pointer_type (obj_type
),
423 *arg_types
= type_array
.release ();
425 return EXT_LANG_RC_OK
;
428 /* Implementation of get_xmethod_result_type for Python. */
431 gdbpy_get_xmethod_result_type (const struct extension_language_defn
*extlang
,
432 struct xmethod_worker
*worker
,
434 struct value
**args
, int nargs
,
435 struct type
**result_type_ptr
)
437 struct gdbpy_worker_data
*worker_data
438 = (struct gdbpy_worker_data
*) worker
->data
;
439 PyObject
*py_worker
= worker_data
->worker
;
440 struct type
*obj_type
, *this_type
;
443 gdbpy_enter
enter_py (get_current_arch (), current_language
);
445 /* First see if there is a get_result_type method.
446 If not this could be an old xmethod (pre 7.9.1). */
447 gdbpy_ref get_result_type_method
448 (PyObject_GetAttrString (py_worker
, get_result_type_method_name
));
449 if (get_result_type_method
== NULL
)
452 *result_type_ptr
= NULL
;
453 return EXT_LANG_RC_OK
;
456 obj_type
= check_typedef (value_type (obj
));
457 this_type
= check_typedef (type_object_to_type (worker_data
->this_type
));
458 if (TYPE_CODE (obj_type
) == TYPE_CODE_PTR
)
460 struct type
*this_ptr
= lookup_pointer_type (this_type
);
462 if (!types_equal (obj_type
, this_ptr
))
463 obj
= value_cast (this_ptr
, obj
);
465 else if (TYPE_CODE (obj_type
) == TYPE_CODE_REF
)
467 struct type
*this_ref
= lookup_reference_type (this_type
);
469 if (!types_equal (obj_type
, this_ref
))
470 obj
= value_cast (this_ref
, obj
);
474 if (!types_equal (obj_type
, this_type
))
475 obj
= value_cast (this_type
, obj
);
477 gdbpy_ref
py_value_obj (value_to_value_object (obj
));
478 if (py_value_obj
== NULL
)
480 gdbpy_print_stack ();
481 return EXT_LANG_RC_ERROR
;
484 gdbpy_ref
py_arg_tuple (PyTuple_New (nargs
+ 1));
485 if (py_arg_tuple
== NULL
)
487 gdbpy_print_stack ();
488 return EXT_LANG_RC_ERROR
;
491 /* PyTuple_SET_ITEM steals the reference of the element, hence the
493 PyTuple_SET_ITEM (py_arg_tuple
.get (), 0, py_value_obj
.release ());
495 for (i
= 0; i
< nargs
; i
++)
497 PyObject
*py_value_arg
= value_to_value_object (args
[i
]);
499 if (py_value_arg
== NULL
)
501 gdbpy_print_stack ();
502 return EXT_LANG_RC_ERROR
;
504 PyTuple_SET_ITEM (py_arg_tuple
.get (), i
+ 1, py_value_arg
);
507 gdbpy_ref py_result_type
508 (PyObject_CallObject (get_result_type_method
.get (), py_arg_tuple
.get ()));
509 if (py_result_type
== NULL
)
511 gdbpy_print_stack ();
512 return EXT_LANG_RC_ERROR
;
515 *result_type_ptr
= type_object_to_type (py_result_type
.get ());
516 if (*result_type_ptr
== NULL
)
518 PyErr_SetString (PyExc_TypeError
,
519 _("Type returned by the get_result_type method of an"
520 " xmethod worker object is not a gdb.Type object."));
521 gdbpy_print_stack ();
522 return EXT_LANG_RC_ERROR
;
525 return EXT_LANG_RC_OK
;
528 /* Implementation of invoke_xmethod for Python. */
531 gdbpy_invoke_xmethod (const struct extension_language_defn
*extlang
,
532 struct xmethod_worker
*worker
,
533 struct value
*obj
, struct value
**args
, int nargs
)
536 struct type
*obj_type
, *this_type
;
537 struct value
*res
= NULL
;
538 struct gdbpy_worker_data
*worker_data
539 = (struct gdbpy_worker_data
*) worker
->data
;
540 PyObject
*xmethod_worker
= worker_data
->worker
;
542 gdbpy_enter
enter_py (get_current_arch (), current_language
);
544 obj_type
= check_typedef (value_type (obj
));
545 this_type
= check_typedef (type_object_to_type (worker_data
->this_type
));
546 if (TYPE_CODE (obj_type
) == TYPE_CODE_PTR
)
548 struct type
*this_ptr
= lookup_pointer_type (this_type
);
550 if (!types_equal (obj_type
, this_ptr
))
551 obj
= value_cast (this_ptr
, obj
);
553 else if (TYPE_CODE (obj_type
) == TYPE_CODE_REF
)
555 struct type
*this_ref
= lookup_reference_type (this_type
);
557 if (!types_equal (obj_type
, this_ref
))
558 obj
= value_cast (this_ref
, obj
);
562 if (!types_equal (obj_type
, this_type
))
563 obj
= value_cast (this_type
, obj
);
565 gdbpy_ref
py_value_obj (value_to_value_object (obj
));
566 if (py_value_obj
== NULL
)
568 gdbpy_print_stack ();
569 error (_("Error while executing Python code."));
572 gdbpy_ref
py_arg_tuple (PyTuple_New (nargs
+ 1));
573 if (py_arg_tuple
== NULL
)
575 gdbpy_print_stack ();
576 error (_("Error while executing Python code."));
579 /* PyTuple_SET_ITEM steals the reference of the element, hence the
581 PyTuple_SET_ITEM (py_arg_tuple
.get (), 0, py_value_obj
.release ());
583 for (i
= 0; i
< nargs
; i
++)
585 PyObject
*py_value_arg
= value_to_value_object (args
[i
]);
587 if (py_value_arg
== NULL
)
589 gdbpy_print_stack ();
590 error (_("Error while executing Python code."));
593 PyTuple_SET_ITEM (py_arg_tuple
.get (), i
+ 1, py_value_arg
);
596 gdbpy_ref
py_result (PyObject_CallObject (xmethod_worker
,
597 py_arg_tuple
.get ()));
598 if (py_result
== NULL
)
600 gdbpy_print_stack ();
601 error (_("Error while executing Python code."));
604 if (py_result
!= Py_None
)
606 res
= convert_value_from_python (py_result
.get ());
609 gdbpy_print_stack ();
610 error (_("Error while executing Python code."));
615 res
= allocate_value (lookup_typename (python_language
, python_gdbarch
,
622 /* Creates a new Python xmethod_worker object.
623 The new object has data of type 'struct gdbpy_worker_data' composed
624 with the components PY_WORKER and THIS_TYPE. */
626 static struct xmethod_worker
*
627 new_python_xmethod_worker (PyObject
*py_worker
, PyObject
*this_type
)
629 struct gdbpy_worker_data
*data
;
631 gdb_assert (py_worker
!= NULL
&& this_type
!= NULL
);
633 data
= XCNEW (struct gdbpy_worker_data
);
634 data
->worker
= py_worker
;
635 data
->this_type
= this_type
;
636 Py_INCREF (py_worker
);
637 Py_INCREF (this_type
);
639 return new_xmethod_worker (&extension_language_python
, data
);
643 gdbpy_initialize_xmethods (void)
645 py_match_method_name
= PyString_FromString (match_method_name
);
646 if (py_match_method_name
== NULL
)
649 py_get_arg_types_method_name
650 = PyString_FromString (get_arg_types_method_name
);
651 if (py_get_arg_types_method_name
== NULL
)