1 /* General python/gdb code
3 Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "arch-utils.h"
24 #include "cli/cli-script.h"
33 /* True if we should print the stack when catching a Python error,
35 static int gdbpy_should_print_stack
= 1;
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;
44 #include "libiberty.h"
45 #include "cli/cli-decode.h"
48 #include "exceptions.h"
49 #include "python-internal.h"
52 #include "gdbthread.h"
54 static PyMethodDef GdbMethods
[];
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
;
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
;
70 /* Restore global language and architecture and Python GIL state
71 when leaving the Python interpreter. */
75 PyGILState_STATE state
;
76 struct gdbarch
*gdbarch
;
77 const struct language_defn
*language
;
81 restore_python_env (void *p
)
83 struct python_env
*env
= (struct python_env
*)p
;
84 PyGILState_Release (env
->state
);
85 python_gdbarch
= env
->gdbarch
;
86 python_language
= env
->language
;
90 /* Called before entering the Python interpreter to install the
91 current language and architecture to be used for Python values. */
94 ensure_python_env (struct gdbarch
*gdbarch
,
95 const struct language_defn
*language
)
97 struct python_env
*env
= xmalloc (sizeof *env
);
99 env
->state
= PyGILState_Ensure ();
100 env
->gdbarch
= python_gdbarch
;
101 env
->language
= python_language
;
103 python_gdbarch
= gdbarch
;
104 python_language
= language
;
106 return make_cleanup (restore_python_env
, env
);
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. */
116 compute_python_string (struct command_line
*l
)
118 struct command_line
*iter
;
123 for (iter
= l
; iter
; iter
= iter
->next
)
124 size
+= strlen (iter
->line
) + 1;
126 script
= xmalloc (size
+ 1);
128 for (iter
= l
; iter
; iter
= iter
->next
)
130 int len
= strlen (iter
->line
);
131 strcpy (&script
[here
], iter
->line
);
133 script
[here
++] = '\n';
139 /* Take a command line structure representing a 'python' command, and
140 evaluate its body using the Python interpreter. */
143 eval_python_from_control_command (struct command_line
*cmd
)
147 struct cleanup
*cleanup
;
149 if (cmd
->body_count
!= 1)
150 error (_("Invalid \"python\" block structure."));
152 cleanup
= ensure_python_env (get_current_arch (), current_language
);
154 script
= compute_python_string (cmd
->body_list
[0]);
155 ret
= PyRun_SimpleString (script
);
159 gdbpy_print_stack ();
160 error (_("Error while executing Python code."));
163 do_cleanups (cleanup
);
166 /* Implementation of the gdb "python" command. */
169 python_command (char *arg
, int from_tty
)
171 struct cleanup
*cleanup
;
172 cleanup
= ensure_python_env (get_current_arch (), current_language
);
174 while (arg
&& *arg
&& isspace (*arg
))
178 if (PyRun_SimpleString (arg
))
180 gdbpy_print_stack ();
181 error (_("Error while executing Python code."));
186 struct command_line
*l
= get_command_line (python_control
, "");
187 make_cleanup_free_command_lines (&l
);
188 execute_control_command_untraced (l
);
191 do_cleanups (cleanup
);
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
201 parameter_to_python (struct cmd_list_element
*cmd
)
203 switch (cmd
->var_type
)
206 case var_string_noescape
:
207 case var_optional_filename
:
211 char *str
= * (char **) cmd
->var
;
214 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
219 if (* (int *) cmd
->var
)
225 case var_auto_boolean
:
227 enum auto_boolean ab
= * (enum auto_boolean
*) cmd
->var
;
228 if (ab
== AUTO_BOOLEAN_TRUE
)
230 else if (ab
== AUTO_BOOLEAN_FALSE
)
237 if ((* (int *) cmd
->var
) == INT_MAX
)
241 return PyLong_FromLong (* (int *) cmd
->var
);
245 unsigned int val
= * (unsigned int *) cmd
->var
;
248 return PyLong_FromUnsignedLong (val
);
252 return PyErr_Format (PyExc_RuntimeError
, "programmer error: unhandled type");
255 /* A Python function which returns a gdb parameter's value as a Python
259 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
261 struct cmd_list_element
*alias
, *prefix
, *cmd
;
264 volatile struct gdb_exception except
;
266 if (! PyArg_ParseTuple (args
, "s", &arg
))
269 newarg
= concat ("show ", arg
, (char *) NULL
);
271 TRY_CATCH (except
, RETURN_MASK_ALL
)
273 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
276 GDB_PY_HANDLE_EXCEPTION (except
);
278 return PyErr_Format (PyExc_RuntimeError
,
279 "could not find parameter `%s'", arg
);
282 return PyErr_Format (PyExc_RuntimeError
, "`%s' is not a parameter", arg
);
283 return parameter_to_python (cmd
);
286 /* A Python function which evaluates a string using the gdb CLI. */
289 execute_gdb_command (PyObject
*self
, PyObject
*args
)
291 struct cmd_list_element
*alias
, *prefix
, *cmd
;
293 PyObject
*from_tty_obj
= NULL
;
296 volatile struct gdb_exception except
;
298 if (! PyArg_ParseTuple (args
, "s|O!", &arg
, &PyBool_Type
, &from_tty_obj
))
304 cmp
= PyObject_IsTrue (from_tty_obj
);
310 TRY_CATCH (except
, RETURN_MASK_ALL
)
312 /* Copy the argument text in case the command modifies it. */
313 char *copy
= xstrdup (arg
);
314 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
315 execute_command (copy
, from_tty
);
316 do_cleanups (cleanup
);
318 GDB_PY_HANDLE_EXCEPTION (except
);
320 /* Do any commands attached to breakpoint we stopped at. */
321 bpstat_do_actions ();
326 /* Parse a string and evaluate it as an expression. */
328 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
331 struct value
*result
= NULL
;
332 volatile struct gdb_exception except
;
334 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
337 TRY_CATCH (except
, RETURN_MASK_ALL
)
339 result
= parse_and_eval (expr_str
);
341 GDB_PY_HANDLE_EXCEPTION (except
);
343 return value_to_value_object (result
);
350 /* A python function to write a single string using gdb's filtered
353 gdbpy_write (PyObject
*self
, PyObject
*args
)
356 if (! PyArg_ParseTuple (args
, "s", &arg
))
358 printf_filtered ("%s", arg
);
362 /* A python function to flush gdb's filtered output stream. */
364 gdbpy_flush (PyObject
*self
, PyObject
*args
)
366 gdb_flush (gdb_stdout
);
370 /* Print a python exception trace, or print nothing and clear the
371 python exception, depending on gdbpy_should_print_stack. Only call
372 this if a python exception is set. */
374 gdbpy_print_stack (void)
376 if (gdbpy_should_print_stack
)
384 /* The "current" objfile. This is set when gdb detects that a new
385 objfile has been loaded. It is only set for the duration of a call
386 to gdbpy_new_objfile; it is NULL at other times. */
387 static struct objfile
*gdbpy_current_objfile
;
389 /* The file name we attempt to read. */
390 #define GDBPY_AUTO_FILENAME "-gdb.py"
392 /* This is a new_objfile observer callback which loads python code
393 based on the path to the objfile. */
395 gdbpy_new_objfile (struct objfile
*objfile
)
398 char *filename
, *debugfile
;
401 struct cleanup
*cleanups
;
403 if (!gdbpy_auto_load
|| !objfile
|| !objfile
->name
)
406 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
408 gdbpy_current_objfile
= objfile
;
410 realname
= gdb_realpath (objfile
->name
);
411 len
= strlen (realname
);
412 filename
= xmalloc (len
+ sizeof (GDBPY_AUTO_FILENAME
));
413 memcpy (filename
, realname
, len
);
414 strcpy (filename
+ len
, GDBPY_AUTO_FILENAME
);
416 input
= fopen (filename
, "r");
417 debugfile
= filename
;
419 make_cleanup (xfree
, filename
);
420 make_cleanup (xfree
, realname
);
422 if (!input
&& debug_file_directory
)
424 /* Also try the same file in the separate debug info directory. */
425 debugfile
= xmalloc (strlen (filename
)
426 + strlen (debug_file_directory
) + 1);
427 strcpy (debugfile
, debug_file_directory
);
428 /* FILENAME is absolute, so we don't need a "/" here. */
429 strcat (debugfile
, filename
);
431 make_cleanup (xfree
, debugfile
);
432 input
= fopen (debugfile
, "r");
435 if (!input
&& gdb_datadir
)
437 /* Also try the same file in a subdirectory of gdb's data
439 debugfile
= xmalloc (strlen (gdb_datadir
) + strlen (filename
)
440 + strlen ("/auto-load") + 1);
441 strcpy (debugfile
, gdb_datadir
);
442 strcat (debugfile
, "/auto-load");
443 /* FILENAME is absolute, so we don't need a "/" here. */
444 strcat (debugfile
, filename
);
446 make_cleanup (xfree
, debugfile
);
447 input
= fopen (debugfile
, "r");
452 /* We don't want to throw an exception here -- but the user
453 would like to know that something went wrong. */
454 if (PyRun_SimpleFile (input
, debugfile
))
455 gdbpy_print_stack ();
459 do_cleanups (cleanups
);
460 gdbpy_current_objfile
= NULL
;
463 /* Return the current Objfile, or None if there isn't one. */
465 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
469 if (! gdbpy_current_objfile
)
472 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
478 /* Return a sequence holding all the Objfiles. */
480 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
482 struct objfile
*objf
;
485 list
= PyList_New (0);
491 PyObject
*item
= objfile_to_objfile_object (objf
);
492 if (!item
|| PyList_Append (list
, item
) == -1)
502 #else /* HAVE_PYTHON */
504 /* Dummy implementation of the gdb "python" command. */
507 python_command (char *arg
, int from_tty
)
509 while (arg
&& *arg
&& isspace (*arg
))
512 error (_("Python scripting is not supported in this copy of GDB."));
515 struct command_line
*l
= get_command_line (python_control
, "");
516 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
517 execute_control_command_untraced (l
);
518 do_cleanups (cleanups
);
523 eval_python_from_control_command (struct command_line
*cmd
)
525 error (_("Python scripting is not supported in this copy of GDB."));
528 #endif /* HAVE_PYTHON */
532 /* Lists for 'maint set python' commands. */
534 static struct cmd_list_element
*set_python_list
;
535 static struct cmd_list_element
*show_python_list
;
537 /* Function for use by 'maint set python' prefix command. */
540 set_python (char *args
, int from_tty
)
542 help_list (set_python_list
, "maintenance set python ", -1, gdb_stdout
);
545 /* Function for use by 'maint show python' prefix command. */
548 show_python (char *args
, int from_tty
)
550 cmd_show_list (show_python_list
, from_tty
, "");
553 /* Initialize the Python code. */
555 /* Provide a prototype to silence -Wmissing-prototypes. */
556 extern initialize_file_ftype _initialize_python
;
559 _initialize_python (void)
561 add_com ("python", class_obscure
, python_command
,
564 Evaluate a Python command.\n\
566 The command can be given as an argument, for instance:\n\
570 If no argument is given, the following lines are read and used\n\
571 as the Python commands. Type a line containing \"end\" to indicate\n\
572 the end of the command.")
573 #else /* HAVE_PYTHON */
575 Evaluate a Python command.\n\
577 Python scripting is not supported in this copy of GDB.\n\
578 This command is only a placeholder.")
579 #endif /* HAVE_PYTHON */
582 add_prefix_cmd ("python", no_class
, show_python
,
583 _("Prefix command for python maintenance settings."),
584 &show_python_list
, "maintenance show python ", 0,
585 &maintenance_show_cmdlist
);
586 add_prefix_cmd ("python", no_class
, set_python
,
587 _("Prefix command for python maintenance settings."),
588 &set_python_list
, "maintenance set python ", 0,
589 &maintenance_set_cmdlist
);
591 add_setshow_boolean_cmd ("print-stack", class_maintenance
,
592 &gdbpy_should_print_stack
, _("\
593 Enable or disable printing of Python stack dump on error."), _("\
594 Show whether Python stack will be printed on error."), _("\
595 Enables or disables printing of Python stack traces."),
600 add_setshow_boolean_cmd ("auto-load", class_maintenance
,
601 &gdbpy_auto_load
, _("\
602 Enable or disable auto-loading of Python code when an object is opened."), _("\
603 Show whether Python code will be auto-loaded when an object is opened."), _("\
604 Enables or disables auto-loading of Python code when an object is opened."),
611 PyEval_InitThreads ();
613 gdb_module
= Py_InitModule ("gdb", GdbMethods
);
615 /* The casts to (char*) are for python 2.4. */
616 PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
);
617 PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", (char*) host_name
);
618 PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG", (char*) target_name
);
620 gdbpy_initialize_values ();
621 gdbpy_initialize_frames ();
622 gdbpy_initialize_commands ();
623 gdbpy_initialize_functions ();
624 gdbpy_initialize_types ();
625 gdbpy_initialize_objfile ();
627 PyRun_SimpleString ("import gdb");
628 PyRun_SimpleString ("gdb.pretty_printers = []");
630 observer_attach_new_objfile (gdbpy_new_objfile
);
632 gdbpy_to_string_cst
= PyString_FromString ("to_string");
633 gdbpy_children_cst
= PyString_FromString ("children");
634 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
635 gdbpy_doc_cst
= PyString_FromString ("__doc__");
637 /* Create a couple objects which are used for Python's stdout and
639 PyRun_SimpleString ("\
641 class GdbOutputFile:\n\
649 def write(self, s):\n\
652 def writelines(self, iterable):\n\
653 for line in iterable:\n\
659 sys.stderr = GdbOutputFile()\n\
660 sys.stdout = GdbOutputFile()\n\
663 /* Release the GIL while gdb runs. */
664 PyThreadState_Swap (NULL
);
665 PyEval_ReleaseLock ();
667 #endif /* HAVE_PYTHON */
674 static PyMethodDef GdbMethods
[] =
676 { "history", gdbpy_history
, METH_VARARGS
,
677 "Get a value from history" },
678 { "execute", execute_gdb_command
, METH_VARARGS
,
679 "Execute a gdb command" },
680 { "parameter", gdbpy_parameter
, METH_VARARGS
,
681 "Return a gdb parameter's value" },
683 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
684 "Find the default visualizer for a Value." },
686 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
687 "Return the current Objfile being loaded, or None." },
688 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
689 "Return a sequence of all loaded objfiles." },
691 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
692 "selected_frame () -> gdb.Frame.\n\
693 Return the selected frame object." },
694 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
695 "stop_reason_string (Integer) -> String.\n\
696 Return a string explaining unwind stop reason." },
698 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
699 METH_VARARGS
| METH_KEYWORDS
,
700 "lookup_type (name [, block]) -> type\n\
701 Return a Type corresponding to the given name." },
703 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
704 "parse_and_eval (String) -> Value.\n\
705 Parse String as an expression, evaluate it, and return the result as a Value."
708 { "write", gdbpy_write
, METH_VARARGS
,
709 "Write a string using gdb's filtered stream." },
710 { "flush", gdbpy_flush
, METH_NOARGS
,
711 "Flush gdb's filtered stdout stream." },
713 {NULL
, NULL
, 0, NULL
}
716 #endif /* HAVE_PYTHON */