1 /* General python/gdb code 2 3 Copyright (C) 2008-2013 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 "command.h" 23 #include "ui-out.h" 24 #include "cli/cli-script.h" 25 #include "gdbcmd.h" 26 #include "progspace.h" 27 #include "objfiles.h" 28 #include "value.h" 29 #include "language.h" 30 #include "exceptions.h" 31 #include "event-loop.h" 32 #include "serial.h" 33 #include "readline/tilde.h" 34 #include "python.h" 35 #include "cli/cli-utils.h" 36 37 #include <ctype.h> 38 39 /* Declared constants and enum for python stack printing. */ 40 static const char python_excp_none[] = "none"; 41 static const char python_excp_full[] = "full"; 42 static const char python_excp_message[] = "message"; 43 44 /* "set python print-stack" choices. */ 45 static const char *const python_excp_enums[] = 46 { 47 python_excp_none, 48 python_excp_full, 49 python_excp_message, 50 NULL 51 }; 52 53 /* The exception printing variable. 'full' if we want to print the 54 error message and stack, 'none' if we want to print nothing, and 55 'message' if we only want to print the error message. 'message' is 56 the default. */ 57 static const char *gdbpy_should_print_stack = python_excp_message; 58 59 #ifdef HAVE_PYTHON 60 61 #include "libiberty.h" 62 #include "cli/cli-decode.h" 63 #include "charset.h" 64 #include "top.h" 65 #include "solib.h" 66 #include "python-internal.h" 67 #include "linespec.h" 68 #include "source.h" 69 #include "version.h" 70 #include "target.h" 71 #include "gdbthread.h" 72 #include "observer.h" 73 #include "interps.h" 74 #include "event-top.h" 75 76 static PyMethodDef GdbMethods[]; 77 78 #ifdef IS_PY3K 79 static struct PyModuleDef GdbModuleDef; 80 #endif 81 82 PyObject *gdb_module; 83 PyObject *gdb_python_module; 84 85 /* Some string constants we may wish to use. */ 86 PyObject *gdbpy_to_string_cst; 87 PyObject *gdbpy_children_cst; 88 PyObject *gdbpy_display_hint_cst; 89 PyObject *gdbpy_doc_cst; 90 PyObject *gdbpy_enabled_cst; 91 PyObject *gdbpy_value_cst; 92 93 /* The GdbError exception. */ 94 PyObject *gdbpy_gdberror_exc; 95 96 /* The `gdb.error' base class. */ 97 PyObject *gdbpy_gdb_error; 98 99 /* The `gdb.MemoryError' exception. */ 100 PyObject *gdbpy_gdb_memory_error; 101 102 /* Architecture and language to be used in callbacks from 103 the Python interpreter. */ 104 struct gdbarch *python_gdbarch; 105 const struct language_defn *python_language; 106 107 /* Restore global language and architecture and Python GIL state 108 when leaving the Python interpreter. */ 109 110 struct python_env 111 { 112 PyGILState_STATE state; 113 struct gdbarch *gdbarch; 114 const struct language_defn *language; 115 PyObject *error_type, *error_value, *error_traceback; 116 }; 117 118 static void 119 restore_python_env (void *p) 120 { 121 struct python_env *env = (struct python_env *)p; 122 123 /* Leftover Python error is forbidden by Python Exception Handling. */ 124 if (PyErr_Occurred ()) 125 { 126 /* This order is similar to the one calling error afterwards. */ 127 gdbpy_print_stack (); 128 warning (_("internal error: Unhandled Python exception")); 129 } 130 131 PyErr_Restore (env->error_type, env->error_value, env->error_traceback); 132 133 PyGILState_Release (env->state); 134 python_gdbarch = env->gdbarch; 135 python_language = env->language; 136 xfree (env); 137 } 138 139 /* Called before entering the Python interpreter to install the 140 current language and architecture to be used for Python values. */ 141 142 struct cleanup * 143 ensure_python_env (struct gdbarch *gdbarch, 144 const struct language_defn *language) 145 { 146 struct python_env *env = xmalloc (sizeof *env); 147 148 env->state = PyGILState_Ensure (); 149 env->gdbarch = python_gdbarch; 150 env->language = python_language; 151 152 python_gdbarch = gdbarch; 153 python_language = language; 154 155 /* Save it and ensure ! PyErr_Occurred () afterwards. */ 156 PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback); 157 158 return make_cleanup (restore_python_env, env); 159 } 160 161 /* Clear the quit flag. */ 162 163 void 164 clear_quit_flag (void) 165 { 166 /* This clears the flag as a side effect. */ 167 PyOS_InterruptOccurred (); 168 } 169 170 /* Set the quit flag. */ 171 172 void 173 set_quit_flag (void) 174 { 175 PyErr_SetInterrupt (); 176 } 177 178 /* Return true if the quit flag has been set, false otherwise. */ 179 180 int 181 check_quit_flag (void) 182 { 183 return PyOS_InterruptOccurred (); 184 } 185 186 /* Evaluate a Python command like PyRun_SimpleString, but uses 187 Py_single_input which prints the result of expressions, and does 188 not automatically print the stack on errors. */ 189 190 static int 191 eval_python_command (const char *command) 192 { 193 PyObject *m, *d, *v; 194 195 m = PyImport_AddModule ("__main__"); 196 if (m == NULL) 197 return -1; 198 199 d = PyModule_GetDict (m); 200 if (d == NULL) 201 return -1; 202 v = PyRun_StringFlags (command, Py_single_input, d, d, NULL); 203 if (v == NULL) 204 return -1; 205 206 Py_DECREF (v); 207 #ifndef IS_PY3K 208 if (Py_FlushLine ()) 209 PyErr_Clear (); 210 #endif 211 212 return 0; 213 } 214 215 /* Implementation of the gdb "python-interactive" command. */ 216 217 static void 218 python_interactive_command (char *arg, int from_tty) 219 { 220 struct cleanup *cleanup; 221 int err; 222 223 cleanup = make_cleanup_restore_integer (&interpreter_async); 224 interpreter_async = 0; 225 226 arg = skip_spaces (arg); 227 228 ensure_python_env (get_current_arch (), current_language); 229 230 if (arg && *arg) 231 { 232 int len = strlen (arg); 233 char *script = xmalloc (len + 2); 234 235 strcpy (script, arg); 236 script[len] = '\n'; 237 script[len + 1] = '\0'; 238 err = eval_python_command (script); 239 xfree (script); 240 } 241 else 242 { 243 err = PyRun_InteractiveLoop (instream, "<stdin>"); 244 dont_repeat (); 245 } 246 247 if (err) 248 { 249 gdbpy_print_stack (); 250 error (_("Error while executing Python code.")); 251 } 252 253 do_cleanups (cleanup); 254 } 255 256 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run 257 named FILENAME. 258 259 On Windows hosts few users would build Python themselves (this is no 260 trivial task on this platform), and thus use binaries built by 261 someone else instead. There may happen situation where the Python 262 library and GDB are using two different versions of the C runtime 263 library. Python, being built with VC, would use one version of the 264 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll. 265 A FILE * from one runtime does not necessarily operate correctly in 266 the other runtime. 267 268 To work around this potential issue, we create on Windows hosts the 269 FILE object using Python routines, thus making sure that it is 270 compatible with the Python library. */ 271 272 static void 273 python_run_simple_file (FILE *file, const char *filename) 274 { 275 #ifndef _WIN32 276 277 PyRun_SimpleFile (file, filename); 278 279 #else /* _WIN32 */ 280 281 char *full_path; 282 PyObject *python_file; 283 struct cleanup *cleanup; 284 285 /* Because we have a string for a filename, and are using Python to 286 open the file, we need to expand any tilde in the path first. */ 287 full_path = tilde_expand (filename); 288 cleanup = make_cleanup (xfree, full_path); 289 python_file = PyFile_FromString (full_path, "r"); 290 if (! python_file) 291 { 292 do_cleanups (cleanup); 293 gdbpy_print_stack (); 294 error (_("Error while opening file: %s"), full_path); 295 } 296 297 make_cleanup_py_decref (python_file); 298 PyRun_SimpleFile (PyFile_AsFile (python_file), filename); 299 do_cleanups (cleanup); 300 301 #endif /* _WIN32 */ 302 } 303 304 /* Given a command_line, return a command string suitable for passing 305 to Python. Lines in the string are separated by newlines. The 306 return value is allocated using xmalloc and the caller is 307 responsible for freeing it. */ 308 309 static char * 310 compute_python_string (struct command_line *l) 311 { 312 struct command_line *iter; 313 char *script = NULL; 314 int size = 0; 315 int here; 316 317 for (iter = l; iter; iter = iter->next) 318 size += strlen (iter->line) + 1; 319 320 script = xmalloc (size + 1); 321 here = 0; 322 for (iter = l; iter; iter = iter->next) 323 { 324 int len = strlen (iter->line); 325 326 strcpy (&script[here], iter->line); 327 here += len; 328 script[here++] = '\n'; 329 } 330 script[here] = '\0'; 331 return script; 332 } 333 334 /* Take a command line structure representing a 'python' command, and 335 evaluate its body using the Python interpreter. */ 336 337 void 338 eval_python_from_control_command (struct command_line *cmd) 339 { 340 int ret; 341 char *script; 342 struct cleanup *cleanup; 343 344 if (cmd->body_count != 1) 345 error (_("Invalid \"python\" block structure.")); 346 347 cleanup = ensure_python_env (get_current_arch (), current_language); 348 349 script = compute_python_string (cmd->body_list[0]); 350 ret = PyRun_SimpleString (script); 351 xfree (script); 352 if (ret) 353 error (_("Error while executing Python code.")); 354 355 do_cleanups (cleanup); 356 } 357 358 /* Implementation of the gdb "python" command. */ 359 360 static void 361 python_command (char *arg, int from_tty) 362 { 363 struct cleanup *cleanup; 364 365 cleanup = ensure_python_env (get_current_arch (), current_language); 366 367 make_cleanup_restore_integer (&interpreter_async); 368 interpreter_async = 0; 369 370 arg = skip_spaces (arg); 371 if (arg && *arg) 372 { 373 if (PyRun_SimpleString (arg)) 374 error (_("Error while executing Python code.")); 375 } 376 else 377 { 378 struct command_line *l = get_command_line (python_control, ""); 379 380 make_cleanup_free_command_lines (&l); 381 execute_control_command_untraced (l); 382 } 383 384 do_cleanups (cleanup); 385 } 386 387 388 389 /* Transform a gdb parameters's value into a Python value. May return 390 NULL (and set a Python exception) on error. Helper function for 391 get_parameter. */ 392 PyObject * 393 gdbpy_parameter_value (enum var_types type, void *var) 394 { 395 switch (type) 396 { 397 case var_string: 398 case var_string_noescape: 399 case var_optional_filename: 400 case var_filename: 401 case var_enum: 402 { 403 char *str = * (char **) var; 404 405 if (! str) 406 str = ""; 407 return PyString_Decode (str, strlen (str), host_charset (), NULL); 408 } 409 410 case var_boolean: 411 { 412 if (* (int *) var) 413 Py_RETURN_TRUE; 414 else 415 Py_RETURN_FALSE; 416 } 417 418 case var_auto_boolean: 419 { 420 enum auto_boolean ab = * (enum auto_boolean *) var; 421 422 if (ab == AUTO_BOOLEAN_TRUE) 423 Py_RETURN_TRUE; 424 else if (ab == AUTO_BOOLEAN_FALSE) 425 Py_RETURN_FALSE; 426 else 427 Py_RETURN_NONE; 428 } 429 430 case var_integer: 431 if ((* (int *) var) == INT_MAX) 432 Py_RETURN_NONE; 433 /* Fall through. */ 434 case var_zinteger: 435 return PyLong_FromLong (* (int *) var); 436 437 case var_uinteger: 438 { 439 unsigned int val = * (unsigned int *) var; 440 441 if (val == UINT_MAX) 442 Py_RETURN_NONE; 443 return PyLong_FromUnsignedLong (val); 444 } 445 } 446 447 return PyErr_Format (PyExc_RuntimeError, 448 _("Programmer error: unhandled type.")); 449 } 450 451 /* A Python function which returns a gdb parameter's value as a Python 452 value. */ 453 454 PyObject * 455 gdbpy_parameter (PyObject *self, PyObject *args) 456 { 457 struct cmd_list_element *alias, *prefix, *cmd; 458 const char *arg; 459 char *newarg; 460 int found = -1; 461 volatile struct gdb_exception except; 462 463 if (! PyArg_ParseTuple (args, "s", &arg)) 464 return NULL; 465 466 newarg = concat ("show ", arg, (char *) NULL); 467 468 TRY_CATCH (except, RETURN_MASK_ALL) 469 { 470 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd); 471 } 472 xfree (newarg); 473 GDB_PY_HANDLE_EXCEPTION (except); 474 if (!found) 475 return PyErr_Format (PyExc_RuntimeError, 476 _("Could not find parameter `%s'."), arg); 477 478 if (! cmd->var) 479 return PyErr_Format (PyExc_RuntimeError, 480 _("`%s' is not a parameter."), arg); 481 return gdbpy_parameter_value (cmd->var_type, cmd->var); 482 } 483 484 /* Wrapper for target_charset. */ 485 486 static PyObject * 487 gdbpy_target_charset (PyObject *self, PyObject *args) 488 { 489 const char *cset = target_charset (python_gdbarch); 490 491 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL); 492 } 493 494 /* Wrapper for target_wide_charset. */ 495 496 static PyObject * 497 gdbpy_target_wide_charset (PyObject *self, PyObject *args) 498 { 499 const char *cset = target_wide_charset (python_gdbarch); 500 501 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL); 502 } 503 504 /* A Python function which evaluates a string using the gdb CLI. */ 505 506 static PyObject * 507 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw) 508 { 509 const char *arg; 510 PyObject *from_tty_obj = NULL, *to_string_obj = NULL; 511 int from_tty, to_string; 512 volatile struct gdb_exception except; 513 static char *keywords[] = {"command", "from_tty", "to_string", NULL }; 514 char *result = NULL; 515 516 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg, 517 &PyBool_Type, &from_tty_obj, 518 &PyBool_Type, &to_string_obj)) 519 return NULL; 520 521 from_tty = 0; 522 if (from_tty_obj) 523 { 524 int cmp = PyObject_IsTrue (from_tty_obj); 525 if (cmp < 0) 526 return NULL; 527 from_tty = cmp; 528 } 529 530 to_string = 0; 531 if (to_string_obj) 532 { 533 int cmp = PyObject_IsTrue (to_string_obj); 534 if (cmp < 0) 535 return NULL; 536 to_string = cmp; 537 } 538 539 TRY_CATCH (except, RETURN_MASK_ALL) 540 { 541 /* Copy the argument text in case the command modifies it. */ 542 char *copy = xstrdup (arg); 543 struct cleanup *cleanup = make_cleanup (xfree, copy); 544 545 make_cleanup_restore_integer (&interpreter_async); 546 interpreter_async = 0; 547 548 prevent_dont_repeat (); 549 if (to_string) 550 result = execute_command_to_string (copy, from_tty); 551 else 552 { 553 result = NULL; 554 execute_command (copy, from_tty); 555 } 556 557 do_cleanups (cleanup); 558 } 559 GDB_PY_HANDLE_EXCEPTION (except); 560 561 /* Do any commands attached to breakpoint we stopped at. */ 562 bpstat_do_actions (); 563 564 if (result) 565 { 566 PyObject *r = PyString_FromString (result); 567 xfree (result); 568 return r; 569 } 570 Py_RETURN_NONE; 571 } 572 573 /* Implementation of gdb.solib_name (Long) -> String. 574 Returns the name of the shared library holding a given address, or None. */ 575 576 static PyObject * 577 gdbpy_solib_name (PyObject *self, PyObject *args) 578 { 579 char *soname; 580 PyObject *str_obj; 581 gdb_py_longest pc; 582 583 if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc)) 584 return NULL; 585 586 soname = solib_name_from_address (current_program_space, pc); 587 if (soname) 588 str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL); 589 else 590 { 591 str_obj = Py_None; 592 Py_INCREF (Py_None); 593 } 594 595 return str_obj; 596 } 597 598 /* A Python function which is a wrapper for decode_line_1. */ 599 600 static PyObject * 601 gdbpy_decode_line (PyObject *self, PyObject *args) 602 { 603 struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to 604 appease gcc. */ 605 struct symtab_and_line sal; 606 const char *arg = NULL; 607 char *copy_to_free = NULL, *copy = NULL; 608 struct cleanup *cleanups; 609 PyObject *result = NULL; 610 PyObject *return_result = NULL; 611 PyObject *unparsed = NULL; 612 volatile struct gdb_exception except; 613 614 if (! PyArg_ParseTuple (args, "|s", &arg)) 615 return NULL; 616 617 cleanups = make_cleanup (null_cleanup, NULL); 618 619 sals.sals = NULL; 620 TRY_CATCH (except, RETURN_MASK_ALL) 621 { 622 if (arg) 623 { 624 copy = xstrdup (arg); 625 copy_to_free = copy; 626 sals = decode_line_1 (©, 0, 0, 0); 627 } 628 else 629 { 630 set_default_source_symtab_and_line (); 631 sal = get_current_source_symtab_and_line (); 632 sals.sals = &sal; 633 sals.nelts = 1; 634 } 635 } 636 637 if (sals.sals != NULL && sals.sals != &sal) 638 { 639 make_cleanup (xfree, copy_to_free); 640 make_cleanup (xfree, sals.sals); 641 } 642 643 if (except.reason < 0) 644 { 645 do_cleanups (cleanups); 646 /* We know this will always throw. */ 647 GDB_PY_HANDLE_EXCEPTION (except); 648 } 649 650 if (sals.nelts) 651 { 652 int i; 653 654 result = PyTuple_New (sals.nelts); 655 if (! result) 656 goto error; 657 for (i = 0; i < sals.nelts; ++i) 658 { 659 PyObject *obj; 660 661 obj = symtab_and_line_to_sal_object (sals.sals[i]); 662 if (! obj) 663 { 664 Py_DECREF (result); 665 goto error; 666 } 667 668 PyTuple_SetItem (result, i, obj); 669 } 670 } 671 else 672 { 673 result = Py_None; 674 Py_INCREF (Py_None); 675 } 676 677 return_result = PyTuple_New (2); 678 if (! return_result) 679 { 680 Py_DECREF (result); 681 goto error; 682 } 683 684 if (copy && strlen (copy) > 0) 685 { 686 unparsed = PyString_FromString (copy); 687 if (unparsed == NULL) 688 { 689 Py_DECREF (result); 690 Py_DECREF (return_result); 691 return_result = NULL; 692 goto error; 693 } 694 } 695 else 696 { 697 unparsed = Py_None; 698 Py_INCREF (Py_None); 699 } 700 701 PyTuple_SetItem (return_result, 0, unparsed); 702 PyTuple_SetItem (return_result, 1, result); 703 704 error: 705 do_cleanups (cleanups); 706 707 return return_result; 708 } 709 710 /* Parse a string and evaluate it as an expression. */ 711 static PyObject * 712 gdbpy_parse_and_eval (PyObject *self, PyObject *args) 713 { 714 const char *expr_str; 715 struct value *result = NULL; 716 volatile struct gdb_exception except; 717 718 if (!PyArg_ParseTuple (args, "s", &expr_str)) 719 return NULL; 720 721 TRY_CATCH (except, RETURN_MASK_ALL) 722 { 723 result = parse_and_eval (expr_str); 724 } 725 GDB_PY_HANDLE_EXCEPTION (except); 726 727 return value_to_value_object (result); 728 } 729 730 /* Implementation of gdb.find_pc_line function. 731 Returns the gdb.Symtab_and_line object corresponding to a PC value. */ 732 733 static PyObject * 734 gdbpy_find_pc_line (PyObject *self, PyObject *args) 735 { 736 gdb_py_ulongest pc_llu; 737 volatile struct gdb_exception except; 738 PyObject *result = NULL; /* init for gcc -Wall */ 739 740 if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu)) 741 return NULL; 742 743 TRY_CATCH (except, RETURN_MASK_ALL) 744 { 745 struct symtab_and_line sal; 746 CORE_ADDR pc; 747 748 pc = (CORE_ADDR) pc_llu; 749 sal = find_pc_line (pc, 0); 750 result = symtab_and_line_to_sal_object (sal); 751 } 752 GDB_PY_HANDLE_EXCEPTION (except); 753 754 return result; 755 } 756 757 /* Read a file as Python code. 758 FILE is the file to run. FILENAME is name of the file FILE. 759 This does not throw any errors. If an exception occurs python will print 760 the traceback and clear the error indicator. */ 761 762 void 763 source_python_script (FILE *file, const char *filename) 764 { 765 struct cleanup *cleanup; 766 767 cleanup = ensure_python_env (get_current_arch (), current_language); 768 python_run_simple_file (file, filename); 769 do_cleanups (cleanup); 770 } 771 772 773 774 /* Posting and handling events. */ 775 776 /* A single event. */ 777 struct gdbpy_event 778 { 779 /* The Python event. This is just a callable object. */ 780 PyObject *event; 781 /* The next event. */ 782 struct gdbpy_event *next; 783 }; 784 785 /* All pending events. */ 786 static struct gdbpy_event *gdbpy_event_list; 787 /* The final link of the event list. */ 788 static struct gdbpy_event **gdbpy_event_list_end; 789 790 /* We use a file handler, and not an async handler, so that we can 791 wake up the main thread even when it is blocked in poll(). */ 792 static struct serial *gdbpy_event_fds[2]; 793 794 /* The file handler callback. This reads from the internal pipe, and 795 then processes the Python event queue. This will always be run in 796 the main gdb thread. */ 797 798 static void 799 gdbpy_run_events (struct serial *scb, void *context) 800 { 801 struct cleanup *cleanup; 802 803 cleanup = ensure_python_env (get_current_arch (), current_language); 804 805 /* Flush the fd. Do this before flushing the events list, so that 806 any new event post afterwards is sure to re-awake the event 807 loop. */ 808 while (serial_readchar (gdbpy_event_fds[0], 0) >= 0) 809 ; 810 811 while (gdbpy_event_list) 812 { 813 /* Dispatching the event might push a new element onto the event 814 loop, so we update here "atomically enough". */ 815 struct gdbpy_event *item = gdbpy_event_list; 816 gdbpy_event_list = gdbpy_event_list->next; 817 if (gdbpy_event_list == NULL) 818 gdbpy_event_list_end = &gdbpy_event_list; 819 820 /* Ignore errors. */ 821 if (PyObject_CallObject (item->event, NULL) == NULL) 822 PyErr_Clear (); 823 824 Py_DECREF (item->event); 825 xfree (item); 826 } 827 828 do_cleanups (cleanup); 829 } 830 831 /* Submit an event to the gdb thread. */ 832 static PyObject * 833 gdbpy_post_event (PyObject *self, PyObject *args) 834 { 835 struct gdbpy_event *event; 836 PyObject *func; 837 int wakeup; 838 839 if (!PyArg_ParseTuple (args, "O", &func)) 840 return NULL; 841 842 if (!PyCallable_Check (func)) 843 { 844 PyErr_SetString (PyExc_RuntimeError, 845 _("Posted event is not callable")); 846 return NULL; 847 } 848 849 Py_INCREF (func); 850 851 /* From here until the end of the function, we have the GIL, so we 852 can operate on our global data structures without worrying. */ 853 wakeup = gdbpy_event_list == NULL; 854 855 event = XNEW (struct gdbpy_event); 856 event->event = func; 857 event->next = NULL; 858 *gdbpy_event_list_end = event; 859 gdbpy_event_list_end = &event->next; 860 861 /* Wake up gdb when needed. */ 862 if (wakeup) 863 { 864 char c = 'q'; /* Anything. */ 865 866 if (serial_write (gdbpy_event_fds[1], &c, 1)) 867 return PyErr_SetFromErrno (PyExc_IOError); 868 } 869 870 Py_RETURN_NONE; 871 } 872 873 /* Initialize the Python event handler. */ 874 static void 875 gdbpy_initialize_events (void) 876 { 877 if (serial_pipe (gdbpy_event_fds) == 0) 878 { 879 gdbpy_event_list_end = &gdbpy_event_list; 880 serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL); 881 } 882 } 883 884 885 886 static void 887 before_prompt_hook (const char *current_gdb_prompt) 888 { 889 struct cleanup *cleanup; 890 char *prompt = NULL; 891 892 cleanup = ensure_python_env (get_current_arch (), current_language); 893 894 if (gdb_python_module 895 && PyObject_HasAttrString (gdb_python_module, "prompt_hook")) 896 { 897 PyObject *hook; 898 899 hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook"); 900 if (hook == NULL) 901 goto fail; 902 903 if (PyCallable_Check (hook)) 904 { 905 PyObject *result; 906 PyObject *current_prompt; 907 908 current_prompt = PyString_FromString (current_gdb_prompt); 909 if (current_prompt == NULL) 910 goto fail; 911 912 result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL); 913 914 Py_DECREF (current_prompt); 915 916 if (result == NULL) 917 goto fail; 918 919 make_cleanup_py_decref (result); 920 921 /* Return type should be None, or a String. If it is None, 922 fall through, we will not set a prompt. If it is a 923 string, set PROMPT. Anything else, set an exception. */ 924 if (result != Py_None && ! PyString_Check (result)) 925 { 926 PyErr_Format (PyExc_RuntimeError, 927 _("Return from prompt_hook must " \ 928 "be either a Python string, or None")); 929 goto fail; 930 } 931 932 if (result != Py_None) 933 { 934 prompt = python_string_to_host_string (result); 935 936 if (prompt == NULL) 937 goto fail; 938 else 939 make_cleanup (xfree, prompt); 940 } 941 } 942 } 943 944 /* If a prompt has been set, PROMPT will not be NULL. If it is 945 NULL, do not set the prompt. */ 946 if (prompt != NULL) 947 set_prompt (prompt); 948 949 do_cleanups (cleanup); 950 return; 951 952 fail: 953 gdbpy_print_stack (); 954 do_cleanups (cleanup); 955 return; 956 } 957 958 959 960 /* Printing. */ 961 962 /* A python function to write a single string using gdb's filtered 963 output stream . The optional keyword STREAM can be used to write 964 to a particular stream. The default stream is to gdb_stdout. */ 965 966 static PyObject * 967 gdbpy_write (PyObject *self, PyObject *args, PyObject *kw) 968 { 969 const char *arg; 970 static char *keywords[] = {"text", "stream", NULL }; 971 int stream_type = 0; 972 volatile struct gdb_exception except; 973 974 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg, 975 &stream_type)) 976 return NULL; 977 978 TRY_CATCH (except, RETURN_MASK_ALL) 979 { 980 switch (stream_type) 981 { 982 case 1: 983 { 984 fprintf_filtered (gdb_stderr, "%s", arg); 985 break; 986 } 987 case 2: 988 { 989 fprintf_filtered (gdb_stdlog, "%s", arg); 990 break; 991 } 992 default: 993 fprintf_filtered (gdb_stdout, "%s", arg); 994 } 995 } 996 GDB_PY_HANDLE_EXCEPTION (except); 997 998 Py_RETURN_NONE; 999 } 1000 1001 /* A python function to flush a gdb stream. The optional keyword 1002 STREAM can be used to flush a particular stream. The default stream 1003 is gdb_stdout. */ 1004 1005 static PyObject * 1006 gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw) 1007 { 1008 static char *keywords[] = {"stream", NULL }; 1009 int stream_type = 0; 1010 1011 if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords, 1012 &stream_type)) 1013 return NULL; 1014 1015 switch (stream_type) 1016 { 1017 case 1: 1018 { 1019 gdb_flush (gdb_stderr); 1020 break; 1021 } 1022 case 2: 1023 { 1024 gdb_flush (gdb_stdlog); 1025 break; 1026 } 1027 default: 1028 gdb_flush (gdb_stdout); 1029 } 1030 1031 Py_RETURN_NONE; 1032 } 1033 1034 /* Print a python exception trace, print just a message, or print 1035 nothing and clear the python exception, depending on 1036 gdbpy_should_print_stack. Only call this if a python exception is 1037 set. */ 1038 void 1039 gdbpy_print_stack (void) 1040 { 1041 volatile struct gdb_exception except; 1042 1043 /* Print "none", just clear exception. */ 1044 if (gdbpy_should_print_stack == python_excp_none) 1045 { 1046 PyErr_Clear (); 1047 } 1048 /* Print "full" message and backtrace. */ 1049 else if (gdbpy_should_print_stack == python_excp_full) 1050 { 1051 PyErr_Print (); 1052 /* PyErr_Print doesn't necessarily end output with a newline. 1053 This works because Python's stdout/stderr is fed through 1054 printf_filtered. */ 1055 TRY_CATCH (except, RETURN_MASK_ALL) 1056 { 1057 begin_line (); 1058 } 1059 } 1060 /* Print "message", just error print message. */ 1061 else 1062 { 1063 PyObject *ptype, *pvalue, *ptraceback; 1064 char *msg = NULL, *type = NULL; 1065 1066 PyErr_Fetch (&ptype, &pvalue, &ptraceback); 1067 1068 /* Fetch the error message contained within ptype, pvalue. */ 1069 msg = gdbpy_exception_to_string (ptype, pvalue); 1070 type = gdbpy_obj_to_string (ptype); 1071 1072 TRY_CATCH (except, RETURN_MASK_ALL) 1073 { 1074 if (msg == NULL) 1075 { 1076 /* An error occurred computing the string representation of the 1077 error message. */ 1078 fprintf_filtered (gdb_stderr, 1079 _("Error occurred computing Python error" \ 1080 "message.\n")); 1081 } 1082 else 1083 fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n", 1084 type, msg); 1085 } 1086 1087 Py_XDECREF (ptype); 1088 Py_XDECREF (pvalue); 1089 Py_XDECREF (ptraceback); 1090 xfree (msg); 1091 } 1092 } 1093 1094 1095 1096 /* Return the current Progspace. 1097 There always is one. */ 1098 1099 static PyObject * 1100 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2) 1101 { 1102 PyObject *result; 1103 1104 result = pspace_to_pspace_object (current_program_space); 1105 if (result) 1106 Py_INCREF (result); 1107 return result; 1108 } 1109 1110 /* Return a sequence holding all the Progspaces. */ 1111 1112 static PyObject * 1113 gdbpy_progspaces (PyObject *unused1, PyObject *unused2) 1114 { 1115 struct program_space *ps; 1116 PyObject *list; 1117 1118 list = PyList_New (0); 1119 if (!list) 1120 return NULL; 1121 1122 ALL_PSPACES (ps) 1123 { 1124 PyObject *item = pspace_to_pspace_object (ps); 1125 1126 if (!item || PyList_Append (list, item) == -1) 1127 { 1128 Py_DECREF (list); 1129 return NULL; 1130 } 1131 } 1132 1133 return list; 1134 } 1135 1136 1137 1138 /* The "current" objfile. This is set when gdb detects that a new 1139 objfile has been loaded. It is only set for the duration of a call to 1140 source_python_script_for_objfile; it is NULL at other times. */ 1141 static struct objfile *gdbpy_current_objfile; 1142 1143 /* Set the current objfile to OBJFILE and then read FILE named FILENAME 1144 as Python code. This does not throw any errors. If an exception 1145 occurs python will print the traceback and clear the error indicator. */ 1146 1147 void 1148 source_python_script_for_objfile (struct objfile *objfile, FILE *file, 1149 const char *filename) 1150 { 1151 struct cleanup *cleanups; 1152 1153 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language); 1154 gdbpy_current_objfile = objfile; 1155 1156 python_run_simple_file (file, filename); 1157 1158 do_cleanups (cleanups); 1159 gdbpy_current_objfile = NULL; 1160 } 1161 1162 /* Return the current Objfile, or None if there isn't one. */ 1163 1164 static PyObject * 1165 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2) 1166 { 1167 PyObject *result; 1168 1169 if (! gdbpy_current_objfile) 1170 Py_RETURN_NONE; 1171 1172 result = objfile_to_objfile_object (gdbpy_current_objfile); 1173 if (result) 1174 Py_INCREF (result); 1175 return result; 1176 } 1177 1178 /* Return a sequence holding all the Objfiles. */ 1179 1180 static PyObject * 1181 gdbpy_objfiles (PyObject *unused1, PyObject *unused2) 1182 { 1183 struct objfile *objf; 1184 PyObject *list; 1185 1186 list = PyList_New (0); 1187 if (!list) 1188 return NULL; 1189 1190 ALL_OBJFILES (objf) 1191 { 1192 PyObject *item = objfile_to_objfile_object (objf); 1193 1194 if (!item || PyList_Append (list, item) == -1) 1195 { 1196 Py_DECREF (list); 1197 return NULL; 1198 } 1199 } 1200 1201 return list; 1202 } 1203 1204 /* Compute the list of active type printers and return it. The result 1205 of this function can be passed to apply_type_printers, and should 1206 be freed by free_type_printers. */ 1207 1208 void * 1209 start_type_printers (void) 1210 { 1211 struct cleanup *cleanups; 1212 PyObject *type_module, *func, *result_obj = NULL; 1213 1214 cleanups = ensure_python_env (get_current_arch (), current_language); 1215 1216 type_module = PyImport_ImportModule ("gdb.types"); 1217 if (type_module == NULL) 1218 { 1219 gdbpy_print_stack (); 1220 goto done; 1221 } 1222 make_cleanup_py_decref (type_module); 1223 1224 func = PyObject_GetAttrString (type_module, "get_type_recognizers"); 1225 if (func == NULL) 1226 { 1227 gdbpy_print_stack (); 1228 goto done; 1229 } 1230 make_cleanup_py_decref (func); 1231 1232 result_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL); 1233 if (result_obj == NULL) 1234 gdbpy_print_stack (); 1235 1236 done: 1237 do_cleanups (cleanups); 1238 return result_obj; 1239 } 1240 1241 /* If TYPE is recognized by some type printer, return a newly 1242 allocated string holding the type's replacement name. The caller 1243 is responsible for freeing the string. Otherwise, return NULL. 1244 1245 This function has a bit of a funny name, since it actually applies 1246 recognizers, but this seemed clearer given the start_type_printers 1247 and free_type_printers functions. */ 1248 1249 char * 1250 apply_type_printers (void *printers, struct type *type) 1251 { 1252 struct cleanup *cleanups; 1253 PyObject *type_obj, *type_module, *func, *result_obj; 1254 PyObject *printers_obj = printers; 1255 char *result = NULL; 1256 1257 if (printers_obj == NULL) 1258 return NULL; 1259 1260 cleanups = ensure_python_env (get_current_arch (), current_language); 1261 1262 type_obj = type_to_type_object (type); 1263 if (type_obj == NULL) 1264 { 1265 gdbpy_print_stack (); 1266 goto done; 1267 } 1268 make_cleanup_py_decref (type_obj); 1269 1270 type_module = PyImport_ImportModule ("gdb.types"); 1271 if (type_module == NULL) 1272 { 1273 gdbpy_print_stack (); 1274 goto done; 1275 } 1276 make_cleanup_py_decref (type_module); 1277 1278 func = PyObject_GetAttrString (type_module, "apply_type_recognizers"); 1279 if (func == NULL) 1280 { 1281 gdbpy_print_stack (); 1282 goto done; 1283 } 1284 make_cleanup_py_decref (func); 1285 1286 result_obj = PyObject_CallFunctionObjArgs (func, printers_obj, 1287 type_obj, (char *) NULL); 1288 if (result_obj == NULL) 1289 { 1290 gdbpy_print_stack (); 1291 goto done; 1292 } 1293 make_cleanup_py_decref (result_obj); 1294 1295 if (result_obj != Py_None) 1296 { 1297 result = python_string_to_host_string (result_obj); 1298 if (result == NULL) 1299 gdbpy_print_stack (); 1300 } 1301 1302 done: 1303 do_cleanups (cleanups); 1304 return result; 1305 } 1306 1307 /* Free the result of start_type_printers. */ 1308 1309 void 1310 free_type_printers (void *arg) 1311 { 1312 struct cleanup *cleanups; 1313 PyObject *printers = arg; 1314 1315 if (printers == NULL) 1316 return; 1317 1318 cleanups = ensure_python_env (get_current_arch (), current_language); 1319 Py_DECREF (printers); 1320 do_cleanups (cleanups); 1321 } 1322 1323 #else /* HAVE_PYTHON */ 1324 1325 /* Dummy implementation of the gdb "python-interactive" and "python" 1326 command. */ 1327 1328 static void 1329 python_interactive_command (char *arg, int from_tty) 1330 { 1331 arg = skip_spaces (arg); 1332 if (arg && *arg) 1333 error (_("Python scripting is not supported in this copy of GDB.")); 1334 else 1335 { 1336 struct command_line *l = get_command_line (python_control, ""); 1337 struct cleanup *cleanups = make_cleanup_free_command_lines (&l); 1338 1339 execute_control_command_untraced (l); 1340 do_cleanups (cleanups); 1341 } 1342 } 1343 1344 static void 1345 python_command (char *arg, int from_tty) 1346 { 1347 python_interactive_command (arg, from_tty); 1348 } 1349 1350 void 1351 eval_python_from_control_command (struct command_line *cmd) 1352 { 1353 error (_("Python scripting is not supported in this copy of GDB.")); 1354 } 1355 1356 void 1357 source_python_script (FILE *file, const char *filename) 1358 { 1359 throw_error (UNSUPPORTED_ERROR, 1360 _("Python scripting is not supported in this copy of GDB.")); 1361 } 1362 1363 int 1364 gdbpy_should_stop (struct breakpoint_object *bp_obj) 1365 { 1366 internal_error (__FILE__, __LINE__, 1367 _("gdbpy_should_stop called when Python scripting is " \ 1368 "not supported.")); 1369 } 1370 1371 int 1372 gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj) 1373 { 1374 internal_error (__FILE__, __LINE__, 1375 _("gdbpy_breakpoint_has_py_cond called when Python " \ 1376 "scripting is not supported.")); 1377 } 1378 1379 void * 1380 start_type_printers (void) 1381 { 1382 return NULL; 1383 } 1384 1385 char * 1386 apply_type_printers (void *ignore, struct type *type) 1387 { 1388 return NULL; 1389 } 1390 1391 void 1392 free_type_printers (void *arg) 1393 { 1394 } 1395 1396 #endif /* HAVE_PYTHON */ 1397 1398 1399 1400 /* Lists for 'set python' commands. */ 1401 1402 static struct cmd_list_element *user_set_python_list; 1403 static struct cmd_list_element *user_show_python_list; 1404 1405 /* Function for use by 'set python' prefix command. */ 1406 1407 static void 1408 user_set_python (char *args, int from_tty) 1409 { 1410 help_list (user_set_python_list, "set python ", all_commands, 1411 gdb_stdout); 1412 } 1413 1414 /* Function for use by 'show python' prefix command. */ 1415 1416 static void 1417 user_show_python (char *args, int from_tty) 1418 { 1419 cmd_show_list (user_show_python_list, from_tty, ""); 1420 } 1421 1422 /* Initialize the Python code. */ 1423 1424 #ifdef HAVE_PYTHON 1425 1426 /* This is installed as a final cleanup and cleans up the 1427 interpreter. This lets Python's 'atexit' work. */ 1428 1429 static void 1430 finalize_python (void *ignore) 1431 { 1432 /* We don't use ensure_python_env here because if we ever ran the 1433 cleanup, gdb would crash -- because the cleanup calls into the 1434 Python interpreter, which we are about to destroy. It seems 1435 clearer to make the needed calls explicitly here than to create a 1436 cleanup and then mysteriously discard it. */ 1437 (void) PyGILState_Ensure (); 1438 python_gdbarch = target_gdbarch (); 1439 python_language = current_language; 1440 1441 Py_Finalize (); 1442 } 1443 #endif 1444 1445 /* Provide a prototype to silence -Wmissing-prototypes. */ 1446 extern initialize_file_ftype _initialize_python; 1447 1448 void 1449 _initialize_python (void) 1450 { 1451 char *progname; 1452 #ifdef IS_PY3K 1453 int i; 1454 size_t progsize, count; 1455 char *oldloc; 1456 wchar_t *progname_copy; 1457 #endif 1458 1459 add_com ("python-interactive", class_obscure, 1460 python_interactive_command, 1461 #ifdef HAVE_PYTHON 1462 _("\ 1463 Start an interactive Python prompt.\n\ 1464 \n\ 1465 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\ 1466 prompt).\n\ 1467 \n\ 1468 Alternatively, a single-line Python command can be given as an\n\ 1469 argument, and if the command is an expression, the result will be\n\ 1470 printed. For example:\n\ 1471 \n\ 1472 (gdb) python-interactive 2 + 3\n\ 1473 5\n\ 1474 ") 1475 #else /* HAVE_PYTHON */ 1476 _("\ 1477 Start a Python interactive prompt.\n\ 1478 \n\ 1479 Python scripting is not supported in this copy of GDB.\n\ 1480 This command is only a placeholder.") 1481 #endif /* HAVE_PYTHON */ 1482 ); 1483 add_com_alias ("pi", "python-interactive", class_obscure, 1); 1484 1485 add_com ("python", class_obscure, python_command, 1486 #ifdef HAVE_PYTHON 1487 _("\ 1488 Evaluate a Python command.\n\ 1489 \n\ 1490 The command can be given as an argument, for instance:\n\ 1491 \n\ 1492 python print 23\n\ 1493 \n\ 1494 If no argument is given, the following lines are read and used\n\ 1495 as the Python commands. Type a line containing \"end\" to indicate\n\ 1496 the end of the command.") 1497 #else /* HAVE_PYTHON */ 1498 _("\ 1499 Evaluate a Python command.\n\ 1500 \n\ 1501 Python scripting is not supported in this copy of GDB.\n\ 1502 This command is only a placeholder.") 1503 #endif /* HAVE_PYTHON */ 1504 ); 1505 add_com_alias ("py", "python", class_obscure, 1); 1506 1507 /* Add set/show python print-stack. */ 1508 add_prefix_cmd ("python", no_class, user_show_python, 1509 _("Prefix command for python preference settings."), 1510 &user_show_python_list, "show python ", 0, 1511 &showlist); 1512 1513 add_prefix_cmd ("python", no_class, user_set_python, 1514 _("Prefix command for python preference settings."), 1515 &user_set_python_list, "set python ", 0, 1516 &setlist); 1517 1518 add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums, 1519 &gdbpy_should_print_stack, _("\ 1520 Set mode for Python stack dump on error."), _("\ 1521 Show the mode of Python stack printing on error."), _("\ 1522 none == no stack or message will be printed.\n\ 1523 full == a message and a stack will be printed.\n\ 1524 message == an error message without a stack will be printed."), 1525 NULL, NULL, 1526 &user_set_python_list, 1527 &user_show_python_list); 1528 1529 #ifdef HAVE_PYTHON 1530 #ifdef WITH_PYTHON_PATH 1531 /* Work around problem where python gets confused about where it is, 1532 and then can't find its libraries, etc. 1533 NOTE: Python assumes the following layout: 1534 /foo/bin/python 1535 /foo/lib/pythonX.Y/... 1536 This must be done before calling Py_Initialize. */ 1537 progname = concat (ldirname (python_libdir), SLASH_STRING, "bin", 1538 SLASH_STRING, "python", NULL); 1539 #ifdef IS_PY3K 1540 oldloc = setlocale (LC_ALL, NULL); 1541 setlocale (LC_ALL, ""); 1542 progsize = strlen (progname); 1543 if (progsize == (size_t) -1) 1544 { 1545 fprintf (stderr, "Could not convert python path to string\n"); 1546 return; 1547 } 1548 progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t)); 1549 if (!progname_copy) 1550 { 1551 fprintf (stderr, "out of memory\n"); 1552 return; 1553 } 1554 count = mbstowcs (progname_copy, progname, progsize + 1); 1555 if (count == (size_t) -1) 1556 { 1557 fprintf (stderr, "Could not convert python path to string\n"); 1558 return; 1559 } 1560 setlocale (LC_ALL, oldloc); 1561 1562 /* Note that Py_SetProgramName expects the string it is passed to 1563 remain alive for the duration of the program's execution, so 1564 it is not freed after this call. */ 1565 Py_SetProgramName (progname_copy); 1566 #else 1567 Py_SetProgramName (progname); 1568 #endif 1569 #endif 1570 1571 Py_Initialize (); 1572 PyEval_InitThreads (); 1573 1574 #ifdef IS_PY3K 1575 gdb_module = PyModule_Create (&GdbModuleDef); 1576 /* Add _gdb module to the list of known built-in modules. */ 1577 _PyImport_FixupBuiltin (gdb_module, "_gdb"); 1578 #else 1579 gdb_module = Py_InitModule ("_gdb", GdbMethods); 1580 #endif 1581 1582 /* The casts to (char*) are for python 2.4. */ 1583 PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version); 1584 PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name); 1585 PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", 1586 (char*) target_name); 1587 1588 /* Add stream constants. */ 1589 PyModule_AddIntConstant (gdb_module, "STDOUT", 0); 1590 PyModule_AddIntConstant (gdb_module, "STDERR", 1); 1591 PyModule_AddIntConstant (gdb_module, "STDLOG", 2); 1592 1593 gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL); 1594 PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error); 1595 1596 gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError", 1597 gdbpy_gdb_error, NULL); 1598 PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error); 1599 1600 gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL); 1601 PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc); 1602 1603 gdbpy_initialize_gdb_readline (); 1604 gdbpy_initialize_auto_load (); 1605 gdbpy_initialize_values (); 1606 gdbpy_initialize_frames (); 1607 gdbpy_initialize_commands (); 1608 gdbpy_initialize_symbols (); 1609 gdbpy_initialize_symtabs (); 1610 gdbpy_initialize_blocks (); 1611 gdbpy_initialize_functions (); 1612 gdbpy_initialize_parameters (); 1613 gdbpy_initialize_types (); 1614 gdbpy_initialize_pspace (); 1615 gdbpy_initialize_objfile (); 1616 gdbpy_initialize_breakpoints (); 1617 gdbpy_initialize_finishbreakpoints (); 1618 gdbpy_initialize_lazy_string (); 1619 gdbpy_initialize_thread (); 1620 gdbpy_initialize_inferior (); 1621 gdbpy_initialize_events (); 1622 1623 gdbpy_initialize_eventregistry (); 1624 gdbpy_initialize_py_events (); 1625 gdbpy_initialize_event (); 1626 gdbpy_initialize_stop_event (); 1627 gdbpy_initialize_signal_event (); 1628 gdbpy_initialize_breakpoint_event (); 1629 gdbpy_initialize_continue_event (); 1630 gdbpy_initialize_exited_event (); 1631 gdbpy_initialize_thread_event (); 1632 gdbpy_initialize_new_objfile_event () ; 1633 gdbpy_initialize_arch (); 1634 1635 observer_attach_before_prompt (before_prompt_hook); 1636 1637 gdbpy_to_string_cst = PyString_FromString ("to_string"); 1638 gdbpy_children_cst = PyString_FromString ("children"); 1639 gdbpy_display_hint_cst = PyString_FromString ("display_hint"); 1640 gdbpy_doc_cst = PyString_FromString ("__doc__"); 1641 gdbpy_enabled_cst = PyString_FromString ("enabled"); 1642 gdbpy_value_cst = PyString_FromString ("value"); 1643 1644 /* Release the GIL while gdb runs. */ 1645 PyThreadState_Swap (NULL); 1646 PyEval_ReleaseLock (); 1647 1648 make_final_cleanup (finalize_python, NULL); 1649 #endif /* HAVE_PYTHON */ 1650 } 1651 1652 #ifdef HAVE_PYTHON 1653 1654 /* Perform the remaining python initializations. 1655 These must be done after GDB is at least mostly initialized. 1656 E.g., The "info pretty-printer" command needs the "info" prefix 1657 command installed. */ 1658 1659 void 1660 finish_python_initialization (void) 1661 { 1662 PyObject *m; 1663 char *gdb_pythondir; 1664 PyObject *sys_path; 1665 struct cleanup *cleanup; 1666 1667 cleanup = ensure_python_env (get_current_arch (), current_language); 1668 1669 /* Add the initial data-directory to sys.path. */ 1670 1671 gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL); 1672 make_cleanup (xfree, gdb_pythondir); 1673 1674 sys_path = PySys_GetObject ("path"); 1675 1676 /* If sys.path is not defined yet, define it first. */ 1677 if (!(sys_path && PyList_Check (sys_path))) 1678 { 1679 #ifdef IS_PY3K 1680 PySys_SetPath (L""); 1681 #else 1682 PySys_SetPath (""); 1683 #endif 1684 sys_path = PySys_GetObject ("path"); 1685 } 1686 if (sys_path && PyList_Check (sys_path)) 1687 { 1688 PyObject *pythondir; 1689 int err; 1690 1691 pythondir = PyString_FromString (gdb_pythondir); 1692 if (pythondir == NULL) 1693 goto fail; 1694 1695 err = PyList_Insert (sys_path, 0, pythondir); 1696 if (err) 1697 goto fail; 1698 1699 Py_DECREF (pythondir); 1700 } 1701 else 1702 goto fail; 1703 1704 /* Import the gdb module to finish the initialization, and 1705 add it to __main__ for convenience. */ 1706 m = PyImport_AddModule ("__main__"); 1707 if (m == NULL) 1708 goto fail; 1709 1710 gdb_python_module = PyImport_ImportModule ("gdb"); 1711 if (gdb_python_module == NULL) 1712 { 1713 gdbpy_print_stack (); 1714 /* This is passed in one call to warning so that blank lines aren't 1715 inserted between each line of text. */ 1716 warning (_("\n" 1717 "Could not load the Python gdb module from `%s'.\n" 1718 "Limited Python support is available from the _gdb module.\n" 1719 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"), 1720 gdb_pythondir); 1721 do_cleanups (cleanup); 1722 return; 1723 } 1724 1725 if (PyModule_AddObject (m, "gdb", gdb_python_module)) 1726 goto fail; 1727 1728 /* Keep the reference to gdb_python_module since it is in a global 1729 variable. */ 1730 1731 do_cleanups (cleanup); 1732 return; 1733 1734 fail: 1735 gdbpy_print_stack (); 1736 warning (_("internal error: Unhandled Python exception")); 1737 do_cleanups (cleanup); 1738 } 1739 1740 #endif /* HAVE_PYTHON */ 1741 1742 1743 1744 #ifdef HAVE_PYTHON 1745 1746 static PyMethodDef GdbMethods[] = 1747 { 1748 { "history", gdbpy_history, METH_VARARGS, 1749 "Get a value from history" }, 1750 { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS, 1751 "Execute a gdb command" }, 1752 { "parameter", gdbpy_parameter, METH_VARARGS, 1753 "Return a gdb parameter's value" }, 1754 1755 { "breakpoints", gdbpy_breakpoints, METH_NOARGS, 1756 "Return a tuple of all breakpoint objects" }, 1757 1758 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS, 1759 "Find the default visualizer for a Value." }, 1760 1761 { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS, 1762 "Return the current Progspace." }, 1763 { "progspaces", gdbpy_progspaces, METH_NOARGS, 1764 "Return a sequence of all progspaces." }, 1765 1766 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS, 1767 "Return the current Objfile being loaded, or None." }, 1768 { "objfiles", gdbpy_objfiles, METH_NOARGS, 1769 "Return a sequence of all loaded objfiles." }, 1770 1771 { "newest_frame", gdbpy_newest_frame, METH_NOARGS, 1772 "newest_frame () -> gdb.Frame.\n\ 1773 Return the newest frame object." }, 1774 { "selected_frame", gdbpy_selected_frame, METH_NOARGS, 1775 "selected_frame () -> gdb.Frame.\n\ 1776 Return the selected frame object." }, 1777 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS, 1778 "stop_reason_string (Integer) -> String.\n\ 1779 Return a string explaining unwind stop reason." }, 1780 1781 { "lookup_type", (PyCFunction) gdbpy_lookup_type, 1782 METH_VARARGS | METH_KEYWORDS, 1783 "lookup_type (name [, block]) -> type\n\ 1784 Return a Type corresponding to the given name." }, 1785 { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol, 1786 METH_VARARGS | METH_KEYWORDS, 1787 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\ 1788 Return a tuple with the symbol corresponding to the given name (or None) and\n\ 1789 a boolean indicating if name is a field of the current implied argument\n\ 1790 `this' (when the current language is object-oriented)." }, 1791 { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol, 1792 METH_VARARGS | METH_KEYWORDS, 1793 "lookup_global_symbol (name [, domain]) -> symbol\n\ 1794 Return the symbol corresponding to the given name (or None)." }, 1795 { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS, 1796 "Return the block containing the given pc value, or None." }, 1797 { "solib_name", gdbpy_solib_name, METH_VARARGS, 1798 "solib_name (Long) -> String.\n\ 1799 Return the name of the shared library holding a given address, or None." }, 1800 { "decode_line", gdbpy_decode_line, METH_VARARGS, 1801 "decode_line (String) -> Tuple. Decode a string argument the way\n\ 1802 that 'break' or 'edit' does. Return a tuple containing two elements.\n\ 1803 The first element contains any unparsed portion of the String parameter\n\ 1804 (or None if the string was fully parsed). The second element contains\n\ 1805 a tuple that contains all the locations that match, represented as\n\ 1806 gdb.Symtab_and_line objects (or None)."}, 1807 { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS, 1808 "parse_and_eval (String) -> Value.\n\ 1809 Parse String as an expression, evaluate it, and return the result as a Value." 1810 }, 1811 { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS, 1812 "find_pc_line (pc) -> Symtab_and_line.\n\ 1813 Return the gdb.Symtab_and_line object corresponding to the pc value." }, 1814 1815 { "post_event", gdbpy_post_event, METH_VARARGS, 1816 "Post an event into gdb's event loop." }, 1817 1818 { "target_charset", gdbpy_target_charset, METH_NOARGS, 1819 "target_charset () -> string.\n\ 1820 Return the name of the current target charset." }, 1821 { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS, 1822 "target_wide_charset () -> string.\n\ 1823 Return the name of the current target wide charset." }, 1824 1825 { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS, 1826 "string_to_argv (String) -> Array.\n\ 1827 Parse String and return an argv-like array.\n\ 1828 Arguments are separate by spaces and may be quoted." 1829 }, 1830 { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS, 1831 "Write a string using gdb's filtered stream." }, 1832 { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS, 1833 "Flush gdb's filtered stdout stream." }, 1834 { "selected_thread", gdbpy_selected_thread, METH_NOARGS, 1835 "selected_thread () -> gdb.InferiorThread.\n\ 1836 Return the selected thread object." }, 1837 { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS, 1838 "selected_inferior () -> gdb.Inferior.\n\ 1839 Return the selected inferior object." }, 1840 { "inferiors", gdbpy_inferiors, METH_NOARGS, 1841 "inferiors () -> (gdb.Inferior, ...).\n\ 1842 Return a tuple containing all inferiors." }, 1843 {NULL, NULL, 0, NULL} 1844 }; 1845 1846 #ifdef IS_PY3K 1847 static struct PyModuleDef GdbModuleDef = 1848 { 1849 PyModuleDef_HEAD_INIT, 1850 "_gdb", 1851 NULL, 1852 -1, 1853 GdbMethods, 1854 NULL, 1855 NULL, 1856 NULL, 1857 NULL 1858 }; 1859 #endif 1860 #endif /* HAVE_PYTHON */ 1861