1 /* General python/gdb code 2 3 Copyright (C) 2008, 2009, 2010, 2011 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 "python.h" 34 35 #include <ctype.h> 36 37 /* True if we should print the stack when catching a Python error, 38 false otherwise. */ 39 static int gdbpy_should_print_stack = 1; 40 41 #ifdef HAVE_PYTHON 42 43 #include "libiberty.h" 44 #include "cli/cli-decode.h" 45 #include "charset.h" 46 #include "top.h" 47 #include "solib.h" 48 #include "python-internal.h" 49 #include "linespec.h" 50 #include "source.h" 51 #include "version.h" 52 #include "target.h" 53 #include "gdbthread.h" 54 55 static PyMethodDef GdbMethods[]; 56 57 PyObject *gdb_module; 58 59 /* Some string constants we may wish to use. */ 60 PyObject *gdbpy_to_string_cst; 61 PyObject *gdbpy_children_cst; 62 PyObject *gdbpy_display_hint_cst; 63 PyObject *gdbpy_doc_cst; 64 PyObject *gdbpy_enabled_cst; 65 PyObject *gdbpy_value_cst; 66 67 /* The GdbError exception. */ 68 PyObject *gdbpy_gdberror_exc; 69 70 /* The `gdb.error' base class. */ 71 PyObject *gdbpy_gdb_error; 72 73 /* The `gdb.MemoryError' exception. */ 74 PyObject *gdbpy_gdb_memory_error; 75 76 /* Architecture and language to be used in callbacks from 77 the Python interpreter. */ 78 struct gdbarch *python_gdbarch; 79 const struct language_defn *python_language; 80 81 /* Restore global language and architecture and Python GIL state 82 when leaving the Python interpreter. */ 83 84 struct python_env 85 { 86 PyGILState_STATE state; 87 struct gdbarch *gdbarch; 88 const struct language_defn *language; 89 PyObject *error_type, *error_value, *error_traceback; 90 }; 91 92 static void 93 restore_python_env (void *p) 94 { 95 struct python_env *env = (struct python_env *)p; 96 97 /* Leftover Python error is forbidden by Python Exception Handling. */ 98 if (PyErr_Occurred ()) 99 { 100 /* This order is similar to the one calling error afterwards. */ 101 gdbpy_print_stack (); 102 warning (_("internal error: Unhandled Python exception")); 103 } 104 105 PyErr_Restore (env->error_type, env->error_value, env->error_traceback); 106 107 PyGILState_Release (env->state); 108 python_gdbarch = env->gdbarch; 109 python_language = env->language; 110 xfree (env); 111 } 112 113 /* Called before entering the Python interpreter to install the 114 current language and architecture to be used for Python values. */ 115 116 struct cleanup * 117 ensure_python_env (struct gdbarch *gdbarch, 118 const struct language_defn *language) 119 { 120 struct python_env *env = xmalloc (sizeof *env); 121 122 env->state = PyGILState_Ensure (); 123 env->gdbarch = python_gdbarch; 124 env->language = python_language; 125 126 python_gdbarch = gdbarch; 127 python_language = language; 128 129 /* Save it and ensure ! PyErr_Occurred () afterwards. */ 130 PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback); 131 132 return make_cleanup (restore_python_env, env); 133 } 134 135 136 /* Given a command_line, return a command string suitable for passing 137 to Python. Lines in the string are separated by newlines. The 138 return value is allocated using xmalloc and the caller is 139 responsible for freeing it. */ 140 141 static char * 142 compute_python_string (struct command_line *l) 143 { 144 struct command_line *iter; 145 char *script = NULL; 146 int size = 0; 147 int here; 148 149 for (iter = l; iter; iter = iter->next) 150 size += strlen (iter->line) + 1; 151 152 script = xmalloc (size + 1); 153 here = 0; 154 for (iter = l; iter; iter = iter->next) 155 { 156 int len = strlen (iter->line); 157 158 strcpy (&script[here], iter->line); 159 here += len; 160 script[here++] = '\n'; 161 } 162 script[here] = '\0'; 163 return script; 164 } 165 166 /* Take a command line structure representing a 'python' command, and 167 evaluate its body using the Python interpreter. */ 168 169 void 170 eval_python_from_control_command (struct command_line *cmd) 171 { 172 int ret; 173 char *script; 174 struct cleanup *cleanup; 175 176 if (cmd->body_count != 1) 177 error (_("Invalid \"python\" block structure.")); 178 179 cleanup = ensure_python_env (get_current_arch (), current_language); 180 181 script = compute_python_string (cmd->body_list[0]); 182 ret = PyRun_SimpleString (script); 183 xfree (script); 184 if (ret) 185 { 186 gdbpy_print_stack (); 187 error (_("Error while executing Python code.")); 188 } 189 190 do_cleanups (cleanup); 191 } 192 193 /* Implementation of the gdb "python" command. */ 194 195 static void 196 python_command (char *arg, int from_tty) 197 { 198 struct cleanup *cleanup; 199 200 cleanup = ensure_python_env (get_current_arch (), current_language); 201 while (arg && *arg && isspace (*arg)) 202 ++arg; 203 if (arg && *arg) 204 { 205 if (PyRun_SimpleString (arg)) 206 { 207 gdbpy_print_stack (); 208 error (_("Error while executing Python code.")); 209 } 210 } 211 else 212 { 213 struct command_line *l = get_command_line (python_control, ""); 214 215 make_cleanup_free_command_lines (&l); 216 execute_control_command_untraced (l); 217 } 218 219 do_cleanups (cleanup); 220 } 221 222 223 224 /* Transform a gdb parameters's value into a Python value. May return 225 NULL (and set a Python exception) on error. Helper function for 226 get_parameter. */ 227 PyObject * 228 gdbpy_parameter_value (enum var_types type, void *var) 229 { 230 switch (type) 231 { 232 case var_string: 233 case var_string_noescape: 234 case var_optional_filename: 235 case var_filename: 236 case var_enum: 237 { 238 char *str = * (char **) var; 239 240 if (! str) 241 str = ""; 242 return PyString_Decode (str, strlen (str), host_charset (), NULL); 243 } 244 245 case var_boolean: 246 { 247 if (* (int *) var) 248 Py_RETURN_TRUE; 249 else 250 Py_RETURN_FALSE; 251 } 252 253 case var_auto_boolean: 254 { 255 enum auto_boolean ab = * (enum auto_boolean *) var; 256 257 if (ab == AUTO_BOOLEAN_TRUE) 258 Py_RETURN_TRUE; 259 else if (ab == AUTO_BOOLEAN_FALSE) 260 Py_RETURN_FALSE; 261 else 262 Py_RETURN_NONE; 263 } 264 265 case var_integer: 266 if ((* (int *) var) == INT_MAX) 267 Py_RETURN_NONE; 268 /* Fall through. */ 269 case var_zinteger: 270 return PyLong_FromLong (* (int *) var); 271 272 case var_uinteger: 273 { 274 unsigned int val = * (unsigned int *) var; 275 276 if (val == UINT_MAX) 277 Py_RETURN_NONE; 278 return PyLong_FromUnsignedLong (val); 279 } 280 } 281 282 return PyErr_Format (PyExc_RuntimeError, 283 _("Programmer error: unhandled type.")); 284 } 285 286 /* A Python function which returns a gdb parameter's value as a Python 287 value. */ 288 289 PyObject * 290 gdbpy_parameter (PyObject *self, PyObject *args) 291 { 292 struct cmd_list_element *alias, *prefix, *cmd; 293 char *arg, *newarg; 294 int found = -1; 295 volatile struct gdb_exception except; 296 297 if (! PyArg_ParseTuple (args, "s", &arg)) 298 return NULL; 299 300 newarg = concat ("show ", arg, (char *) NULL); 301 302 TRY_CATCH (except, RETURN_MASK_ALL) 303 { 304 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd); 305 } 306 xfree (newarg); 307 GDB_PY_HANDLE_EXCEPTION (except); 308 if (!found) 309 return PyErr_Format (PyExc_RuntimeError, 310 _("Could not find parameter `%s'."), arg); 311 312 if (! cmd->var) 313 return PyErr_Format (PyExc_RuntimeError, 314 _("`%s' is not a parameter."), arg); 315 return gdbpy_parameter_value (cmd->var_type, cmd->var); 316 } 317 318 /* Wrapper for target_charset. */ 319 320 static PyObject * 321 gdbpy_target_charset (PyObject *self, PyObject *args) 322 { 323 const char *cset = target_charset (python_gdbarch); 324 325 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL); 326 } 327 328 /* Wrapper for target_wide_charset. */ 329 330 static PyObject * 331 gdbpy_target_wide_charset (PyObject *self, PyObject *args) 332 { 333 const char *cset = target_wide_charset (python_gdbarch); 334 335 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL); 336 } 337 338 /* A Python function which evaluates a string using the gdb CLI. */ 339 340 static PyObject * 341 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw) 342 { 343 char *arg; 344 PyObject *from_tty_obj = NULL, *to_string_obj = NULL; 345 int from_tty, to_string; 346 volatile struct gdb_exception except; 347 static char *keywords[] = {"command", "from_tty", "to_string", NULL }; 348 char *result = NULL; 349 350 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg, 351 &PyBool_Type, &from_tty_obj, 352 &PyBool_Type, &to_string_obj)) 353 return NULL; 354 355 from_tty = 0; 356 if (from_tty_obj) 357 { 358 int cmp = PyObject_IsTrue (from_tty_obj); 359 if (cmp < 0) 360 return NULL; 361 from_tty = cmp; 362 } 363 364 to_string = 0; 365 if (to_string_obj) 366 { 367 int cmp = PyObject_IsTrue (to_string_obj); 368 if (cmp < 0) 369 return NULL; 370 to_string = cmp; 371 } 372 373 TRY_CATCH (except, RETURN_MASK_ALL) 374 { 375 /* Copy the argument text in case the command modifies it. */ 376 char *copy = xstrdup (arg); 377 struct cleanup *cleanup = make_cleanup (xfree, copy); 378 379 prevent_dont_repeat (); 380 if (to_string) 381 result = execute_command_to_string (copy, from_tty); 382 else 383 { 384 result = NULL; 385 execute_command (copy, from_tty); 386 } 387 388 do_cleanups (cleanup); 389 } 390 GDB_PY_HANDLE_EXCEPTION (except); 391 392 /* Do any commands attached to breakpoint we stopped at. */ 393 bpstat_do_actions (); 394 395 if (result) 396 { 397 PyObject *r = PyString_FromString (result); 398 xfree (result); 399 return r; 400 } 401 Py_RETURN_NONE; 402 } 403 404 /* Implementation of gdb.solib_name (Long) -> String. 405 Returns the name of the shared library holding a given address, or None. */ 406 407 static PyObject * 408 gdbpy_solib_name (PyObject *self, PyObject *args) 409 { 410 char *soname; 411 PyObject *str_obj; 412 gdb_py_longest pc; 413 414 if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc)) 415 return NULL; 416 417 soname = solib_name_from_address (current_program_space, pc); 418 if (soname) 419 str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL); 420 else 421 { 422 str_obj = Py_None; 423 Py_INCREF (Py_None); 424 } 425 426 return str_obj; 427 } 428 429 /* A Python function which is a wrapper for decode_line_1. */ 430 431 static PyObject * 432 gdbpy_decode_line (PyObject *self, PyObject *args) 433 { 434 struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to 435 appease gcc. */ 436 struct symtab_and_line sal; 437 char *arg = NULL; 438 char *copy = NULL; 439 struct cleanup *cleanups; 440 PyObject *result = NULL; 441 PyObject *return_result = NULL; 442 PyObject *unparsed = NULL; 443 volatile struct gdb_exception except; 444 445 if (! PyArg_ParseTuple (args, "|s", &arg)) 446 return NULL; 447 448 cleanups = ensure_python_env (get_current_arch (), current_language); 449 450 TRY_CATCH (except, RETURN_MASK_ALL) 451 { 452 if (arg) 453 { 454 arg = xstrdup (arg); 455 make_cleanup (xfree, arg); 456 copy = arg; 457 sals = decode_line_1 (©, 0, 0, 0, 0); 458 make_cleanup (xfree, sals.sals); 459 } 460 else 461 { 462 set_default_source_symtab_and_line (); 463 sal = get_current_source_symtab_and_line (); 464 sals.sals = &sal; 465 sals.nelts = 1; 466 } 467 } 468 if (except.reason < 0) 469 { 470 do_cleanups (cleanups); 471 /* We know this will always throw. */ 472 GDB_PY_HANDLE_EXCEPTION (except); 473 } 474 475 if (sals.nelts) 476 { 477 int i; 478 479 result = PyTuple_New (sals.nelts); 480 if (! result) 481 goto error; 482 for (i = 0; i < sals.nelts; ++i) 483 { 484 PyObject *obj; 485 char *str; 486 487 obj = symtab_and_line_to_sal_object (sals.sals[i]); 488 if (! obj) 489 { 490 Py_DECREF (result); 491 goto error; 492 } 493 494 PyTuple_SetItem (result, i, obj); 495 } 496 } 497 else 498 { 499 result = Py_None; 500 Py_INCREF (Py_None); 501 } 502 503 return_result = PyTuple_New (2); 504 if (! return_result) 505 { 506 Py_DECREF (result); 507 goto error; 508 } 509 510 if (copy && strlen (copy) > 0) 511 unparsed = PyString_FromString (copy); 512 else 513 { 514 unparsed = Py_None; 515 Py_INCREF (Py_None); 516 } 517 518 PyTuple_SetItem (return_result, 0, unparsed); 519 PyTuple_SetItem (return_result, 1, result); 520 521 do_cleanups (cleanups); 522 523 return return_result; 524 525 error: 526 do_cleanups (cleanups); 527 return NULL; 528 } 529 530 /* Parse a string and evaluate it as an expression. */ 531 static PyObject * 532 gdbpy_parse_and_eval (PyObject *self, PyObject *args) 533 { 534 char *expr_str; 535 struct value *result = NULL; 536 volatile struct gdb_exception except; 537 538 if (!PyArg_ParseTuple (args, "s", &expr_str)) 539 return NULL; 540 541 TRY_CATCH (except, RETURN_MASK_ALL) 542 { 543 result = parse_and_eval (expr_str); 544 } 545 GDB_PY_HANDLE_EXCEPTION (except); 546 547 return value_to_value_object (result); 548 } 549 550 /* Read a file as Python code. STREAM is the input file; FILE is the 551 name of the file. 552 STREAM is not closed, that is the caller's responsibility. */ 553 554 void 555 source_python_script (FILE *stream, const char *file) 556 { 557 struct cleanup *cleanup; 558 559 cleanup = ensure_python_env (get_current_arch (), current_language); 560 561 /* Note: If an exception occurs python will print the traceback and 562 clear the error indicator. */ 563 PyRun_SimpleFile (stream, file); 564 565 do_cleanups (cleanup); 566 } 567 568 569 570 /* Posting and handling events. */ 571 572 /* A single event. */ 573 struct gdbpy_event 574 { 575 /* The Python event. This is just a callable object. */ 576 PyObject *event; 577 /* The next event. */ 578 struct gdbpy_event *next; 579 }; 580 581 /* All pending events. */ 582 static struct gdbpy_event *gdbpy_event_list; 583 /* The final link of the event list. */ 584 static struct gdbpy_event **gdbpy_event_list_end; 585 586 /* We use a file handler, and not an async handler, so that we can 587 wake up the main thread even when it is blocked in poll(). */ 588 static struct serial *gdbpy_event_fds[2]; 589 590 /* The file handler callback. This reads from the internal pipe, and 591 then processes the Python event queue. This will always be run in 592 the main gdb thread. */ 593 594 static void 595 gdbpy_run_events (struct serial *scb, void *context) 596 { 597 struct cleanup *cleanup; 598 int r; 599 600 cleanup = ensure_python_env (get_current_arch (), current_language); 601 602 /* Flush the fd. Do this before flushing the events list, so that 603 any new event post afterwards is sure to re-awake the event 604 loop. */ 605 while (serial_readchar (gdbpy_event_fds[0], 0) >= 0) 606 ; 607 608 while (gdbpy_event_list) 609 { 610 /* Dispatching the event might push a new element onto the event 611 loop, so we update here "atomically enough". */ 612 struct gdbpy_event *item = gdbpy_event_list; 613 gdbpy_event_list = gdbpy_event_list->next; 614 if (gdbpy_event_list == NULL) 615 gdbpy_event_list_end = &gdbpy_event_list; 616 617 /* Ignore errors. */ 618 if (PyObject_CallObject (item->event, NULL) == NULL) 619 PyErr_Clear (); 620 621 Py_DECREF (item->event); 622 xfree (item); 623 } 624 625 do_cleanups (cleanup); 626 } 627 628 /* Submit an event to the gdb thread. */ 629 static PyObject * 630 gdbpy_post_event (PyObject *self, PyObject *args) 631 { 632 struct gdbpy_event *event; 633 PyObject *func; 634 int wakeup; 635 636 if (!PyArg_ParseTuple (args, "O", &func)) 637 return NULL; 638 639 if (!PyCallable_Check (func)) 640 { 641 PyErr_SetString (PyExc_RuntimeError, 642 _("Posted event is not callable")); 643 return NULL; 644 } 645 646 Py_INCREF (func); 647 648 /* From here until the end of the function, we have the GIL, so we 649 can operate on our global data structures without worrying. */ 650 wakeup = gdbpy_event_list == NULL; 651 652 event = XNEW (struct gdbpy_event); 653 event->event = func; 654 event->next = NULL; 655 *gdbpy_event_list_end = event; 656 gdbpy_event_list_end = &event->next; 657 658 /* Wake up gdb when needed. */ 659 if (wakeup) 660 { 661 char c = 'q'; /* Anything. */ 662 663 if (serial_write (gdbpy_event_fds[1], &c, 1)) 664 return PyErr_SetFromErrno (PyExc_IOError); 665 } 666 667 Py_RETURN_NONE; 668 } 669 670 /* Initialize the Python event handler. */ 671 static void 672 gdbpy_initialize_events (void) 673 { 674 if (serial_pipe (gdbpy_event_fds) == 0) 675 { 676 gdbpy_event_list_end = &gdbpy_event_list; 677 serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL); 678 } 679 } 680 681 /* Printing. */ 682 683 /* A python function to write a single string using gdb's filtered 684 output stream . The optional keyword STREAM can be used to write 685 to a particular stream. The default stream is to gdb_stdout. */ 686 687 static PyObject * 688 gdbpy_write (PyObject *self, PyObject *args, PyObject *kw) 689 { 690 char *arg; 691 static char *keywords[] = {"text", "stream", NULL }; 692 int stream_type = 0; 693 694 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg, 695 &stream_type)) 696 return NULL; 697 698 switch (stream_type) 699 { 700 case 1: 701 { 702 fprintf_filtered (gdb_stderr, "%s", arg); 703 break; 704 } 705 case 2: 706 { 707 fprintf_filtered (gdb_stdlog, "%s", arg); 708 break; 709 } 710 default: 711 fprintf_filtered (gdb_stdout, "%s", arg); 712 } 713 714 Py_RETURN_NONE; 715 } 716 717 /* A python function to flush a gdb stream. The optional keyword 718 STREAM can be used to flush a particular stream. The default stream 719 is gdb_stdout. */ 720 721 static PyObject * 722 gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw) 723 { 724 static char *keywords[] = {"stream", NULL }; 725 int stream_type = 0; 726 727 if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords, 728 &stream_type)) 729 return NULL; 730 731 switch (stream_type) 732 { 733 case 1: 734 { 735 gdb_flush (gdb_stderr); 736 break; 737 } 738 case 2: 739 { 740 gdb_flush (gdb_stdlog); 741 break; 742 } 743 default: 744 gdb_flush (gdb_stdout); 745 } 746 747 Py_RETURN_NONE; 748 } 749 750 /* Print a python exception trace, or print nothing and clear the 751 python exception, depending on gdbpy_should_print_stack. Only call 752 this if a python exception is set. */ 753 void 754 gdbpy_print_stack (void) 755 { 756 if (gdbpy_should_print_stack) 757 { 758 PyErr_Print (); 759 /* PyErr_Print doesn't necessarily end output with a newline. 760 This works because Python's stdout/stderr is fed through 761 printf_filtered. */ 762 begin_line (); 763 } 764 else 765 PyErr_Clear (); 766 } 767 768 769 770 /* Return the current Progspace. 771 There always is one. */ 772 773 static PyObject * 774 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2) 775 { 776 PyObject *result; 777 778 result = pspace_to_pspace_object (current_program_space); 779 if (result) 780 Py_INCREF (result); 781 return result; 782 } 783 784 /* Return a sequence holding all the Progspaces. */ 785 786 static PyObject * 787 gdbpy_progspaces (PyObject *unused1, PyObject *unused2) 788 { 789 struct program_space *ps; 790 PyObject *list; 791 792 list = PyList_New (0); 793 if (!list) 794 return NULL; 795 796 ALL_PSPACES (ps) 797 { 798 PyObject *item = pspace_to_pspace_object (ps); 799 800 if (!item || PyList_Append (list, item) == -1) 801 { 802 Py_DECREF (list); 803 return NULL; 804 } 805 } 806 807 return list; 808 } 809 810 811 812 /* The "current" objfile. This is set when gdb detects that a new 813 objfile has been loaded. It is only set for the duration of a call to 814 source_python_script_for_objfile; it is NULL at other times. */ 815 static struct objfile *gdbpy_current_objfile; 816 817 /* Set the current objfile to OBJFILE and then read STREAM,FILE as 818 Python code. */ 819 820 void 821 source_python_script_for_objfile (struct objfile *objfile, 822 FILE *stream, const char *file) 823 { 824 struct cleanup *cleanups; 825 826 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language); 827 gdbpy_current_objfile = objfile; 828 829 /* Note: If an exception occurs python will print the traceback and 830 clear the error indicator. */ 831 PyRun_SimpleFile (stream, file); 832 833 do_cleanups (cleanups); 834 gdbpy_current_objfile = NULL; 835 } 836 837 /* Return the current Objfile, or None if there isn't one. */ 838 839 static PyObject * 840 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2) 841 { 842 PyObject *result; 843 844 if (! gdbpy_current_objfile) 845 Py_RETURN_NONE; 846 847 result = objfile_to_objfile_object (gdbpy_current_objfile); 848 if (result) 849 Py_INCREF (result); 850 return result; 851 } 852 853 /* Return a sequence holding all the Objfiles. */ 854 855 static PyObject * 856 gdbpy_objfiles (PyObject *unused1, PyObject *unused2) 857 { 858 struct objfile *objf; 859 PyObject *list; 860 861 list = PyList_New (0); 862 if (!list) 863 return NULL; 864 865 ALL_OBJFILES (objf) 866 { 867 PyObject *item = objfile_to_objfile_object (objf); 868 869 if (!item || PyList_Append (list, item) == -1) 870 { 871 Py_DECREF (list); 872 return NULL; 873 } 874 } 875 876 return list; 877 } 878 879 #else /* HAVE_PYTHON */ 880 881 /* Dummy implementation of the gdb "python" command. */ 882 883 static void 884 python_command (char *arg, int from_tty) 885 { 886 while (arg && *arg && isspace (*arg)) 887 ++arg; 888 if (arg && *arg) 889 error (_("Python scripting is not supported in this copy of GDB.")); 890 else 891 { 892 struct command_line *l = get_command_line (python_control, ""); 893 struct cleanup *cleanups = make_cleanup_free_command_lines (&l); 894 895 execute_control_command_untraced (l); 896 do_cleanups (cleanups); 897 } 898 } 899 900 void 901 eval_python_from_control_command (struct command_line *cmd) 902 { 903 error (_("Python scripting is not supported in this copy of GDB.")); 904 } 905 906 void 907 source_python_script (FILE *stream, const char *file) 908 { 909 throw_error (UNSUPPORTED_ERROR, 910 _("Python scripting is not supported in this copy of GDB.")); 911 } 912 913 int 914 gdbpy_should_stop (struct breakpoint_object *bp_obj) 915 { 916 internal_error (__FILE__, __LINE__, 917 _("gdbpy_should_stop called when Python scripting is " \ 918 "not supported.")); 919 } 920 921 int 922 gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj) 923 { 924 internal_error (__FILE__, __LINE__, 925 _("gdbpy_breakpoint_has_py_cond called when Python " \ 926 "scripting is not supported.")); 927 } 928 929 #endif /* HAVE_PYTHON */ 930 931 932 933 /* Lists for 'maint set python' commands. */ 934 935 struct cmd_list_element *set_python_list; 936 struct cmd_list_element *show_python_list; 937 938 /* Function for use by 'maint set python' prefix command. */ 939 940 static void 941 set_python (char *args, int from_tty) 942 { 943 help_list (set_python_list, "maintenance set python ", -1, gdb_stdout); 944 } 945 946 /* Function for use by 'maint show python' prefix command. */ 947 948 static void 949 show_python (char *args, int from_tty) 950 { 951 cmd_show_list (show_python_list, from_tty, ""); 952 } 953 954 /* Initialize the Python code. */ 955 956 /* Provide a prototype to silence -Wmissing-prototypes. */ 957 extern initialize_file_ftype _initialize_python; 958 959 void 960 _initialize_python (void) 961 { 962 add_com ("python", class_obscure, python_command, 963 #ifdef HAVE_PYTHON 964 _("\ 965 Evaluate a Python command.\n\ 966 \n\ 967 The command can be given as an argument, for instance:\n\ 968 \n\ 969 python print 23\n\ 970 \n\ 971 If no argument is given, the following lines are read and used\n\ 972 as the Python commands. Type a line containing \"end\" to indicate\n\ 973 the end of the command.") 974 #else /* HAVE_PYTHON */ 975 _("\ 976 Evaluate a Python command.\n\ 977 \n\ 978 Python scripting is not supported in this copy of GDB.\n\ 979 This command is only a placeholder.") 980 #endif /* HAVE_PYTHON */ 981 ); 982 983 add_prefix_cmd ("python", no_class, show_python, 984 _("Prefix command for python maintenance settings."), 985 &show_python_list, "maintenance show python ", 0, 986 &maintenance_show_cmdlist); 987 add_prefix_cmd ("python", no_class, set_python, 988 _("Prefix command for python maintenance settings."), 989 &set_python_list, "maintenance set python ", 0, 990 &maintenance_set_cmdlist); 991 992 add_setshow_boolean_cmd ("print-stack", class_maintenance, 993 &gdbpy_should_print_stack, _("\ 994 Enable or disable printing of Python stack dump on error."), _("\ 995 Show whether Python stack will be printed on error."), _("\ 996 Enables or disables printing of Python stack traces."), 997 NULL, NULL, 998 &set_python_list, 999 &show_python_list); 1000 1001 #ifdef HAVE_PYTHON 1002 #ifdef WITH_PYTHON_PATH 1003 /* Work around problem where python gets confused about where it is, 1004 and then can't find its libraries, etc. 1005 NOTE: Python assumes the following layout: 1006 /foo/bin/python 1007 /foo/lib/pythonX.Y/... 1008 This must be done before calling Py_Initialize. */ 1009 Py_SetProgramName (concat (ldirname (python_libdir), SLASH_STRING, "bin", 1010 SLASH_STRING, "python", NULL)); 1011 #endif 1012 1013 Py_Initialize (); 1014 PyEval_InitThreads (); 1015 1016 gdb_module = Py_InitModule ("gdb", GdbMethods); 1017 1018 /* The casts to (char*) are for python 2.4. */ 1019 PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version); 1020 PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name); 1021 PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", 1022 (char*) target_name); 1023 1024 /* Add stream constants. */ 1025 PyModule_AddIntConstant (gdb_module, "STDOUT", 0); 1026 PyModule_AddIntConstant (gdb_module, "STDERR", 1); 1027 PyModule_AddIntConstant (gdb_module, "STDLOG", 2); 1028 1029 /* gdb.parameter ("data-directory") doesn't necessarily exist when the python 1030 script below is run (depending on order of _initialize_* functions). 1031 Define the initial value of gdb.PYTHONDIR here. */ 1032 { 1033 char *gdb_pythondir; 1034 1035 gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL); 1036 PyModule_AddStringConstant (gdb_module, "PYTHONDIR", gdb_pythondir); 1037 xfree (gdb_pythondir); 1038 } 1039 1040 gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL); 1041 PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error); 1042 1043 gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError", 1044 gdbpy_gdb_error, NULL); 1045 PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error); 1046 1047 gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL); 1048 PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc); 1049 1050 gdbpy_initialize_auto_load (); 1051 gdbpy_initialize_values (); 1052 gdbpy_initialize_frames (); 1053 gdbpy_initialize_commands (); 1054 gdbpy_initialize_symbols (); 1055 gdbpy_initialize_symtabs (); 1056 gdbpy_initialize_blocks (); 1057 gdbpy_initialize_functions (); 1058 gdbpy_initialize_parameters (); 1059 gdbpy_initialize_types (); 1060 gdbpy_initialize_pspace (); 1061 gdbpy_initialize_objfile (); 1062 gdbpy_initialize_breakpoints (); 1063 gdbpy_initialize_lazy_string (); 1064 gdbpy_initialize_thread (); 1065 gdbpy_initialize_inferior (); 1066 gdbpy_initialize_events (); 1067 1068 gdbpy_initialize_eventregistry (); 1069 gdbpy_initialize_py_events (); 1070 gdbpy_initialize_event (); 1071 gdbpy_initialize_stop_event (); 1072 gdbpy_initialize_signal_event (); 1073 gdbpy_initialize_breakpoint_event (); 1074 gdbpy_initialize_continue_event (); 1075 gdbpy_initialize_exited_event (); 1076 gdbpy_initialize_thread_event (); 1077 1078 PyRun_SimpleString ("import gdb"); 1079 PyRun_SimpleString ("gdb.pretty_printers = []"); 1080 1081 gdbpy_to_string_cst = PyString_FromString ("to_string"); 1082 gdbpy_children_cst = PyString_FromString ("children"); 1083 gdbpy_display_hint_cst = PyString_FromString ("display_hint"); 1084 gdbpy_doc_cst = PyString_FromString ("__doc__"); 1085 gdbpy_enabled_cst = PyString_FromString ("enabled"); 1086 gdbpy_value_cst = PyString_FromString ("value"); 1087 1088 /* Release the GIL while gdb runs. */ 1089 PyThreadState_Swap (NULL); 1090 PyEval_ReleaseLock (); 1091 1092 #endif /* HAVE_PYTHON */ 1093 } 1094 1095 #ifdef HAVE_PYTHON 1096 1097 /* Perform the remaining python initializations. 1098 These must be done after GDB is at least mostly initialized. 1099 E.g., The "info pretty-printer" command needs the "info" prefix 1100 command installed. */ 1101 1102 void 1103 finish_python_initialization (void) 1104 { 1105 struct cleanup *cleanup; 1106 1107 cleanup = ensure_python_env (get_current_arch (), current_language); 1108 1109 PyRun_SimpleString ("\ 1110 import os\n\ 1111 import sys\n\ 1112 \n\ 1113 class GdbOutputFile:\n\ 1114 def close(self):\n\ 1115 # Do nothing.\n\ 1116 return None\n\ 1117 \n\ 1118 def isatty(self):\n\ 1119 return False\n\ 1120 \n\ 1121 def write(self, s):\n\ 1122 gdb.write(s, stream=gdb.STDOUT)\n \ 1123 \n\ 1124 def writelines(self, iterable):\n\ 1125 for line in iterable:\n\ 1126 self.write(line)\n\ 1127 \n\ 1128 def flush(self):\n\ 1129 gdb.flush()\n\ 1130 \n\ 1131 sys.stdout = GdbOutputFile()\n\ 1132 \n\ 1133 class GdbOutputErrorFile:\n\ 1134 def close(self):\n\ 1135 # Do nothing.\n\ 1136 return None\n\ 1137 \n\ 1138 def isatty(self):\n\ 1139 return False\n\ 1140 \n\ 1141 def write(self, s):\n\ 1142 gdb.write(s, stream=gdb.STDERR)\n \ 1143 \n\ 1144 def writelines(self, iterable):\n\ 1145 for line in iterable:\n\ 1146 self.write(line)\n \ 1147 \n\ 1148 def flush(self):\n\ 1149 gdb.flush()\n\ 1150 \n\ 1151 sys.stderr = GdbOutputErrorFile()\n\ 1152 \n\ 1153 # Ideally this would live in the gdb module, but it's intentionally written\n\ 1154 # in python, and we need this to bootstrap the gdb module.\n\ 1155 \n\ 1156 def GdbSetPythonDirectory (dir):\n\ 1157 \"Set gdb.PYTHONDIR and update sys.path,etc.\"\n\ 1158 old_dir = gdb.PYTHONDIR\n\ 1159 gdb.PYTHONDIR = dir\n\ 1160 # GDB's python scripts are stored inside gdb.PYTHONDIR. So insert\n\ 1161 # that directory name at the start of sys.path to allow the Python\n\ 1162 # interpreter to find them.\n\ 1163 if old_dir in sys.path:\n\ 1164 sys.path.remove (old_dir)\n\ 1165 sys.path.insert (0, gdb.PYTHONDIR)\n\ 1166 \n\ 1167 # Tell python where to find submodules of gdb.\n\ 1168 gdb.__path__ = [gdb.PYTHONDIR + '/gdb']\n\ 1169 \n\ 1170 # The gdb module is implemented in C rather than in Python. As a result,\n\ 1171 # the associated __init.py__ script is not not executed by default when\n\ 1172 # the gdb module gets imported. Execute that script manually if it\n\ 1173 # exists.\n\ 1174 ipy = gdb.PYTHONDIR + '/gdb/__init__.py'\n\ 1175 if os.path.exists (ipy):\n\ 1176 execfile (ipy)\n\ 1177 \n\ 1178 # Install the default gdb.PYTHONDIR.\n\ 1179 GdbSetPythonDirectory (gdb.PYTHONDIR)\n\ 1180 "); 1181 1182 do_cleanups (cleanup); 1183 } 1184 1185 #endif /* HAVE_PYTHON */ 1186 1187 1188 1189 #ifdef HAVE_PYTHON 1190 1191 static PyMethodDef GdbMethods[] = 1192 { 1193 { "history", gdbpy_history, METH_VARARGS, 1194 "Get a value from history" }, 1195 { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS, 1196 "Execute a gdb command" }, 1197 { "parameter", gdbpy_parameter, METH_VARARGS, 1198 "Return a gdb parameter's value" }, 1199 1200 { "breakpoints", gdbpy_breakpoints, METH_NOARGS, 1201 "Return a tuple of all breakpoint objects" }, 1202 1203 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS, 1204 "Find the default visualizer for a Value." }, 1205 1206 { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS, 1207 "Return the current Progspace." }, 1208 { "progspaces", gdbpy_progspaces, METH_NOARGS, 1209 "Return a sequence of all progspaces." }, 1210 1211 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS, 1212 "Return the current Objfile being loaded, or None." }, 1213 { "objfiles", gdbpy_objfiles, METH_NOARGS, 1214 "Return a sequence of all loaded objfiles." }, 1215 1216 { "newest_frame", gdbpy_newest_frame, METH_NOARGS, 1217 "newest_frame () -> gdb.Frame.\n\ 1218 Return the newest frame object." }, 1219 { "selected_frame", gdbpy_selected_frame, METH_NOARGS, 1220 "selected_frame () -> gdb.Frame.\n\ 1221 Return the selected frame object." }, 1222 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS, 1223 "stop_reason_string (Integer) -> String.\n\ 1224 Return a string explaining unwind stop reason." }, 1225 1226 { "lookup_type", (PyCFunction) gdbpy_lookup_type, 1227 METH_VARARGS | METH_KEYWORDS, 1228 "lookup_type (name [, block]) -> type\n\ 1229 Return a Type corresponding to the given name." }, 1230 { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol, 1231 METH_VARARGS | METH_KEYWORDS, 1232 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\ 1233 Return a tuple with the symbol corresponding to the given name (or None) and\n\ 1234 a boolean indicating if name is a field of the current implied argument\n\ 1235 `this' (when the current language is object-oriented)." }, 1236 { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol, 1237 METH_VARARGS | METH_KEYWORDS, 1238 "lookup_global_symbol (name [, domain]) -> symbol\n\ 1239 Return the symbol corresponding to the given name (or None)." }, 1240 { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS, 1241 "Return the block containing the given pc value, or None." }, 1242 { "solib_name", gdbpy_solib_name, METH_VARARGS, 1243 "solib_name (Long) -> String.\n\ 1244 Return the name of the shared library holding a given address, or None." }, 1245 { "decode_line", gdbpy_decode_line, METH_VARARGS, 1246 "decode_line (String) -> Tuple. Decode a string argument the way\n\ 1247 that 'break' or 'edit' does. Return a tuple containing two elements.\n\ 1248 The first element contains any unparsed portion of the String parameter\n\ 1249 (or None if the string was fully parsed). The second element contains\n\ 1250 a tuple that contains all the locations that match, represented as\n\ 1251 gdb.Symtab_and_line objects (or None)."}, 1252 { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS, 1253 "parse_and_eval (String) -> Value.\n\ 1254 Parse String as an expression, evaluate it, and return the result as a Value." 1255 }, 1256 1257 { "post_event", gdbpy_post_event, METH_VARARGS, 1258 "Post an event into gdb's event loop." }, 1259 1260 { "target_charset", gdbpy_target_charset, METH_NOARGS, 1261 "target_charset () -> string.\n\ 1262 Return the name of the current target charset." }, 1263 { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS, 1264 "target_wide_charset () -> string.\n\ 1265 Return the name of the current target wide charset." }, 1266 1267 { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS, 1268 "string_to_argv (String) -> Array.\n\ 1269 Parse String and return an argv-like array.\n\ 1270 Arguments are separate by spaces and may be quoted." 1271 }, 1272 { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS, 1273 "Write a string using gdb's filtered stream." }, 1274 { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS, 1275 "Flush gdb's filtered stdout stream." }, 1276 { "selected_thread", gdbpy_selected_thread, METH_NOARGS, 1277 "selected_thread () -> gdb.InferiorThread.\n\ 1278 Return the selected thread object." }, 1279 { "inferiors", gdbpy_inferiors, METH_NOARGS, 1280 "inferiors () -> (gdb.Inferior, ...).\n\ 1281 Return a tuple containing all inferiors." }, 1282 {NULL, NULL, 0, NULL} 1283 }; 1284 1285 #endif /* HAVE_PYTHON */ 1286