gdb/python/py-xmethods.c

   1 /* Support for debug methods in Python.
   2
   3    Copyright (C) 2013-2015 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
  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 get_result_type_method_name[] = "get_result_type";
  34 static const char invoke_method_name[] = "invoke";
  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 static PyObject *py_get_result_type_method_name = NULL;
  40 static PyObject *py_invoke_method_name = NULL;
  41
  42 struct gdbpy_worker_data
  43 {
  44   PyObject *worker;
  45   PyObject *this_type;
  46 };
  47
  48 static struct xmethod_worker *new_python_xmethod_worker (PyObject *item,
  49                                                          PyObject *py_obj_type);
  50
  51 /* Implementation of free_xmethod_worker_data for Python.  */
  52
  53 void
  54 gdbpy_free_xmethod_worker_data (const struct extension_language_defn *extlang,
  55                                 void *data)
  56 {
  57   struct gdbpy_worker_data *worker_data = data;
  58   struct cleanup *cleanups;
  59
  60   gdb_assert (worker_data->worker != NULL && worker_data->this_type != NULL);
  61
  62   /* We don't do much here, but we still need the GIL.  */
  63   cleanups = ensure_python_env (get_current_arch (), current_language);
  64
  65   Py_DECREF (worker_data->worker);
  66   Py_DECREF (worker_data->this_type);
  67   xfree (worker_data);
  68
  69   do_cleanups (cleanups);
  70 }
  71
  72 /* Implementation of clone_xmethod_worker_data for Python.  */
  73
  74 void *
  75 gdbpy_clone_xmethod_worker_data (const struct extension_language_defn *extlang,
  76                                  void *data)
  77 {
  78   struct gdbpy_worker_data *worker_data = data, *new_data;
  79   struct cleanup *cleanups;
  80
  81   gdb_assert (worker_data->worker != NULL && worker_data->this_type != NULL);
  82
  83   /* We don't do much here, but we still need the GIL.  */
  84   cleanups = ensure_python_env (get_current_arch (), current_language);
  85
  86   new_data = XCNEW (struct gdbpy_worker_data);
  87   new_data->worker = worker_data->worker;
  88   new_data->this_type = worker_data->this_type;
  89   Py_INCREF (new_data->worker);
  90   Py_INCREF (new_data->this_type);
  91
  92   do_cleanups (cleanups);
  93
  94   return new_data;
  95 }
  96
  97 /* Invoke the "match" method of the MATCHER and return a new reference
  98    to the result.  Returns NULL on error.  */
  99
 100 static PyObject *
 101 invoke_match_method (PyObject *matcher, PyObject *py_obj_type,
 102                      const char *xmethod_name)
 103 {
 104   PyObject *py_xmethod_name;
 105   PyObject *match_method, *enabled_field, *match_result;
 106   struct cleanup *cleanups;
 107   int enabled;
 108
 109   cleanups = make_cleanup (null_cleanup, NULL);
 110
 111   enabled_field = PyObject_GetAttrString (matcher, enabled_field_name);
 112   if (enabled_field == NULL)
 113     {
 114       do_cleanups (cleanups);
 115       return NULL;
 116     }
 117   make_cleanup_py_decref (enabled_field);
 118
 119   enabled = PyObject_IsTrue (enabled_field);
 120   if (enabled == -1)
 121     {
 122       do_cleanups (cleanups);
 123       return NULL;
 124     }
 125   if (enabled == 0)
 126     {
 127       /* Return 'None' if the matcher is not enabled.  */
 128       do_cleanups (cleanups);
 129       Py_RETURN_NONE;
 130     }
 131
 132   match_method = PyObject_GetAttrString (matcher, match_method_name);
 133   if (match_method == NULL)
 134     {
 135       do_cleanups (cleanups);
 136       return NULL;
 137     }
 138   make_cleanup_py_decref (match_method);
 139
 140   py_xmethod_name = PyString_FromString (xmethod_name);
 141   if (py_xmethod_name == NULL)
 142     {
 143       do_cleanups (cleanups);
 144       return NULL;
 145     }
 146   make_cleanup_py_decref (py_xmethod_name);
 147
 148   match_result = PyObject_CallMethodObjArgs (matcher,
 149                                              py_match_method_name,
 150                                              py_obj_type,
 151                                              py_xmethod_name,
 152                                              NULL);
 153
 154   do_cleanups (cleanups);
 155
 156   return match_result;
 157 }
 158
 159 /* Implementation of get_matching_xmethod_workers for Python.  */
 160
 161 enum ext_lang_rc
 162 gdbpy_get_matching_xmethod_workers
 163   (const struct extension_language_defn *extlang,
 164    struct type *obj_type, const char *method_name,
 165    xmethod_worker_vec **dm_vec)
 166 {
 167   struct cleanup *cleanups;
 168   struct objfile *objfile;
 169   VEC (xmethod_worker_ptr) *worker_vec = NULL;
 170   PyObject *py_type, *py_progspace;
 171   PyObject *py_xmethod_matcher_list = NULL, *list_iter, *matcher;
 172
 173   gdb_assert (obj_type != NULL && method_name != NULL);
 174
 175   cleanups = ensure_python_env (get_current_arch (), current_language);
 176
 177   py_type = type_to_type_object (obj_type);
 178   if (py_type == NULL)
 179     {
 180       gdbpy_print_stack ();
 181       do_cleanups (cleanups);
 182
 183       return EXT_LANG_RC_ERROR;
 184     }
 185   make_cleanup_py_decref (py_type);
 186
 187   /* Create an empty list of debug methods.  */
 188   py_xmethod_matcher_list = PyList_New (0);
 189   if (py_xmethod_matcher_list == NULL)
 190     {
 191       gdbpy_print_stack ();
 192       do_cleanups (cleanups);
 193
 194       return EXT_LANG_RC_ERROR;
 195     }
 196
 197   /* Gather debug method matchers registered with the object files.
 198      This could be done differently by iterating over each objfile's matcher
 199      list individually, but there's no data yet to show it's needed.  */
 200   ALL_OBJFILES (objfile)
 201     {
 202       PyObject *py_objfile = objfile_to_objfile_object (objfile);
 203       PyObject *objfile_matchers, *temp = py_xmethod_matcher_list;
 204
 205       if (py_objfile == NULL)
 206         {
 207           gdbpy_print_stack ();
 208           Py_DECREF (py_xmethod_matcher_list);
 209           do_cleanups (cleanups);
 210
 211           return EXT_LANG_RC_ERROR;
 212         }
 213
 214       objfile_matchers = objfpy_get_xmethods (py_objfile, NULL);
 215       py_xmethod_matcher_list = PySequence_Concat (temp, objfile_matchers);
 216       Py_DECREF (temp);
 217       Py_DECREF (objfile_matchers);
 218       if (py_xmethod_matcher_list == NULL)
 219         {
 220           gdbpy_print_stack ();
 221           do_cleanups (cleanups);
 222
 223           return EXT_LANG_RC_ERROR;
 224         }
 225     }
 226
 227   /* Gather debug methods matchers registered with the current program
 228      space.  */
 229   py_progspace = pspace_to_pspace_object (current_program_space);
 230   if (py_progspace != NULL)
 231     {
 232       PyObject *temp = py_xmethod_matcher_list;
 233       PyObject *pspace_matchers = pspy_get_xmethods (py_progspace, NULL);
 234
 235       py_xmethod_matcher_list = PySequence_Concat (temp, pspace_matchers);
 236       Py_DECREF (temp);
 237       Py_DECREF (pspace_matchers);
 238       if (py_xmethod_matcher_list == NULL)
 239         {
 240           gdbpy_print_stack ();
 241           do_cleanups (cleanups);
 242
 243           return EXT_LANG_RC_ERROR;
 244         }
 245     }
 246   else
 247     {
 248       gdbpy_print_stack ();
 249       Py_DECREF (py_xmethod_matcher_list);
 250       do_cleanups (cleanups);
 251
 252       return EXT_LANG_RC_ERROR;
 253     }
 254
 255   /* Gather debug method matchers registered globally.  */
 256   if (gdb_python_module != NULL
 257       && PyObject_HasAttrString (gdb_python_module, matchers_attr_str))
 258     {
 259       PyObject *gdb_matchers;
 260       PyObject *temp = py_xmethod_matcher_list;
 261
 262       gdb_matchers = PyObject_GetAttrString (gdb_python_module,
 263                                              matchers_attr_str);
 264       if (gdb_matchers != NULL)
 265         {
 266           py_xmethod_matcher_list = PySequence_Concat (temp, gdb_matchers);
 267           Py_DECREF (temp);
 268           Py_DECREF (gdb_matchers);
 269           if (py_xmethod_matcher_list == NULL)
 270             {
 271               gdbpy_print_stack ();
 272               do_cleanups (cleanups);
 273
 274               return EXT_LANG_RC_ERROR;
 275             }
 276         }
 277       else
 278         {
 279           gdbpy_print_stack ();
 280           Py_DECREF (py_xmethod_matcher_list);
 281           do_cleanups (cleanups);
 282
 283           return EXT_LANG_RC_ERROR;
 284         }
 285     }
 286
 287   /* Safe to make a cleanup for py_xmethod_matcher_list now as it
 288      will not change any more.  */
 289   make_cleanup_py_decref (py_xmethod_matcher_list);
 290
 291   list_iter = PyObject_GetIter (py_xmethod_matcher_list);
 292   if (list_iter == NULL)
 293     {
 294       gdbpy_print_stack ();
 295       do_cleanups (cleanups);
 296
 297       return EXT_LANG_RC_ERROR;
 298     }
 299   while ((matcher = PyIter_Next (list_iter)) != NULL)
 300     {
 301       PyObject *match_result = invoke_match_method (matcher, py_type,
 302                                                     method_name);
 303
 304       if (match_result == NULL)
 305         {
 306           gdbpy_print_stack ();
 307           Py_DECREF (matcher);
 308           do_cleanups (cleanups);
 309
 310           return EXT_LANG_RC_ERROR;
 311         }
 312       if (match_result == Py_None)
 313         ; /* This means there was no match.  */
 314       else if (PySequence_Check (match_result))
 315         {
 316           PyObject *iter = PyObject_GetIter (match_result);
 317           PyObject *py_worker;
 318
 319           if (iter == NULL)
 320             {
 321               gdbpy_print_stack ();
 322               Py_DECREF (matcher);
 323               Py_DECREF (match_result);
 324               do_cleanups (cleanups);
 325
 326               return EXT_LANG_RC_ERROR;
 327             }
 328           while ((py_worker = PyIter_Next (iter)) != NULL)
 329             {
 330               struct xmethod_worker *worker;
 331
 332               worker = new_python_xmethod_worker (py_worker, py_type);
 333               VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
 334               Py_DECREF (py_worker);
 335             }
 336           Py_DECREF (iter);
 337           /* Report any error that could have occurred while iterating.  */
 338           if (PyErr_Occurred ())
 339             {
 340               gdbpy_print_stack ();
 341               Py_DECREF (matcher);
 342               Py_DECREF (match_result);
 343               do_cleanups (cleanups);
 344
 345               return EXT_LANG_RC_ERROR;
 346             }
 347         }
 348       else
 349         {
 350           struct xmethod_worker *worker;
 351
 352           worker = new_python_xmethod_worker (match_result, py_type);
 353           VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
 354         }
 355
 356       Py_DECREF (match_result);
 357       Py_DECREF (matcher);
 358     }
 359   Py_DECREF (list_iter);
 360   /* Report any error that could have occurred while iterating.  */
 361   if (PyErr_Occurred ())
 362     {
 363       gdbpy_print_stack ();
 364       do_cleanups (cleanups);
 365
 366       return EXT_LANG_RC_ERROR;
 367     }
 368
 369   do_cleanups (cleanups);
 370   *dm_vec = worker_vec;
 371
 372   return EXT_LANG_RC_OK;
 373 }
 374
 375 /* Implementation of get_xmethod_arg_types for Python.  */
 376
 377 enum ext_lang_rc
 378 gdbpy_get_xmethod_arg_types (const struct extension_language_defn *extlang,
 379                              struct xmethod_worker *worker,
 380                              int *nargs, struct type ***arg_types)
 381 {
 382   struct gdbpy_worker_data *worker_data = worker->data;
 383   PyObject *py_worker = worker_data->worker;
 384   PyObject *get_arg_types_method;
 385   PyObject *py_argtype_list, *list_iter = NULL, *item;
 386   struct cleanup *cleanups;
 387   struct type **type_array, *obj_type;
 388   int i = 1, arg_count;
 389
 390   /* Set nargs to -1 so that any premature return from this function returns
 391      an invalid/unusable number of arg types.  */
 392   *nargs = -1;
 393
 394   cleanups = ensure_python_env (get_current_arch (), current_language);
 395
 396   get_arg_types_method =  PyObject_GetAttrString (py_worker,
 397                                                   get_arg_types_method_name);
 398   if (get_arg_types_method == NULL)
 399     {
 400       gdbpy_print_stack ();
 401       do_cleanups (cleanups);
 402
 403       return EXT_LANG_RC_ERROR;
 404     }
 405   make_cleanup_py_decref (get_arg_types_method);
 406
 407   py_argtype_list = PyObject_CallMethodObjArgs (py_worker,
 408                                                 py_get_arg_types_method_name,
 409                                                 NULL);
 410   if (py_argtype_list == NULL)
 411     {
 412       gdbpy_print_stack ();
 413       do_cleanups (cleanups);
 414
 415       return EXT_LANG_RC_ERROR;
 416     }
 417   make_cleanup_py_decref (py_argtype_list);
 418   if (py_argtype_list == Py_None)
 419     arg_count = 0;
 420   else if (PySequence_Check (py_argtype_list))
 421     {
 422       arg_count = PySequence_Size (py_argtype_list);
 423       if (arg_count == -1)
 424         {
 425           gdbpy_print_stack ();
 426           do_cleanups (cleanups);
 427
 428           return EXT_LANG_RC_ERROR;
 429         }
 430
 431       list_iter = PyObject_GetIter (py_argtype_list);
 432       if (list_iter == NULL)
 433         {
 434           gdbpy_print_stack ();
 435           do_cleanups (cleanups);
 436
 437           return EXT_LANG_RC_ERROR;
 438         }
 439       make_cleanup_py_decref (list_iter);
 440     }
 441   else
 442     arg_count = 1;
 443
 444   /* Include the 'this' argument in the size.  */
 445   type_array = XCNEWVEC (struct type *, arg_count + 1);
 446   i = 1;
 447   if (list_iter != NULL)
 448     {
 449       while ((item = PyIter_Next (list_iter)) != NULL)
 450         {
 451           struct type *arg_type = type_object_to_type (item);
 452
 453           Py_DECREF (item);
 454           if (arg_type == NULL)
 455             {
 456               PyErr_SetString (PyExc_TypeError,
 457                                _("Arg type returned by the get_arg_types "
 458                                  "method of a debug method worker object is "
 459                                  "not a gdb.Type object."));
 460               break;
 461             }
 462
 463           type_array[i] = arg_type;
 464           i++;
 465         }
 466     }
 467   else if (arg_count == 1)
 468     {
 469       /* py_argtype_list is not actually a list but a single gdb.Type
 470          object.  */
 471       struct type *arg_type = type_object_to_type (py_argtype_list);
 472
 473       if (arg_type == NULL)
 474         {
 475           PyErr_SetString (PyExc_TypeError,
 476                            _("Arg type returned by the get_arg_types method "
 477                              "of an xmethod worker object is not a gdb.Type "
 478                              "object."));
 479         }
 480       else
 481         {
 482           type_array[i] = arg_type;
 483           i++;
 484         }
 485     }
 486   if (PyErr_Occurred ())
 487     {
 488       gdbpy_print_stack ();
 489       do_cleanups (cleanups);
 490       xfree (type_array);
 491
 492       return EXT_LANG_RC_ERROR;
 493     }
 494
 495   /* Add the type of 'this' as the first argument.  The 'this' pointer should
 496      be a 'const' value.  Hence, create a 'const' variant of the 'this' pointer
 497      type.  */
 498   obj_type = type_object_to_type (worker_data->this_type);
 499   type_array[0] = make_cv_type (1, 0, lookup_pointer_type (obj_type), NULL);
 500   *nargs = i;
 501   *arg_types = type_array;
 502   do_cleanups (cleanups);
 503
 504   return EXT_LANG_RC_OK;
 505 }
 506
 507 /* Implementation of get_xmethod_result_type for Python.  */
 508
 509 enum ext_lang_rc
 510 gdbpy_get_xmethod_result_type (const struct extension_language_defn *extlang,
 511                                struct xmethod_worker *worker,
 512                                struct value *obj,
 513                                struct value **args, int nargs,
 514                                struct type **result_type_ptr)
 515 {
 516   struct gdbpy_worker_data *worker_data = worker->data;
 517   PyObject *py_worker = worker_data->worker;
 518   PyObject *py_value_obj, *py_arg_tuple, *py_result_type;
 519   PyObject *get_result_type_method;
 520   struct type *obj_type, *this_type;
 521   struct cleanup *cleanups;
 522   int i;
 523
 524   cleanups = ensure_python_env (get_current_arch (), current_language);
 525
 526   /* First see if there is a get_result_type method.
 527      If not this could be an old xmethod (pre 7.9.1).  */
 528   get_result_type_method
 529     = PyObject_GetAttrString (py_worker, get_result_type_method_name);
 530   if (get_result_type_method == NULL)
 531     {
 532       PyErr_Clear ();
 533       do_cleanups (cleanups);
 534       *result_type_ptr = NULL;
 535       return EXT_LANG_RC_OK;
 536     }
 537   make_cleanup_py_decref (get_result_type_method);
 538
 539   obj_type = check_typedef (value_type (obj));
 540   this_type = check_typedef (type_object_to_type (worker_data->this_type));
 541   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
 542     {
 543       struct type *this_ptr = lookup_pointer_type (this_type);
 544
 545       if (!types_equal (obj_type, this_ptr))
 546         obj = value_cast (this_ptr, obj);
 547     }
 548   else if (TYPE_CODE (obj_type) == TYPE_CODE_REF)
 549     {
 550       struct type *this_ref = lookup_reference_type (this_type);
 551
 552       if (!types_equal (obj_type, this_ref))
 553         obj = value_cast (this_ref, obj);
 554     }
 555   else
 556     {
 557       if (!types_equal (obj_type, this_type))
 558         obj = value_cast (this_type, obj);
 559     }
 560   py_value_obj = value_to_value_object (obj);
 561   if (py_value_obj == NULL)
 562     goto Fail;
 563   make_cleanup_py_decref (py_value_obj);
 564
 565   py_arg_tuple = PyTuple_New (nargs + 1);
 566   if (py_arg_tuple == NULL)
 567     goto Fail;
 568   make_cleanup_py_decref (py_arg_tuple);
 569
 570   /* PyTuple_SET_ITEM steals the reference of the element.  Hence INCREF the
 571      reference to the 'this' object as we have a cleanup to DECREF it.  */
 572   Py_INCREF (py_value_obj);
 573   PyTuple_SET_ITEM (py_arg_tuple, 0, py_value_obj);
 574
 575   for (i = 0; i < nargs; i++)
 576     {
 577       PyObject *py_value_arg = value_to_value_object (args[i]);
 578
 579       if (py_value_arg == NULL)
 580         goto Fail;
 581       PyTuple_SET_ITEM (py_arg_tuple, i + 1, py_value_arg);
 582     }
 583
 584   py_result_type = PyObject_CallObject (get_result_type_method, py_arg_tuple);
 585   if (py_result_type == NULL)
 586     goto Fail;
 587   make_cleanup_py_decref (py_result_type);
 588
 589   *result_type_ptr = type_object_to_type (py_result_type);
 590   if (*result_type_ptr == NULL)
 591     {
 592       PyErr_SetString (PyExc_TypeError,
 593                        _("Type returned by the get_result_type method of an"
 594                          " xmethod worker object is not a gdb.Type object."));
 595       goto Fail;
 596     }
 597
 598   do_cleanups (cleanups);
 599   return EXT_LANG_RC_OK;
 600
 601  Fail:
 602   gdbpy_print_stack ();
 603   do_cleanups (cleanups);
 604   return EXT_LANG_RC_ERROR;
 605 }
 606
 607 /* Implementation of invoke_xmethod for Python.  */
 608
 609 struct value *
 610 gdbpy_invoke_xmethod (const struct extension_language_defn *extlang,
 611                       struct xmethod_worker *worker,
 612                       struct value *obj, struct value **args, int nargs)
 613 {
 614   int i;
 615   struct cleanup *cleanups;
 616   PyObject *py_value_obj, *py_arg_tuple, *py_result;
 617   struct type *obj_type, *this_type;
 618   struct value *res = NULL;
 619   struct gdbpy_worker_data *worker_data = worker->data;
 620   PyObject *xmethod_worker = worker_data->worker;
 621
 622   cleanups = ensure_python_env (get_current_arch (), current_language);
 623
 624   obj_type = check_typedef (value_type (obj));
 625   this_type = check_typedef (type_object_to_type (worker_data->this_type));
 626   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
 627     {
 628       struct type *this_ptr = lookup_pointer_type (this_type);
 629
 630       if (!types_equal (obj_type, this_ptr))
 631         obj = value_cast (this_ptr, obj);
 632     }
 633   else if (TYPE_CODE (obj_type) == TYPE_CODE_REF)
 634     {
 635       struct type *this_ref = lookup_reference_type (this_type);
 636
 637       if (!types_equal (obj_type, this_ref))
 638         obj = value_cast (this_ref, obj);
 639     }
 640   else
 641     {
 642       if (!types_equal (obj_type, this_type))
 643         obj = value_cast (this_type, obj);
 644     }
 645   py_value_obj = value_to_value_object (obj);
 646   if (py_value_obj == NULL)
 647     {
 648       gdbpy_print_stack ();
 649       error (_("Error while executing Python code."));
 650     }
 651   make_cleanup_py_decref (py_value_obj);
 652
 653   py_arg_tuple = PyTuple_New (nargs + 1);
 654   if (py_arg_tuple == NULL)
 655     {
 656       gdbpy_print_stack ();
 657       error (_("Error while executing Python code."));
 658     }
 659   make_cleanup_py_decref (py_arg_tuple);
 660
 661   /* PyTuple_SET_ITEM steals the reference of the element.  Hence INCREF the
 662      reference to the 'this' object as we have a cleanup to DECREF it.  */
 663   Py_INCREF (py_value_obj);
 664   PyTuple_SET_ITEM (py_arg_tuple, 0, py_value_obj);
 665
 666   for (i = 0; i < nargs; i++)
 667     {
 668       PyObject *py_value_arg = value_to_value_object (args[i]);
 669
 670       if (py_value_arg == NULL)
 671         {
 672           gdbpy_print_stack ();
 673           error (_("Error while executing Python code."));
 674         }
 675
 676       PyTuple_SET_ITEM (py_arg_tuple, i + 1, py_value_arg);
 677     }
 678
 679   py_result = PyObject_CallObject (xmethod_worker, py_arg_tuple);
 680   if (py_result == NULL)
 681     {
 682       gdbpy_print_stack ();
 683       error (_("Error while executing Python code."));
 684     }
 685   make_cleanup_py_decref (py_result);
 686
 687   if (py_result != Py_None)
 688     {
 689       res = convert_value_from_python (py_result);
 690       if (res == NULL)
 691         {
 692           gdbpy_print_stack ();
 693           error (_("Error while executing Python code."));
 694         }
 695     }
 696   else
 697     {
 698       res = allocate_value (lookup_typename (python_language, python_gdbarch,
 699                                              "void", NULL, 0));
 700     }
 701
 702   do_cleanups (cleanups);
 703
 704   return res;
 705 }
 706
 707 /* Creates a new Python xmethod_worker object.
 708    The new object has data of type 'struct gdbpy_worker_data' composed
 709    with the components PY_WORKER and THIS_TYPE.  */
 710
 711 static struct xmethod_worker *
 712 new_python_xmethod_worker (PyObject *py_worker, PyObject *this_type)
 713 {
 714   struct gdbpy_worker_data *data;
 715
 716   gdb_assert (py_worker != NULL && this_type != NULL);
 717
 718   data = XCNEW (struct gdbpy_worker_data);
 719   data->worker = py_worker;
 720   data->this_type = this_type;
 721   Py_INCREF (py_worker);
 722   Py_INCREF (this_type);
 723
 724   return new_xmethod_worker (&extension_language_python, data);
 725 }
 726
 727 int
 728 gdbpy_initialize_xmethods (void)
 729 {
 730   py_match_method_name = PyString_FromString (match_method_name);
 731   if (py_match_method_name == NULL)
 732     return -1;
 733
 734   py_invoke_method_name = PyString_FromString (invoke_method_name);
 735   if (py_invoke_method_name == NULL)
 736     return -1;
 737
 738   py_get_arg_types_method_name
 739     = PyString_FromString (get_arg_types_method_name);
 740   if (py_get_arg_types_method_name == NULL)
 741     return -1;
 742
 743   py_get_result_type_method_name
 744     = PyString_FromString (get_result_type_method_name);
 745   if (py_get_result_type_method_name == NULL)
 746     return -1;
 747
 748   return 1;
 749 }