1 /* General python/gdb code 2 3 Copyright (C) 2008, 2009 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 "objfiles.h" 27 #include "observer.h" 28 #include "value.h" 29 #include "language.h" 30 31 #include <ctype.h> 32 33 /* True if we should print the stack when catching a Python error, 34 false otherwise. */ 35 static int gdbpy_should_print_stack = 1; 36 37 /* This is true if we should auto-load python code when an objfile is 38 opened, false otherwise. */ 39 static int gdbpy_auto_load = 1; 40 41 #ifdef HAVE_PYTHON 42 43 #include "python.h" 44 #include "libiberty.h" 45 #include "cli/cli-decode.h" 46 #include "charset.h" 47 #include "top.h" 48 #include "exceptions.h" 49 #include "python-internal.h" 50 #include "version.h" 51 #include "target.h" 52 #include "gdbthread.h" 53 54 static PyMethodDef GdbMethods[]; 55 56 PyObject *gdb_module; 57 58 /* Some string constants we may wish to use. */ 59 PyObject *gdbpy_to_string_cst; 60 PyObject *gdbpy_children_cst; 61 PyObject *gdbpy_display_hint_cst; 62 PyObject *gdbpy_doc_cst; 63 64 65 /* Architecture and language to be used in callbacks from 66 the Python interpreter. */ 67 struct gdbarch *python_gdbarch; 68 const struct language_defn *python_language; 69 70 /* Restore global language and architecture and Python GIL state 71 when leaving the Python interpreter. */ 72 73 struct python_env 74 { 75 PyGILState_STATE state; 76 struct gdbarch *gdbarch; 77 const struct language_defn *language; 78 }; 79 80 static void 81 restore_python_env (void *p) 82 { 83 struct python_env *env = (struct python_env *)p; 84 PyGILState_Release (env->state); 85 python_gdbarch = env->gdbarch; 86 python_language = env->language; 87 xfree (env); 88 } 89 90 /* Called before entering the Python interpreter to install the 91 current language and architecture to be used for Python values. */ 92 93 struct cleanup * 94 ensure_python_env (struct gdbarch *gdbarch, 95 const struct language_defn *language) 96 { 97 struct python_env *env = xmalloc (sizeof *env); 98 99 env->state = PyGILState_Ensure (); 100 env->gdbarch = python_gdbarch; 101 env->language = python_language; 102 103 python_gdbarch = gdbarch; 104 python_language = language; 105 106 return make_cleanup (restore_python_env, env); 107 } 108 109 110 /* Given a command_line, return a command string suitable for passing 111 to Python. Lines in the string are separated by newlines. The 112 return value is allocated using xmalloc and the caller is 113 responsible for freeing it. */ 114 115 static char * 116 compute_python_string (struct command_line *l) 117 { 118 struct command_line *iter; 119 char *script = NULL; 120 int size = 0; 121 int here; 122 123 for (iter = l; iter; iter = iter->next) 124 size += strlen (iter->line) + 1; 125 126 script = xmalloc (size + 1); 127 here = 0; 128 for (iter = l; iter; iter = iter->next) 129 { 130 int len = strlen (iter->line); 131 strcpy (&script[here], iter->line); 132 here += len; 133 script[here++] = '\n'; 134 } 135 script[here] = '\0'; 136 return script; 137 } 138 139 /* Take a command line structure representing a 'python' command, and 140 evaluate its body using the Python interpreter. */ 141 142 void 143 eval_python_from_control_command (struct command_line *cmd) 144 { 145 int ret; 146 char *script; 147 struct cleanup *cleanup; 148 149 if (cmd->body_count != 1) 150 error (_("Invalid \"python\" block structure.")); 151 152 cleanup = ensure_python_env (get_current_arch (), current_language); 153 154 script = compute_python_string (cmd->body_list[0]); 155 ret = PyRun_SimpleString (script); 156 xfree (script); 157 if (ret) 158 { 159 gdbpy_print_stack (); 160 error (_("Error while executing Python code.")); 161 } 162 163 do_cleanups (cleanup); 164 } 165 166 /* Implementation of the gdb "python" command. */ 167 168 static void 169 python_command (char *arg, int from_tty) 170 { 171 struct cleanup *cleanup; 172 cleanup = ensure_python_env (get_current_arch (), current_language); 173 174 while (arg && *arg && isspace (*arg)) 175 ++arg; 176 if (arg && *arg) 177 { 178 if (PyRun_SimpleString (arg)) 179 { 180 gdbpy_print_stack (); 181 error (_("Error while executing Python code.")); 182 } 183 } 184 else 185 { 186 struct command_line *l = get_command_line (python_control, ""); 187 make_cleanup_free_command_lines (&l); 188 execute_control_command_untraced (l); 189 } 190 191 do_cleanups (cleanup); 192 } 193 194 195 196 /* Transform a gdb parameters's value into a Python value. May return 197 NULL (and set a Python exception) on error. Helper function for 198 get_parameter. */ 199 200 static PyObject * 201 parameter_to_python (struct cmd_list_element *cmd) 202 { 203 switch (cmd->var_type) 204 { 205 case var_string: 206 case var_string_noescape: 207 case var_optional_filename: 208 case var_filename: 209 case var_enum: 210 { 211 char *str = * (char **) cmd->var; 212 if (! str) 213 str = ""; 214 return PyString_Decode (str, strlen (str), host_charset (), NULL); 215 } 216 217 case var_boolean: 218 { 219 if (* (int *) cmd->var) 220 Py_RETURN_TRUE; 221 else 222 Py_RETURN_FALSE; 223 } 224 225 case var_auto_boolean: 226 { 227 enum auto_boolean ab = * (enum auto_boolean *) cmd->var; 228 if (ab == AUTO_BOOLEAN_TRUE) 229 Py_RETURN_TRUE; 230 else if (ab == AUTO_BOOLEAN_FALSE) 231 Py_RETURN_FALSE; 232 else 233 Py_RETURN_NONE; 234 } 235 236 case var_integer: 237 if ((* (int *) cmd->var) == INT_MAX) 238 Py_RETURN_NONE; 239 /* Fall through. */ 240 case var_zinteger: 241 return PyLong_FromLong (* (int *) cmd->var); 242 243 case var_uinteger: 244 { 245 unsigned int val = * (unsigned int *) cmd->var; 246 if (val == UINT_MAX) 247 Py_RETURN_NONE; 248 return PyLong_FromUnsignedLong (val); 249 } 250 } 251 252 return PyErr_Format (PyExc_RuntimeError, "programmer error: unhandled type"); 253 } 254 255 /* A Python function which returns a gdb parameter's value as a Python 256 value. */ 257 258 static PyObject * 259 gdbpy_parameter (PyObject *self, PyObject *args) 260 { 261 struct cmd_list_element *alias, *prefix, *cmd; 262 char *arg, *newarg; 263 int found = -1; 264 volatile struct gdb_exception except; 265 266 if (! PyArg_ParseTuple (args, "s", &arg)) 267 return NULL; 268 269 newarg = concat ("show ", arg, (char *) NULL); 270 271 TRY_CATCH (except, RETURN_MASK_ALL) 272 { 273 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd); 274 } 275 xfree (newarg); 276 GDB_PY_HANDLE_EXCEPTION (except); 277 if (!found) 278 return PyErr_Format (PyExc_RuntimeError, 279 "could not find parameter `%s'", arg); 280 281 if (! cmd->var) 282 return PyErr_Format (PyExc_RuntimeError, "`%s' is not a parameter", arg); 283 return parameter_to_python (cmd); 284 } 285 286 /* A Python function which evaluates a string using the gdb CLI. */ 287 288 static PyObject * 289 execute_gdb_command (PyObject *self, PyObject *args) 290 { 291 struct cmd_list_element *alias, *prefix, *cmd; 292 char *arg, *newarg; 293 PyObject *from_tty_obj = NULL; 294 int from_tty; 295 int cmp; 296 volatile struct gdb_exception except; 297 298 if (! PyArg_ParseTuple (args, "s|O!", &arg, &PyBool_Type, &from_tty_obj)) 299 return NULL; 300 301 from_tty = 0; 302 if (from_tty_obj) 303 { 304 cmp = PyObject_IsTrue (from_tty_obj); 305 if (cmp < 0) 306 return NULL; 307 from_tty = cmp; 308 } 309 310 TRY_CATCH (except, RETURN_MASK_ALL) 311 { 312 execute_command (arg, from_tty); 313 } 314 GDB_PY_HANDLE_EXCEPTION (except); 315 316 /* Do any commands attached to breakpoint we stopped at. */ 317 bpstat_do_actions (); 318 319 Py_RETURN_NONE; 320 } 321 322 323 324 /* Printing. */ 325 326 /* A python function to write a single string using gdb's filtered 327 output stream. */ 328 static PyObject * 329 gdbpy_write (PyObject *self, PyObject *args) 330 { 331 char *arg; 332 if (! PyArg_ParseTuple (args, "s", &arg)) 333 return NULL; 334 printf_filtered ("%s", arg); 335 Py_RETURN_NONE; 336 } 337 338 /* A python function to flush gdb's filtered output stream. */ 339 static PyObject * 340 gdbpy_flush (PyObject *self, PyObject *args) 341 { 342 gdb_flush (gdb_stdout); 343 Py_RETURN_NONE; 344 } 345 346 /* Print a python exception trace, or print nothing and clear the 347 python exception, depending on gdbpy_should_print_stack. Only call 348 this if a python exception is set. */ 349 void 350 gdbpy_print_stack (void) 351 { 352 if (gdbpy_should_print_stack) 353 PyErr_Print (); 354 else 355 PyErr_Clear (); 356 } 357 358 359 360 /* The "current" objfile. This is set when gdb detects that a new 361 objfile has been loaded. It is only set for the duration of a call 362 to gdbpy_new_objfile; it is NULL at other times. */ 363 static struct objfile *gdbpy_current_objfile; 364 365 /* The file name we attempt to read. */ 366 #define GDBPY_AUTO_FILENAME "-gdb.py" 367 368 /* This is a new_objfile observer callback which loads python code 369 based on the path to the objfile. */ 370 static void 371 gdbpy_new_objfile (struct objfile *objfile) 372 { 373 char *realname; 374 char *filename, *debugfile; 375 int len; 376 FILE *input; 377 struct cleanup *cleanups; 378 379 if (!gdbpy_auto_load || !objfile || !objfile->name) 380 return; 381 382 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language); 383 384 gdbpy_current_objfile = objfile; 385 386 realname = gdb_realpath (objfile->name); 387 len = strlen (realname); 388 filename = xmalloc (len + sizeof (GDBPY_AUTO_FILENAME)); 389 memcpy (filename, realname, len); 390 strcpy (filename + len, GDBPY_AUTO_FILENAME); 391 392 input = fopen (filename, "r"); 393 debugfile = filename; 394 395 make_cleanup (xfree, filename); 396 make_cleanup (xfree, realname); 397 398 if (!input && debug_file_directory) 399 { 400 /* Also try the same file in the separate debug info directory. */ 401 debugfile = xmalloc (strlen (filename) 402 + strlen (debug_file_directory) + 1); 403 strcpy (debugfile, debug_file_directory); 404 /* FILENAME is absolute, so we don't need a "/" here. */ 405 strcat (debugfile, filename); 406 407 make_cleanup (xfree, debugfile); 408 input = fopen (debugfile, "r"); 409 } 410 411 if (!input && gdb_datadir) 412 { 413 /* Also try the same file in a subdirectory of gdb's data 414 directory. */ 415 debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename) 416 + strlen ("/auto-load") + 1); 417 strcpy (debugfile, gdb_datadir); 418 strcat (debugfile, "/auto-load"); 419 /* FILENAME is absolute, so we don't need a "/" here. */ 420 strcat (debugfile, filename); 421 422 make_cleanup (xfree, debugfile); 423 input = fopen (debugfile, "r"); 424 } 425 426 if (input) 427 { 428 /* We don't want to throw an exception here -- but the user 429 would like to know that something went wrong. */ 430 if (PyRun_SimpleFile (input, debugfile)) 431 gdbpy_print_stack (); 432 fclose (input); 433 } 434 435 do_cleanups (cleanups); 436 gdbpy_current_objfile = NULL; 437 } 438 439 /* Return the current Objfile, or None if there isn't one. */ 440 static PyObject * 441 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2) 442 { 443 PyObject *result; 444 445 if (! gdbpy_current_objfile) 446 Py_RETURN_NONE; 447 448 result = objfile_to_objfile_object (gdbpy_current_objfile); 449 if (result) 450 Py_INCREF (result); 451 return result; 452 } 453 454 /* Return a sequence holding all the Objfiles. */ 455 static PyObject * 456 gdbpy_objfiles (PyObject *unused1, PyObject *unused2) 457 { 458 struct objfile *objf; 459 PyObject *list; 460 461 list = PyList_New (0); 462 if (!list) 463 return NULL; 464 465 ALL_OBJFILES (objf) 466 { 467 PyObject *item = objfile_to_objfile_object (objf); 468 if (!item || PyList_Append (list, item) == -1) 469 { 470 Py_DECREF (list); 471 return NULL; 472 } 473 } 474 475 return list; 476 } 477 478 #else /* HAVE_PYTHON */ 479 480 /* Dummy implementation of the gdb "python" command. */ 481 482 static void 483 python_command (char *arg, int from_tty) 484 { 485 while (arg && *arg && isspace (*arg)) 486 ++arg; 487 if (arg && *arg) 488 error (_("Python scripting is not supported in this copy of GDB.")); 489 else 490 { 491 struct command_line *l = get_command_line (python_control, ""); 492 struct cleanup *cleanups = make_cleanup_free_command_lines (&l); 493 execute_control_command_untraced (l); 494 do_cleanups (cleanups); 495 } 496 } 497 498 void 499 eval_python_from_control_command (struct command_line *cmd) 500 { 501 error (_("Python scripting is not supported in this copy of GDB.")); 502 } 503 504 #endif /* HAVE_PYTHON */ 505 506 507 508 /* Lists for 'maint set python' commands. */ 509 510 static struct cmd_list_element *set_python_list; 511 static struct cmd_list_element *show_python_list; 512 513 /* Function for use by 'maint set python' prefix command. */ 514 515 static void 516 set_python (char *args, int from_tty) 517 { 518 help_list (set_python_list, "maintenance set python ", -1, gdb_stdout); 519 } 520 521 /* Function for use by 'maint show python' prefix command. */ 522 523 static void 524 show_python (char *args, int from_tty) 525 { 526 cmd_show_list (show_python_list, from_tty, ""); 527 } 528 529 /* Initialize the Python code. */ 530 531 /* Provide a prototype to silence -Wmissing-prototypes. */ 532 extern initialize_file_ftype _initialize_python; 533 534 void 535 _initialize_python (void) 536 { 537 add_com ("python", class_obscure, python_command, 538 #ifdef HAVE_PYTHON 539 _("\ 540 Evaluate a Python command.\n\ 541 \n\ 542 The command can be given as an argument, for instance:\n\ 543 \n\ 544 python print 23\n\ 545 \n\ 546 If no argument is given, the following lines are read and used\n\ 547 as the Python commands. Type a line containing \"end\" to indicate\n\ 548 the end of the command.") 549 #else /* HAVE_PYTHON */ 550 _("\ 551 Evaluate a Python command.\n\ 552 \n\ 553 Python scripting is not supported in this copy of GDB.\n\ 554 This command is only a placeholder.") 555 #endif /* HAVE_PYTHON */ 556 ); 557 558 add_prefix_cmd ("python", no_class, show_python, 559 _("Prefix command for python maintenance settings."), 560 &show_python_list, "maintenance show python ", 0, 561 &maintenance_show_cmdlist); 562 add_prefix_cmd ("python", no_class, set_python, 563 _("Prefix command for python maintenance settings."), 564 &set_python_list, "maintenance set python ", 0, 565 &maintenance_set_cmdlist); 566 567 add_setshow_boolean_cmd ("print-stack", class_maintenance, 568 &gdbpy_should_print_stack, _("\ 569 Enable or disable printing of Python stack dump on error."), _("\ 570 Show whether Python stack will be printed on error."), _("\ 571 Enables or disables printing of Python stack traces."), 572 NULL, NULL, 573 &set_python_list, 574 &show_python_list); 575 576 add_setshow_boolean_cmd ("auto-load", class_maintenance, 577 &gdbpy_auto_load, _("\ 578 Enable or disable auto-loading of Python code when an object is opened."), _("\ 579 Show whether Python code will be auto-loaded when an object is opened."), _("\ 580 Enables or disables auto-loading of Python code when an object is opened."), 581 NULL, NULL, 582 &set_python_list, 583 &show_python_list); 584 585 #ifdef HAVE_PYTHON 586 Py_Initialize (); 587 PyEval_InitThreads (); 588 589 gdb_module = Py_InitModule ("gdb", GdbMethods); 590 591 /* The casts to (char*) are for python 2.4. */ 592 PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version); 593 PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name); 594 PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name); 595 596 gdbpy_initialize_values (); 597 gdbpy_initialize_frames (); 598 gdbpy_initialize_commands (); 599 gdbpy_initialize_functions (); 600 gdbpy_initialize_types (); 601 gdbpy_initialize_objfile (); 602 603 PyRun_SimpleString ("import gdb"); 604 PyRun_SimpleString ("gdb.pretty_printers = []"); 605 606 observer_attach_new_objfile (gdbpy_new_objfile); 607 608 gdbpy_to_string_cst = PyString_FromString ("to_string"); 609 gdbpy_children_cst = PyString_FromString ("children"); 610 gdbpy_display_hint_cst = PyString_FromString ("display_hint"); 611 gdbpy_doc_cst = PyString_FromString ("__doc__"); 612 613 /* Create a couple objects which are used for Python's stdout and 614 stderr. */ 615 PyRun_SimpleString ("\ 616 import sys\n\ 617 class GdbOutputFile:\n\ 618 def close(self):\n\ 619 # Do nothing.\n\ 620 return None\n\ 621 \n\ 622 def isatty(self):\n\ 623 return False\n\ 624 \n\ 625 def write(self, s):\n\ 626 gdb.write(s)\n\ 627 \n\ 628 def writelines(self, iterable):\n\ 629 for line in iterable:\n\ 630 self.write(line)\n\ 631 \n\ 632 def flush(self):\n\ 633 gdb.flush()\n\ 634 \n\ 635 sys.stderr = GdbOutputFile()\n\ 636 sys.stdout = GdbOutputFile()\n\ 637 "); 638 639 /* Release the GIL while gdb runs. */ 640 PyThreadState_Swap (NULL); 641 PyEval_ReleaseLock (); 642 643 #endif /* HAVE_PYTHON */ 644 } 645 646 647 648 #if HAVE_PYTHON 649 650 static PyMethodDef GdbMethods[] = 651 { 652 { "history", gdbpy_history, METH_VARARGS, 653 "Get a value from history" }, 654 { "execute", execute_gdb_command, METH_VARARGS, 655 "Execute a gdb command" }, 656 { "parameter", gdbpy_parameter, METH_VARARGS, 657 "Return a gdb parameter's value" }, 658 659 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS, 660 "Find the default visualizer for a Value." }, 661 662 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS, 663 "Return the current Objfile being loaded, or None." }, 664 { "objfiles", gdbpy_objfiles, METH_NOARGS, 665 "Return a sequence of all loaded objfiles." }, 666 667 { "selected_frame", gdbpy_selected_frame, METH_NOARGS, 668 "selected_frame () -> gdb.Frame.\n\ 669 Return the selected frame object." }, 670 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS, 671 "stop_reason_string (Integer) -> String.\n\ 672 Return a string explaining unwind stop reason." }, 673 674 { "lookup_type", (PyCFunction) gdbpy_lookup_type, 675 METH_VARARGS | METH_KEYWORDS, 676 "lookup_type (name [, block]) -> type\n\ 677 Return a Type corresponding to the given name." }, 678 679 { "write", gdbpy_write, METH_VARARGS, 680 "Write a string using gdb's filtered stream." }, 681 { "flush", gdbpy_flush, METH_NOARGS, 682 "Flush gdb's filtered stdout stream." }, 683 684 {NULL, NULL, 0, NULL} 685 }; 686 687 #endif /* HAVE_PYTHON */ 688