gdb/python/py-xmethods.c

   1 /* Support for debug methods in Python.
   2
   3    Copyright (C) 2013-2016 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 matchers_attr_str[] = "xmethods";
  35
  36 static PyObject *py_match_method_name = NULL;
  37 static PyObject *py_get_arg_types_method_name = NULL;
  38
  39 struct gdbpy_worker_data
  40 {
  41   PyObject *worker;
  42   PyObject *this_type;
  43 };
  44
  45 static struct xmethod_worker *new_python_xmethod_worker (PyObject *item,
  46                                                          PyObject *py_obj_type);
  47
  48 /* Implementation of free_xmethod_worker_data for Python.  */
  49
  50 void
  51 gdbpy_free_xmethod_worker_data (const struct extension_language_defn *extlang,
  52                                 void *data)
  53 {
  54   struct gdbpy_worker_data *worker_data = (struct gdbpy_worker_data *) data;
  55   struct cleanup *cleanups;
  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   cleanups = ensure_python_env (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   do_cleanups (cleanups);
  67 }
  68
  69 /* Implementation of clone_xmethod_worker_data for Python.  */
  70
  71 void *
  72 gdbpy_clone_xmethod_worker_data (const struct extension_language_defn *extlang,
  73                                  void *data)
  74 {
  75   struct gdbpy_worker_data *worker_data
  76     = (struct gdbpy_worker_data *) data, *new_data;
  77   struct cleanup *cleanups;
  78
  79   gdb_assert (worker_data->worker != NULL && worker_data->this_type != NULL);
  80
  81   /* We don't do much here, but we still need the GIL.  */
  82   cleanups = ensure_python_env (get_current_arch (), current_language);
  83
  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);
  89
  90   do_cleanups (cleanups);
  91
  92   return new_data;
  93 }
  94
  95 /* Invoke the "match" method of the MATCHER and return a new reference
  96    to the result.  Returns NULL on error.  */
  97
  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;
 106
 107   cleanups = make_cleanup (null_cleanup, NULL);
 108
 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);
 116
 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     }
 129
 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);
 137
 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);
 145
 146   match_result = PyObject_CallMethodObjArgs (matcher,
 147                                              py_match_method_name,
 148                                              py_obj_type,
 149                                              py_xmethod_name,
 150                                              NULL);
 151
 152   do_cleanups (cleanups);
 153
 154   return match_result;
 155 }
 156
 157 /* Implementation of get_matching_xmethod_workers for Python.  */
 158
 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;
 170
 171   gdb_assert (obj_type != NULL && method_name != NULL);
 172
 173   cleanups = ensure_python_env (get_current_arch (), current_language);
 174
 175   py_type = type_to_type_object (obj_type);
 176   if (py_type == NULL)
 177     {
 178       gdbpy_print_stack ();
 179       do_cleanups (cleanups);
 180
 181       return EXT_LANG_RC_ERROR;
 182     }
 183   make_cleanup_py_decref (py_type);
 184
 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);
 191
 192       return EXT_LANG_RC_ERROR;
 193     }
 194
 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;
 202
 203       if (py_objfile == NULL)
 204         {
 205           gdbpy_print_stack ();
 206           Py_DECREF (py_xmethod_matcher_list);
 207           do_cleanups (cleanups);
 208
 209           return EXT_LANG_RC_ERROR;
 210         }
 211
 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);
 220
 221           return EXT_LANG_RC_ERROR;
 222         }
 223     }
 224
 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);
 232
 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);
 240
 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);
 249
 250       return EXT_LANG_RC_ERROR;
 251     }
 252
 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;
 259
 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);
 271
 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);
 280
 281           return EXT_LANG_RC_ERROR;
 282         }
 283     }
 284
 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);
 288
 289   list_iter = PyObject_GetIter (py_xmethod_matcher_list);
 290   if (list_iter == NULL)
 291     {
 292       gdbpy_print_stack ();
 293       do_cleanups (cleanups);
 294
 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);
 301
 302       if (match_result == NULL)
 303         {
 304           gdbpy_print_stack ();
 305           Py_DECREF (matcher);
 306           do_cleanups (cleanups);
 307
 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;
 316
 317           if (iter == NULL)
 318             {
 319               gdbpy_print_stack ();
 320               Py_DECREF (matcher);
 321               Py_DECREF (match_result);
 322               do_cleanups (cleanups);
 323
 324               return EXT_LANG_RC_ERROR;
 325             }
 326           while ((py_worker = PyIter_Next (iter)) != NULL)
 327             {
 328               struct xmethod_worker *worker;
 329
 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);
 342
 343               return EXT_LANG_RC_ERROR;
 344             }
 345         }
 346       else
 347         {
 348           struct xmethod_worker *worker;
 349
 350           worker = new_python_xmethod_worker (match_result, py_type);
 351           VEC_safe_push (xmethod_worker_ptr, worker_vec, worker);
 352         }
 353
 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);
 363
 364       return EXT_LANG_RC_ERROR;
 365     }
 366
 367   do_cleanups (cleanups);
 368   *dm_vec = worker_vec;
 369
 370   return EXT_LANG_RC_OK;
 371 }
 372
 373 /* Implementation of get_xmethod_arg_types for Python.  */
 374
 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
 381     = (struct gdbpy_worker_data *) worker->data;
 382   PyObject *py_worker = worker_data->worker;
 383   PyObject *get_arg_types_method;
 384   PyObject *py_argtype_list, *list_iter = NULL, *item;
 385   struct cleanup *cleanups;
 386   struct type **type_array, *obj_type;
 387   int i = 1, arg_count;
 388
 389   /* Set nargs to -1 so that any premature return from this function returns
 390      an invalid/unusable number of arg types.  */
 391   *nargs = -1;
 392
 393   cleanups = ensure_python_env (get_current_arch (), current_language);
 394
 395   get_arg_types_method =  PyObject_GetAttrString (py_worker,
 396                                                   get_arg_types_method_name);
 397   if (get_arg_types_method == NULL)
 398     {
 399       gdbpy_print_stack ();
 400       do_cleanups (cleanups);
 401
 402       return EXT_LANG_RC_ERROR;
 403     }
 404   make_cleanup_py_decref (get_arg_types_method);
 405
 406   py_argtype_list = PyObject_CallMethodObjArgs (py_worker,
 407                                                 py_get_arg_types_method_name,
 408                                                 NULL);
 409   if (py_argtype_list == NULL)
 410     {
 411       gdbpy_print_stack ();
 412       do_cleanups (cleanups);
 413
 414       return EXT_LANG_RC_ERROR;
 415     }
 416   make_cleanup_py_decref (py_argtype_list);
 417   if (py_argtype_list == Py_None)
 418     arg_count = 0;
 419   else if (PySequence_Check (py_argtype_list))
 420     {
 421       arg_count = PySequence_Size (py_argtype_list);
 422       if (arg_count == -1)
 423         {
 424           gdbpy_print_stack ();
 425           do_cleanups (cleanups);
 426
 427           return EXT_LANG_RC_ERROR;
 428         }
 429
 430       list_iter = PyObject_GetIter (py_argtype_list);
 431       if (list_iter == NULL)
 432         {
 433           gdbpy_print_stack ();
 434           do_cleanups (cleanups);
 435
 436           return EXT_LANG_RC_ERROR;
 437         }
 438       make_cleanup_py_decref (list_iter);
 439     }
 440   else
 441     arg_count = 1;
 442
 443   /* Include the 'this' argument in the size.  */
 444   type_array = XCNEWVEC (struct type *, arg_count + 1);
 445   i = 1;
 446   if (list_iter != NULL)
 447     {
 448       while ((item = PyIter_Next (list_iter)) != NULL)
 449         {
 450           struct type *arg_type = type_object_to_type (item);
 451
 452           Py_DECREF (item);
 453           if (arg_type == NULL)
 454             {
 455               PyErr_SetString (PyExc_TypeError,
 456                                _("Arg type returned by the get_arg_types "
 457                                  "method of a debug method worker object is "
 458                                  "not a gdb.Type object."));
 459               break;
 460             }
 461
 462           type_array[i] = arg_type;
 463           i++;
 464         }
 465     }
 466   else if (arg_count == 1)
 467     {
 468       /* py_argtype_list is not actually a list but a single gdb.Type
 469          object.  */
 470       struct type *arg_type = type_object_to_type (py_argtype_list);
 471
 472       if (arg_type == NULL)
 473         {
 474           PyErr_SetString (PyExc_TypeError,
 475                            _("Arg type returned by the get_arg_types method "
 476                              "of an xmethod worker object is not a gdb.Type "
 477                              "object."));
 478         }
 479       else
 480         {
 481           type_array[i] = arg_type;
 482           i++;
 483         }
 484     }
 485   if (PyErr_Occurred ())
 486     {
 487       gdbpy_print_stack ();
 488       do_cleanups (cleanups);
 489       xfree (type_array);
 490
 491       return EXT_LANG_RC_ERROR;
 492     }
 493
 494   /* Add the type of 'this' as the first argument.  The 'this' pointer should
 495      be a 'const' value.  Hence, create a 'const' variant of the 'this' pointer
 496      type.  */
 497   obj_type = type_object_to_type (worker_data->this_type);
 498   type_array[0] = make_cv_type (1, 0, lookup_pointer_type (obj_type), NULL);
 499   *nargs = i;
 500   *arg_types = type_array;
 501   do_cleanups (cleanups);
 502
 503   return EXT_LANG_RC_OK;
 504 }
 505
 506 /* Implementation of get_xmethod_result_type for Python.  */
 507
 508 enum ext_lang_rc
 509 gdbpy_get_xmethod_result_type (const struct extension_language_defn *extlang,
 510                                struct xmethod_worker *worker,
 511                                struct value *obj,
 512                                struct value **args, int nargs,
 513                                struct type **result_type_ptr)
 514 {
 515   struct gdbpy_worker_data *worker_data
 516     = (struct gdbpy_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
 620     = (struct gdbpy_worker_data *) worker->data;
 621   PyObject *xmethod_worker = worker_data->worker;
 622
 623   cleanups = ensure_python_env (get_current_arch (), current_language);
 624
 625   obj_type = check_typedef (value_type (obj));
 626   this_type = check_typedef (type_object_to_type (worker_data->this_type));
 627   if (TYPE_CODE (obj_type) == TYPE_CODE_PTR)
 628     {
 629       struct type *this_ptr = lookup_pointer_type (this_type);
 630
 631       if (!types_equal (obj_type, this_ptr))
 632         obj = value_cast (this_ptr, obj);
 633     }
 634   else if (TYPE_CODE (obj_type) == TYPE_CODE_REF)
 635     {
 636       struct type *this_ref = lookup_reference_type (this_type);
 637
 638       if (!types_equal (obj_type, this_ref))
 639         obj = value_cast (this_ref, obj);
 640     }
 641   else
 642     {
 643       if (!types_equal (obj_type, this_type))
 644         obj = value_cast (this_type, obj);
 645     }
 646   py_value_obj = value_to_value_object (obj);
 647   if (py_value_obj == NULL)
 648     {
 649       gdbpy_print_stack ();
 650       error (_("Error while executing Python code."));
 651     }
 652   make_cleanup_py_decref (py_value_obj);
 653
 654   py_arg_tuple = PyTuple_New (nargs + 1);
 655   if (py_arg_tuple == NULL)
 656     {
 657       gdbpy_print_stack ();
 658       error (_("Error while executing Python code."));
 659     }
 660   make_cleanup_py_decref (py_arg_tuple);
 661
 662   /* PyTuple_SET_ITEM steals the reference of the element.  Hence INCREF the
 663      reference to the 'this' object as we have a cleanup to DECREF it.  */
 664   Py_INCREF (py_value_obj);
 665   PyTuple_SET_ITEM (py_arg_tuple, 0, py_value_obj);
 666
 667   for (i = 0; i < nargs; i++)
 668     {
 669       PyObject *py_value_arg = value_to_value_object (args[i]);
 670
 671       if (py_value_arg == NULL)
 672         {
 673           gdbpy_print_stack ();
 674           error (_("Error while executing Python code."));
 675         }
 676
 677       PyTuple_SET_ITEM (py_arg_tuple, i + 1, py_value_arg);
 678     }
 679
 680   py_result = PyObject_CallObject (xmethod_worker, py_arg_tuple);
 681   if (py_result == NULL)
 682     {
 683       gdbpy_print_stack ();
 684       error (_("Error while executing Python code."));
 685     }
 686   make_cleanup_py_decref (py_result);
 687
 688   if (py_result != Py_None)
 689     {
 690       res = convert_value_from_python (py_result);
 691       if (res == NULL)
 692         {
 693           gdbpy_print_stack ();
 694           error (_("Error while executing Python code."));
 695         }
 696     }
 697   else
 698     {
 699       res = allocate_value (lookup_typename (python_language, python_gdbarch,
 700                                              "void", NULL, 0));
 701     }
 702
 703   do_cleanups (cleanups);
 704
 705   return res;
 706 }
 707
 708 /* Creates a new Python xmethod_worker object.
 709    The new object has data of type 'struct gdbpy_worker_data' composed
 710    with the components PY_WORKER and THIS_TYPE.  */
 711
 712 static struct xmethod_worker *
 713 new_python_xmethod_worker (PyObject *py_worker, PyObject *this_type)
 714 {
 715   struct gdbpy_worker_data *data;
 716
 717   gdb_assert (py_worker != NULL && this_type != NULL);
 718
 719   data = XCNEW (struct gdbpy_worker_data);
 720   data->worker = py_worker;
 721   data->this_type = this_type;
 722   Py_INCREF (py_worker);
 723   Py_INCREF (this_type);
 724
 725   return new_xmethod_worker (&extension_language_python, data);
 726 }
 727
 728 int
 729 gdbpy_initialize_xmethods (void)
 730 {
 731   py_match_method_name = PyString_FromString (match_method_name);
 732   if (py_match_method_name == NULL)
 733     return -1;
 734
 735   py_get_arg_types_method_name
 736     = PyString_FromString (get_arg_types_method_name);
 737   if (py_get_arg_types_method_name == NULL)
 738     return -1;
 739
 740   return 1;
 741 }