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 } 742