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"
26 #include "progspace.h"
30 #include "exceptions.h"
34 /* True if we should print the stack when catching a Python error,
36 static int gdbpy_should_print_stack
= 1;
41 #include "libiberty.h"
42 #include "cli/cli-decode.h"
45 #include "python-internal.h"
48 #include "gdbthread.h"
50 static PyMethodDef GdbMethods
[];
54 /* Some string constants we may wish to use. */
55 PyObject
*gdbpy_to_string_cst
;
56 PyObject
*gdbpy_children_cst
;
57 PyObject
*gdbpy_display_hint_cst
;
58 PyObject
*gdbpy_doc_cst
;
61 /* Architecture and language to be used in callbacks from
62 the Python interpreter. */
63 struct gdbarch
*python_gdbarch
;
64 const struct language_defn
*python_language
;
66 /* Restore global language and architecture and Python GIL state
67 when leaving the Python interpreter. */
71 PyGILState_STATE state
;
72 struct gdbarch
*gdbarch
;
73 const struct language_defn
*language
;
77 restore_python_env (void *p
)
79 struct python_env
*env
= (struct python_env
*)p
;
80 PyGILState_Release (env
->state
);
81 python_gdbarch
= env
->gdbarch
;
82 python_language
= env
->language
;
86 /* Called before entering the Python interpreter to install the
87 current language and architecture to be used for Python values. */
90 ensure_python_env (struct gdbarch
*gdbarch
,
91 const struct language_defn
*language
)
93 struct python_env
*env
= xmalloc (sizeof *env
);
95 env
->state
= PyGILState_Ensure ();
96 env
->gdbarch
= python_gdbarch
;
97 env
->language
= python_language
;
99 python_gdbarch
= gdbarch
;
100 python_language
= language
;
102 return make_cleanup (restore_python_env
, env
);
106 /* Given a command_line, return a command string suitable for passing
107 to Python. Lines in the string are separated by newlines. The
108 return value is allocated using xmalloc and the caller is
109 responsible for freeing it. */
112 compute_python_string (struct command_line
*l
)
114 struct command_line
*iter
;
119 for (iter
= l
; iter
; iter
= iter
->next
)
120 size
+= strlen (iter
->line
) + 1;
122 script
= xmalloc (size
+ 1);
124 for (iter
= l
; iter
; iter
= iter
->next
)
126 int len
= strlen (iter
->line
);
127 strcpy (&script
[here
], iter
->line
);
129 script
[here
++] = '\n';
135 /* Take a command line structure representing a 'python' command, and
136 evaluate its body using the Python interpreter. */
139 eval_python_from_control_command (struct command_line
*cmd
)
143 struct cleanup
*cleanup
;
145 if (cmd
->body_count
!= 1)
146 error (_("Invalid \"python\" block structure."));
148 cleanup
= ensure_python_env (get_current_arch (), current_language
);
150 script
= compute_python_string (cmd
->body_list
[0]);
151 ret
= PyRun_SimpleString (script
);
155 gdbpy_print_stack ();
156 error (_("Error while executing Python code."));
159 do_cleanups (cleanup
);
162 /* Implementation of the gdb "python" command. */
165 python_command (char *arg
, int from_tty
)
167 struct cleanup
*cleanup
;
168 cleanup
= ensure_python_env (get_current_arch (), current_language
);
170 while (arg
&& *arg
&& isspace (*arg
))
174 if (PyRun_SimpleString (arg
))
176 gdbpy_print_stack ();
177 error (_("Error while executing Python code."));
182 struct command_line
*l
= get_command_line (python_control
, "");
183 make_cleanup_free_command_lines (&l
);
184 execute_control_command_untraced (l
);
187 do_cleanups (cleanup
);
192 /* Transform a gdb parameters's value into a Python value. May return
193 NULL (and set a Python exception) on error. Helper function for
196 gdbpy_parameter_value (enum var_types type
, void *var
)
201 case var_string_noescape
:
202 case var_optional_filename
:
206 char *str
= * (char **) var
;
209 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
220 case var_auto_boolean
:
222 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
223 if (ab
== AUTO_BOOLEAN_TRUE
)
225 else if (ab
== AUTO_BOOLEAN_FALSE
)
232 if ((* (int *) var
) == INT_MAX
)
236 return PyLong_FromLong (* (int *) var
);
240 unsigned int val
= * (unsigned int *) var
;
243 return PyLong_FromUnsignedLong (val
);
247 return PyErr_Format (PyExc_RuntimeError
,
248 _("Programmer error: unhandled type."));
251 /* A Python function which returns a gdb parameter's value as a Python
255 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
257 struct cmd_list_element
*alias
, *prefix
, *cmd
;
260 volatile struct gdb_exception except
;
262 if (! PyArg_ParseTuple (args
, "s", &arg
))
265 newarg
= concat ("show ", arg
, (char *) NULL
);
267 TRY_CATCH (except
, RETURN_MASK_ALL
)
269 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
272 GDB_PY_HANDLE_EXCEPTION (except
);
274 return PyErr_Format (PyExc_RuntimeError
,
275 _("Could not find parameter `%s'."), arg
);
278 return PyErr_Format (PyExc_RuntimeError
,
279 _("`%s' is not a parameter."), arg
);
280 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
283 /* Wrapper for target_charset. */
286 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
288 const char *cset
= target_charset (python_gdbarch
);
289 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
292 /* Wrapper for target_wide_charset. */
295 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
297 const char *cset
= target_wide_charset (python_gdbarch
);
298 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
301 /* A Python function which evaluates a string using the gdb CLI. */
304 execute_gdb_command (PyObject
*self
, PyObject
*args
)
307 PyObject
*from_tty_obj
= NULL
;
310 volatile struct gdb_exception except
;
312 if (! PyArg_ParseTuple (args
, "s|O!", &arg
, &PyBool_Type
, &from_tty_obj
))
318 cmp
= PyObject_IsTrue (from_tty_obj
);
324 TRY_CATCH (except
, RETURN_MASK_ALL
)
326 /* Copy the argument text in case the command modifies it. */
327 char *copy
= xstrdup (arg
);
328 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
329 execute_command (copy
, from_tty
);
330 do_cleanups (cleanup
);
332 GDB_PY_HANDLE_EXCEPTION (except
);
334 /* Do any commands attached to breakpoint we stopped at. */
335 bpstat_do_actions ();
340 /* Parse a string and evaluate it as an expression. */
342 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
345 struct value
*result
= NULL
;
346 volatile struct gdb_exception except
;
348 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
351 TRY_CATCH (except
, RETURN_MASK_ALL
)
353 result
= parse_and_eval (expr_str
);
355 GDB_PY_HANDLE_EXCEPTION (except
);
357 return value_to_value_object (result
);
360 /* Read a file as Python code. STREAM is the input file; FILE is the
362 STREAM is not closed, that is the caller's responsibility. */
365 source_python_script (FILE *stream
, const char *file
)
367 struct cleanup
*cleanup
;
369 cleanup
= ensure_python_env (get_current_arch (), current_language
);
371 PyRun_SimpleFile (stream
, file
);
373 do_cleanups (cleanup
);
380 /* A python function to write a single string using gdb's filtered
383 gdbpy_write (PyObject
*self
, PyObject
*args
)
386 if (! PyArg_ParseTuple (args
, "s", &arg
))
388 printf_filtered ("%s", arg
);
392 /* A python function to flush gdb's filtered output stream. */
394 gdbpy_flush (PyObject
*self
, PyObject
*args
)
396 gdb_flush (gdb_stdout
);
400 /* Print a python exception trace, or print nothing and clear the
401 python exception, depending on gdbpy_should_print_stack. Only call
402 this if a python exception is set. */
404 gdbpy_print_stack (void)
406 if (gdbpy_should_print_stack
)
414 /* Return the current Progspace.
415 There always is one. */
418 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
422 result
= pspace_to_pspace_object (current_program_space
);
428 /* Return a sequence holding all the Progspaces. */
431 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
433 struct program_space
*ps
;
436 list
= PyList_New (0);
442 PyObject
*item
= pspace_to_pspace_object (ps
);
443 if (!item
|| PyList_Append (list
, item
) == -1)
455 /* The "current" objfile. This is set when gdb detects that a new
456 objfile has been loaded. It is only set for the duration of a call to
457 source_python_script_for_objfile; it is NULL at other times. */
458 static struct objfile
*gdbpy_current_objfile
;
460 /* Set the current objfile to OBJFILE and then read STREAM,FILE as
464 source_python_script_for_objfile (struct objfile
*objfile
,
465 FILE *stream
, const char *file
)
467 struct cleanup
*cleanups
;
469 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
470 gdbpy_current_objfile
= objfile
;
472 /* We don't want to throw an exception here -- but the user
473 would like to know that something went wrong. */
474 if (PyRun_SimpleFile (stream
, file
))
475 gdbpy_print_stack ();
477 do_cleanups (cleanups
);
478 gdbpy_current_objfile
= NULL
;
481 /* Return the current Objfile, or None if there isn't one. */
484 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
488 if (! gdbpy_current_objfile
)
491 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
497 /* Return a sequence holding all the Objfiles. */
500 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
502 struct objfile
*objf
;
505 list
= PyList_New (0);
511 PyObject
*item
= objfile_to_objfile_object (objf
);
512 if (!item
|| PyList_Append (list
, item
) == -1)
522 #else /* HAVE_PYTHON */
524 /* Dummy implementation of the gdb "python" command. */
527 python_command (char *arg
, int from_tty
)
529 while (arg
&& *arg
&& isspace (*arg
))
532 error (_("Python scripting is not supported in this copy of GDB."));
535 struct command_line
*l
= get_command_line (python_control
, "");
536 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
537 execute_control_command_untraced (l
);
538 do_cleanups (cleanups
);
543 eval_python_from_control_command (struct command_line
*cmd
)
545 error (_("Python scripting is not supported in this copy of GDB."));
549 source_python_script (FILE *stream
, const char *file
)
551 throw_error (UNSUPPORTED_ERROR
,
552 _("Python scripting is not supported in this copy of GDB."));
555 #endif /* HAVE_PYTHON */
559 /* Lists for 'maint set python' commands. */
561 struct cmd_list_element
*set_python_list
;
562 struct cmd_list_element
*show_python_list
;
564 /* Function for use by 'maint set python' prefix command. */
567 set_python (char *args
, int from_tty
)
569 help_list (set_python_list
, "maintenance set python ", -1, gdb_stdout
);
572 /* Function for use by 'maint show python' prefix command. */
575 show_python (char *args
, int from_tty
)
577 cmd_show_list (show_python_list
, from_tty
, "");
580 /* Initialize the Python code. */
582 /* Provide a prototype to silence -Wmissing-prototypes. */
583 extern initialize_file_ftype _initialize_python
;
586 _initialize_python (void)
588 add_com ("python", class_obscure
, python_command
,
591 Evaluate a Python command.\n\
593 The command can be given as an argument, for instance:\n\
597 If no argument is given, the following lines are read and used\n\
598 as the Python commands. Type a line containing \"end\" to indicate\n\
599 the end of the command.")
600 #else /* HAVE_PYTHON */
602 Evaluate a Python command.\n\
604 Python scripting is not supported in this copy of GDB.\n\
605 This command is only a placeholder.")
606 #endif /* HAVE_PYTHON */
609 add_prefix_cmd ("python", no_class
, show_python
,
610 _("Prefix command for python maintenance settings."),
611 &show_python_list
, "maintenance show python ", 0,
612 &maintenance_show_cmdlist
);
613 add_prefix_cmd ("python", no_class
, set_python
,
614 _("Prefix command for python maintenance settings."),
615 &set_python_list
, "maintenance set python ", 0,
616 &maintenance_set_cmdlist
);
618 add_setshow_boolean_cmd ("print-stack", class_maintenance
,
619 &gdbpy_should_print_stack
, _("\
620 Enable or disable printing of Python stack dump on error."), _("\
621 Show whether Python stack will be printed on error."), _("\
622 Enables or disables printing of Python stack traces."),
629 PyEval_InitThreads ();
631 gdb_module
= Py_InitModule ("gdb", GdbMethods
);
633 /* The casts to (char*) are for python 2.4. */
634 PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
);
635 PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", (char*) host_name
);
636 PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG", (char*) target_name
);
638 gdbpy_initialize_auto_load ();
639 gdbpy_initialize_values ();
640 gdbpy_initialize_frames ();
641 gdbpy_initialize_commands ();
642 gdbpy_initialize_symbols ();
643 gdbpy_initialize_symtabs ();
644 gdbpy_initialize_blocks ();
645 gdbpy_initialize_functions ();
646 gdbpy_initialize_parameters ();
647 gdbpy_initialize_types ();
648 gdbpy_initialize_pspace ();
649 gdbpy_initialize_objfile ();
650 gdbpy_initialize_breakpoints ();
651 gdbpy_initialize_lazy_string ();
653 PyRun_SimpleString ("import gdb");
654 PyRun_SimpleString ("gdb.pretty_printers = []");
656 gdbpy_to_string_cst
= PyString_FromString ("to_string");
657 gdbpy_children_cst
= PyString_FromString ("children");
658 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
659 gdbpy_doc_cst
= PyString_FromString ("__doc__");
661 /* Create a couple objects which are used for Python's stdout and
663 PyRun_SimpleString ("\
665 class GdbOutputFile:\n\
673 def write(self, s):\n\
676 def writelines(self, iterable):\n\
677 for line in iterable:\n\
683 sys.stderr = GdbOutputFile()\n\
684 sys.stdout = GdbOutputFile()\n\
687 /* Release the GIL while gdb runs. */
688 PyThreadState_Swap (NULL
);
689 PyEval_ReleaseLock ();
691 #endif /* HAVE_PYTHON */
698 static PyMethodDef GdbMethods
[] =
700 { "history", gdbpy_history
, METH_VARARGS
,
701 "Get a value from history" },
702 { "execute", execute_gdb_command
, METH_VARARGS
,
703 "Execute a gdb command" },
704 { "parameter", gdbpy_parameter
, METH_VARARGS
,
705 "Return a gdb parameter's value" },
707 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
708 "Return a tuple of all breakpoint objects" },
710 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
711 "Find the default visualizer for a Value." },
713 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
714 "Return the current Progspace." },
715 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
716 "Return a sequence of all progspaces." },
718 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
719 "Return the current Objfile being loaded, or None." },
720 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
721 "Return a sequence of all loaded objfiles." },
723 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
724 "selected_frame () -> gdb.Frame.\n\
725 Return the selected frame object." },
726 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
727 "stop_reason_string (Integer) -> String.\n\
728 Return a string explaining unwind stop reason." },
730 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
731 METH_VARARGS
| METH_KEYWORDS
,
732 "lookup_type (name [, block]) -> type\n\
733 Return a Type corresponding to the given name." },
734 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
735 METH_VARARGS
| METH_KEYWORDS
,
736 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
737 Return a tuple with the symbol corresponding to the given name (or None) and\n\
738 a boolean indicating if name is a field of the current implied argument\n\
739 `this' (when the current language is object-oriented)." },
740 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
741 "Return the block containing the given pc value, or None." },
742 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
743 "parse_and_eval (String) -> Value.\n\
744 Parse String as an expression, evaluate it, and return the result as a Value."
747 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
748 "target_charset () -> string.\n\
749 Return the name of the current target charset." },
750 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
751 "target_wide_charset () -> string.\n\
752 Return the name of the current target wide charset." },
754 { "write", gdbpy_write
, METH_VARARGS
,
755 "Write a string using gdb's filtered stream." },
756 { "flush", gdbpy_flush
, METH_NOARGS
,
757 "Flush gdb's filtered stdout stream." },
759 {NULL
, NULL
, 0, NULL
}
762 #endif /* HAVE_PYTHON */