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 "gdbsupport/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
) noexcept
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 (objfile
->arch (), 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 (objfile
->arch (), 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 /* Initialize the Python code. */
1597 /* This is installed as a final cleanup and cleans up the
1598 interpreter. This lets Python's 'atexit' work. */
1601 finalize_python (void *ignore
)
1603 struct active_ext_lang_state
*previous_active
;
1605 /* We don't use ensure_python_env here because if we ever ran the
1606 cleanup, gdb would crash -- because the cleanup calls into the
1607 Python interpreter, which we are about to destroy. It seems
1608 clearer to make the needed calls explicitly here than to create a
1609 cleanup and then mysteriously discard it. */
1611 /* This is only called as a final cleanup so we can assume the active
1612 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1613 previous_active
= set_active_ext_lang (&extension_language_python
);
1615 (void) PyGILState_Ensure ();
1616 python_gdbarch
= target_gdbarch ();
1617 python_language
= current_language
;
1621 restore_active_ext_lang (previous_active
);
1625 /* This is called via the PyImport_AppendInittab mechanism called
1626 during initialization, to make the built-in _gdb module known to
1628 PyMODINIT_FUNC
init__gdb_module (void);
1630 init__gdb_module (void)
1632 return PyModule_Create (&python_GdbModuleDef
);
1637 do_start_initialization ()
1640 size_t progsize
, count
;
1641 /* Python documentation indicates that the memory given
1642 to Py_SetProgramName cannot be freed. However, it seems that
1643 at least Python 3.7.4 Py_SetProgramName takes a copy of the
1644 given program_name. Making progname_copy static and not release
1645 the memory avoids a leak report for Python versions that duplicate
1646 program_name, and respect the requirement of Py_SetProgramName
1647 for Python versions that do not duplicate program_name. */
1648 static wchar_t *progname_copy
;
1651 #ifdef WITH_PYTHON_PATH
1652 /* Work around problem where python gets confused about where it is,
1653 and then can't find its libraries, etc.
1654 NOTE: Python assumes the following layout:
1656 /foo/lib/pythonX.Y/...
1657 This must be done before calling Py_Initialize. */
1658 gdb::unique_xmalloc_ptr
<char> progname
1659 (concat (ldirname (python_libdir
.c_str ()).c_str (), SLASH_STRING
, "bin",
1660 SLASH_STRING
, "python", (char *) NULL
));
1662 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1663 setlocale (LC_ALL
, "");
1664 progsize
= strlen (progname
.get ());
1665 progname_copy
= XNEWVEC (wchar_t, progsize
+ 1);
1666 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1667 if (count
== (size_t) -1)
1669 fprintf (stderr
, "Could not convert python path to string\n");
1672 setlocale (LC_ALL
, oldloc
.c_str ());
1674 /* Note that Py_SetProgramName expects the string it is passed to
1675 remain alive for the duration of the program's execution, so
1676 it is not freed after this call. */
1677 Py_SetProgramName (progname_copy
);
1679 /* Define _gdb as a built-in module. */
1680 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1682 Py_SetProgramName (progname
.release ());
1687 #if PY_VERSION_HEX < 0x03090000
1688 /* PyEval_InitThreads became deprecated in Python 3.9 and will
1689 be removed in Python 3.11. Prior to Python 3.7, this call was
1690 required to initialize the GIL. */
1691 PyEval_InitThreads ();
1695 gdb_module
= PyImport_ImportModule ("_gdb");
1697 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1699 if (gdb_module
== NULL
)
1702 if (PyModule_AddStringConstant (gdb_module
, "VERSION", version
) < 0
1703 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", host_name
) < 0
1704 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1708 /* Add stream constants. */
1709 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1710 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1711 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1714 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1715 if (gdbpy_gdb_error
== NULL
1716 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1719 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1720 gdbpy_gdb_error
, NULL
);
1721 if (gdbpy_gdb_memory_error
== NULL
1722 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1723 gdbpy_gdb_memory_error
) < 0)
1726 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1727 if (gdbpy_gdberror_exc
== NULL
1728 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1729 gdbpy_gdberror_exc
) < 0)
1732 gdbpy_initialize_gdb_readline ();
1734 if (gdbpy_initialize_auto_load () < 0
1735 || gdbpy_initialize_values () < 0
1736 || gdbpy_initialize_frames () < 0
1737 || gdbpy_initialize_commands () < 0
1738 || gdbpy_initialize_instruction () < 0
1739 || gdbpy_initialize_record () < 0
1740 || gdbpy_initialize_btrace () < 0
1741 || gdbpy_initialize_symbols () < 0
1742 || gdbpy_initialize_symtabs () < 0
1743 || gdbpy_initialize_blocks () < 0
1744 || gdbpy_initialize_functions () < 0
1745 || gdbpy_initialize_parameters () < 0
1746 || gdbpy_initialize_types () < 0
1747 || gdbpy_initialize_pspace () < 0
1748 || gdbpy_initialize_objfile () < 0
1749 || gdbpy_initialize_breakpoints () < 0
1750 || gdbpy_initialize_finishbreakpoints () < 0
1751 || gdbpy_initialize_lazy_string () < 0
1752 || gdbpy_initialize_linetable () < 0
1753 || gdbpy_initialize_thread () < 0
1754 || gdbpy_initialize_inferior () < 0
1755 || gdbpy_initialize_eventregistry () < 0
1756 || gdbpy_initialize_py_events () < 0
1757 || gdbpy_initialize_event () < 0
1758 || gdbpy_initialize_arch () < 0
1759 || gdbpy_initialize_xmethods () < 0
1760 || gdbpy_initialize_unwind () < 0
1761 || gdbpy_initialize_tui () < 0)
1764 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1765 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1767 #include "py-event-types.def"
1768 #undef GDB_PY_DEFINE_EVENT_TYPE
1770 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1771 if (gdbpy_to_string_cst
== NULL
)
1773 gdbpy_children_cst
= PyString_FromString ("children");
1774 if (gdbpy_children_cst
== NULL
)
1776 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1777 if (gdbpy_display_hint_cst
== NULL
)
1779 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1780 if (gdbpy_doc_cst
== NULL
)
1782 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1783 if (gdbpy_enabled_cst
== NULL
)
1785 gdbpy_value_cst
= PyString_FromString ("value");
1786 if (gdbpy_value_cst
== NULL
)
1789 /* Release the GIL while gdb runs. */
1790 PyThreadState_Swap (NULL
);
1791 PyEval_ReleaseLock ();
1793 make_final_cleanup (finalize_python
, NULL
);
1795 /* Only set this when initialization has succeeded. */
1796 gdb_python_initialized
= 1;
1800 #endif /* HAVE_PYTHON */
1803 cmd_list_element
*python_cmd_element
= nullptr;
1805 void _initialize_python ();
1807 _initialize_python ()
1809 add_com ("python-interactive", class_obscure
,
1810 python_interactive_command
,
1813 Start an interactive Python prompt.\n\
1815 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1818 Alternatively, a single-line Python command can be given as an\n\
1819 argument, and if the command is an expression, the result will be\n\
1820 printed. For example:\n\
1822 (gdb) python-interactive 2 + 3\n\
1824 #else /* HAVE_PYTHON */
1826 Start a Python interactive prompt.\n\
1828 Python scripting is not supported in this copy of GDB.\n\
1829 This command is only a placeholder.")
1830 #endif /* HAVE_PYTHON */
1832 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1834 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1837 Evaluate a Python command.\n\
1839 The command can be given as an argument, for instance:\n\
1841 python print (23)\n\
1843 If no argument is given, the following lines are read and used\n\
1844 as the Python commands. Type a line containing \"end\" to indicate\n\
1845 the end of the command.")
1846 #else /* HAVE_PYTHON */
1848 Evaluate a Python command.\n\
1850 Python scripting is not supported in this copy of GDB.\n\
1851 This command is only a placeholder.")
1852 #endif /* HAVE_PYTHON */
1854 add_com_alias ("py", "python", class_obscure
, 1);
1856 /* Add set/show python print-stack. */
1857 add_basic_prefix_cmd ("python", no_class
,
1858 _("Prefix command for python preference settings."),
1859 &user_show_python_list
, "show python ", 0,
1862 add_show_prefix_cmd ("python", no_class
,
1863 _("Prefix command for python preference settings."),
1864 &user_set_python_list
, "set python ", 0,
1867 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1868 &gdbpy_should_print_stack
, _("\
1869 Set mode for Python stack dump on error."), _("\
1870 Show the mode of Python stack printing on error."), _("\
1871 none == no stack or message will be printed.\n\
1872 full == a message and a stack will be printed.\n\
1873 message == an error message without a stack will be printed."),
1875 &user_set_python_list
,
1876 &user_show_python_list
);
1879 if (!do_start_initialization () && PyErr_Occurred ())
1880 gdbpy_print_stack ();
1881 #endif /* HAVE_PYTHON */
1886 /* Helper function for gdbpy_finish_initialization. This does the
1887 work and then returns false if an error has occurred and must be
1888 displayed, or true on success. */
1891 do_finish_initialization (const struct extension_language_defn
*extlang
)
1896 /* Add the initial data-directory to sys.path. */
1898 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1901 sys_path
= PySys_GetObject ("path");
1903 /* If sys.path is not defined yet, define it first. */
1904 if (!(sys_path
&& PyList_Check (sys_path
)))
1907 PySys_SetPath (L
"");
1911 sys_path
= PySys_GetObject ("path");
1913 if (sys_path
&& PyList_Check (sys_path
))
1915 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1916 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1922 /* Import the gdb module to finish the initialization, and
1923 add it to __main__ for convenience. */
1924 m
= PyImport_AddModule ("__main__");
1928 /* Keep the reference to gdb_python_module since it is in a global
1930 gdb_python_module
= PyImport_ImportModule ("gdb");
1931 if (gdb_python_module
== NULL
)
1933 gdbpy_print_stack ();
1934 /* This is passed in one call to warning so that blank lines aren't
1935 inserted between each line of text. */
1937 "Could not load the Python gdb module from `%s'.\n"
1938 "Limited Python support is available from the _gdb module.\n"
1939 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
1940 gdb_pythondir
.c_str ());
1941 /* We return "success" here as we've already emitted the
1946 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1949 /* Perform the remaining python initializations.
1950 These must be done after GDB is at least mostly initialized.
1951 E.g., The "info pretty-printer" command needs the "info" prefix
1953 This is the extension_language_ops.finish_initialization "method". */
1956 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1958 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1960 if (!do_finish_initialization (extlang
))
1962 gdbpy_print_stack ();
1963 warning (_("internal error: Unhandled Python exception"));
1967 /* Return non-zero if Python has successfully initialized.
1968 This is the extension_languages_ops.initialized "method". */
1971 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1973 return gdb_python_initialized
;
1976 #endif /* HAVE_PYTHON */
1982 PyMethodDef python_GdbMethods
[] =
1984 { "history", gdbpy_history
, METH_VARARGS
,
1985 "Get a value from history" },
1986 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1987 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1988 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1989 a Python String containing the output of the command if to_string is\n\
1991 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1992 "Return a gdb parameter's value" },
1994 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1995 "Return a tuple of all breakpoint objects" },
1997 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1998 "Find the default visualizer for a Value." },
2000 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2001 "Return a sequence of all progspaces." },
2003 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2004 "Return the current Objfile being loaded, or None." },
2006 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2007 "newest_frame () -> gdb.Frame.\n\
2008 Return the newest frame object." },
2009 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2010 "selected_frame () -> gdb.Frame.\n\
2011 Return the selected frame object." },
2012 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2013 "stop_reason_string (Integer) -> String.\n\
2014 Return a string explaining unwind stop reason." },
2016 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2017 "start_recording ([method] [, format]) -> gdb.Record.\n\
2018 Start recording with the given method. If no method is given, will fall back\n\
2019 to the system default method. If no format is given, will fall back to the\n\
2020 default format for the given method."},
2021 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2022 "current_recording () -> gdb.Record.\n\
2023 Return current recording object." },
2024 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2025 "stop_recording () -> None.\n\
2026 Stop current recording." },
2028 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2029 METH_VARARGS
| METH_KEYWORDS
,
2030 "lookup_type (name [, block]) -> type\n\
2031 Return a Type corresponding to the given name." },
2032 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2033 METH_VARARGS
| METH_KEYWORDS
,
2034 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2035 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2036 a boolean indicating if name is a field of the current implied argument\n\
2037 `this' (when the current language is object-oriented)." },
2038 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2039 METH_VARARGS
| METH_KEYWORDS
,
2040 "lookup_global_symbol (name [, domain]) -> symbol\n\
2041 Return the symbol corresponding to the given name (or None)." },
2042 { "lookup_static_symbol", (PyCFunction
) gdbpy_lookup_static_symbol
,
2043 METH_VARARGS
| METH_KEYWORDS
,
2044 "lookup_static_symbol (name [, domain]) -> symbol\n\
2045 Return the static-linkage symbol corresponding to the given name (or None)." },
2046 { "lookup_static_symbols", (PyCFunction
) gdbpy_lookup_static_symbols
,
2047 METH_VARARGS
| METH_KEYWORDS
,
2048 "lookup_static_symbols (name [, domain]) -> symbol\n\
2049 Return a list of all static-linkage symbols corresponding to the given name." },
2051 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2052 METH_VARARGS
| METH_KEYWORDS
,
2053 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2054 Look up the specified objfile.\n\
2055 If by_build_id is True, the objfile is looked up by using name\n\
2056 as its build id." },
2058 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2059 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2060 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2061 The first element contains any unparsed portion of the String parameter\n\
2062 (or None if the string was fully parsed). The second element contains\n\
2063 a tuple that contains all the locations that match, represented as\n\
2064 gdb.Symtab_and_line objects (or None)."},
2065 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2066 "parse_and_eval (String) -> Value.\n\
2067 Parse String as an expression, evaluate it, and return the result as a Value."
2070 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2071 "Post an event into gdb's event loop." },
2073 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2074 "target_charset () -> string.\n\
2075 Return the name of the current target charset." },
2076 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2077 "target_wide_charset () -> string.\n\
2078 Return the name of the current target wide charset." },
2079 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2080 "rbreak (Regex) -> List.\n\
2081 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2082 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2083 "string_to_argv (String) -> Array.\n\
2084 Parse String and return an argv-like array.\n\
2085 Arguments are separate by spaces and may be quoted."
2087 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2088 "Write a string using gdb's filtered stream." },
2089 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2090 "Flush gdb's filtered stdout stream." },
2091 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2092 "selected_thread () -> gdb.InferiorThread.\n\
2093 Return the selected thread object." },
2094 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2095 "selected_inferior () -> gdb.Inferior.\n\
2096 Return the selected inferior object." },
2097 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2098 "inferiors () -> (gdb.Inferior, ...).\n\
2099 Return a tuple containing all inferiors." },
2101 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2102 "invalidate_cached_frames () -> None.\n\
2103 Invalidate any cached frame objects in gdb.\n\
2104 Intended for internal use only." },
2106 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2107 "convenience_variable (NAME) -> value.\n\
2108 Return the value of the convenience variable $NAME,\n\
2109 or None if not set." },
2110 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2111 "convenience_variable (NAME, VALUE) -> None.\n\
2112 Set the value of the convenience variable $NAME." },
2115 { "register_window_type", (PyCFunction
) gdbpy_register_tui_window
,
2116 METH_VARARGS
| METH_KEYWORDS
,
2117 "register_window_type (NAME, CONSTRUCSTOR) -> None\n\
2118 Register a TUI window constructor." },
2121 {NULL
, NULL
, 0, NULL
}
2125 struct PyModuleDef python_GdbModuleDef
=
2127 PyModuleDef_HEAD_INIT
,
2139 /* Define all the event objects. */
2140 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2141 PyTypeObject name##_event_object_type \
2142 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2144 PyVarObject_HEAD_INIT (NULL, 0) \
2145 "gdb." py_name, /* tp_name */ \
2146 sizeof (event_object), /* tp_basicsize */ \
2147 0, /* tp_itemsize */ \
2148 evpy_dealloc, /* tp_dealloc */ \
2150 0, /* tp_getattr */ \
2151 0, /* tp_setattr */ \
2152 0, /* tp_compare */ \
2154 0, /* tp_as_number */ \
2155 0, /* tp_as_sequence */ \
2156 0, /* tp_as_mapping */ \
2160 0, /* tp_getattro */ \
2161 0, /* tp_setattro */ \
2162 0, /* tp_as_buffer */ \
2163 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2165 0, /* tp_traverse */ \
2167 0, /* tp_richcompare */ \
2168 0, /* tp_weaklistoffset */ \
2170 0, /* tp_iternext */ \
2171 0, /* tp_methods */ \
2172 0, /* tp_members */ \
2173 0, /* tp_getset */ \
2174 &base, /* tp_base */ \
2176 0, /* tp_descr_get */ \
2177 0, /* tp_descr_set */ \
2178 0, /* tp_dictoffset */ \
2182 #include "py-event-types.def"
2183 #undef GDB_PY_DEFINE_EVENT_TYPE
2185 #endif /* HAVE_PYTHON */