1 /* General python/gdb code
3 Copyright (C) 2008-2023 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"
38 #include "observable.h"
41 #include "gdbsupport/selftest.h"
44 /* Declared constants and enum for python stack printing. */
45 static const char python_excp_none
[] = "none";
46 static const char python_excp_full
[] = "full";
47 static const char python_excp_message
[] = "message";
49 /* "set python print-stack" choices. */
50 static const char *const python_excp_enums
[] =
58 /* The exception printing variable. 'full' if we want to print the
59 error message and stack, 'none' if we want to print nothing, and
60 'message' if we only want to print the error message. 'message' is
62 static const char *gdbpy_should_print_stack
= python_excp_message
;
67 #include "cli/cli-decode.h"
71 #include "python-internal.h"
74 #include "gdbsupport/version.h"
76 #include "gdbthread.h"
78 #include "event-top.h"
81 /* True if Python has been successfully initialized, false
84 int gdb_python_initialized
;
86 extern PyMethodDef python_GdbMethods
[];
89 PyObject
*gdb_python_module
;
91 /* Some string constants we may wish to use. */
92 PyObject
*gdbpy_to_string_cst
;
93 PyObject
*gdbpy_children_cst
;
94 PyObject
*gdbpy_display_hint_cst
;
95 PyObject
*gdbpy_doc_cst
;
96 PyObject
*gdbpy_enabled_cst
;
97 PyObject
*gdbpy_value_cst
;
99 /* The GdbError exception. */
100 PyObject
*gdbpy_gdberror_exc
;
102 /* The `gdb.error' base class. */
103 PyObject
*gdbpy_gdb_error
;
105 /* The `gdb.MemoryError' exception. */
106 PyObject
*gdbpy_gdb_memory_error
;
108 static script_sourcer_func gdbpy_source_script
;
109 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
110 static objfile_script_executor_func gdbpy_execute_objfile_script
;
111 static void gdbpy_initialize (const struct extension_language_defn
*);
112 static int gdbpy_initialized (const struct extension_language_defn
*);
113 static void gdbpy_eval_from_control_command
114 (const struct extension_language_defn
*, struct command_line
*cmd
);
115 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
116 struct ext_lang_type_printers
*);
117 static enum ext_lang_rc gdbpy_apply_type_printers
118 (const struct extension_language_defn
*,
119 const struct ext_lang_type_printers
*, struct type
*,
120 gdb::unique_xmalloc_ptr
<char> *);
121 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
122 struct ext_lang_type_printers
*);
123 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
124 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
125 static enum ext_lang_rc gdbpy_before_prompt_hook
126 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
127 static gdb::optional
<std::string
> gdbpy_colorize
128 (const std::string
&filename
, const std::string
&contents
);
129 static gdb::optional
<std::string
> gdbpy_colorize_disasm
130 (const std::string
&content
, gdbarch
*gdbarch
);
132 /* The interface between gdb proper and loading of python scripts. */
134 static const struct extension_language_script_ops python_extension_script_ops
=
137 gdbpy_source_objfile_script
,
138 gdbpy_execute_objfile_script
,
139 gdbpy_auto_load_enabled
142 /* The interface between gdb proper and python extensions. */
144 static const struct extension_language_ops python_extension_ops
=
149 gdbpy_eval_from_control_command
,
151 gdbpy_start_type_printers
,
152 gdbpy_apply_type_printers
,
153 gdbpy_free_type_printers
,
155 gdbpy_apply_val_pretty_printer
,
157 gdbpy_apply_frame_filter
,
159 gdbpy_preserve_values
,
161 gdbpy_breakpoint_has_cond
,
162 gdbpy_breakpoint_cond_says_stop
,
165 gdbpy_check_quit_flag
,
167 gdbpy_before_prompt_hook
,
169 gdbpy_get_matching_xmethod_workers
,
173 gdbpy_colorize_disasm
,
178 #endif /* HAVE_PYTHON */
180 /* The main struct describing GDB's interface to the Python
181 extension language. */
182 const struct extension_language_defn extension_language_python
=
194 &python_extension_script_ops
,
195 &python_extension_ops
204 /* Architecture and language to be used in callbacks from
205 the Python interpreter. */
206 struct gdbarch
*gdbpy_enter::python_gdbarch
;
208 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
209 const struct language_defn
*language
)
210 : m_gdbarch (python_gdbarch
),
211 m_language (language
== nullptr ? nullptr : current_language
)
213 /* We should not ever enter Python unless initialized. */
214 if (!gdb_python_initialized
)
215 error (_("Python not initialized"));
217 m_previous_active
= set_active_ext_lang (&extension_language_python
);
219 m_state
= PyGILState_Ensure ();
221 python_gdbarch
= gdbarch
;
222 if (language
!= nullptr)
223 set_language (language
->la_language
);
225 /* Save it and ensure ! PyErr_Occurred () afterwards. */
229 gdbpy_enter::~gdbpy_enter ()
231 /* Leftover Python error is forbidden by Python Exception Handling. */
232 if (PyErr_Occurred ())
234 /* This order is similar to the one calling error afterwards. */
235 gdbpy_print_stack ();
236 warning (_("internal error: Unhandled Python exception"));
241 python_gdbarch
= m_gdbarch
;
242 if (m_language
!= nullptr)
243 set_language (m_language
->la_language
);
245 restore_active_ext_lang (m_previous_active
);
246 PyGILState_Release (m_state
);
250 gdbpy_enter::get_gdbarch ()
252 if (python_gdbarch
!= nullptr)
253 return python_gdbarch
;
254 return get_current_arch ();
258 gdbpy_enter::finalize ()
260 python_gdbarch
= current_inferior ()->arch ();
263 /* A helper class to save and restore the GIL, but without touching
264 the other globals that are handled by gdbpy_enter. */
271 : m_state (PyGILState_Ensure ())
277 PyGILState_Release (m_state
);
280 DISABLE_COPY_AND_ASSIGN (gdbpy_gil
);
284 PyGILState_STATE m_state
;
287 /* Set the quit flag. */
290 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
292 PyErr_SetInterrupt ();
295 /* Return true if the quit flag has been set, false otherwise. */
298 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
300 if (!gdb_python_initialized
)
304 return PyOS_InterruptOccurred ();
307 /* Evaluate a Python command like PyRun_SimpleString, but uses
308 Py_single_input which prints the result of expressions, and does
309 not automatically print the stack on errors. */
312 eval_python_command (const char *command
)
316 m
= PyImport_AddModule ("__main__");
320 d
= PyModule_GetDict (m
);
323 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
330 /* Implementation of the gdb "python-interactive" command. */
333 python_interactive_command (const char *arg
, int from_tty
)
335 struct ui
*ui
= current_ui
;
338 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
340 arg
= skip_spaces (arg
);
342 gdbpy_enter enter_py
;
346 std::string script
= std::string (arg
) + "\n";
347 err
= eval_python_command (script
.c_str ());
351 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
357 gdbpy_print_stack ();
358 error (_("Error while executing Python code."));
362 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
365 On Windows hosts few users would build Python themselves (this is no
366 trivial task on this platform), and thus use binaries built by
367 someone else instead. There may happen situation where the Python
368 library and GDB are using two different versions of the C runtime
369 library. Python, being built with VC, would use one version of the
370 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
371 A FILE * from one runtime does not necessarily operate correctly in
374 To work around this potential issue, we run code in Python to load
378 python_run_simple_file (FILE *file
, const char *filename
)
382 PyRun_SimpleFile (file
, filename
);
386 /* Because we have a string for a filename, and are using Python to
387 open the file, we need to expand any tilde in the path first. */
388 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
390 if (gdb_python_module
== nullptr
391 || ! PyObject_HasAttrString (gdb_python_module
, "_execute_file"))
392 error (_("Installation error: gdb._execute_file function is missing"));
394 gdbpy_ref
<> return_value
395 (PyObject_CallMethod (gdb_python_module
, "_execute_file", "s",
397 if (return_value
== nullptr)
399 /* Use PyErr_PrintEx instead of gdbpy_print_stack to better match the
400 behavior of the non-Windows codepath. */
407 /* Given a command_line, return a command string suitable for passing
408 to Python. Lines in the string are separated by newlines. */
411 compute_python_string (struct command_line
*l
)
413 struct command_line
*iter
;
416 for (iter
= l
; iter
; iter
= iter
->next
)
418 script
+= iter
->line
;
424 /* Take a command line structure representing a 'python' command, and
425 evaluate its body using the Python interpreter. */
428 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
429 struct command_line
*cmd
)
433 if (cmd
->body_list_1
!= nullptr)
434 error (_("Invalid \"python\" block structure."));
436 gdbpy_enter enter_py
;
438 std::string script
= compute_python_string (cmd
->body_list_0
.get ());
439 ret
= PyRun_SimpleString (script
.c_str ());
441 error (_("Error while executing Python code."));
444 /* Implementation of the gdb "python" command. */
447 python_command (const char *arg
, int from_tty
)
449 gdbpy_enter enter_py
;
451 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
453 arg
= skip_spaces (arg
);
456 if (PyRun_SimpleString (arg
))
457 error (_("Error while executing Python code."));
461 counted_command_line l
= get_command_line (python_control
, "");
463 execute_control_command_untraced (l
.get ());
469 /* Transform a gdb parameters's value into a Python value. May return
470 NULL (and set a Python exception) on error. Helper function for
473 gdbpy_parameter_value (const setting
&var
)
478 case var_string_noescape
:
479 case var_optional_filename
:
484 if (var
.type () == var_enum
)
485 str
= var
.get
<const char *> ();
487 str
= var
.get
<std::string
> ().c_str ();
489 return host_string_to_python_string (str
).release ();
494 if (var
.get
<bool> ())
500 case var_auto_boolean
:
502 enum auto_boolean ab
= var
.get
<enum auto_boolean
> ();
504 if (ab
== AUTO_BOOLEAN_TRUE
)
506 else if (ab
== AUTO_BOOLEAN_FALSE
)
517 = (var
.type () == var_uinteger
518 ? static_cast<LONGEST
> (var
.get
<unsigned int> ())
519 : static_cast<LONGEST
> (var
.get
<int> ()));
521 if (var
.extra_literals () != nullptr)
522 for (const literal_def
*l
= var
.extra_literals ();
523 l
->literal
!= nullptr;
527 if (strcmp (l
->literal
, "unlimited") == 0)
529 /* Compatibility hack for API brokenness. */
530 if (var
.type () == var_pinteger
531 && l
->val
.has_value ()
537 else if (l
->val
.has_value ())
540 return host_string_to_python_string (l
->literal
).release ();
543 if (var
.type () == var_uinteger
)
545 gdb_py_object_from_ulongest
546 (static_cast<unsigned int> (value
)).release ();
549 gdb_py_object_from_longest
550 (static_cast<int> (value
)).release ();
554 return PyErr_Format (PyExc_RuntimeError
,
555 _("Programmer error: unhandled type."));
558 /* A Python function which returns a gdb parameter's value as a Python
562 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
564 struct cmd_list_element
*alias
, *prefix
, *cmd
;
568 if (! PyArg_ParseTuple (args
, "s", &arg
))
571 std::string newarg
= std::string ("show ") + arg
;
575 found
= lookup_cmd_composition (newarg
.c_str (), &alias
, &prefix
, &cmd
);
577 catch (const gdb_exception
&ex
)
579 GDB_PY_HANDLE_EXCEPTION (ex
);
583 return PyErr_Format (PyExc_RuntimeError
,
584 _("Could not find parameter `%s'."), arg
);
586 if (!cmd
->var
.has_value ())
587 return PyErr_Format (PyExc_RuntimeError
,
588 _("`%s' is not a parameter."), arg
);
590 return gdbpy_parameter_value (*cmd
->var
);
593 /* Wrapper for target_charset. */
596 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
598 const char *cset
= target_charset (gdbpy_enter::get_gdbarch ());
600 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
603 /* Wrapper for target_wide_charset. */
606 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
608 const char *cset
= target_wide_charset (gdbpy_enter::get_gdbarch ());
610 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
613 /* Implement gdb.host_charset(). */
616 gdbpy_host_charset (PyObject
*self
, PyObject
*args
)
618 const char *cset
= host_charset ();
620 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
623 /* A Python function which evaluates a string using the gdb CLI. */
626 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
629 PyObject
*from_tty_obj
= nullptr;
630 PyObject
*to_string_obj
= nullptr;
631 static const char *keywords
[] = { "command", "from_tty", "to_string",
634 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
635 &PyBool_Type
, &from_tty_obj
,
636 &PyBool_Type
, &to_string_obj
))
639 bool from_tty
= false;
640 if (from_tty_obj
!= nullptr)
642 int cmp
= PyObject_IsTrue (from_tty_obj
);
645 from_tty
= (cmp
!= 0);
648 bool to_string
= false;
649 if (to_string_obj
!= nullptr)
651 int cmp
= PyObject_IsTrue (to_string_obj
);
654 to_string
= (cmp
!= 0);
657 std::string to_string_res
;
659 scoped_restore preventer
= prevent_dont_repeat ();
663 gdbpy_allow_threads allow_threads
;
665 struct interp
*interp
;
667 std::string arg_copy
= arg
;
669 char *save_ptr
= nullptr;
671 = [&] (std::string
&buffer
)
673 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
679 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
682 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
685 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
687 /* Use the console interpreter uiout to have the same print format
688 for console or MI. */
689 interp
= interp_lookup (current_ui
, "console");
690 current_uiout
= interp
->interp_ui_out ();
693 to_string_res
= execute_control_commands_to_string (lines
.get (),
696 execute_control_commands (lines
.get (), from_tty
);
699 /* Do any commands attached to breakpoint we stopped at. */
700 bpstat_do_actions ();
702 catch (const gdb_exception
&except
)
704 /* If an exception occurred then we won't hit normal_stop (), or have
705 an exception reach the top level of the event loop, which are the
706 two usual places in which stdin would be re-enabled. So, before we
707 convert the exception and continue back in Python, we should
708 re-enable stdin here. */
709 async_enable_stdin ();
710 GDB_PY_HANDLE_EXCEPTION (except
);
714 return PyUnicode_FromString (to_string_res
.c_str ());
718 /* Implementation of Python rbreak command. Take a REGEX and
719 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
720 Python list that contains newly set breakpoints that match that
721 criteria. REGEX refers to a GDB format standard regex pattern of
722 symbols names to search; MINSYMS is an optional boolean (default
723 False) that indicates if the function should search GDB's minimal
724 symbols; THROTTLE is an optional integer (default unlimited) that
725 indicates the maximum amount of breakpoints allowable before the
726 function exits (note, if the throttle bound is passed, no
727 breakpoints will be set and a runtime error returned); SYMTABS is
728 an optional Python iterable that contains a set of gdb.Symtabs to
729 constrain the search within. */
732 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
735 std::vector
<symbol_search
> symbols
;
736 unsigned long count
= 0;
737 PyObject
*symtab_list
= NULL
;
738 PyObject
*minsyms_p_obj
= NULL
;
740 unsigned int throttle
= 0;
741 static const char *keywords
[] = {"regex","minsyms", "throttle",
744 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
745 ®ex
, &PyBool_Type
,
746 &minsyms_p_obj
, &throttle
,
750 /* Parse minsyms keyword. */
751 if (minsyms_p_obj
!= NULL
)
753 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
759 global_symbol_searcher
spec (FUNCTIONS_DOMAIN
, regex
);
761 for (const char *elem
: spec
.filenames
)
762 xfree ((void *) elem
);
765 /* The "symtabs" keyword is any Python iterable object that returns
766 a gdb.Symtab on each iteration. If specified, iterate through
767 the provided gdb.Symtabs and extract their full path. As
768 python_string_to_target_string returns a
769 gdb::unique_xmalloc_ptr<char> and a vector containing these types
770 cannot be coerced to a const char **p[] via the vector.data call,
771 release the value from the unique_xmalloc_ptr and place it in a
772 simple type symtab_list_type (which holds the vector and a
773 destructor that frees the contents of the allocated strings. */
774 if (symtab_list
!= NULL
)
776 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
783 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
787 if (PyErr_Occurred ())
792 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
795 if (obj_name
== NULL
)
798 /* Is the object file still valid? */
799 if (obj_name
== Py_None
)
802 gdb::unique_xmalloc_ptr
<char> filename
=
803 python_string_to_target_string (obj_name
.get ());
805 if (filename
== NULL
)
808 /* Make sure there is a definite place to store the value of
809 filename before it is released. */
810 spec
.filenames
.push_back (nullptr);
811 spec
.filenames
.back () = filename
.release ();
815 /* The search spec. */
816 symbols
= spec
.search ();
818 /* Count the number of symbols (both symbols and optionally minimal
819 symbols) so we can correctly check the throttle limit. */
820 for (const symbol_search
&p
: symbols
)
822 /* Minimal symbols included? */
825 if (p
.msymbol
.minsym
!= NULL
)
829 if (p
.symbol
!= NULL
)
833 /* Check throttle bounds and exit if in excess. */
834 if (throttle
!= 0 && count
> throttle
)
836 PyErr_SetString (PyExc_RuntimeError
,
837 _("Number of breakpoints exceeds throttled maximum."));
841 gdbpy_ref
<> return_list (PyList_New (0));
843 if (return_list
== NULL
)
846 /* Construct full path names for symbols and call the Python
847 breakpoint constructor on the resulting names. Be tolerant of
848 individual breakpoint failures. */
849 for (const symbol_search
&p
: symbols
)
851 std::string symbol_name
;
853 /* Skipping minimal symbols? */
855 if (p
.msymbol
.minsym
!= NULL
)
858 if (p
.msymbol
.minsym
== NULL
)
860 struct symtab
*symtab
= p
.symbol
->symtab ();
861 const char *fullname
= symtab_to_fullname (symtab
);
863 symbol_name
= fullname
;
865 symbol_name
+= p
.symbol
->linkage_name ();
868 symbol_name
= p
.msymbol
.minsym
->linkage_name ();
870 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
871 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
872 &breakpoint_object_type
,
875 /* Tolerate individual breakpoint failures. */
877 gdbpy_print_stack ();
880 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
884 return return_list
.release ();
887 /* A Python function which is a wrapper for decode_line_1. */
890 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
892 const char *arg
= NULL
;
894 gdbpy_ref
<> unparsed
;
895 location_spec_up locspec
;
897 if (! PyArg_ParseTuple (args
, "|s", &arg
))
900 /* Treat a string consisting of just whitespace the same as
904 arg
= skip_spaces (arg
);
910 locspec
= string_to_location_spec_basic (&arg
, current_language
,
911 symbol_name_match_type::WILD
);
913 std::vector
<symtab_and_line
> decoded_sals
;
914 symtab_and_line def_sal
;
915 gdb::array_view
<symtab_and_line
> sals
;
920 decoded_sals
= decode_line_1 (locspec
.get (), 0, NULL
, NULL
, 0);
925 set_default_source_symtab_and_line ();
926 def_sal
= get_current_source_symtab_and_line ();
930 catch (const gdb_exception
&ex
)
932 /* We know this will always throw. */
933 gdbpy_convert_exception (ex
);
939 result
.reset (PyTuple_New (sals
.size ()));
942 for (size_t i
= 0; i
< sals
.size (); ++i
)
944 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
948 PyTuple_SetItem (result
.get (), i
, obj
);
952 result
= gdbpy_ref
<>::new_reference (Py_None
);
954 gdbpy_ref
<> return_result (PyTuple_New (2));
955 if (return_result
== NULL
)
958 if (arg
!= NULL
&& strlen (arg
) > 0)
960 unparsed
.reset (PyUnicode_FromString (arg
));
961 if (unparsed
== NULL
)
965 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
967 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
968 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
970 return return_result
.release ();
973 /* Parse a string and evaluate it as an expression. */
975 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
977 static const char *keywords
[] = { "expression", "global_context", nullptr };
979 const char *expr_str
;
980 PyObject
*global_context_obj
= nullptr;
982 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!", keywords
,
984 &PyBool_Type
, &global_context_obj
))
987 parser_flags flags
= 0;
988 if (global_context_obj
!= NULL
)
990 int cmp
= PyObject_IsTrue (global_context_obj
);
994 flags
|= PARSER_LEAVE_BLOCK_ALONE
;
997 PyObject
*result
= nullptr;
1000 scoped_value_mark free_values
;
1003 /* Allow other Python threads to run while we're evaluating
1004 the expression. This is important because the expression
1005 could involve inferior calls or otherwise be a lengthy
1006 calculation. We take care here to re-acquire the GIL here
1007 before continuing with Python work. */
1008 gdbpy_allow_threads allow_threads
;
1009 val
= parse_and_eval (expr_str
, flags
);
1011 result
= value_to_value_object (val
);
1013 catch (const gdb_exception
&except
)
1015 GDB_PY_HANDLE_EXCEPTION (except
);
1021 /* Implementation of gdb.invalidate_cached_frames. */
1024 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
1026 reinit_frame_cache ();
1030 /* Read a file as Python code.
1031 This is the extension_language_script_ops.script_sourcer "method".
1032 FILE is the file to load. FILENAME is name of the file FILE.
1033 This does not throw any errors. If an exception occurs python will print
1034 the traceback and clear the error indicator. */
1037 gdbpy_source_script (const struct extension_language_defn
*extlang
,
1038 FILE *file
, const char *filename
)
1040 gdbpy_enter enter_py
;
1041 python_run_simple_file (file
, filename
);
1046 /* Posting and handling events. */
1048 /* A single event. */
1051 gdbpy_event (gdbpy_ref
<> &&func
)
1052 : m_func (func
.release ())
1056 gdbpy_event (gdbpy_event
&&other
) noexcept
1057 : m_func (other
.m_func
)
1059 other
.m_func
= nullptr;
1062 gdbpy_event (const gdbpy_event
&other
)
1063 : m_func (other
.m_func
)
1066 Py_XINCREF (m_func
);
1072 Py_XDECREF (m_func
);
1075 gdbpy_event
&operator= (const gdbpy_event
&other
) = delete;
1079 gdbpy_enter enter_py
;
1081 gdbpy_ref
<> call_result (PyObject_CallObject (m_func
, NULL
));
1082 if (call_result
== NULL
)
1083 gdbpy_print_stack ();
1088 /* The Python event. This is just a callable object. Note that
1089 this is not a gdbpy_ref<>, because we have to take particular
1090 care to only destroy the reference when holding the GIL. */
1094 /* Submit an event to the gdb thread. */
1096 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1100 if (!PyArg_ParseTuple (args
, "O", &func
))
1103 if (!PyCallable_Check (func
))
1105 PyErr_SetString (PyExc_RuntimeError
,
1106 _("Posted event is not callable"));
1110 gdbpy_ref
<> func_ref
= gdbpy_ref
<>::new_reference (func
);
1111 gdbpy_event
event (std::move (func_ref
));
1112 run_on_main_thread (event
);
1119 /* This is the extension_language_ops.before_prompt "method". */
1121 static enum ext_lang_rc
1122 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1123 const char *current_gdb_prompt
)
1125 if (!gdb_python_initialized
)
1126 return EXT_LANG_RC_NOP
;
1128 gdbpy_enter enter_py
;
1130 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1131 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1132 return EXT_LANG_RC_ERROR
;
1134 if (gdb_python_module
1135 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1137 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1141 gdbpy_print_stack ();
1142 return EXT_LANG_RC_ERROR
;
1145 if (PyCallable_Check (hook
.get ()))
1147 gdbpy_ref
<> current_prompt (PyUnicode_FromString (current_gdb_prompt
));
1148 if (current_prompt
== NULL
)
1150 gdbpy_print_stack ();
1151 return EXT_LANG_RC_ERROR
;
1155 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1159 gdbpy_print_stack ();
1160 return EXT_LANG_RC_ERROR
;
1163 /* Return type should be None, or a String. If it is None,
1164 fall through, we will not set a prompt. If it is a
1165 string, set PROMPT. Anything else, set an exception. */
1166 if (result
!= Py_None
&& !PyUnicode_Check (result
.get ()))
1168 PyErr_Format (PyExc_RuntimeError
,
1169 _("Return from prompt_hook must " \
1170 "be either a Python string, or None"));
1171 gdbpy_print_stack ();
1172 return EXT_LANG_RC_ERROR
;
1175 if (result
!= Py_None
)
1177 gdb::unique_xmalloc_ptr
<char>
1178 prompt (python_string_to_host_string (result
.get ()));
1182 gdbpy_print_stack ();
1183 return EXT_LANG_RC_ERROR
;
1186 set_prompt (prompt
.get ());
1187 return EXT_LANG_RC_OK
;
1192 return EXT_LANG_RC_NOP
;
1195 /* This is the extension_language_ops.colorize "method". */
1197 static gdb::optional
<std::string
>
1198 gdbpy_colorize (const std::string
&filename
, const std::string
&contents
)
1200 if (!gdb_python_initialized
)
1203 gdbpy_enter enter_py
;
1205 gdbpy_ref
<> module (PyImport_ImportModule ("gdb.styling"));
1206 if (module
== nullptr)
1208 gdbpy_print_stack ();
1212 if (!PyObject_HasAttrString (module
.get (), "colorize"))
1215 gdbpy_ref
<> hook (PyObject_GetAttrString (module
.get (), "colorize"));
1216 if (hook
== nullptr)
1218 gdbpy_print_stack ();
1222 if (!PyCallable_Check (hook
.get ()))
1225 gdbpy_ref
<> fname_arg (PyUnicode_FromString (filename
.c_str ()));
1226 if (fname_arg
== nullptr)
1228 gdbpy_print_stack ();
1232 /* The pygments library, which is what we currently use for applying
1233 styling, is happy to take input as a bytes object, and to figure out
1234 the encoding for itself. This removes the need for us to figure out
1235 (guess?) at how the content is encoded, which is probably a good
1237 gdbpy_ref
<> contents_arg (PyBytes_FromStringAndSize (contents
.c_str (),
1239 if (contents_arg
== nullptr)
1241 gdbpy_print_stack ();
1245 /* Calling gdb.colorize passing in the filename (a string), and the file
1246 contents (a bytes object). This function should return either a bytes
1247 object, the same contents with styling applied, or None to indicate
1248 that no styling should be performed. */
1249 gdbpy_ref
<> result (PyObject_CallFunctionObjArgs (hook
.get (),
1251 contents_arg
.get (),
1253 if (result
== nullptr)
1255 gdbpy_print_stack ();
1259 if (result
== Py_None
)
1261 else if (!PyBytes_Check (result
.get ()))
1263 PyErr_SetString (PyExc_TypeError
,
1264 _("Return value from gdb.colorize should be a bytes object or None."));
1265 gdbpy_print_stack ();
1269 return std::string (PyBytes_AsString (result
.get ()));
1272 /* This is the extension_language_ops.colorize_disasm "method". */
1274 static gdb::optional
<std::string
>
1275 gdbpy_colorize_disasm (const std::string
&content
, gdbarch
*gdbarch
)
1277 if (!gdb_python_initialized
)
1280 gdbpy_enter enter_py
;
1282 gdbpy_ref
<> module (PyImport_ImportModule ("gdb.styling"));
1283 if (module
== nullptr)
1285 gdbpy_print_stack ();
1289 if (!PyObject_HasAttrString (module
.get (), "colorize_disasm"))
1292 gdbpy_ref
<> hook (PyObject_GetAttrString (module
.get (),
1293 "colorize_disasm"));
1294 if (hook
== nullptr)
1296 gdbpy_print_stack ();
1300 if (!PyCallable_Check (hook
.get ()))
1303 gdbpy_ref
<> content_arg (PyBytes_FromString (content
.c_str ()));
1304 if (content_arg
== nullptr)
1306 gdbpy_print_stack ();
1310 gdbpy_ref
<> gdbarch_arg (gdbarch_to_arch_object (gdbarch
));
1311 if (gdbarch_arg
== nullptr)
1313 gdbpy_print_stack ();
1317 gdbpy_ref
<> result (PyObject_CallFunctionObjArgs (hook
.get (),
1321 if (result
== nullptr)
1323 gdbpy_print_stack ();
1327 if (result
== Py_None
)
1330 if (!PyBytes_Check (result
.get ()))
1332 PyErr_SetString (PyExc_TypeError
,
1333 _("Return value from gdb.colorize_disasm should be a bytes object or None."));
1334 gdbpy_print_stack ();
1338 return std::string (PyBytes_AsString (result
.get ()));
1343 /* Implement gdb.format_address(ADDR,P_SPACE,ARCH). Provide access to
1344 GDB's print_address function from Python. The returned address will
1345 have the format '0x..... <symbol+offset>'. */
1348 gdbpy_format_address (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1350 static const char *keywords
[] =
1352 "address", "progspace", "architecture", nullptr
1354 PyObject
*addr_obj
= nullptr, *pspace_obj
= nullptr, *arch_obj
= nullptr;
1356 struct gdbarch
*gdbarch
= nullptr;
1357 struct program_space
*pspace
= nullptr;
1359 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "O|OO", keywords
,
1360 &addr_obj
, &pspace_obj
, &arch_obj
))
1363 if (get_addr_from_python (addr_obj
, &addr
) < 0)
1366 /* If the user passed None for progspace or architecture, then we
1367 consider this to mean "the default". Here we replace references to
1368 None with nullptr, this means that in the following code we only have
1369 to handle the nullptr case. These are only borrowed references, so
1370 no decref is required here. */
1371 if (pspace_obj
== Py_None
)
1372 pspace_obj
= nullptr;
1373 if (arch_obj
== Py_None
)
1376 if (pspace_obj
== nullptr && arch_obj
== nullptr)
1378 /* Grab both of these from the current inferior, and its associated
1379 default architecture. */
1380 pspace
= current_inferior ()->pspace
;
1381 gdbarch
= current_inferior ()->arch ();
1383 else if (arch_obj
== nullptr || pspace_obj
== nullptr)
1385 /* If the user has only given one of program space or architecture,
1386 then don't use the default for the other. Sure we could use the
1387 default, but it feels like there's too much scope of mistakes in
1388 this case, so better to require the user to provide both
1390 PyErr_SetString (PyExc_ValueError
,
1391 _("The architecture and progspace arguments must both be supplied"));
1396 /* The user provided an address, program space, and architecture.
1397 Just check that these objects are valid. */
1398 if (!gdbpy_is_progspace (pspace_obj
))
1400 PyErr_SetString (PyExc_TypeError
,
1401 _("The progspace argument is not a gdb.Progspace object"));
1405 pspace
= progspace_object_to_program_space (pspace_obj
);
1406 if (pspace
== nullptr)
1408 PyErr_SetString (PyExc_ValueError
,
1409 _("The progspace argument is not valid"));
1413 if (!gdbpy_is_architecture (arch_obj
))
1415 PyErr_SetString (PyExc_TypeError
,
1416 _("The architecture argument is not a gdb.Architecture object"));
1420 /* Architectures are never deleted once created, so gdbarch should
1421 never come back as nullptr. */
1422 gdbarch
= arch_object_to_gdbarch (arch_obj
);
1423 gdb_assert (gdbarch
!= nullptr);
1426 /* By this point we should know the program space and architecture we are
1428 gdb_assert (pspace
!= nullptr);
1429 gdb_assert (gdbarch
!= nullptr);
1431 /* Unfortunately print_address relies on the current program space for
1432 its symbol lookup. Temporarily switch now. */
1433 scoped_restore_current_program_space restore_progspace
;
1434 set_current_program_space (pspace
);
1436 /* Format the address, and return it as a string. */
1438 print_address (gdbarch
, addr
, &buf
);
1439 return PyUnicode_FromString (buf
.c_str ());
1446 /* A python function to write a single string using gdb's filtered
1447 output stream . The optional keyword STREAM can be used to write
1448 to a particular stream. The default stream is to gdb_stdout. */
1451 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1454 static const char *keywords
[] = { "text", "stream", NULL
};
1455 int stream_type
= 0;
1457 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1463 switch (stream_type
)
1467 gdb_printf (gdb_stderr
, "%s", arg
);
1472 gdb_printf (gdb_stdlog
, "%s", arg
);
1476 gdb_printf (gdb_stdout
, "%s", arg
);
1479 catch (const gdb_exception
&except
)
1481 GDB_PY_HANDLE_EXCEPTION (except
);
1487 /* A python function to flush a gdb stream. The optional keyword
1488 STREAM can be used to flush a particular stream. The default stream
1492 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1494 static const char *keywords
[] = { "stream", NULL
};
1495 int stream_type
= 0;
1497 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1501 switch (stream_type
)
1505 gdb_flush (gdb_stderr
);
1510 gdb_flush (gdb_stdlog
);
1514 gdb_flush (gdb_stdout
);
1520 /* Return non-zero if print-stack is not "none". */
1523 gdbpy_print_python_errors_p (void)
1525 return gdbpy_should_print_stack
!= python_excp_none
;
1528 /* Print a python exception trace, print just a message, or print
1529 nothing and clear the python exception, depending on
1530 gdbpy_should_print_stack. Only call this if a python exception is
1533 gdbpy_print_stack (void)
1536 /* Print "none", just clear exception. */
1537 if (gdbpy_should_print_stack
== python_excp_none
)
1541 /* Print "full" message and backtrace. */
1542 else if (gdbpy_should_print_stack
== python_excp_full
)
1545 /* PyErr_Print doesn't necessarily end output with a newline.
1546 This works because Python's stdout/stderr is fed through
1552 catch (const gdb_exception
&except
)
1556 /* Print "message", just error print message. */
1559 gdbpy_err_fetch fetched_error
;
1561 gdb::unique_xmalloc_ptr
<char> msg
= fetched_error
.to_string ();
1562 gdb::unique_xmalloc_ptr
<char> type
;
1563 /* Don't compute TYPE if MSG already indicates that there is an
1566 type
= fetched_error
.type_to_string ();
1570 if (msg
== NULL
|| type
== NULL
)
1572 /* An error occurred computing the string representation of the
1574 gdb_printf (gdb_stderr
,
1575 _("Error occurred computing Python error" \
1580 gdb_printf (gdb_stderr
, "Python Exception %s: %s\n",
1581 type
.get (), msg
.get ());
1583 catch (const gdb_exception
&except
)
1589 /* Like gdbpy_print_stack, but if the exception is a
1590 KeyboardException, throw a gdb "quit" instead. */
1593 gdbpy_print_stack_or_quit ()
1595 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1598 throw_quit ("Quit");
1600 gdbpy_print_stack ();
1605 /* Return a sequence holding all the Progspaces. */
1608 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1610 gdbpy_ref
<> list (PyList_New (0));
1614 for (struct program_space
*ps
: program_spaces
)
1616 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1618 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1622 return list
.release ();
1625 /* Return the name of the current language. */
1628 gdbpy_current_language (PyObject
*unused1
, PyObject
*unused2
)
1630 return host_string_to_python_string (current_language
->name ()).release ();
1636 struct objfile
*gdbpy_current_objfile
;
1638 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1639 as Python code. This does not throw any errors. If an exception
1640 occurs python will print the traceback and clear the error indicator.
1641 This is the extension_language_script_ops.objfile_script_sourcer
1645 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1646 struct objfile
*objfile
, FILE *file
,
1647 const char *filename
)
1649 if (!gdb_python_initialized
)
1652 gdbpy_enter
enter_py (objfile
->arch ());
1653 scoped_restore restire_current_objfile
1654 = make_scoped_restore (&gdbpy_current_objfile
, objfile
);
1656 python_run_simple_file (file
, filename
);
1659 /* Set the current objfile to OBJFILE and then execute SCRIPT
1660 as Python code. This does not throw any errors. If an exception
1661 occurs python will print the traceback and clear the error indicator.
1662 This is the extension_language_script_ops.objfile_script_executor
1666 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1667 struct objfile
*objfile
, const char *name
,
1670 if (!gdb_python_initialized
)
1673 gdbpy_enter
enter_py (objfile
->arch ());
1674 scoped_restore restire_current_objfile
1675 = make_scoped_restore (&gdbpy_current_objfile
, objfile
);
1677 PyRun_SimpleString (script
);
1680 /* Return the current Objfile, or None if there isn't one. */
1683 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1685 if (! gdbpy_current_objfile
)
1688 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1691 /* Compute the list of active python type printers and store them in
1692 EXT_PRINTERS->py_type_printers. The product of this function is used by
1693 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1694 This is the extension_language_ops.start_type_printers "method". */
1697 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1698 struct ext_lang_type_printers
*ext_printers
)
1700 PyObject
*printers_obj
= NULL
;
1702 if (!gdb_python_initialized
)
1705 gdbpy_enter enter_py
;
1707 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1708 if (type_module
== NULL
)
1710 gdbpy_print_stack ();
1714 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1715 "get_type_recognizers"));
1718 gdbpy_print_stack ();
1722 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1723 if (printers_obj
== NULL
)
1724 gdbpy_print_stack ();
1726 ext_printers
->py_type_printers
= printers_obj
;
1729 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1730 a newly allocated string holding the type's replacement name, and return
1732 If there's a Python error return EXT_LANG_RC_ERROR.
1733 Otherwise, return EXT_LANG_RC_NOP.
1734 This is the extension_language_ops.apply_type_printers "method". */
1736 static enum ext_lang_rc
1737 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1738 const struct ext_lang_type_printers
*ext_printers
,
1740 gdb::unique_xmalloc_ptr
<char> *prettied_type
)
1742 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1743 gdb::unique_xmalloc_ptr
<char> result
;
1745 if (printers_obj
== NULL
)
1746 return EXT_LANG_RC_NOP
;
1748 if (!gdb_python_initialized
)
1749 return EXT_LANG_RC_NOP
;
1751 gdbpy_enter enter_py
;
1753 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1754 if (type_obj
== NULL
)
1756 gdbpy_print_stack ();
1757 return EXT_LANG_RC_ERROR
;
1760 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1761 if (type_module
== NULL
)
1763 gdbpy_print_stack ();
1764 return EXT_LANG_RC_ERROR
;
1767 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1768 "apply_type_recognizers"));
1771 gdbpy_print_stack ();
1772 return EXT_LANG_RC_ERROR
;
1775 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1779 if (result_obj
== NULL
)
1781 gdbpy_print_stack ();
1782 return EXT_LANG_RC_ERROR
;
1785 if (result_obj
== Py_None
)
1786 return EXT_LANG_RC_NOP
;
1788 result
= python_string_to_host_string (result_obj
.get ());
1791 gdbpy_print_stack ();
1792 return EXT_LANG_RC_ERROR
;
1795 *prettied_type
= std::move (result
);
1796 return EXT_LANG_RC_OK
;
1799 /* Free the result of start_type_printers.
1800 This is the extension_language_ops.free_type_printers "method". */
1803 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1804 struct ext_lang_type_printers
*ext_printers
)
1806 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1808 if (printers
== NULL
)
1811 if (!gdb_python_initialized
)
1814 gdbpy_enter enter_py
;
1815 Py_DECREF (printers
);
1818 #else /* HAVE_PYTHON */
1820 /* Dummy implementation of the gdb "python-interactive" and "python"
1824 python_interactive_command (const char *arg
, int from_tty
)
1826 arg
= skip_spaces (arg
);
1828 error (_("Python scripting is not supported in this copy of GDB."));
1831 counted_command_line l
= get_command_line (python_control
, "");
1833 execute_control_command_untraced (l
.get ());
1838 python_command (const char *arg
, int from_tty
)
1840 python_interactive_command (arg
, from_tty
);
1843 #endif /* HAVE_PYTHON */
1845 /* When this is turned on before Python is initialised then Python will
1846 ignore any environment variables related to Python. This is equivalent
1847 to passing `-E' to the python program. */
1848 static bool python_ignore_environment
= false;
1850 /* Implement 'show python ignore-environment'. */
1853 show_python_ignore_environment (struct ui_file
*file
, int from_tty
,
1854 struct cmd_list_element
*c
, const char *value
)
1856 gdb_printf (file
, _("Python's ignore-environment setting is %s.\n"),
1860 /* Implement 'set python ignore-environment'. This sets Python's internal
1861 flag no matter when the command is issued, however, if this is used
1862 after Py_Initialize has been called then most of the environment will
1863 already have been read. */
1866 set_python_ignore_environment (const char *args
, int from_tty
,
1867 struct cmd_list_element
*c
)
1870 /* Py_IgnoreEnvironmentFlag is deprecated in Python 3.12. Disable
1871 its usage in Python 3.10 and above since the PyConfig mechanism
1872 is now (also) used in 3.10 and higher. See do_start_initialization()
1874 #if PY_VERSION_HEX < 0x030a0000
1875 Py_IgnoreEnvironmentFlag
= python_ignore_environment
? 1 : 0;
1880 /* When this is turned on before Python is initialised then Python will
1881 not write `.pyc' files on import of a module. */
1882 static enum auto_boolean python_dont_write_bytecode
= AUTO_BOOLEAN_AUTO
;
1884 /* Implement 'show python dont-write-bytecode'. */
1887 show_python_dont_write_bytecode (struct ui_file
*file
, int from_tty
,
1888 struct cmd_list_element
*c
, const char *value
)
1890 if (python_dont_write_bytecode
== AUTO_BOOLEAN_AUTO
)
1892 const char *auto_string
1893 = (python_ignore_environment
1894 || getenv ("PYTHONDONTWRITEBYTECODE") == nullptr) ? "off" : "on";
1897 _("Python's dont-write-bytecode setting is %s (currently %s).\n"),
1898 value
, auto_string
);
1901 gdb_printf (file
, _("Python's dont-write-bytecode setting is %s.\n"),
1906 /* Return value to assign to PyConfig.write_bytecode or, when
1907 negated (via !), Py_DontWriteBytecodeFlag. Py_DontWriteBytecodeFlag
1908 is deprecated in Python 3.12. */
1911 python_write_bytecode ()
1915 if (python_dont_write_bytecode
== AUTO_BOOLEAN_AUTO
)
1917 if (python_ignore_environment
)
1921 const char *pdwbc
= getenv ("PYTHONDONTWRITEBYTECODE");
1922 wbc
= (pdwbc
== nullptr || pdwbc
[0] == '\0') ? 1 : 0;
1926 wbc
= python_dont_write_bytecode
== AUTO_BOOLEAN_TRUE
? 0 : 1;
1930 #endif /* HAVE_PYTHON */
1932 /* Implement 'set python dont-write-bytecode'. This sets Python's internal
1933 flag no matter when the command is issued, however, if this is used
1934 after Py_Initialize has been called then many modules could already
1935 have been imported and their byte code written out. */
1938 set_python_dont_write_bytecode (const char *args
, int from_tty
,
1939 struct cmd_list_element
*c
)
1942 /* Py_DontWriteBytecodeFlag is deprecated in Python 3.12. Disable
1943 its usage in Python 3.10 and above since the PyConfig mechanism
1944 is now (also) used in 3.10 and higher. See do_start_initialization()
1946 #if PY_VERSION_HEX < 0x030a0000
1947 Py_DontWriteBytecodeFlag
= !python_write_bytecode ();
1949 #endif /* HAVE_PYTHON */
1954 /* Lists for 'set python' commands. */
1956 static struct cmd_list_element
*user_set_python_list
;
1957 static struct cmd_list_element
*user_show_python_list
;
1959 /* Initialize the Python code. */
1963 /* This is installed as a final cleanup and cleans up the
1964 interpreter. This lets Python's 'atexit' work. */
1967 finalize_python (void *ignore
)
1969 struct active_ext_lang_state
*previous_active
;
1971 /* We don't use ensure_python_env here because if we ever ran the
1972 cleanup, gdb would crash -- because the cleanup calls into the
1973 Python interpreter, which we are about to destroy. It seems
1974 clearer to make the needed calls explicitly here than to create a
1975 cleanup and then mysteriously discard it. */
1977 /* This is only called as a final cleanup so we can assume the active
1978 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1979 previous_active
= set_active_ext_lang (&extension_language_python
);
1981 (void) PyGILState_Ensure ();
1982 gdbpy_enter::finalize ();
1984 /* Call the gdbpy_finalize_* functions from every *.c file. */
1985 gdbpy_initialize_file::finalize_all ();
1989 gdb_python_initialized
= false;
1990 restore_active_ext_lang (previous_active
);
1993 static struct PyModuleDef python_GdbModuleDef
=
1995 PyModuleDef_HEAD_INIT
,
2006 /* This is called via the PyImport_AppendInittab mechanism called
2007 during initialization, to make the built-in _gdb module known to
2009 PyMODINIT_FUNC
init__gdb_module (void);
2011 init__gdb_module (void)
2013 return PyModule_Create (&python_GdbModuleDef
);
2016 /* Emit a gdb.GdbExitingEvent, return a negative value if there are any
2017 errors, otherwise, return 0. */
2020 emit_exiting_event (int exit_code
)
2022 if (evregpy_no_listeners_p (gdb_py_events
.gdb_exiting
))
2025 gdbpy_ref
<> event_obj
= create_event_object (&gdb_exiting_event_object_type
);
2026 if (event_obj
== nullptr)
2029 gdbpy_ref
<> code
= gdb_py_object_from_longest (exit_code
);
2030 if (evpy_add_attribute (event_obj
.get (), "exit_code", code
.get ()) < 0)
2033 return evpy_emit_event (event_obj
.get (), gdb_py_events
.gdb_exiting
);
2036 /* Callback for the gdb_exiting observable. EXIT_CODE is the value GDB
2040 gdbpy_gdb_exiting (int exit_code
)
2042 if (!gdb_python_initialized
)
2045 gdbpy_enter enter_py
;
2047 if (emit_exiting_event (exit_code
) < 0)
2048 gdbpy_print_stack ();
2052 do_start_initialization ()
2054 /* Define all internal modules. These are all imported (and thus
2055 created) during initialization. */
2056 struct _inittab mods
[] =
2058 { "_gdb", init__gdb_module
},
2059 { "_gdbevents", gdbpy_events_mod_func
},
2060 { nullptr, nullptr }
2063 if (PyImport_ExtendInittab (mods
) < 0)
2066 #ifdef WITH_PYTHON_PATH
2067 /* Work around problem where python gets confused about where it is,
2068 and then can't find its libraries, etc.
2069 NOTE: Python assumes the following layout:
2071 /foo/lib/pythonX.Y/...
2072 This must be done before calling Py_Initialize. */
2073 gdb::unique_xmalloc_ptr
<char> progname
2074 (concat (ldirname (python_libdir
.c_str ()).c_str (), SLASH_STRING
, "bin",
2075 SLASH_STRING
, "python", (char *) NULL
));
2076 /* Python documentation indicates that the memory given
2077 to Py_SetProgramName cannot be freed. However, it seems that
2078 at least Python 3.7.4 Py_SetProgramName takes a copy of the
2079 given program_name. Making progname_copy static and not release
2080 the memory avoids a leak report for Python versions that duplicate
2081 program_name, and respect the requirement of Py_SetProgramName
2082 for Python versions that do not duplicate program_name. */
2083 static wchar_t *progname_copy
;
2085 std::string oldloc
= setlocale (LC_ALL
, NULL
);
2086 setlocale (LC_ALL
, "");
2087 size_t progsize
= strlen (progname
.get ());
2088 progname_copy
= XNEWVEC (wchar_t, progsize
+ 1);
2089 size_t count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
2090 if (count
== (size_t) -1)
2092 fprintf (stderr
, "Could not convert python path to string\n");
2095 setlocale (LC_ALL
, oldloc
.c_str ());
2097 /* Py_SetProgramName was deprecated in Python 3.11. Use PyConfig
2098 mechanisms for Python 3.10 and newer. */
2099 #if PY_VERSION_HEX < 0x030a0000
2100 /* Note that Py_SetProgramName expects the string it is passed to
2101 remain alive for the duration of the program's execution, so
2102 it is not freed after this call. */
2103 Py_SetProgramName (progname_copy
);
2108 PyConfig_InitPythonConfig (&config
);
2109 PyStatus status
= PyConfig_SetString (&config
, &config
.program_name
,
2111 if (PyStatus_Exception (status
))
2114 config
.write_bytecode
= python_write_bytecode ();
2115 config
.use_environment
= !python_ignore_environment
;
2117 status
= PyConfig_Read (&config
);
2118 if (PyStatus_Exception (status
))
2121 status
= Py_InitializeFromConfig (&config
);
2124 PyConfig_Clear (&config
);
2125 if (PyStatus_Exception (status
))
2132 #if PY_VERSION_HEX < 0x03090000
2133 /* PyEval_InitThreads became deprecated in Python 3.9 and will
2134 be removed in Python 3.11. Prior to Python 3.7, this call was
2135 required to initialize the GIL. */
2136 PyEval_InitThreads ();
2139 gdb_module
= PyImport_ImportModule ("_gdb");
2140 if (gdb_module
== NULL
)
2143 if (PyModule_AddStringConstant (gdb_module
, "VERSION", version
) < 0
2144 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", host_name
) < 0
2145 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
2149 /* Add stream constants. */
2150 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
2151 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
2152 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
2155 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
2156 if (gdbpy_gdb_error
== NULL
2157 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
2160 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
2161 gdbpy_gdb_error
, NULL
);
2162 if (gdbpy_gdb_memory_error
== NULL
2163 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
2164 gdbpy_gdb_memory_error
) < 0)
2167 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
2168 if (gdbpy_gdberror_exc
== NULL
2169 || gdb_pymodule_addobject (gdb_module
, "GdbError",
2170 gdbpy_gdberror_exc
) < 0)
2173 /* Call the gdbpy_initialize_* functions from every *.c file. */
2174 if (!gdbpy_initialize_file::initialize_all ())
2177 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2178 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
2180 #include "py-event-types.def"
2181 #undef GDB_PY_DEFINE_EVENT_TYPE
2183 gdbpy_to_string_cst
= PyUnicode_FromString ("to_string");
2184 if (gdbpy_to_string_cst
== NULL
)
2186 gdbpy_children_cst
= PyUnicode_FromString ("children");
2187 if (gdbpy_children_cst
== NULL
)
2189 gdbpy_display_hint_cst
= PyUnicode_FromString ("display_hint");
2190 if (gdbpy_display_hint_cst
== NULL
)
2192 gdbpy_doc_cst
= PyUnicode_FromString ("__doc__");
2193 if (gdbpy_doc_cst
== NULL
)
2195 gdbpy_enabled_cst
= PyUnicode_FromString ("enabled");
2196 if (gdbpy_enabled_cst
== NULL
)
2198 gdbpy_value_cst
= PyUnicode_FromString ("value");
2199 if (gdbpy_value_cst
== NULL
)
2202 gdb::observers::gdb_exiting
.attach (gdbpy_gdb_exiting
, "python");
2204 /* Release the GIL while gdb runs. */
2205 PyEval_SaveThread ();
2207 make_final_cleanup (finalize_python
, NULL
);
2209 /* Only set this when initialization has succeeded. */
2210 gdb_python_initialized
= 1;
2215 namespace selftests
{
2217 /* Entry point for python unit tests. */
2222 #define CMD(S) execute_command_to_string (S, "python print(5)", 0, true)
2227 SELF_CHECK (output
== "5\n");
2230 bool saw_exception
= false;
2232 scoped_restore reset_gdb_python_initialized
2233 = make_scoped_restore (&gdb_python_initialized
, 0);
2238 catch (const gdb_exception
&e
)
2240 saw_exception
= true;
2241 SELF_CHECK (e
.reason
== RETURN_ERROR
);
2242 SELF_CHECK (e
.error
== GENERIC_ERROR
);
2243 SELF_CHECK (*e
.message
== "Python not initialized");
2245 SELF_CHECK (saw_exception
);
2246 SELF_CHECK (output
.empty ());
2249 saw_exception
= false;
2251 scoped_restore save_hook
2252 = make_scoped_restore (&hook_set_active_ext_lang
,
2253 []() { raise (SIGINT
); });
2258 catch (const gdb_exception
&e
)
2260 saw_exception
= true;
2261 SELF_CHECK (e
.reason
== RETURN_ERROR
);
2262 SELF_CHECK (e
.error
== GENERIC_ERROR
);
2263 SELF_CHECK (*e
.message
== "Error while executing Python code.");
2265 SELF_CHECK (saw_exception
);
2266 std::string
ref_output_0 ("Traceback (most recent call last):\n"
2267 " File \"<string>\", line 0, in <module>\n"
2268 "KeyboardInterrupt\n");
2269 std::string
ref_output_1 ("Traceback (most recent call last):\n"
2270 " File \"<string>\", line 1, in <module>\n"
2271 "KeyboardInterrupt\n");
2272 SELF_CHECK (output
== ref_output_0
|| output
== ref_output_1
);
2280 } // namespace selftests
2281 #endif /* GDB_SELF_TEST */
2283 #endif /* HAVE_PYTHON */
2286 cmd_list_element
*python_cmd_element
= nullptr;
2288 void _initialize_python ();
2290 _initialize_python ()
2292 cmd_list_element
*python_interactive_cmd
2293 = add_com ("python-interactive", class_obscure
,
2294 python_interactive_command
,
2297 Start an interactive Python prompt.\n\
2299 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
2302 Alternatively, a single-line Python command can be given as an\n\
2303 argument, and if the command is an expression, the result will be\n\
2304 printed. For example:\n\
2306 (gdb) python-interactive 2 + 3\n\
2308 #else /* HAVE_PYTHON */
2310 Start a Python interactive prompt.\n\
2312 Python scripting is not supported in this copy of GDB.\n\
2313 This command is only a placeholder.")
2314 #endif /* HAVE_PYTHON */
2316 add_com_alias ("pi", python_interactive_cmd
, class_obscure
, 1);
2318 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
2321 Evaluate a Python command.\n\
2323 The command can be given as an argument, for instance:\n\
2325 python print (23)\n\
2327 If no argument is given, the following lines are read and used\n\
2328 as the Python commands. Type a line containing \"end\" to indicate\n\
2329 the end of the command.")
2330 #else /* HAVE_PYTHON */
2332 Evaluate a Python command.\n\
2334 Python scripting is not supported in this copy of GDB.\n\
2335 This command is only a placeholder.")
2336 #endif /* HAVE_PYTHON */
2338 add_com_alias ("py", python_cmd_element
, class_obscure
, 1);
2340 /* Add set/show python print-stack. */
2341 add_setshow_prefix_cmd ("python", no_class
,
2342 _("Prefix command for python preference settings."),
2343 _("Prefix command for python preference settings."),
2344 &user_set_python_list
, &user_show_python_list
,
2345 &setlist
, &showlist
);
2347 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
2348 &gdbpy_should_print_stack
, _("\
2349 Set mode for Python stack dump on error."), _("\
2350 Show the mode of Python stack printing on error."), _("\
2351 none == no stack or message will be printed.\n\
2352 full == a message and a stack will be printed.\n\
2353 message == an error message without a stack will be printed."),
2355 &user_set_python_list
,
2356 &user_show_python_list
);
2358 add_setshow_boolean_cmd ("ignore-environment", no_class
,
2359 &python_ignore_environment
, _("\
2360 Set whether the Python interpreter should ignore environment variables."), _(" \
2361 Show whether the Python interpreter showlist ignore environment variables."), _(" \
2362 When enabled GDB's Python interpreter will ignore any Python related\n \
2363 flags in the environment. This is equivalent to passing `-E' to a\n \
2364 python executable."),
2365 set_python_ignore_environment
,
2366 show_python_ignore_environment
,
2367 &user_set_python_list
,
2368 &user_show_python_list
);
2370 add_setshow_auto_boolean_cmd ("dont-write-bytecode", no_class
,
2371 &python_dont_write_bytecode
, _("\
2372 Set whether the Python interpreter should avoid byte-compiling python modules."), _("\
2373 Show whether the Python interpreter should avoid byte-compiling python modules."), _("\
2374 When enabled, GDB's embedded Python interpreter won't byte-compile python\n\
2375 modules. In order to take effect, this setting must be enabled in an early\n\
2376 initialization file, i.e. those run via the --early-init-eval-command or\n\
2377 -eix command line options. A 'set python dont-write-bytecode on' command\n\
2378 can also be issued directly from the GDB command line via the\n\
2379 --early-init-eval-command or -eiex command line options.\n\
2381 This setting defaults to 'auto'. In this mode, provided the 'python\n\
2382 ignore-environment' setting is 'off', the environment variable\n\
2383 PYTHONDONTWRITEBYTECODE is examined to determine whether or not to\n\
2384 byte-compile python modules. PYTHONDONTWRITEBYTECODE is considered to be\n\
2385 off/disabled either when set to the empty string or when the\n\
2386 environment variable doesn't exist. All other settings, including those\n\
2387 which don't seem to make sense, indicate that it's on/enabled."),
2388 set_python_dont_write_bytecode
,
2389 show_python_dont_write_bytecode
,
2390 &user_set_python_list
,
2391 &user_show_python_list
);
2395 selftests::register_test ("python", selftests::test_python
);
2396 #endif /* GDB_SELF_TEST */
2397 #endif /* HAVE_PYTHON */
2402 /* Helper function for gdbpy_initialize. This does the work and then
2403 returns false if an error has occurred and must be displayed, or true on
2407 do_initialize (const struct extension_language_defn
*extlang
)
2412 /* Add the initial data-directory to sys.path. */
2414 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
2417 sys_path
= PySys_GetObject ("path");
2419 /* PySys_SetPath was deprecated in Python 3.11. Disable this
2420 deprecated code for Python 3.10 and newer. Also note that this
2421 ifdef eliminates potential initialization of sys.path via
2422 PySys_SetPath. My (kevinb's) understanding of PEP 587 suggests
2423 that it's not necessary due to module_search_paths being
2424 initialized to an empty list following any of the PyConfig
2425 initialization functions. If it does turn out that some kind of
2426 initialization is still needed, it should be added to the
2427 PyConfig-based initialization in do_start_initialize(). */
2428 #if PY_VERSION_HEX < 0x030a0000
2429 /* If sys.path is not defined yet, define it first. */
2430 if (!(sys_path
&& PyList_Check (sys_path
)))
2432 PySys_SetPath (L
"");
2433 sys_path
= PySys_GetObject ("path");
2436 if (sys_path
&& PyList_Check (sys_path
))
2438 gdbpy_ref
<> pythondir (PyUnicode_FromString (gdb_pythondir
.c_str ()));
2439 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
2445 /* Import the gdb module to finish the initialization, and
2446 add it to __main__ for convenience. */
2447 m
= PyImport_AddModule ("__main__");
2451 /* Keep the reference to gdb_python_module since it is in a global
2453 gdb_python_module
= PyImport_ImportModule ("gdb");
2454 if (gdb_python_module
== NULL
)
2456 gdbpy_print_stack ();
2457 /* This is passed in one call to warning so that blank lines aren't
2458 inserted between each line of text. */
2460 "Could not load the Python gdb module from `%s'.\n"
2461 "Limited Python support is available from the _gdb module.\n"
2462 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
2463 gdb_pythondir
.c_str ());
2464 /* We return "success" here as we've already emitted the
2469 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
2472 /* Perform Python initialization. This will be called after GDB has
2473 performed all of its own initialization. This is the
2474 extension_language_ops.initialize "method". */
2477 gdbpy_initialize (const struct extension_language_defn
*extlang
)
2479 if (!do_start_initialization () && PyErr_Occurred ())
2480 gdbpy_print_stack ();
2482 gdbpy_enter enter_py
;
2484 if (!do_initialize (extlang
))
2486 gdbpy_print_stack ();
2487 warning (_("internal error: Unhandled Python exception"));
2491 /* Return non-zero if Python has successfully initialized.
2492 This is the extension_languages_ops.initialized "method". */
2495 gdbpy_initialized (const struct extension_language_defn
*extlang
)
2497 return gdb_python_initialized
;
2500 PyMethodDef python_GdbMethods
[] =
2502 { "history", gdbpy_history
, METH_VARARGS
,
2503 "Get a value from history" },
2504 { "add_history", gdbpy_add_history
, METH_VARARGS
,
2505 "Add a value to the value history list" },
2506 { "history_count", gdbpy_history_count
, METH_NOARGS
,
2507 "Return an integer, the number of values in GDB's value history" },
2508 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
2509 "execute (command [, from_tty] [, to_string]) -> [String]\n\
2510 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
2511 a Python String containing the output of the command if to_string is\n\
2513 { "execute_mi", (PyCFunction
) gdbpy_execute_mi_command
,
2514 METH_VARARGS
| METH_KEYWORDS
,
2515 "execute_mi (command, arg...) -> dictionary\n\
2516 Evaluate command, a string, as a gdb MI command.\n\
2517 Arguments (also strings) are passed to the command." },
2518 { "parameter", gdbpy_parameter
, METH_VARARGS
,
2519 "Return a gdb parameter's value" },
2521 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
2522 "Return a tuple of all breakpoint objects" },
2524 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
2525 "Find the default visualizer for a Value." },
2527 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2528 "Return a sequence of all progspaces." },
2530 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2531 "Return the current Objfile being loaded, or None." },
2533 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2534 "newest_frame () -> gdb.Frame.\n\
2535 Return the newest frame object." },
2536 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2537 "selected_frame () -> gdb.Frame.\n\
2538 Return the selected frame object." },
2539 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2540 "stop_reason_string (Integer) -> String.\n\
2541 Return a string explaining unwind stop reason." },
2543 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2544 "start_recording ([method] [, format]) -> gdb.Record.\n\
2545 Start recording with the given method. If no method is given, will fall back\n\
2546 to the system default method. If no format is given, will fall back to the\n\
2547 default format for the given method."},
2548 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2549 "current_recording () -> gdb.Record.\n\
2550 Return current recording object." },
2551 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2552 "stop_recording () -> None.\n\
2553 Stop current recording." },
2555 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2556 METH_VARARGS
| METH_KEYWORDS
,
2557 "lookup_type (name [, block]) -> type\n\
2558 Return a Type corresponding to the given name." },
2559 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2560 METH_VARARGS
| METH_KEYWORDS
,
2561 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2562 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2563 a boolean indicating if name is a field of the current implied argument\n\
2564 `this' (when the current language is object-oriented)." },
2565 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2566 METH_VARARGS
| METH_KEYWORDS
,
2567 "lookup_global_symbol (name [, domain]) -> symbol\n\
2568 Return the symbol corresponding to the given name (or None)." },
2569 { "lookup_static_symbol", (PyCFunction
) gdbpy_lookup_static_symbol
,
2570 METH_VARARGS
| METH_KEYWORDS
,
2571 "lookup_static_symbol (name [, domain]) -> symbol\n\
2572 Return the static-linkage symbol corresponding to the given name (or None)." },
2573 { "lookup_static_symbols", (PyCFunction
) gdbpy_lookup_static_symbols
,
2574 METH_VARARGS
| METH_KEYWORDS
,
2575 "lookup_static_symbols (name [, domain]) -> symbol\n\
2576 Return a list of all static-linkage symbols corresponding to the given name." },
2578 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2579 METH_VARARGS
| METH_KEYWORDS
,
2580 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2581 Look up the specified objfile.\n\
2582 If by_build_id is True, the objfile is looked up by using name\n\
2583 as its build id." },
2585 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2586 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2587 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2588 The first element contains any unparsed portion of the String parameter\n\
2589 (or None if the string was fully parsed). The second element contains\n\
2590 a tuple that contains all the locations that match, represented as\n\
2591 gdb.Symtab_and_line objects (or None)."},
2592 { "parse_and_eval", (PyCFunction
) gdbpy_parse_and_eval
,
2593 METH_VARARGS
| METH_KEYWORDS
,
2594 "parse_and_eval (String, [Boolean]) -> Value.\n\
2595 Parse String as an expression, evaluate it, and return the result as a Value."
2598 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2599 "Post an event into gdb's event loop." },
2601 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2602 "target_charset () -> string.\n\
2603 Return the name of the current target charset." },
2604 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2605 "target_wide_charset () -> string.\n\
2606 Return the name of the current target wide charset." },
2607 { "host_charset", gdbpy_host_charset
, METH_NOARGS
,
2608 "host_charset () -> string.\n\
2609 Return the name of the current host charset." },
2610 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2611 "rbreak (Regex) -> List.\n\
2612 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2613 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2614 "string_to_argv (String) -> Array.\n\
2615 Parse String and return an argv-like array.\n\
2616 Arguments are separate by spaces and may be quoted."
2618 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2619 "Write a string using gdb's filtered stream." },
2620 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2621 "Flush gdb's filtered stdout stream." },
2622 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2623 "selected_thread () -> gdb.InferiorThread.\n\
2624 Return the selected thread object." },
2625 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2626 "selected_inferior () -> gdb.Inferior.\n\
2627 Return the selected inferior object." },
2628 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2629 "inferiors () -> (gdb.Inferior, ...).\n\
2630 Return a tuple containing all inferiors." },
2632 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2633 "invalidate_cached_frames () -> None.\n\
2634 Invalidate any cached frame objects in gdb.\n\
2635 Intended for internal use only." },
2637 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2638 "convenience_variable (NAME) -> value.\n\
2639 Return the value of the convenience variable $NAME,\n\
2640 or None if not set." },
2641 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2642 "convenience_variable (NAME, VALUE) -> None.\n\
2643 Set the value of the convenience variable $NAME." },
2646 { "register_window_type", (PyCFunction
) gdbpy_register_tui_window
,
2647 METH_VARARGS
| METH_KEYWORDS
,
2648 "register_window_type (NAME, CONSTRUCTOR) -> None\n\
2649 Register a TUI window constructor." },
2652 { "architecture_names", gdbpy_all_architecture_names
, METH_NOARGS
,
2653 "architecture_names () -> List.\n\
2654 Return a list of all the architecture names GDB understands." },
2656 { "connections", gdbpy_connections
, METH_NOARGS
,
2657 "connections () -> List.\n\
2658 Return a list of gdb.TargetConnection objects." },
2660 { "format_address", (PyCFunction
) gdbpy_format_address
,
2661 METH_VARARGS
| METH_KEYWORDS
,
2662 "format_address (ADDRESS, PROG_SPACE, ARCH) -> String.\n\
2663 Format ADDRESS, an address within PROG_SPACE, a gdb.Progspace, using\n\
2664 ARCH, a gdb.Architecture to determine the address size. The format of\n\
2665 the returned string is 'ADDRESS <SYMBOL+OFFSET>' without the quotes." },
2667 { "current_language", gdbpy_current_language
, METH_NOARGS
,
2668 "current_language () -> string\n\
2669 Return the name of the currently selected language." },
2671 { "print_options", gdbpy_print_options
, METH_NOARGS
,
2672 "print_options () -> dict\n\
2673 Return the current print options." },
2675 { "notify_mi", (PyCFunction
) gdbpy_notify_mi
,
2676 METH_VARARGS
| METH_KEYWORDS
,
2677 "notify_mi (name, data) -> None\n\
2678 Output async record to MI channels if any." },
2679 {NULL
, NULL
, 0, NULL
}
2682 /* Define all the event objects. */
2683 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2684 PyTypeObject name##_event_object_type \
2685 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2687 PyVarObject_HEAD_INIT (NULL, 0) \
2688 "gdb." py_name, /* tp_name */ \
2689 sizeof (event_object), /* tp_basicsize */ \
2690 0, /* tp_itemsize */ \
2691 evpy_dealloc, /* tp_dealloc */ \
2693 0, /* tp_getattr */ \
2694 0, /* tp_setattr */ \
2695 0, /* tp_compare */ \
2697 0, /* tp_as_number */ \
2698 0, /* tp_as_sequence */ \
2699 0, /* tp_as_mapping */ \
2703 0, /* tp_getattro */ \
2704 0, /* tp_setattro */ \
2705 0, /* tp_as_buffer */ \
2706 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2708 0, /* tp_traverse */ \
2710 0, /* tp_richcompare */ \
2711 0, /* tp_weaklistoffset */ \
2713 0, /* tp_iternext */ \
2714 0, /* tp_methods */ \
2715 0, /* tp_members */ \
2716 0, /* tp_getset */ \
2717 &base, /* tp_base */ \
2719 0, /* tp_descr_get */ \
2720 0, /* tp_descr_set */ \
2721 0, /* tp_dictoffset */ \
2725 #include "py-event-types.def"
2726 #undef GDB_PY_DEFINE_EVENT_TYPE
2728 #endif /* HAVE_PYTHON */