]> Git Repo - binutils.git/blob - gdb/python/py-xmethods.c
Update copyright year range in all GDB files
[binutils.git] / 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 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,
114                                                     match_method_name));
115   if (match_method == NULL)
116     return NULL;
117
118   gdbpy_ref<> py_xmethod_name (PyString_FromString (xmethod_name));
119   if (py_xmethod_name == NULL)
120     return NULL;
121
122   return PyObject_CallMethodObjArgs (matcher, py_match_method_name,
123                                      py_obj_type, py_xmethod_name.get (),
124                                      NULL);
125 }
126
127 /* Implementation of get_matching_xmethod_workers for Python.  */
128
129 enum ext_lang_rc
130 gdbpy_get_matching_xmethod_workers
131   (const struct extension_language_defn *extlang,
132    struct type *obj_type, const char *method_name,
133    xmethod_worker_vec **dm_vec)
134 {
135   struct objfile *objfile;
136   VEC (xmethod_worker_ptr) *worker_vec = NULL;
137   PyObject *py_progspace;
138
139   gdb_assert (obj_type != NULL && method_name != NULL);
140
141   gdbpy_enter enter_py (get_current_arch (), current_language);
142
143   gdbpy_ref<> py_type (type_to_type_object (obj_type));
144   if (py_type == NULL)
145     {
146       gdbpy_print_stack ();
147       return EXT_LANG_RC_ERROR;
148     }
149
150   /* Create an empty list of debug methods.  */
151   gdbpy_ref<> py_xmethod_matcher_list (PyList_New (0));
152   if (py_xmethod_matcher_list == NULL)
153     {
154       gdbpy_print_stack ();
155       return EXT_LANG_RC_ERROR;
156     }
157
158   /* Gather debug method matchers registered with the object files.
159      This could be done differently by iterating over each objfile's matcher
160      list individually, but there's no data yet to show it's needed.  */
161   ALL_OBJFILES (objfile)
162     {
163       PyObject *py_objfile = objfile_to_objfile_object (objfile);
164
165       if (py_objfile == NULL)
166         {
167           gdbpy_print_stack ();
168           return EXT_LANG_RC_ERROR;
169         }
170
171       gdbpy_ref<> objfile_matchers (objfpy_get_xmethods (py_objfile, NULL));
172       gdbpy_ref<> temp (PySequence_Concat (py_xmethod_matcher_list.get (),
173                                            objfile_matchers.get ()));
174       if (temp == NULL)
175         {
176           gdbpy_print_stack ();
177           return EXT_LANG_RC_ERROR;
178         }
179
180       py_xmethod_matcher_list = std::move (temp);
181     }
182
183   /* Gather debug methods matchers registered with the current program
184      space.  */
185   py_progspace = pspace_to_pspace_object (current_program_space);
186   if (py_progspace != NULL)
187     {
188       gdbpy_ref<> pspace_matchers (pspy_get_xmethods (py_progspace, NULL));
189
190       gdbpy_ref<> temp (PySequence_Concat (py_xmethod_matcher_list.get (),
191                                            pspace_matchers.get ()));
192       if (temp == NULL)
193         {
194           gdbpy_print_stack ();
195           return EXT_LANG_RC_ERROR;
196         }
197
198       py_xmethod_matcher_list = std::move (temp);
199     }
200   else
201     {
202       gdbpy_print_stack ();
203       return EXT_LANG_RC_ERROR;
204     }
205
206   /* Gather debug method matchers registered globally.  */
207   if (gdb_python_module != NULL
208       && PyObject_HasAttrString (gdb_python_module, matchers_attr_str))
209     {
210       gdbpy_ref<> gdb_matchers (PyObject_GetAttrString (gdb_python_module,
211                                                         matchers_attr_str));
212       if (gdb_matchers != NULL)
213         {
214           gdbpy_ref<> temp (PySequence_Concat (py_xmethod_matcher_list.get (),
215                                                gdb_matchers.get ()));
216           if (temp == NULL)
217             {
218               gdbpy_print_stack ();
219               return EXT_LANG_RC_ERROR;
220             }
221
222           py_xmethod_matcher_list = std::move (temp);
223         }
224       else
225         {
226           gdbpy_print_stack ();
227           return EXT_LANG_RC_ERROR;
228         }
229     }
230
231   gdbpy_ref<> list_iter (PyObject_GetIter (py_xmethod_matcher_list.get ()));
232   if (list_iter == NULL)
233     {
234       gdbpy_print_stack ();
235       return EXT_LANG_RC_ERROR;
236     }
237   while (true)
238     {
239       gdbpy_ref<> matcher (PyIter_Next (list_iter.get ()));
240       if (matcher == NULL)
241         {
242           if (PyErr_Occurred ())
243             {
244               gdbpy_print_stack ();
245               return EXT_LANG_RC_ERROR;
246             }
247           break;
248         }
249
250       gdbpy_ref<> match_result (invoke_match_method (matcher.get (),
251                                                      py_type.get (),
252                                                      method_name));
253
254       if (match_result == NULL)
255         {
256           gdbpy_print_stack ();
257           return EXT_LANG_RC_ERROR;
258         }
259       if (match_result == Py_None)
260         ; /* This means there was no match.  */
261       else if (PySequence_Check (match_result.get ()))
262         {
263           gdbpy_ref<> iter (PyObject_GetIter (match_result.get ()));
264
265           if (iter == NULL)
266             {
267               gdbpy_print_stack ();
268               return EXT_LANG_RC_ERROR;
269             }
270           while (true)
271             {
272               struct xmethod_worker *worker;
273
274               gdbpy_ref<> py_worker (PyIter_Next (iter.get ()));
275               if (py_worker == NULL)
276                 {
277                   if (PyErr_Occurred ())
278                     {
279                       gdbpy_print_stack ();
280                       return EXT_LANG_RC_ERROR;
281                     }
282                   break;
283                 }
284
285               worker = new_python_xmethod_worker (py_worker.get (),
286                                                   py_type.get ());
287               VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
288             }
289         }
290       else
291         {
292           struct xmethod_worker *worker;
293
294           worker = new_python_xmethod_worker (match_result.get (),
295                                               py_type.get ());
296           VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
297         }
298     }
299
300   *dm_vec = worker_vec;
301
302   return EXT_LANG_RC_OK;
303 }
304
305 /* Implementation of get_xmethod_arg_types for Python.  */
306
307 enum ext_lang_rc
308 gdbpy_get_xmethod_arg_types (const struct extension_language_defn *extlang,
309                              struct xmethod_worker *worker,
310                              int *nargs, struct type ***arg_types)
311 {
312   /* The gdbpy_enter object needs to be placed first, so that it's the last to
313      be destroyed.  */
314   gdbpy_enter enter_py (get_current_arch (), current_language);
315   struct gdbpy_worker_data *worker_data
316     = (struct gdbpy_worker_data *) worker->data;
317   PyObject *py_worker = worker_data->worker;
318   struct type *obj_type;
319   int i = 1, arg_count;
320   gdbpy_ref<> list_iter;
321
322   /* Set nargs to -1 so that any premature return from this function returns
323      an invalid/unusable number of arg types.  */
324   *nargs = -1;
325
326   gdbpy_ref<> get_arg_types_method
327     (PyObject_GetAttrString (py_worker, get_arg_types_method_name));
328   if (get_arg_types_method == NULL)
329     {
330       gdbpy_print_stack ();
331       return EXT_LANG_RC_ERROR;
332     }
333
334   gdbpy_ref<> py_argtype_list
335     (PyObject_CallMethodObjArgs (py_worker, py_get_arg_types_method_name,
336                                  NULL));
337   if (py_argtype_list == NULL)
338     {
339       gdbpy_print_stack ();
340       return EXT_LANG_RC_ERROR;
341     }
342
343   if (py_argtype_list == Py_None)
344     arg_count = 0;
345   else if (PySequence_Check (py_argtype_list.get ()))
346     {
347       arg_count = PySequence_Size (py_argtype_list.get ());
348       if (arg_count == -1)
349         {
350           gdbpy_print_stack ();
351           return EXT_LANG_RC_ERROR;
352         }
353
354       list_iter.reset (PyObject_GetIter (py_argtype_list.get ()));
355       if (list_iter == NULL)
356         {
357           gdbpy_print_stack ();
358           return EXT_LANG_RC_ERROR;
359         }
360     }
361   else
362     arg_count = 1;
363
364   /* Include the 'this' argument in the size.  */
365   gdb::unique_xmalloc_ptr<struct type *> type_array
366     (XCNEWVEC (struct type *, arg_count + 1));
367   i = 1;
368   if (list_iter != NULL)
369     {
370       while (true)
371         {
372           gdbpy_ref<> item (PyIter_Next (list_iter.get ()));
373           if (item == NULL)
374             {
375               if (PyErr_Occurred ())
376                 {
377                   gdbpy_print_stack ();
378                   return EXT_LANG_RC_ERROR;
379                 }
380               break;
381             }
382
383           struct type *arg_type = type_object_to_type (item.get ());
384           if (arg_type == NULL)
385             {
386               PyErr_SetString (PyExc_TypeError,
387                                _("Arg type returned by the get_arg_types "
388                                  "method of a debug method worker object is "
389                                  "not a gdb.Type object."));
390               return EXT_LANG_RC_ERROR;
391             }
392
393           (type_array.get ())[i] = arg_type;
394           i++;
395         }
396     }
397   else if (arg_count == 1)
398     {
399       /* py_argtype_list is not actually a list but a single gdb.Type
400          object.  */
401       struct type *arg_type = type_object_to_type (py_argtype_list.get ());
402
403       if (arg_type == NULL)
404         {
405           PyErr_SetString (PyExc_TypeError,
406                            _("Arg type returned by the get_arg_types method "
407                              "of an xmethod worker object is not a gdb.Type "
408                              "object."));
409           return EXT_LANG_RC_ERROR;
410         }
411       else
412         {
413           (type_array.get ())[i] = arg_type;
414           i++;
415         }
416     }
417
418   /* Add the type of 'this' as the first argument.  The 'this' pointer should
419      be a 'const' value.  Hence, create a 'const' variant of the 'this' pointer
420      type.  */
421   obj_type = type_object_to_type (worker_data->this_type);
422   (type_array.get ())[0] = make_cv_type (1, 0, lookup_pointer_type (obj_type),
423                                          NULL);
424   *nargs = i;
425   *arg_types = type_array.release ();
426
427   return EXT_LANG_RC_OK;
428 }
429
430 /* Implementation of get_xmethod_result_type for Python.  */
431
432 enum ext_lang_rc
433 gdbpy_get_xmethod_result_type (const struct extension_language_defn *extlang,
434                                struct xmethod_worker *worker,
435                                struct value *obj,
436                                struct value **args, int nargs,
437                                struct type **result_type_ptr)
438 {
439   struct gdbpy_worker_data *worker_data
440     = (struct gdbpy_worker_data *) worker->data;
441   PyObject *py_worker = worker_data->worker;
442   struct type *obj_type, *this_type;
443   int i;
444
445   gdbpy_enter enter_py (get_current_arch (), current_language);
446
447   /* First see if there is a get_result_type method.
448      If not this could be an old xmethod (pre 7.9.1).  */
449   gdbpy_ref<> get_result_type_method
450     (PyObject_GetAttrString (py_worker, get_result_type_method_name));
451   if (get_result_type_method == NULL)
452     {
453       PyErr_Clear ();
454       *result_type_ptr = NULL;
455       return EXT_LANG_RC_OK;
456     }
457
458   obj_type = check_typedef (value_type (obj));
459   this_type = check_typedef (type_object_to_type (worker_data->this_type));
460   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
461     {
462       struct type *this_ptr = lookup_pointer_type (this_type);
463
464       if (!types_equal (obj_type, this_ptr))
465         obj = value_cast (this_ptr, obj);
466     }
467   else if (TYPE_IS_REFERENCE (obj_type))
468     {
469       struct type *this_ref
470         = lookup_reference_type (this_type, TYPE_CODE (obj_type));
471
472       if (!types_equal (obj_type, this_ref))
473         obj = value_cast (this_ref, obj);
474     }
475   else
476     {
477       if (!types_equal (obj_type, this_type))
478         obj = value_cast (this_type, obj);
479     }
480   gdbpy_ref<> py_value_obj (value_to_value_object (obj));
481   if (py_value_obj == NULL)
482     {
483       gdbpy_print_stack ();
484       return EXT_LANG_RC_ERROR;
485     }
486
487   gdbpy_ref<> py_arg_tuple (PyTuple_New (nargs + 1));
488   if (py_arg_tuple == NULL)
489     {
490       gdbpy_print_stack ();
491       return EXT_LANG_RC_ERROR;
492     }
493
494   /* PyTuple_SET_ITEM steals the reference of the element, hence the
495      release.  */
496   PyTuple_SET_ITEM (py_arg_tuple.get (), 0, py_value_obj.release ());
497
498   for (i = 0; i < nargs; i++)
499     {
500       PyObject *py_value_arg = value_to_value_object (args[i]);
501
502       if (py_value_arg == NULL)
503         {
504           gdbpy_print_stack ();
505           return EXT_LANG_RC_ERROR;
506         }
507       PyTuple_SET_ITEM (py_arg_tuple.get (), i + 1, py_value_arg);
508     }
509
510   gdbpy_ref<> py_result_type
511     (PyObject_CallObject (get_result_type_method.get (), py_arg_tuple.get ()));
512   if (py_result_type == NULL)
513     {
514       gdbpy_print_stack ();
515       return EXT_LANG_RC_ERROR;
516     }
517
518   *result_type_ptr = type_object_to_type (py_result_type.get ());
519   if (*result_type_ptr == NULL)
520     {
521       PyErr_SetString (PyExc_TypeError,
522                        _("Type returned by the get_result_type method of an"
523                          " xmethod worker object is not a gdb.Type object."));
524       gdbpy_print_stack ();
525       return EXT_LANG_RC_ERROR;
526     }
527
528   return EXT_LANG_RC_OK;
529 }
530
531 /* Implementation of invoke_xmethod for Python.  */
532
533 struct value *
534 gdbpy_invoke_xmethod (const struct extension_language_defn *extlang,
535                       struct xmethod_worker *worker,
536                       struct value *obj, struct value **args, int nargs)
537 {
538   int i;
539   struct type *obj_type, *this_type;
540   struct value *res = NULL;
541   struct gdbpy_worker_data *worker_data
542     = (struct gdbpy_worker_data *) worker->data;
543   PyObject *xmethod_worker = worker_data->worker;
544
545   gdbpy_enter enter_py (get_current_arch (), current_language);
546
547   obj_type = check_typedef (value_type (obj));
548   this_type = check_typedef (type_object_to_type (worker_data->this_type));
549   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
550     {
551       struct type *this_ptr = lookup_pointer_type (this_type);
552
553       if (!types_equal (obj_type, this_ptr))
554         obj = value_cast (this_ptr, obj);
555     }
556   else if (TYPE_IS_REFERENCE (obj_type))
557     {
558       struct type *this_ref
559         = lookup_reference_type (this_type, TYPE_CODE (obj_type));
560
561       if (!types_equal (obj_type, this_ref))
562         obj = value_cast (this_ref, obj);
563     }
564   else
565     {
566       if (!types_equal (obj_type, this_type))
567         obj = value_cast (this_type, obj);
568     }
569   gdbpy_ref<> py_value_obj (value_to_value_object (obj));
570   if (py_value_obj == NULL)
571     {
572       gdbpy_print_stack ();
573       error (_("Error while executing Python code."));
574     }
575
576   gdbpy_ref<> py_arg_tuple (PyTuple_New (nargs + 1));
577   if (py_arg_tuple == NULL)
578     {
579       gdbpy_print_stack ();
580       error (_("Error while executing Python code."));
581     }
582
583   /* PyTuple_SET_ITEM steals the reference of the element, hence the
584      release.  */
585   PyTuple_SET_ITEM (py_arg_tuple.get (), 0, py_value_obj.release ());
586
587   for (i = 0; i < nargs; i++)
588     {
589       PyObject *py_value_arg = value_to_value_object (args[i]);
590
591       if (py_value_arg == NULL)
592         {
593           gdbpy_print_stack ();
594           error (_("Error while executing Python code."));
595         }
596
597       PyTuple_SET_ITEM (py_arg_tuple.get (), i + 1, py_value_arg);
598     }
599
600   gdbpy_ref<> py_result (PyObject_CallObject (xmethod_worker,
601                                               py_arg_tuple.get ()));
602   if (py_result == NULL)
603     {
604       gdbpy_print_stack ();
605       error (_("Error while executing Python code."));
606     }
607
608   if (py_result != Py_None)
609     {
610       res = convert_value_from_python (py_result.get ());
611       if (res == NULL)
612         {
613           gdbpy_print_stack ();
614           error (_("Error while executing Python code."));
615         }
616     }
617   else
618     {
619       res = allocate_value (lookup_typename (python_language, python_gdbarch,
620                                              "void", NULL, 0));
621     }
622
623   return res;
624 }
625
626 /* Creates a new Python xmethod_worker object.
627    The new object has data of type 'struct gdbpy_worker_data' composed
628    with the components PY_WORKER and THIS_TYPE.  */
629
630 static struct xmethod_worker *
631 new_python_xmethod_worker (PyObject *py_worker, PyObject *this_type)
632 {
633   struct gdbpy_worker_data *data;
634
635   gdb_assert (py_worker != NULL && this_type != NULL);
636
637   data = XCNEW (struct gdbpy_worker_data);
638   data->worker = py_worker;
639   data->this_type = this_type;
640   Py_INCREF (py_worker);
641   Py_INCREF (this_type);
642
643   return new_xmethod_worker (&extension_language_python, data);
644 }
645
646 int
647 gdbpy_initialize_xmethods (void)
648 {
649   py_match_method_name = PyString_FromString (match_method_name);
650   if (py_match_method_name == NULL)
651     return -1;
652
653   py_get_arg_types_method_name
654     = PyString_FromString (get_arg_types_method_name);
655   if (py_get_arg_types_method_name == NULL)
656     return -1;
657
658   return 1;
659 }
This page took 0.094157 seconds and 4 git commands to generate.