1 /* General python/gdb code
3 Copyright (C) 2008-2020 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 "event-loop.h"
31 #include "readline/tilde.h"
33 #include "extension-priv.h"
34 #include "cli/cli-utils.h"
37 #include "run-on-main-thread.h"
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";
44 /* "set python print-stack" choices. */
45 static const char *const python_excp_enums
[] =
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
57 static const char *gdbpy_should_print_stack
= python_excp_message
;
60 /* Forward decls, these are defined later. */
61 extern const struct extension_language_script_ops python_extension_script_ops
;
62 extern const struct extension_language_ops python_extension_ops
;
65 /* The main struct describing GDB's interface to the Python
66 extension language. */
67 const struct extension_language_defn extension_language_python
=
79 &python_extension_script_ops
,
89 #include "cli/cli-decode.h"
92 #include "python-internal.h"
95 #include "gdbsupport/version.h"
97 #include "gdbthread.h"
99 #include "event-top.h"
100 #include "py-event.h"
102 /* True if Python has been successfully initialized, false
105 int gdb_python_initialized
;
107 extern PyMethodDef python_GdbMethods
[];
110 extern struct PyModuleDef python_GdbModuleDef
;
113 PyObject
*gdb_module
;
114 PyObject
*gdb_python_module
;
116 /* Some string constants we may wish to use. */
117 PyObject
*gdbpy_to_string_cst
;
118 PyObject
*gdbpy_children_cst
;
119 PyObject
*gdbpy_display_hint_cst
;
120 PyObject
*gdbpy_doc_cst
;
121 PyObject
*gdbpy_enabled_cst
;
122 PyObject
*gdbpy_value_cst
;
124 /* The GdbError exception. */
125 PyObject
*gdbpy_gdberror_exc
;
127 /* The `gdb.error' base class. */
128 PyObject
*gdbpy_gdb_error
;
130 /* The `gdb.MemoryError' exception. */
131 PyObject
*gdbpy_gdb_memory_error
;
133 static script_sourcer_func gdbpy_source_script
;
134 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
135 static objfile_script_executor_func gdbpy_execute_objfile_script
;
136 static void gdbpy_finish_initialization
137 (const struct extension_language_defn
*);
138 static int gdbpy_initialized (const struct extension_language_defn
*);
139 static void gdbpy_eval_from_control_command
140 (const struct extension_language_defn
*, struct command_line
*cmd
);
141 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
142 struct ext_lang_type_printers
*);
143 static enum ext_lang_rc gdbpy_apply_type_printers
144 (const struct extension_language_defn
*,
145 const struct ext_lang_type_printers
*, struct type
*, char **);
146 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
147 struct ext_lang_type_printers
*);
148 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
149 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
150 static enum ext_lang_rc gdbpy_before_prompt_hook
151 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
152 static gdb::optional
<std::string
> gdbpy_colorize
153 (const std::string
&filename
, const std::string
&contents
);
155 /* The interface between gdb proper and loading of python scripts. */
157 const struct extension_language_script_ops python_extension_script_ops
=
160 gdbpy_source_objfile_script
,
161 gdbpy_execute_objfile_script
,
162 gdbpy_auto_load_enabled
165 /* The interface between gdb proper and python extensions. */
167 const struct extension_language_ops python_extension_ops
=
169 gdbpy_finish_initialization
,
172 gdbpy_eval_from_control_command
,
174 gdbpy_start_type_printers
,
175 gdbpy_apply_type_printers
,
176 gdbpy_free_type_printers
,
178 gdbpy_apply_val_pretty_printer
,
180 gdbpy_apply_frame_filter
,
182 gdbpy_preserve_values
,
184 gdbpy_breakpoint_has_cond
,
185 gdbpy_breakpoint_cond_says_stop
,
188 gdbpy_check_quit_flag
,
190 gdbpy_before_prompt_hook
,
192 gdbpy_get_matching_xmethod_workers
,
197 /* Architecture and language to be used in callbacks from
198 the Python interpreter. */
199 struct gdbarch
*python_gdbarch
;
200 const struct language_defn
*python_language
;
202 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
203 const struct language_defn
*language
)
204 : m_gdbarch (python_gdbarch
),
205 m_language (python_language
)
207 /* We should not ever enter Python unless initialized. */
208 if (!gdb_python_initialized
)
209 error (_("Python not initialized"));
211 m_previous_active
= set_active_ext_lang (&extension_language_python
);
213 m_state
= PyGILState_Ensure ();
215 python_gdbarch
= gdbarch
;
216 python_language
= language
;
218 /* Save it and ensure ! PyErr_Occurred () afterwards. */
222 gdbpy_enter::~gdbpy_enter ()
224 /* Leftover Python error is forbidden by Python Exception Handling. */
225 if (PyErr_Occurred ())
227 /* This order is similar to the one calling error afterwards. */
228 gdbpy_print_stack ();
229 warning (_("internal error: Unhandled Python exception"));
234 python_gdbarch
= m_gdbarch
;
235 python_language
= m_language
;
237 restore_active_ext_lang (m_previous_active
);
238 PyGILState_Release (m_state
);
241 /* Set the quit flag. */
244 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
246 PyErr_SetInterrupt ();
249 /* Return true if the quit flag has been set, false otherwise. */
252 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
254 return PyOS_InterruptOccurred ();
257 /* Evaluate a Python command like PyRun_SimpleString, but uses
258 Py_single_input which prints the result of expressions, and does
259 not automatically print the stack on errors. */
262 eval_python_command (const char *command
)
266 m
= PyImport_AddModule ("__main__");
270 d
= PyModule_GetDict (m
);
273 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
285 /* Implementation of the gdb "python-interactive" command. */
288 python_interactive_command (const char *arg
, int from_tty
)
290 struct ui
*ui
= current_ui
;
293 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
295 arg
= skip_spaces (arg
);
297 gdbpy_enter
enter_py (get_current_arch (), current_language
);
301 std::string script
= std::string (arg
) + "\n";
302 err
= eval_python_command (script
.c_str ());
306 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
312 gdbpy_print_stack ();
313 error (_("Error while executing Python code."));
317 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
320 On Windows hosts few users would build Python themselves (this is no
321 trivial task on this platform), and thus use binaries built by
322 someone else instead. There may happen situation where the Python
323 library and GDB are using two different versions of the C runtime
324 library. Python, being built with VC, would use one version of the
325 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
326 A FILE * from one runtime does not necessarily operate correctly in
329 To work around this potential issue, we run code in Python to load
333 python_run_simple_file (FILE *file
, const char *filename
)
337 PyRun_SimpleFile (file
, filename
);
341 /* Because we have a string for a filename, and are using Python to
342 open the file, we need to expand any tilde in the path first. */
343 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
345 if (gdb_python_module
== nullptr
346 || ! PyObject_HasAttrString (gdb_python_module
, "_execute_file"))
347 error (_("Installation error: gdb._execute_file function is missing"));
349 gdbpy_ref
<> return_value
350 (PyObject_CallMethod (gdb_python_module
, "_execute_file", "s",
352 if (return_value
== nullptr)
354 /* Use PyErr_PrintEx instead of gdbpy_print_stack to better match the
355 behavior of the non-Windows codepath. */
362 /* Given a command_line, return a command string suitable for passing
363 to Python. Lines in the string are separated by newlines. */
366 compute_python_string (struct command_line
*l
)
368 struct command_line
*iter
;
371 for (iter
= l
; iter
; iter
= iter
->next
)
373 script
+= iter
->line
;
379 /* Take a command line structure representing a 'python' command, and
380 evaluate its body using the Python interpreter. */
383 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
384 struct command_line
*cmd
)
388 if (cmd
->body_list_1
!= nullptr)
389 error (_("Invalid \"python\" block structure."));
391 gdbpy_enter
enter_py (get_current_arch (), current_language
);
393 std::string script
= compute_python_string (cmd
->body_list_0
.get ());
394 ret
= PyRun_SimpleString (script
.c_str ());
396 error (_("Error while executing Python code."));
399 /* Implementation of the gdb "python" command. */
402 python_command (const char *arg
, int from_tty
)
404 gdbpy_enter
enter_py (get_current_arch (), current_language
);
406 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
408 arg
= skip_spaces (arg
);
411 if (PyRun_SimpleString (arg
))
412 error (_("Error while executing Python code."));
416 counted_command_line l
= get_command_line (python_control
, "");
418 execute_control_command_untraced (l
.get ());
424 /* Transform a gdb parameters's value into a Python value. May return
425 NULL (and set a Python exception) on error. Helper function for
428 gdbpy_parameter_value (enum var_types type
, void *var
)
433 case var_string_noescape
:
434 case var_optional_filename
:
438 const char *str
= *(char **) var
;
442 return host_string_to_python_string (str
).release ();
453 case var_auto_boolean
:
455 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
457 if (ab
== AUTO_BOOLEAN_TRUE
)
459 else if (ab
== AUTO_BOOLEAN_FALSE
)
466 if ((* (int *) var
) == INT_MAX
)
470 case var_zuinteger_unlimited
:
471 return PyLong_FromLong (* (int *) var
);
475 unsigned int val
= * (unsigned int *) var
;
479 return PyLong_FromUnsignedLong (val
);
484 unsigned int val
= * (unsigned int *) var
;
485 return PyLong_FromUnsignedLong (val
);
489 return PyErr_Format (PyExc_RuntimeError
,
490 _("Programmer error: unhandled type."));
493 /* A Python function which returns a gdb parameter's value as a Python
497 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
499 struct cmd_list_element
*alias
, *prefix
, *cmd
;
503 if (! PyArg_ParseTuple (args
, "s", &arg
))
506 std::string newarg
= std::string ("show ") + arg
;
510 found
= lookup_cmd_composition (newarg
.c_str (), &alias
, &prefix
, &cmd
);
512 catch (const gdb_exception
&ex
)
514 GDB_PY_HANDLE_EXCEPTION (ex
);
518 return PyErr_Format (PyExc_RuntimeError
,
519 _("Could not find parameter `%s'."), arg
);
522 return PyErr_Format (PyExc_RuntimeError
,
523 _("`%s' is not a parameter."), arg
);
524 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
527 /* Wrapper for target_charset. */
530 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
532 const char *cset
= target_charset (python_gdbarch
);
534 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
537 /* Wrapper for target_wide_charset. */
540 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
542 const char *cset
= target_wide_charset (python_gdbarch
);
544 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
547 /* A Python function which evaluates a string using the gdb CLI. */
550 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
553 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
554 int from_tty
, to_string
;
555 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
557 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
558 &PyBool_Type
, &from_tty_obj
,
559 &PyBool_Type
, &to_string_obj
))
565 int cmp
= PyObject_IsTrue (from_tty_obj
);
574 int cmp
= PyObject_IsTrue (to_string_obj
);
580 std::string to_string_res
;
582 scoped_restore preventer
= prevent_dont_repeat ();
586 gdbpy_allow_threads allow_threads
;
588 struct interp
*interp
;
590 std::string arg_copy
= arg
;
592 char *save_ptr
= nullptr;
596 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
602 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
605 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
608 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
610 /* Use the console interpreter uiout to have the same print format
611 for console or MI. */
612 interp
= interp_lookup (current_ui
, "console");
613 current_uiout
= interp
->interp_ui_out ();
616 to_string_res
= execute_control_commands_to_string (lines
.get (),
619 execute_control_commands (lines
.get (), from_tty
);
622 /* Do any commands attached to breakpoint we stopped at. */
623 bpstat_do_actions ();
625 catch (const gdb_exception
&except
)
627 /* If an exception occurred then we won't hit normal_stop (), or have
628 an exception reach the top level of the event loop, which are the
629 two usual places in which stdin would be re-enabled. So, before we
630 convert the exception and continue back in Python, we should
631 re-enable stdin here. */
632 async_enable_stdin ();
633 GDB_PY_HANDLE_EXCEPTION (except
);
637 return PyString_FromString (to_string_res
.c_str ());
641 /* Implementation of Python rbreak command. Take a REGEX and
642 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
643 Python list that contains newly set breakpoints that match that
644 criteria. REGEX refers to a GDB format standard regex pattern of
645 symbols names to search; MINSYMS is an optional boolean (default
646 False) that indicates if the function should search GDB's minimal
647 symbols; THROTTLE is an optional integer (default unlimited) that
648 indicates the maximum amount of breakpoints allowable before the
649 function exits (note, if the throttle bound is passed, no
650 breakpoints will be set and a runtime error returned); SYMTABS is
651 an optional Python iterable that contains a set of gdb.Symtabs to
652 constrain the search within. */
655 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
658 std::vector
<symbol_search
> symbols
;
659 unsigned long count
= 0;
660 PyObject
*symtab_list
= NULL
;
661 PyObject
*minsyms_p_obj
= NULL
;
663 unsigned int throttle
= 0;
664 static const char *keywords
[] = {"regex","minsyms", "throttle",
667 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
668 ®ex
, &PyBool_Type
,
669 &minsyms_p_obj
, &throttle
,
673 /* Parse minsyms keyword. */
674 if (minsyms_p_obj
!= NULL
)
676 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
682 global_symbol_searcher
spec (FUNCTIONS_DOMAIN
, regex
);
684 for (const char *elem
: spec
.filenames
)
685 xfree ((void *) elem
);
688 /* The "symtabs" keyword is any Python iterable object that returns
689 a gdb.Symtab on each iteration. If specified, iterate through
690 the provided gdb.Symtabs and extract their full path. As
691 python_string_to_target_string returns a
692 gdb::unique_xmalloc_ptr<char> and a vector containing these types
693 cannot be coerced to a const char **p[] via the vector.data call,
694 release the value from the unique_xmalloc_ptr and place it in a
695 simple type symtab_list_type (which holds the vector and a
696 destructor that frees the contents of the allocated strings. */
697 if (symtab_list
!= NULL
)
699 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
706 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
710 if (PyErr_Occurred ())
715 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
718 if (obj_name
== NULL
)
721 /* Is the object file still valid? */
722 if (obj_name
== Py_None
)
725 gdb::unique_xmalloc_ptr
<char> filename
=
726 python_string_to_target_string (obj_name
.get ());
728 if (filename
== NULL
)
731 /* Make sure there is a definite place to store the value of
732 filename before it is released. */
733 spec
.filenames
.push_back (nullptr);
734 spec
.filenames
.back () = filename
.release ();
738 /* The search spec. */
739 symbols
= spec
.search ();
741 /* Count the number of symbols (both symbols and optionally minimal
742 symbols) so we can correctly check the throttle limit. */
743 for (const symbol_search
&p
: symbols
)
745 /* Minimal symbols included? */
748 if (p
.msymbol
.minsym
!= NULL
)
752 if (p
.symbol
!= NULL
)
756 /* Check throttle bounds and exit if in excess. */
757 if (throttle
!= 0 && count
> throttle
)
759 PyErr_SetString (PyExc_RuntimeError
,
760 _("Number of breakpoints exceeds throttled maximum."));
764 gdbpy_ref
<> return_list (PyList_New (0));
766 if (return_list
== NULL
)
769 /* Construct full path names for symbols and call the Python
770 breakpoint constructor on the resulting names. Be tolerant of
771 individual breakpoint failures. */
772 for (const symbol_search
&p
: symbols
)
774 std::string symbol_name
;
776 /* Skipping minimal symbols? */
778 if (p
.msymbol
.minsym
!= NULL
)
781 if (p
.msymbol
.minsym
== NULL
)
783 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
784 const char *fullname
= symtab_to_fullname (symtab
);
786 symbol_name
= fullname
;
788 symbol_name
+= p
.symbol
->linkage_name ();
791 symbol_name
= p
.msymbol
.minsym
->linkage_name ();
793 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
794 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
795 &breakpoint_object_type
,
798 /* Tolerate individual breakpoint failures. */
800 gdbpy_print_stack ();
803 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
807 return return_list
.release ();
810 /* A Python function which is a wrapper for decode_line_1. */
813 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
815 const char *arg
= NULL
;
817 gdbpy_ref
<> unparsed
;
818 event_location_up location
;
820 if (! PyArg_ParseTuple (args
, "|s", &arg
))
823 /* Treat a string consisting of just whitespace the same as
827 arg
= skip_spaces (arg
);
833 location
= string_to_event_location_basic (&arg
, python_language
,
834 symbol_name_match_type::WILD
);
836 std::vector
<symtab_and_line
> decoded_sals
;
837 symtab_and_line def_sal
;
838 gdb::array_view
<symtab_and_line
> sals
;
841 if (location
!= NULL
)
843 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
848 set_default_source_symtab_and_line ();
849 def_sal
= get_current_source_symtab_and_line ();
853 catch (const gdb_exception
&ex
)
855 /* We know this will always throw. */
856 gdbpy_convert_exception (ex
);
862 result
.reset (PyTuple_New (sals
.size ()));
865 for (size_t i
= 0; i
< sals
.size (); ++i
)
867 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
871 PyTuple_SetItem (result
.get (), i
, obj
);
875 result
= gdbpy_ref
<>::new_reference (Py_None
);
877 gdbpy_ref
<> return_result (PyTuple_New (2));
878 if (return_result
== NULL
)
881 if (arg
!= NULL
&& strlen (arg
) > 0)
883 unparsed
.reset (PyString_FromString (arg
));
884 if (unparsed
== NULL
)
888 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
890 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
891 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
893 return return_result
.release ();
896 /* Parse a string and evaluate it as an expression. */
898 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
900 const char *expr_str
;
901 struct value
*result
= NULL
;
903 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
908 gdbpy_allow_threads allow_threads
;
909 result
= parse_and_eval (expr_str
);
911 catch (const gdb_exception
&except
)
913 GDB_PY_HANDLE_EXCEPTION (except
);
916 return value_to_value_object (result
);
919 /* Implementation of gdb.invalidate_cached_frames. */
922 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
924 reinit_frame_cache ();
928 /* Read a file as Python code.
929 This is the extension_language_script_ops.script_sourcer "method".
930 FILE is the file to load. FILENAME is name of the file FILE.
931 This does not throw any errors. If an exception occurs python will print
932 the traceback and clear the error indicator. */
935 gdbpy_source_script (const struct extension_language_defn
*extlang
,
936 FILE *file
, const char *filename
)
938 gdbpy_enter
enter_py (get_current_arch (), current_language
);
939 python_run_simple_file (file
, filename
);
944 /* Posting and handling events. */
946 /* A helper class to save and restore the GIL, but without touching
947 the other globals that are handled by gdbpy_enter. */
954 : m_state (PyGILState_Ensure ())
960 PyGILState_Release (m_state
);
963 DISABLE_COPY_AND_ASSIGN (gdbpy_gil
);
967 PyGILState_STATE m_state
;
970 /* A single event. */
973 gdbpy_event (gdbpy_ref
<> &&func
)
974 : m_func (func
.release ())
978 gdbpy_event (gdbpy_event
&&other
)
979 : m_func (other
.m_func
)
981 other
.m_func
= nullptr;
984 gdbpy_event (const gdbpy_event
&other
)
985 : m_func (other
.m_func
)
997 gdbpy_event
&operator= (const gdbpy_event
&other
) = delete;
1001 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1003 gdbpy_ref
<> call_result (PyObject_CallObject (m_func
, NULL
));
1004 if (call_result
== NULL
)
1005 gdbpy_print_stack ();
1010 /* The Python event. This is just a callable object. Note that
1011 this is not a gdbpy_ref<>, because we have to take particular
1012 care to only destroy the reference when holding the GIL. */
1016 /* Submit an event to the gdb thread. */
1018 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1022 if (!PyArg_ParseTuple (args
, "O", &func
))
1025 if (!PyCallable_Check (func
))
1027 PyErr_SetString (PyExc_RuntimeError
,
1028 _("Posted event is not callable"));
1032 gdbpy_ref
<> func_ref
= gdbpy_ref
<>::new_reference (func
);
1033 gdbpy_event
event (std::move (func_ref
));
1034 run_on_main_thread (event
);
1041 /* This is the extension_language_ops.before_prompt "method". */
1043 static enum ext_lang_rc
1044 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1045 const char *current_gdb_prompt
)
1047 if (!gdb_python_initialized
)
1048 return EXT_LANG_RC_NOP
;
1050 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1052 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1053 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1054 return EXT_LANG_RC_ERROR
;
1056 if (gdb_python_module
1057 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1059 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1063 gdbpy_print_stack ();
1064 return EXT_LANG_RC_ERROR
;
1067 if (PyCallable_Check (hook
.get ()))
1069 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1070 if (current_prompt
== NULL
)
1072 gdbpy_print_stack ();
1073 return EXT_LANG_RC_ERROR
;
1077 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1081 gdbpy_print_stack ();
1082 return EXT_LANG_RC_ERROR
;
1085 /* Return type should be None, or a String. If it is None,
1086 fall through, we will not set a prompt. If it is a
1087 string, set PROMPT. Anything else, set an exception. */
1088 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1090 PyErr_Format (PyExc_RuntimeError
,
1091 _("Return from prompt_hook must " \
1092 "be either a Python string, or None"));
1093 gdbpy_print_stack ();
1094 return EXT_LANG_RC_ERROR
;
1097 if (result
!= Py_None
)
1099 gdb::unique_xmalloc_ptr
<char>
1100 prompt (python_string_to_host_string (result
.get ()));
1104 gdbpy_print_stack ();
1105 return EXT_LANG_RC_ERROR
;
1108 set_prompt (prompt
.get ());
1109 return EXT_LANG_RC_OK
;
1114 return EXT_LANG_RC_NOP
;
1117 /* This is the extension_language_ops.colorize "method". */
1119 static gdb::optional
<std::string
>
1120 gdbpy_colorize (const std::string
&filename
, const std::string
&contents
)
1122 if (!gdb_python_initialized
)
1125 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1127 if (gdb_python_module
== nullptr
1128 || !PyObject_HasAttrString (gdb_python_module
, "colorize"))
1131 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
, "colorize"));
1132 if (hook
== nullptr)
1134 gdbpy_print_stack ();
1138 if (!PyCallable_Check (hook
.get ()))
1141 gdbpy_ref
<> fname_arg (PyString_FromString (filename
.c_str ()));
1142 if (fname_arg
== nullptr)
1144 gdbpy_print_stack ();
1147 gdbpy_ref
<> contents_arg (PyString_FromString (contents
.c_str ()));
1148 if (contents_arg
== nullptr)
1150 gdbpy_print_stack ();
1154 gdbpy_ref
<> result (PyObject_CallFunctionObjArgs (hook
.get (),
1156 contents_arg
.get (),
1158 if (result
== nullptr)
1160 gdbpy_print_stack ();
1164 if (!gdbpy_is_string (result
.get ()))
1167 gdbpy_ref
<> unic
= python_string_to_unicode (result
.get ());
1168 if (unic
== nullptr)
1170 gdbpy_print_stack ();
1173 gdbpy_ref
<> host_str (PyUnicode_AsEncodedString (unic
.get (),
1176 if (host_str
== nullptr)
1178 gdbpy_print_stack ();
1182 return std::string (PyBytes_AsString (host_str
.get ()));
1189 /* A python function to write a single string using gdb's filtered
1190 output stream . The optional keyword STREAM can be used to write
1191 to a particular stream. The default stream is to gdb_stdout. */
1194 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1197 static const char *keywords
[] = { "text", "stream", NULL
};
1198 int stream_type
= 0;
1200 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1206 switch (stream_type
)
1210 fprintf_filtered (gdb_stderr
, "%s", arg
);
1215 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1219 fprintf_filtered (gdb_stdout
, "%s", arg
);
1222 catch (const gdb_exception
&except
)
1224 GDB_PY_HANDLE_EXCEPTION (except
);
1230 /* A python function to flush a gdb stream. The optional keyword
1231 STREAM can be used to flush a particular stream. The default stream
1235 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1237 static const char *keywords
[] = { "stream", NULL
};
1238 int stream_type
= 0;
1240 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1244 switch (stream_type
)
1248 gdb_flush (gdb_stderr
);
1253 gdb_flush (gdb_stdlog
);
1257 gdb_flush (gdb_stdout
);
1263 /* Return non-zero if print-stack is not "none". */
1266 gdbpy_print_python_errors_p (void)
1268 return gdbpy_should_print_stack
!= python_excp_none
;
1271 /* Print a python exception trace, print just a message, or print
1272 nothing and clear the python exception, depending on
1273 gdbpy_should_print_stack. Only call this if a python exception is
1276 gdbpy_print_stack (void)
1279 /* Print "none", just clear exception. */
1280 if (gdbpy_should_print_stack
== python_excp_none
)
1284 /* Print "full" message and backtrace. */
1285 else if (gdbpy_should_print_stack
== python_excp_full
)
1288 /* PyErr_Print doesn't necessarily end output with a newline.
1289 This works because Python's stdout/stderr is fed through
1295 catch (const gdb_exception
&except
)
1299 /* Print "message", just error print message. */
1302 gdbpy_err_fetch fetched_error
;
1304 gdb::unique_xmalloc_ptr
<char> msg
= fetched_error
.to_string ();
1305 gdb::unique_xmalloc_ptr
<char> type
;
1306 /* Don't compute TYPE if MSG already indicates that there is an
1309 type
= fetched_error
.type_to_string ();
1313 if (msg
== NULL
|| type
== NULL
)
1315 /* An error occurred computing the string representation of the
1317 fprintf_filtered (gdb_stderr
,
1318 _("Error occurred computing Python error" \
1323 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1324 type
.get (), msg
.get ());
1326 catch (const gdb_exception
&except
)
1332 /* Like gdbpy_print_stack, but if the exception is a
1333 KeyboardException, throw a gdb "quit" instead. */
1336 gdbpy_print_stack_or_quit ()
1338 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1341 throw_quit ("Quit");
1343 gdbpy_print_stack ();
1348 /* Return a sequence holding all the Progspaces. */
1351 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1353 struct program_space
*ps
;
1355 gdbpy_ref
<> list (PyList_New (0));
1361 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1363 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1367 return list
.release ();
1372 /* The "current" objfile. This is set when gdb detects that a new
1373 objfile has been loaded. It is only set for the duration of a call to
1374 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1376 static struct objfile
*gdbpy_current_objfile
;
1378 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1379 as Python code. This does not throw any errors. If an exception
1380 occurs python will print the traceback and clear the error indicator.
1381 This is the extension_language_script_ops.objfile_script_sourcer
1385 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1386 struct objfile
*objfile
, FILE *file
,
1387 const char *filename
)
1389 if (!gdb_python_initialized
)
1392 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1393 gdbpy_current_objfile
= objfile
;
1395 python_run_simple_file (file
, filename
);
1397 gdbpy_current_objfile
= NULL
;
1400 /* Set the current objfile to OBJFILE and then execute SCRIPT
1401 as Python code. This does not throw any errors. If an exception
1402 occurs python will print the traceback and clear the error indicator.
1403 This is the extension_language_script_ops.objfile_script_executor
1407 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1408 struct objfile
*objfile
, const char *name
,
1411 if (!gdb_python_initialized
)
1414 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1415 gdbpy_current_objfile
= objfile
;
1417 PyRun_SimpleString (script
);
1419 gdbpy_current_objfile
= NULL
;
1422 /* Return the current Objfile, or None if there isn't one. */
1425 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1427 if (! gdbpy_current_objfile
)
1430 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1433 /* Compute the list of active python type printers and store them in
1434 EXT_PRINTERS->py_type_printers. The product of this function is used by
1435 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1436 This is the extension_language_ops.start_type_printers "method". */
1439 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1440 struct ext_lang_type_printers
*ext_printers
)
1442 PyObject
*printers_obj
= NULL
;
1444 if (!gdb_python_initialized
)
1447 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1449 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1450 if (type_module
== NULL
)
1452 gdbpy_print_stack ();
1456 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1457 "get_type_recognizers"));
1460 gdbpy_print_stack ();
1464 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1465 if (printers_obj
== NULL
)
1466 gdbpy_print_stack ();
1468 ext_printers
->py_type_printers
= printers_obj
;
1471 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1472 a newly allocated string holding the type's replacement name, and return
1473 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1474 If there's a Python error return EXT_LANG_RC_ERROR.
1475 Otherwise, return EXT_LANG_RC_NOP.
1476 This is the extension_language_ops.apply_type_printers "method". */
1478 static enum ext_lang_rc
1479 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1480 const struct ext_lang_type_printers
*ext_printers
,
1481 struct type
*type
, char **prettied_type
)
1483 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1484 gdb::unique_xmalloc_ptr
<char> result
;
1486 if (printers_obj
== NULL
)
1487 return EXT_LANG_RC_NOP
;
1489 if (!gdb_python_initialized
)
1490 return EXT_LANG_RC_NOP
;
1492 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1494 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1495 if (type_obj
== NULL
)
1497 gdbpy_print_stack ();
1498 return EXT_LANG_RC_ERROR
;
1501 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1502 if (type_module
== NULL
)
1504 gdbpy_print_stack ();
1505 return EXT_LANG_RC_ERROR
;
1508 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1509 "apply_type_recognizers"));
1512 gdbpy_print_stack ();
1513 return EXT_LANG_RC_ERROR
;
1516 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1520 if (result_obj
== NULL
)
1522 gdbpy_print_stack ();
1523 return EXT_LANG_RC_ERROR
;
1526 if (result_obj
== Py_None
)
1527 return EXT_LANG_RC_NOP
;
1529 result
= python_string_to_host_string (result_obj
.get ());
1532 gdbpy_print_stack ();
1533 return EXT_LANG_RC_ERROR
;
1536 *prettied_type
= result
.release ();
1537 return EXT_LANG_RC_OK
;
1540 /* Free the result of start_type_printers.
1541 This is the extension_language_ops.free_type_printers "method". */
1544 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1545 struct ext_lang_type_printers
*ext_printers
)
1547 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1549 if (printers
== NULL
)
1552 if (!gdb_python_initialized
)
1555 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1556 Py_DECREF (printers
);
1559 #else /* HAVE_PYTHON */
1561 /* Dummy implementation of the gdb "python-interactive" and "python"
1565 python_interactive_command (const char *arg
, int from_tty
)
1567 arg
= skip_spaces (arg
);
1569 error (_("Python scripting is not supported in this copy of GDB."));
1572 counted_command_line l
= get_command_line (python_control
, "");
1574 execute_control_command_untraced (l
.get ());
1579 python_command (const char *arg
, int from_tty
)
1581 python_interactive_command (arg
, from_tty
);
1584 #endif /* HAVE_PYTHON */
1588 /* Lists for 'set python' commands. */
1590 static struct cmd_list_element
*user_set_python_list
;
1591 static struct cmd_list_element
*user_show_python_list
;
1593 /* Function for use by 'set python' prefix command. */
1596 user_set_python (const char *args
, int from_tty
)
1598 help_list (user_set_python_list
, "set python ", all_commands
,
1602 /* Function for use by 'show python' prefix command. */
1605 user_show_python (const char *args
, int from_tty
)
1607 cmd_show_list (user_show_python_list
, from_tty
, "");
1610 /* Initialize the Python code. */
1614 /* This is installed as a final cleanup and cleans up the
1615 interpreter. This lets Python's 'atexit' work. */
1618 finalize_python (void *ignore
)
1620 struct active_ext_lang_state
*previous_active
;
1622 /* We don't use ensure_python_env here because if we ever ran the
1623 cleanup, gdb would crash -- because the cleanup calls into the
1624 Python interpreter, which we are about to destroy. It seems
1625 clearer to make the needed calls explicitly here than to create a
1626 cleanup and then mysteriously discard it. */
1628 /* This is only called as a final cleanup so we can assume the active
1629 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1630 previous_active
= set_active_ext_lang (&extension_language_python
);
1632 (void) PyGILState_Ensure ();
1633 python_gdbarch
= target_gdbarch ();
1634 python_language
= current_language
;
1638 restore_active_ext_lang (previous_active
);
1642 /* This is called via the PyImport_AppendInittab mechanism called
1643 during initialization, to make the built-in _gdb module known to
1645 PyMODINIT_FUNC
init__gdb_module (void);
1647 init__gdb_module (void)
1649 return PyModule_Create (&python_GdbModuleDef
);
1654 do_start_initialization ()
1657 size_t progsize
, count
;
1658 /* Python documentation indicates that the memory given
1659 to Py_SetProgramName cannot be freed. However, it seems that
1660 at least Python 3.7.4 Py_SetProgramName takes a copy of the
1661 given program_name. Making progname_copy static and not release
1662 the memory avoids a leak report for Python versions that duplicate
1663 program_name, and respect the requirement of Py_SetProgramName
1664 for Python versions that do not duplicate program_name. */
1665 static wchar_t *progname_copy
;
1668 #ifdef WITH_PYTHON_PATH
1669 /* Work around problem where python gets confused about where it is,
1670 and then can't find its libraries, etc.
1671 NOTE: Python assumes the following layout:
1673 /foo/lib/pythonX.Y/...
1674 This must be done before calling Py_Initialize. */
1675 gdb::unique_xmalloc_ptr
<char> progname
1676 (concat (ldirname (python_libdir
.c_str ()).c_str (), SLASH_STRING
, "bin",
1677 SLASH_STRING
, "python", (char *) NULL
));
1679 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1680 setlocale (LC_ALL
, "");
1681 progsize
= strlen (progname
.get ());
1682 progname_copy
= (wchar_t *) xmalloc ((progsize
+ 1) * sizeof (wchar_t));
1685 fprintf (stderr
, "out of memory\n");
1688 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1689 if (count
== (size_t) -1)
1691 fprintf (stderr
, "Could not convert python path to string\n");
1694 setlocale (LC_ALL
, oldloc
.c_str ());
1696 /* Note that Py_SetProgramName expects the string it is passed to
1697 remain alive for the duration of the program's execution, so
1698 it is not freed after this call. */
1699 Py_SetProgramName (progname_copy
);
1701 /* Define _gdb as a built-in module. */
1702 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1704 Py_SetProgramName (progname
.release ());
1709 PyEval_InitThreads ();
1712 gdb_module
= PyImport_ImportModule ("_gdb");
1714 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1716 if (gdb_module
== NULL
)
1719 if (PyModule_AddStringConstant (gdb_module
, "VERSION", version
) < 0
1720 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", host_name
) < 0
1721 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1725 /* Add stream constants. */
1726 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1727 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1728 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1731 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1732 if (gdbpy_gdb_error
== NULL
1733 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1736 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1737 gdbpy_gdb_error
, NULL
);
1738 if (gdbpy_gdb_memory_error
== NULL
1739 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1740 gdbpy_gdb_memory_error
) < 0)
1743 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1744 if (gdbpy_gdberror_exc
== NULL
1745 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1746 gdbpy_gdberror_exc
) < 0)
1749 gdbpy_initialize_gdb_readline ();
1751 if (gdbpy_initialize_auto_load () < 0
1752 || gdbpy_initialize_values () < 0
1753 || gdbpy_initialize_frames () < 0
1754 || gdbpy_initialize_commands () < 0
1755 || gdbpy_initialize_instruction () < 0
1756 || gdbpy_initialize_record () < 0
1757 || gdbpy_initialize_btrace () < 0
1758 || gdbpy_initialize_symbols () < 0
1759 || gdbpy_initialize_symtabs () < 0
1760 || gdbpy_initialize_blocks () < 0
1761 || gdbpy_initialize_functions () < 0
1762 || gdbpy_initialize_parameters () < 0
1763 || gdbpy_initialize_types () < 0
1764 || gdbpy_initialize_pspace () < 0
1765 || gdbpy_initialize_objfile () < 0
1766 || gdbpy_initialize_breakpoints () < 0
1767 || gdbpy_initialize_finishbreakpoints () < 0
1768 || gdbpy_initialize_lazy_string () < 0
1769 || gdbpy_initialize_linetable () < 0
1770 || gdbpy_initialize_thread () < 0
1771 || gdbpy_initialize_inferior () < 0
1772 || gdbpy_initialize_eventregistry () < 0
1773 || gdbpy_initialize_py_events () < 0
1774 || gdbpy_initialize_event () < 0
1775 || gdbpy_initialize_arch () < 0
1776 || gdbpy_initialize_xmethods () < 0
1777 || gdbpy_initialize_unwind () < 0)
1780 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1781 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1783 #include "py-event-types.def"
1784 #undef GDB_PY_DEFINE_EVENT_TYPE
1786 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1787 if (gdbpy_to_string_cst
== NULL
)
1789 gdbpy_children_cst
= PyString_FromString ("children");
1790 if (gdbpy_children_cst
== NULL
)
1792 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1793 if (gdbpy_display_hint_cst
== NULL
)
1795 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1796 if (gdbpy_doc_cst
== NULL
)
1798 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1799 if (gdbpy_enabled_cst
== NULL
)
1801 gdbpy_value_cst
= PyString_FromString ("value");
1802 if (gdbpy_value_cst
== NULL
)
1805 /* Release the GIL while gdb runs. */
1806 PyThreadState_Swap (NULL
);
1807 PyEval_ReleaseLock ();
1809 make_final_cleanup (finalize_python
, NULL
);
1811 /* Only set this when initialization has succeeded. */
1812 gdb_python_initialized
= 1;
1816 #endif /* HAVE_PYTHON */
1819 cmd_list_element
*python_cmd_element
= nullptr;
1821 void _initialize_python ();
1823 _initialize_python ()
1825 add_com ("python-interactive", class_obscure
,
1826 python_interactive_command
,
1829 Start an interactive Python prompt.\n\
1831 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1834 Alternatively, a single-line Python command can be given as an\n\
1835 argument, and if the command is an expression, the result will be\n\
1836 printed. For example:\n\
1838 (gdb) python-interactive 2 + 3\n\
1840 #else /* HAVE_PYTHON */
1842 Start a Python interactive prompt.\n\
1844 Python scripting is not supported in this copy of GDB.\n\
1845 This command is only a placeholder.")
1846 #endif /* HAVE_PYTHON */
1848 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1850 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1853 Evaluate a Python command.\n\
1855 The command can be given as an argument, for instance:\n\
1857 python print (23)\n\
1859 If no argument is given, the following lines are read and used\n\
1860 as the Python commands. Type a line containing \"end\" to indicate\n\
1861 the end of the command.")
1862 #else /* HAVE_PYTHON */
1864 Evaluate a Python command.\n\
1866 Python scripting is not supported in this copy of GDB.\n\
1867 This command is only a placeholder.")
1868 #endif /* HAVE_PYTHON */
1870 add_com_alias ("py", "python", class_obscure
, 1);
1872 /* Add set/show python print-stack. */
1873 add_prefix_cmd ("python", no_class
, user_show_python
,
1874 _("Prefix command for python preference settings."),
1875 &user_show_python_list
, "show python ", 0,
1878 add_prefix_cmd ("python", no_class
, user_set_python
,
1879 _("Prefix command for python preference settings."),
1880 &user_set_python_list
, "set python ", 0,
1883 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1884 &gdbpy_should_print_stack
, _("\
1885 Set mode for Python stack dump on error."), _("\
1886 Show the mode of Python stack printing on error."), _("\
1887 none == no stack or message will be printed.\n\
1888 full == a message and a stack will be printed.\n\
1889 message == an error message without a stack will be printed."),
1891 &user_set_python_list
,
1892 &user_show_python_list
);
1895 if (!do_start_initialization () && PyErr_Occurred ())
1896 gdbpy_print_stack ();
1897 #endif /* HAVE_PYTHON */
1902 /* Helper function for gdbpy_finish_initialization. This does the
1903 work and then returns false if an error has occurred and must be
1904 displayed, or true on success. */
1907 do_finish_initialization (const struct extension_language_defn
*extlang
)
1912 /* Add the initial data-directory to sys.path. */
1914 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1917 sys_path
= PySys_GetObject ("path");
1919 /* If sys.path is not defined yet, define it first. */
1920 if (!(sys_path
&& PyList_Check (sys_path
)))
1923 PySys_SetPath (L
"");
1927 sys_path
= PySys_GetObject ("path");
1929 if (sys_path
&& PyList_Check (sys_path
))
1931 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1932 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1938 /* Import the gdb module to finish the initialization, and
1939 add it to __main__ for convenience. */
1940 m
= PyImport_AddModule ("__main__");
1944 /* Keep the reference to gdb_python_module since it is in a global
1946 gdb_python_module
= PyImport_ImportModule ("gdb");
1947 if (gdb_python_module
== NULL
)
1949 gdbpy_print_stack ();
1950 /* This is passed in one call to warning so that blank lines aren't
1951 inserted between each line of text. */
1953 "Could not load the Python gdb module from `%s'.\n"
1954 "Limited Python support is available from the _gdb module.\n"
1955 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
1956 gdb_pythondir
.c_str ());
1957 /* We return "success" here as we've already emitted the
1962 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1965 /* Perform the remaining python initializations.
1966 These must be done after GDB is at least mostly initialized.
1967 E.g., The "info pretty-printer" command needs the "info" prefix
1969 This is the extension_language_ops.finish_initialization "method". */
1972 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1974 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1976 if (!do_finish_initialization (extlang
))
1978 gdbpy_print_stack ();
1979 warning (_("internal error: Unhandled Python exception"));
1983 /* Return non-zero if Python has successfully initialized.
1984 This is the extension_languages_ops.initialized "method". */
1987 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1989 return gdb_python_initialized
;
1992 #endif /* HAVE_PYTHON */
1998 PyMethodDef python_GdbMethods
[] =
2000 { "history", gdbpy_history
, METH_VARARGS
,
2001 "Get a value from history" },
2002 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
2003 "execute (command [, from_tty] [, to_string]) -> [String]\n\
2004 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
2005 a Python String containing the output of the command if to_string is\n\
2007 { "parameter", gdbpy_parameter
, METH_VARARGS
,
2008 "Return a gdb parameter's value" },
2010 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
2011 "Return a tuple of all breakpoint objects" },
2013 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
2014 "Find the default visualizer for a Value." },
2016 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2017 "Return a sequence of all progspaces." },
2019 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2020 "Return the current Objfile being loaded, or None." },
2022 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2023 "newest_frame () -> gdb.Frame.\n\
2024 Return the newest frame object." },
2025 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2026 "selected_frame () -> gdb.Frame.\n\
2027 Return the selected frame object." },
2028 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2029 "stop_reason_string (Integer) -> String.\n\
2030 Return a string explaining unwind stop reason." },
2032 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2033 "start_recording ([method] [, format]) -> gdb.Record.\n\
2034 Start recording with the given method. If no method is given, will fall back\n\
2035 to the system default method. If no format is given, will fall back to the\n\
2036 default format for the given method."},
2037 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2038 "current_recording () -> gdb.Record.\n\
2039 Return current recording object." },
2040 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2041 "stop_recording () -> None.\n\
2042 Stop current recording." },
2044 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2045 METH_VARARGS
| METH_KEYWORDS
,
2046 "lookup_type (name [, block]) -> type\n\
2047 Return a Type corresponding to the given name." },
2048 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2049 METH_VARARGS
| METH_KEYWORDS
,
2050 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2051 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2052 a boolean indicating if name is a field of the current implied argument\n\
2053 `this' (when the current language is object-oriented)." },
2054 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2055 METH_VARARGS
| METH_KEYWORDS
,
2056 "lookup_global_symbol (name [, domain]) -> symbol\n\
2057 Return the symbol corresponding to the given name (or None)." },
2058 { "lookup_static_symbol", (PyCFunction
) gdbpy_lookup_static_symbol
,
2059 METH_VARARGS
| METH_KEYWORDS
,
2060 "lookup_static_symbol (name [, domain]) -> symbol\n\
2061 Return the static-linkage symbol corresponding to the given name (or None)." },
2062 { "lookup_static_symbols", (PyCFunction
) gdbpy_lookup_static_symbols
,
2063 METH_VARARGS
| METH_KEYWORDS
,
2064 "lookup_static_symbols (name [, domain]) -> symbol\n\
2065 Return a list of all static-linkage symbols corresponding to the given name." },
2067 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2068 METH_VARARGS
| METH_KEYWORDS
,
2069 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2070 Look up the specified objfile.\n\
2071 If by_build_id is True, the objfile is looked up by using name\n\
2072 as its build id." },
2074 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2075 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2076 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2077 The first element contains any unparsed portion of the String parameter\n\
2078 (or None if the string was fully parsed). The second element contains\n\
2079 a tuple that contains all the locations that match, represented as\n\
2080 gdb.Symtab_and_line objects (or None)."},
2081 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2082 "parse_and_eval (String) -> Value.\n\
2083 Parse String as an expression, evaluate it, and return the result as a Value."
2086 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2087 "Post an event into gdb's event loop." },
2089 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2090 "target_charset () -> string.\n\
2091 Return the name of the current target charset." },
2092 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2093 "target_wide_charset () -> string.\n\
2094 Return the name of the current target wide charset." },
2095 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2096 "rbreak (Regex) -> List.\n\
2097 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2098 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2099 "string_to_argv (String) -> Array.\n\
2100 Parse String and return an argv-like array.\n\
2101 Arguments are separate by spaces and may be quoted."
2103 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2104 "Write a string using gdb's filtered stream." },
2105 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2106 "Flush gdb's filtered stdout stream." },
2107 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2108 "selected_thread () -> gdb.InferiorThread.\n\
2109 Return the selected thread object." },
2110 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2111 "selected_inferior () -> gdb.Inferior.\n\
2112 Return the selected inferior object." },
2113 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2114 "inferiors () -> (gdb.Inferior, ...).\n\
2115 Return a tuple containing all inferiors." },
2117 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2118 "invalidate_cached_frames () -> None.\n\
2119 Invalidate any cached frame objects in gdb.\n\
2120 Intended for internal use only." },
2122 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2123 "convenience_variable (NAME) -> value.\n\
2124 Return the value of the convenience variable $NAME,\n\
2125 or None if not set." },
2126 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2127 "convenience_variable (NAME, VALUE) -> None.\n\
2128 Set the value of the convenience variable $NAME." },
2130 {NULL
, NULL
, 0, NULL
}
2134 struct PyModuleDef python_GdbModuleDef
=
2136 PyModuleDef_HEAD_INIT
,
2148 /* Define all the event objects. */
2149 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2150 PyTypeObject name##_event_object_type \
2151 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2153 PyVarObject_HEAD_INIT (NULL, 0) \
2154 "gdb." py_name, /* tp_name */ \
2155 sizeof (event_object), /* tp_basicsize */ \
2156 0, /* tp_itemsize */ \
2157 evpy_dealloc, /* tp_dealloc */ \
2159 0, /* tp_getattr */ \
2160 0, /* tp_setattr */ \
2161 0, /* tp_compare */ \
2163 0, /* tp_as_number */ \
2164 0, /* tp_as_sequence */ \
2165 0, /* tp_as_mapping */ \
2169 0, /* tp_getattro */ \
2170 0, /* tp_setattro */ \
2171 0, /* tp_as_buffer */ \
2172 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2174 0, /* tp_traverse */ \
2176 0, /* tp_richcompare */ \
2177 0, /* tp_weaklistoffset */ \
2179 0, /* tp_iternext */ \
2180 0, /* tp_methods */ \
2181 0, /* tp_members */ \
2182 0, /* tp_getset */ \
2183 &base, /* tp_base */ \
2185 0, /* tp_descr_get */ \
2186 0, /* tp_descr_set */ \
2187 0, /* tp_dictoffset */ \
2191 #include "py-event-types.def"
2192 #undef GDB_PY_DEFINE_EVENT_TYPE
2194 #endif /* HAVE_PYTHON */