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 /* A helper class to save and restore the GIL, but without touching
242 the other globals that are handled by gdbpy_enter. */
249 : m_state (PyGILState_Ensure ())
255 PyGILState_Release (m_state
);
258 DISABLE_COPY_AND_ASSIGN (gdbpy_gil
);
262 PyGILState_STATE m_state
;
265 /* Set the quit flag. */
268 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
270 PyErr_SetInterrupt ();
273 /* Return true if the quit flag has been set, false otherwise. */
276 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
278 if (!gdb_python_initialized
)
282 return PyOS_InterruptOccurred ();
285 /* Evaluate a Python command like PyRun_SimpleString, but uses
286 Py_single_input which prints the result of expressions, and does
287 not automatically print the stack on errors. */
290 eval_python_command (const char *command
)
294 m
= PyImport_AddModule ("__main__");
298 d
= PyModule_GetDict (m
);
301 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
313 /* Implementation of the gdb "python-interactive" command. */
316 python_interactive_command (const char *arg
, int from_tty
)
318 struct ui
*ui
= current_ui
;
321 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
323 arg
= skip_spaces (arg
);
325 gdbpy_enter
enter_py (get_current_arch (), current_language
);
329 std::string script
= std::string (arg
) + "\n";
330 err
= eval_python_command (script
.c_str ());
334 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
340 gdbpy_print_stack ();
341 error (_("Error while executing Python code."));
345 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
348 On Windows hosts few users would build Python themselves (this is no
349 trivial task on this platform), and thus use binaries built by
350 someone else instead. There may happen situation where the Python
351 library and GDB are using two different versions of the C runtime
352 library. Python, being built with VC, would use one version of the
353 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
354 A FILE * from one runtime does not necessarily operate correctly in
357 To work around this potential issue, we run code in Python to load
361 python_run_simple_file (FILE *file
, const char *filename
)
365 PyRun_SimpleFile (file
, filename
);
369 /* Because we have a string for a filename, and are using Python to
370 open the file, we need to expand any tilde in the path first. */
371 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
373 if (gdb_python_module
== nullptr
374 || ! PyObject_HasAttrString (gdb_python_module
, "_execute_file"))
375 error (_("Installation error: gdb._execute_file function is missing"));
377 gdbpy_ref
<> return_value
378 (PyObject_CallMethod (gdb_python_module
, "_execute_file", "s",
380 if (return_value
== nullptr)
382 /* Use PyErr_PrintEx instead of gdbpy_print_stack to better match the
383 behavior of the non-Windows codepath. */
390 /* Given a command_line, return a command string suitable for passing
391 to Python. Lines in the string are separated by newlines. */
394 compute_python_string (struct command_line
*l
)
396 struct command_line
*iter
;
399 for (iter
= l
; iter
; iter
= iter
->next
)
401 script
+= iter
->line
;
407 /* Take a command line structure representing a 'python' command, and
408 evaluate its body using the Python interpreter. */
411 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
412 struct command_line
*cmd
)
416 if (cmd
->body_list_1
!= nullptr)
417 error (_("Invalid \"python\" block structure."));
419 gdbpy_enter
enter_py (get_current_arch (), current_language
);
421 std::string script
= compute_python_string (cmd
->body_list_0
.get ());
422 ret
= PyRun_SimpleString (script
.c_str ());
424 error (_("Error while executing Python code."));
427 /* Implementation of the gdb "python" command. */
430 python_command (const char *arg
, int from_tty
)
432 gdbpy_enter
enter_py (get_current_arch (), current_language
);
434 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
436 arg
= skip_spaces (arg
);
439 if (PyRun_SimpleString (arg
))
440 error (_("Error while executing Python code."));
444 counted_command_line l
= get_command_line (python_control
, "");
446 execute_control_command_untraced (l
.get ());
452 /* Transform a gdb parameters's value into a Python value. May return
453 NULL (and set a Python exception) on error. Helper function for
456 gdbpy_parameter_value (enum var_types type
, void *var
)
461 case var_string_noescape
:
462 case var_optional_filename
:
466 const char *str
= *(char **) var
;
470 return host_string_to_python_string (str
).release ();
481 case var_auto_boolean
:
483 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
485 if (ab
== AUTO_BOOLEAN_TRUE
)
487 else if (ab
== AUTO_BOOLEAN_FALSE
)
494 if ((* (int *) var
) == INT_MAX
)
498 case var_zuinteger_unlimited
:
499 return PyLong_FromLong (* (int *) var
);
503 unsigned int val
= * (unsigned int *) var
;
507 return PyLong_FromUnsignedLong (val
);
512 unsigned int val
= * (unsigned int *) var
;
513 return PyLong_FromUnsignedLong (val
);
517 return PyErr_Format (PyExc_RuntimeError
,
518 _("Programmer error: unhandled type."));
521 /* A Python function which returns a gdb parameter's value as a Python
525 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
527 struct cmd_list_element
*alias
, *prefix
, *cmd
;
531 if (! PyArg_ParseTuple (args
, "s", &arg
))
534 std::string newarg
= std::string ("show ") + arg
;
538 found
= lookup_cmd_composition (newarg
.c_str (), &alias
, &prefix
, &cmd
);
540 catch (const gdb_exception
&ex
)
542 GDB_PY_HANDLE_EXCEPTION (ex
);
546 return PyErr_Format (PyExc_RuntimeError
,
547 _("Could not find parameter `%s'."), arg
);
550 return PyErr_Format (PyExc_RuntimeError
,
551 _("`%s' is not a parameter."), arg
);
552 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
555 /* Wrapper for target_charset. */
558 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
560 const char *cset
= target_charset (python_gdbarch
);
562 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
565 /* Wrapper for target_wide_charset. */
568 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
570 const char *cset
= target_wide_charset (python_gdbarch
);
572 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
575 /* A Python function which evaluates a string using the gdb CLI. */
578 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
581 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
582 int from_tty
, to_string
;
583 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
585 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
586 &PyBool_Type
, &from_tty_obj
,
587 &PyBool_Type
, &to_string_obj
))
593 int cmp
= PyObject_IsTrue (from_tty_obj
);
602 int cmp
= PyObject_IsTrue (to_string_obj
);
608 std::string to_string_res
;
610 scoped_restore preventer
= prevent_dont_repeat ();
614 gdbpy_allow_threads allow_threads
;
616 struct interp
*interp
;
618 std::string arg_copy
= arg
;
620 char *save_ptr
= nullptr;
624 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
630 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
633 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
636 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
638 /* Use the console interpreter uiout to have the same print format
639 for console or MI. */
640 interp
= interp_lookup (current_ui
, "console");
641 current_uiout
= interp
->interp_ui_out ();
644 to_string_res
= execute_control_commands_to_string (lines
.get (),
647 execute_control_commands (lines
.get (), from_tty
);
650 /* Do any commands attached to breakpoint we stopped at. */
651 bpstat_do_actions ();
653 catch (const gdb_exception
&except
)
655 /* If an exception occurred then we won't hit normal_stop (), or have
656 an exception reach the top level of the event loop, which are the
657 two usual places in which stdin would be re-enabled. So, before we
658 convert the exception and continue back in Python, we should
659 re-enable stdin here. */
660 async_enable_stdin ();
661 GDB_PY_HANDLE_EXCEPTION (except
);
665 return PyString_FromString (to_string_res
.c_str ());
669 /* Implementation of Python rbreak command. Take a REGEX and
670 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
671 Python list that contains newly set breakpoints that match that
672 criteria. REGEX refers to a GDB format standard regex pattern of
673 symbols names to search; MINSYMS is an optional boolean (default
674 False) that indicates if the function should search GDB's minimal
675 symbols; THROTTLE is an optional integer (default unlimited) that
676 indicates the maximum amount of breakpoints allowable before the
677 function exits (note, if the throttle bound is passed, no
678 breakpoints will be set and a runtime error returned); SYMTABS is
679 an optional Python iterable that contains a set of gdb.Symtabs to
680 constrain the search within. */
683 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
686 std::vector
<symbol_search
> symbols
;
687 unsigned long count
= 0;
688 PyObject
*symtab_list
= NULL
;
689 PyObject
*minsyms_p_obj
= NULL
;
691 unsigned int throttle
= 0;
692 static const char *keywords
[] = {"regex","minsyms", "throttle",
695 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
696 ®ex
, &PyBool_Type
,
697 &minsyms_p_obj
, &throttle
,
701 /* Parse minsyms keyword. */
702 if (minsyms_p_obj
!= NULL
)
704 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
710 global_symbol_searcher
spec (FUNCTIONS_DOMAIN
, regex
);
712 for (const char *elem
: spec
.filenames
)
713 xfree ((void *) elem
);
716 /* The "symtabs" keyword is any Python iterable object that returns
717 a gdb.Symtab on each iteration. If specified, iterate through
718 the provided gdb.Symtabs and extract their full path. As
719 python_string_to_target_string returns a
720 gdb::unique_xmalloc_ptr<char> and a vector containing these types
721 cannot be coerced to a const char **p[] via the vector.data call,
722 release the value from the unique_xmalloc_ptr and place it in a
723 simple type symtab_list_type (which holds the vector and a
724 destructor that frees the contents of the allocated strings. */
725 if (symtab_list
!= NULL
)
727 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
734 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
738 if (PyErr_Occurred ())
743 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
746 if (obj_name
== NULL
)
749 /* Is the object file still valid? */
750 if (obj_name
== Py_None
)
753 gdb::unique_xmalloc_ptr
<char> filename
=
754 python_string_to_target_string (obj_name
.get ());
756 if (filename
== NULL
)
759 /* Make sure there is a definite place to store the value of
760 filename before it is released. */
761 spec
.filenames
.push_back (nullptr);
762 spec
.filenames
.back () = filename
.release ();
766 /* The search spec. */
767 symbols
= spec
.search ();
769 /* Count the number of symbols (both symbols and optionally minimal
770 symbols) so we can correctly check the throttle limit. */
771 for (const symbol_search
&p
: symbols
)
773 /* Minimal symbols included? */
776 if (p
.msymbol
.minsym
!= NULL
)
780 if (p
.symbol
!= NULL
)
784 /* Check throttle bounds and exit if in excess. */
785 if (throttle
!= 0 && count
> throttle
)
787 PyErr_SetString (PyExc_RuntimeError
,
788 _("Number of breakpoints exceeds throttled maximum."));
792 gdbpy_ref
<> return_list (PyList_New (0));
794 if (return_list
== NULL
)
797 /* Construct full path names for symbols and call the Python
798 breakpoint constructor on the resulting names. Be tolerant of
799 individual breakpoint failures. */
800 for (const symbol_search
&p
: symbols
)
802 std::string symbol_name
;
804 /* Skipping minimal symbols? */
806 if (p
.msymbol
.minsym
!= NULL
)
809 if (p
.msymbol
.minsym
== NULL
)
811 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
812 const char *fullname
= symtab_to_fullname (symtab
);
814 symbol_name
= fullname
;
816 symbol_name
+= p
.symbol
->linkage_name ();
819 symbol_name
= p
.msymbol
.minsym
->linkage_name ();
821 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
822 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
823 &breakpoint_object_type
,
826 /* Tolerate individual breakpoint failures. */
828 gdbpy_print_stack ();
831 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
835 return return_list
.release ();
838 /* A Python function which is a wrapper for decode_line_1. */
841 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
843 const char *arg
= NULL
;
845 gdbpy_ref
<> unparsed
;
846 event_location_up location
;
848 if (! PyArg_ParseTuple (args
, "|s", &arg
))
851 /* Treat a string consisting of just whitespace the same as
855 arg
= skip_spaces (arg
);
861 location
= string_to_event_location_basic (&arg
, python_language
,
862 symbol_name_match_type::WILD
);
864 std::vector
<symtab_and_line
> decoded_sals
;
865 symtab_and_line def_sal
;
866 gdb::array_view
<symtab_and_line
> sals
;
869 if (location
!= NULL
)
871 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
876 set_default_source_symtab_and_line ();
877 def_sal
= get_current_source_symtab_and_line ();
881 catch (const gdb_exception
&ex
)
883 /* We know this will always throw. */
884 gdbpy_convert_exception (ex
);
890 result
.reset (PyTuple_New (sals
.size ()));
893 for (size_t i
= 0; i
< sals
.size (); ++i
)
895 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
899 PyTuple_SetItem (result
.get (), i
, obj
);
903 result
= gdbpy_ref
<>::new_reference (Py_None
);
905 gdbpy_ref
<> return_result (PyTuple_New (2));
906 if (return_result
== NULL
)
909 if (arg
!= NULL
&& strlen (arg
) > 0)
911 unparsed
.reset (PyString_FromString (arg
));
912 if (unparsed
== NULL
)
916 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
918 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
919 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
921 return return_result
.release ();
924 /* Parse a string and evaluate it as an expression. */
926 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
928 const char *expr_str
;
929 struct value
*result
= NULL
;
931 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
936 gdbpy_allow_threads allow_threads
;
937 result
= parse_and_eval (expr_str
);
939 catch (const gdb_exception
&except
)
941 GDB_PY_HANDLE_EXCEPTION (except
);
944 return value_to_value_object (result
);
947 /* Implementation of gdb.invalidate_cached_frames. */
950 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
952 reinit_frame_cache ();
956 /* Read a file as Python code.
957 This is the extension_language_script_ops.script_sourcer "method".
958 FILE is the file to load. FILENAME is name of the file FILE.
959 This does not throw any errors. If an exception occurs python will print
960 the traceback and clear the error indicator. */
963 gdbpy_source_script (const struct extension_language_defn
*extlang
,
964 FILE *file
, const char *filename
)
966 gdbpy_enter
enter_py (get_current_arch (), current_language
);
967 python_run_simple_file (file
, filename
);
972 /* Posting and handling events. */
974 /* A single event. */
977 gdbpy_event (gdbpy_ref
<> &&func
)
978 : m_func (func
.release ())
982 gdbpy_event (gdbpy_event
&&other
) noexcept
983 : m_func (other
.m_func
)
985 other
.m_func
= nullptr;
988 gdbpy_event (const gdbpy_event
&other
)
989 : m_func (other
.m_func
)
1001 gdbpy_event
&operator= (const gdbpy_event
&other
) = delete;
1005 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1007 gdbpy_ref
<> call_result (PyObject_CallObject (m_func
, NULL
));
1008 if (call_result
== NULL
)
1009 gdbpy_print_stack ();
1014 /* The Python event. This is just a callable object. Note that
1015 this is not a gdbpy_ref<>, because we have to take particular
1016 care to only destroy the reference when holding the GIL. */
1020 /* Submit an event to the gdb thread. */
1022 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1026 if (!PyArg_ParseTuple (args
, "O", &func
))
1029 if (!PyCallable_Check (func
))
1031 PyErr_SetString (PyExc_RuntimeError
,
1032 _("Posted event is not callable"));
1036 gdbpy_ref
<> func_ref
= gdbpy_ref
<>::new_reference (func
);
1037 gdbpy_event
event (std::move (func_ref
));
1038 run_on_main_thread (event
);
1045 /* This is the extension_language_ops.before_prompt "method". */
1047 static enum ext_lang_rc
1048 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1049 const char *current_gdb_prompt
)
1051 if (!gdb_python_initialized
)
1052 return EXT_LANG_RC_NOP
;
1054 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1056 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1057 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1058 return EXT_LANG_RC_ERROR
;
1060 if (gdb_python_module
1061 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1063 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1067 gdbpy_print_stack ();
1068 return EXT_LANG_RC_ERROR
;
1071 if (PyCallable_Check (hook
.get ()))
1073 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1074 if (current_prompt
== NULL
)
1076 gdbpy_print_stack ();
1077 return EXT_LANG_RC_ERROR
;
1081 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1085 gdbpy_print_stack ();
1086 return EXT_LANG_RC_ERROR
;
1089 /* Return type should be None, or a String. If it is None,
1090 fall through, we will not set a prompt. If it is a
1091 string, set PROMPT. Anything else, set an exception. */
1092 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1094 PyErr_Format (PyExc_RuntimeError
,
1095 _("Return from prompt_hook must " \
1096 "be either a Python string, or None"));
1097 gdbpy_print_stack ();
1098 return EXT_LANG_RC_ERROR
;
1101 if (result
!= Py_None
)
1103 gdb::unique_xmalloc_ptr
<char>
1104 prompt (python_string_to_host_string (result
.get ()));
1108 gdbpy_print_stack ();
1109 return EXT_LANG_RC_ERROR
;
1112 set_prompt (prompt
.get ());
1113 return EXT_LANG_RC_OK
;
1118 return EXT_LANG_RC_NOP
;
1121 /* This is the extension_language_ops.colorize "method". */
1123 static gdb::optional
<std::string
>
1124 gdbpy_colorize (const std::string
&filename
, const std::string
&contents
)
1126 if (!gdb_python_initialized
)
1129 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1131 if (gdb_python_module
== nullptr
1132 || !PyObject_HasAttrString (gdb_python_module
, "colorize"))
1135 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
, "colorize"));
1136 if (hook
== nullptr)
1138 gdbpy_print_stack ();
1142 if (!PyCallable_Check (hook
.get ()))
1145 gdbpy_ref
<> fname_arg (PyString_FromString (filename
.c_str ()));
1146 if (fname_arg
== nullptr)
1148 gdbpy_print_stack ();
1151 gdbpy_ref
<> contents_arg (PyString_FromString (contents
.c_str ()));
1152 if (contents_arg
== nullptr)
1154 gdbpy_print_stack ();
1158 gdbpy_ref
<> result (PyObject_CallFunctionObjArgs (hook
.get (),
1160 contents_arg
.get (),
1162 if (result
== nullptr)
1164 gdbpy_print_stack ();
1168 if (!gdbpy_is_string (result
.get ()))
1171 gdbpy_ref
<> unic
= python_string_to_unicode (result
.get ());
1172 if (unic
== nullptr)
1174 gdbpy_print_stack ();
1177 gdbpy_ref
<> host_str (PyUnicode_AsEncodedString (unic
.get (),
1180 if (host_str
== nullptr)
1182 gdbpy_print_stack ();
1186 return std::string (PyBytes_AsString (host_str
.get ()));
1193 /* A python function to write a single string using gdb's filtered
1194 output stream . The optional keyword STREAM can be used to write
1195 to a particular stream. The default stream is to gdb_stdout. */
1198 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1201 static const char *keywords
[] = { "text", "stream", NULL
};
1202 int stream_type
= 0;
1204 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1210 switch (stream_type
)
1214 fprintf_filtered (gdb_stderr
, "%s", arg
);
1219 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1223 fprintf_filtered (gdb_stdout
, "%s", arg
);
1226 catch (const gdb_exception
&except
)
1228 GDB_PY_HANDLE_EXCEPTION (except
);
1234 /* A python function to flush a gdb stream. The optional keyword
1235 STREAM can be used to flush a particular stream. The default stream
1239 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1241 static const char *keywords
[] = { "stream", NULL
};
1242 int stream_type
= 0;
1244 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1248 switch (stream_type
)
1252 gdb_flush (gdb_stderr
);
1257 gdb_flush (gdb_stdlog
);
1261 gdb_flush (gdb_stdout
);
1267 /* Return non-zero if print-stack is not "none". */
1270 gdbpy_print_python_errors_p (void)
1272 return gdbpy_should_print_stack
!= python_excp_none
;
1275 /* Print a python exception trace, print just a message, or print
1276 nothing and clear the python exception, depending on
1277 gdbpy_should_print_stack. Only call this if a python exception is
1280 gdbpy_print_stack (void)
1283 /* Print "none", just clear exception. */
1284 if (gdbpy_should_print_stack
== python_excp_none
)
1288 /* Print "full" message and backtrace. */
1289 else if (gdbpy_should_print_stack
== python_excp_full
)
1292 /* PyErr_Print doesn't necessarily end output with a newline.
1293 This works because Python's stdout/stderr is fed through
1299 catch (const gdb_exception
&except
)
1303 /* Print "message", just error print message. */
1306 gdbpy_err_fetch fetched_error
;
1308 gdb::unique_xmalloc_ptr
<char> msg
= fetched_error
.to_string ();
1309 gdb::unique_xmalloc_ptr
<char> type
;
1310 /* Don't compute TYPE if MSG already indicates that there is an
1313 type
= fetched_error
.type_to_string ();
1317 if (msg
== NULL
|| type
== NULL
)
1319 /* An error occurred computing the string representation of the
1321 fprintf_filtered (gdb_stderr
,
1322 _("Error occurred computing Python error" \
1327 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1328 type
.get (), msg
.get ());
1330 catch (const gdb_exception
&except
)
1336 /* Like gdbpy_print_stack, but if the exception is a
1337 KeyboardException, throw a gdb "quit" instead. */
1340 gdbpy_print_stack_or_quit ()
1342 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1345 throw_quit ("Quit");
1347 gdbpy_print_stack ();
1352 /* Return a sequence holding all the Progspaces. */
1355 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1357 gdbpy_ref
<> list (PyList_New (0));
1361 for (struct program_space
*ps
: program_spaces
)
1363 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1365 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1369 return list
.release ();
1374 /* The "current" objfile. This is set when gdb detects that a new
1375 objfile has been loaded. It is only set for the duration of a call to
1376 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1378 static struct objfile
*gdbpy_current_objfile
;
1380 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1381 as Python code. This does not throw any errors. If an exception
1382 occurs python will print the traceback and clear the error indicator.
1383 This is the extension_language_script_ops.objfile_script_sourcer
1387 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1388 struct objfile
*objfile
, FILE *file
,
1389 const char *filename
)
1391 if (!gdb_python_initialized
)
1394 gdbpy_enter
enter_py (objfile
->arch (), current_language
);
1395 gdbpy_current_objfile
= objfile
;
1397 python_run_simple_file (file
, filename
);
1399 gdbpy_current_objfile
= NULL
;
1402 /* Set the current objfile to OBJFILE and then execute SCRIPT
1403 as Python code. This does not throw any errors. If an exception
1404 occurs python will print the traceback and clear the error indicator.
1405 This is the extension_language_script_ops.objfile_script_executor
1409 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1410 struct objfile
*objfile
, const char *name
,
1413 if (!gdb_python_initialized
)
1416 gdbpy_enter
enter_py (objfile
->arch (), current_language
);
1417 gdbpy_current_objfile
= objfile
;
1419 PyRun_SimpleString (script
);
1421 gdbpy_current_objfile
= NULL
;
1424 /* Return the current Objfile, or None if there isn't one. */
1427 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1429 if (! gdbpy_current_objfile
)
1432 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1435 /* Compute the list of active python type printers and store them in
1436 EXT_PRINTERS->py_type_printers. The product of this function is used by
1437 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1438 This is the extension_language_ops.start_type_printers "method". */
1441 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1442 struct ext_lang_type_printers
*ext_printers
)
1444 PyObject
*printers_obj
= NULL
;
1446 if (!gdb_python_initialized
)
1449 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1451 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1452 if (type_module
== NULL
)
1454 gdbpy_print_stack ();
1458 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1459 "get_type_recognizers"));
1462 gdbpy_print_stack ();
1466 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1467 if (printers_obj
== NULL
)
1468 gdbpy_print_stack ();
1470 ext_printers
->py_type_printers
= printers_obj
;
1473 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1474 a newly allocated string holding the type's replacement name, and return
1475 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1476 If there's a Python error return EXT_LANG_RC_ERROR.
1477 Otherwise, return EXT_LANG_RC_NOP.
1478 This is the extension_language_ops.apply_type_printers "method". */
1480 static enum ext_lang_rc
1481 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1482 const struct ext_lang_type_printers
*ext_printers
,
1483 struct type
*type
, char **prettied_type
)
1485 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1486 gdb::unique_xmalloc_ptr
<char> result
;
1488 if (printers_obj
== NULL
)
1489 return EXT_LANG_RC_NOP
;
1491 if (!gdb_python_initialized
)
1492 return EXT_LANG_RC_NOP
;
1494 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1496 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1497 if (type_obj
== NULL
)
1499 gdbpy_print_stack ();
1500 return EXT_LANG_RC_ERROR
;
1503 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1504 if (type_module
== NULL
)
1506 gdbpy_print_stack ();
1507 return EXT_LANG_RC_ERROR
;
1510 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1511 "apply_type_recognizers"));
1514 gdbpy_print_stack ();
1515 return EXT_LANG_RC_ERROR
;
1518 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1522 if (result_obj
== NULL
)
1524 gdbpy_print_stack ();
1525 return EXT_LANG_RC_ERROR
;
1528 if (result_obj
== Py_None
)
1529 return EXT_LANG_RC_NOP
;
1531 result
= python_string_to_host_string (result_obj
.get ());
1534 gdbpy_print_stack ();
1535 return EXT_LANG_RC_ERROR
;
1538 *prettied_type
= result
.release ();
1539 return EXT_LANG_RC_OK
;
1542 /* Free the result of start_type_printers.
1543 This is the extension_language_ops.free_type_printers "method". */
1546 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1547 struct ext_lang_type_printers
*ext_printers
)
1549 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1551 if (printers
== NULL
)
1554 if (!gdb_python_initialized
)
1557 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1558 Py_DECREF (printers
);
1561 #else /* HAVE_PYTHON */
1563 /* Dummy implementation of the gdb "python-interactive" and "python"
1567 python_interactive_command (const char *arg
, int from_tty
)
1569 arg
= skip_spaces (arg
);
1571 error (_("Python scripting is not supported in this copy of GDB."));
1574 counted_command_line l
= get_command_line (python_control
, "");
1576 execute_control_command_untraced (l
.get ());
1581 python_command (const char *arg
, int from_tty
)
1583 python_interactive_command (arg
, from_tty
);
1586 #endif /* HAVE_PYTHON */
1590 /* Lists for 'set python' commands. */
1592 static struct cmd_list_element
*user_set_python_list
;
1593 static struct cmd_list_element
*user_show_python_list
;
1595 /* Initialize the Python code. */
1599 /* This is installed as a final cleanup and cleans up the
1600 interpreter. This lets Python's 'atexit' work. */
1603 finalize_python (void *ignore
)
1605 struct active_ext_lang_state
*previous_active
;
1607 /* We don't use ensure_python_env here because if we ever ran the
1608 cleanup, gdb would crash -- because the cleanup calls into the
1609 Python interpreter, which we are about to destroy. It seems
1610 clearer to make the needed calls explicitly here than to create a
1611 cleanup and then mysteriously discard it. */
1613 /* This is only called as a final cleanup so we can assume the active
1614 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1615 previous_active
= set_active_ext_lang (&extension_language_python
);
1617 (void) PyGILState_Ensure ();
1618 python_gdbarch
= target_gdbarch ();
1619 python_language
= current_language
;
1623 gdb_python_initialized
= false;
1624 restore_active_ext_lang (previous_active
);
1628 /* This is called via the PyImport_AppendInittab mechanism called
1629 during initialization, to make the built-in _gdb module known to
1631 PyMODINIT_FUNC
init__gdb_module (void);
1633 init__gdb_module (void)
1635 return PyModule_Create (&python_GdbModuleDef
);
1640 do_start_initialization ()
1643 size_t progsize
, count
;
1644 /* Python documentation indicates that the memory given
1645 to Py_SetProgramName cannot be freed. However, it seems that
1646 at least Python 3.7.4 Py_SetProgramName takes a copy of the
1647 given program_name. Making progname_copy static and not release
1648 the memory avoids a leak report for Python versions that duplicate
1649 program_name, and respect the requirement of Py_SetProgramName
1650 for Python versions that do not duplicate program_name. */
1651 static wchar_t *progname_copy
;
1654 #ifdef WITH_PYTHON_PATH
1655 /* Work around problem where python gets confused about where it is,
1656 and then can't find its libraries, etc.
1657 NOTE: Python assumes the following layout:
1659 /foo/lib/pythonX.Y/...
1660 This must be done before calling Py_Initialize. */
1661 gdb::unique_xmalloc_ptr
<char> progname
1662 (concat (ldirname (python_libdir
.c_str ()).c_str (), SLASH_STRING
, "bin",
1663 SLASH_STRING
, "python", (char *) NULL
));
1665 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1666 setlocale (LC_ALL
, "");
1667 progsize
= strlen (progname
.get ());
1668 progname_copy
= XNEWVEC (wchar_t, progsize
+ 1);
1669 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1670 if (count
== (size_t) -1)
1672 fprintf (stderr
, "Could not convert python path to string\n");
1675 setlocale (LC_ALL
, oldloc
.c_str ());
1677 /* Note that Py_SetProgramName expects the string it is passed to
1678 remain alive for the duration of the program's execution, so
1679 it is not freed after this call. */
1680 Py_SetProgramName (progname_copy
);
1682 /* Define _gdb as a built-in module. */
1683 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1685 Py_SetProgramName (progname
.release ());
1690 #if PY_VERSION_HEX < 0x03090000
1691 /* PyEval_InitThreads became deprecated in Python 3.9 and will
1692 be removed in Python 3.11. Prior to Python 3.7, this call was
1693 required to initialize the GIL. */
1694 PyEval_InitThreads ();
1698 gdb_module
= PyImport_ImportModule ("_gdb");
1700 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1702 if (gdb_module
== NULL
)
1705 if (PyModule_AddStringConstant (gdb_module
, "VERSION", version
) < 0
1706 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", host_name
) < 0
1707 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1711 /* Add stream constants. */
1712 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1713 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1714 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1717 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1718 if (gdbpy_gdb_error
== NULL
1719 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1722 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1723 gdbpy_gdb_error
, NULL
);
1724 if (gdbpy_gdb_memory_error
== NULL
1725 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1726 gdbpy_gdb_memory_error
) < 0)
1729 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1730 if (gdbpy_gdberror_exc
== NULL
1731 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1732 gdbpy_gdberror_exc
) < 0)
1735 gdbpy_initialize_gdb_readline ();
1737 if (gdbpy_initialize_auto_load () < 0
1738 || gdbpy_initialize_values () < 0
1739 || gdbpy_initialize_frames () < 0
1740 || gdbpy_initialize_commands () < 0
1741 || gdbpy_initialize_instruction () < 0
1742 || gdbpy_initialize_record () < 0
1743 || gdbpy_initialize_btrace () < 0
1744 || gdbpy_initialize_symbols () < 0
1745 || gdbpy_initialize_symtabs () < 0
1746 || gdbpy_initialize_blocks () < 0
1747 || gdbpy_initialize_functions () < 0
1748 || gdbpy_initialize_parameters () < 0
1749 || gdbpy_initialize_types () < 0
1750 || gdbpy_initialize_pspace () < 0
1751 || gdbpy_initialize_objfile () < 0
1752 || gdbpy_initialize_breakpoints () < 0
1753 || gdbpy_initialize_finishbreakpoints () < 0
1754 || gdbpy_initialize_lazy_string () < 0
1755 || gdbpy_initialize_linetable () < 0
1756 || gdbpy_initialize_thread () < 0
1757 || gdbpy_initialize_inferior () < 0
1758 || gdbpy_initialize_eventregistry () < 0
1759 || gdbpy_initialize_py_events () < 0
1760 || gdbpy_initialize_event () < 0
1761 || gdbpy_initialize_arch () < 0
1762 || gdbpy_initialize_registers () < 0
1763 || gdbpy_initialize_xmethods () < 0
1764 || gdbpy_initialize_unwind () < 0
1765 || gdbpy_initialize_tui () < 0)
1768 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1769 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1771 #include "py-event-types.def"
1772 #undef GDB_PY_DEFINE_EVENT_TYPE
1774 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1775 if (gdbpy_to_string_cst
== NULL
)
1777 gdbpy_children_cst
= PyString_FromString ("children");
1778 if (gdbpy_children_cst
== NULL
)
1780 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1781 if (gdbpy_display_hint_cst
== NULL
)
1783 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1784 if (gdbpy_doc_cst
== NULL
)
1786 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1787 if (gdbpy_enabled_cst
== NULL
)
1789 gdbpy_value_cst
= PyString_FromString ("value");
1790 if (gdbpy_value_cst
== NULL
)
1793 /* Release the GIL while gdb runs. */
1794 PyEval_SaveThread ();
1796 make_final_cleanup (finalize_python
, NULL
);
1798 /* Only set this when initialization has succeeded. */
1799 gdb_python_initialized
= 1;
1803 #endif /* HAVE_PYTHON */
1806 cmd_list_element
*python_cmd_element
= nullptr;
1808 void _initialize_python ();
1810 _initialize_python ()
1812 add_com ("python-interactive", class_obscure
,
1813 python_interactive_command
,
1816 Start an interactive Python prompt.\n\
1818 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1821 Alternatively, a single-line Python command can be given as an\n\
1822 argument, and if the command is an expression, the result will be\n\
1823 printed. For example:\n\
1825 (gdb) python-interactive 2 + 3\n\
1827 #else /* HAVE_PYTHON */
1829 Start a Python interactive prompt.\n\
1831 Python scripting is not supported in this copy of GDB.\n\
1832 This command is only a placeholder.")
1833 #endif /* HAVE_PYTHON */
1835 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1837 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1840 Evaluate a Python command.\n\
1842 The command can be given as an argument, for instance:\n\
1844 python print (23)\n\
1846 If no argument is given, the following lines are read and used\n\
1847 as the Python commands. Type a line containing \"end\" to indicate\n\
1848 the end of the command.")
1849 #else /* HAVE_PYTHON */
1851 Evaluate a Python command.\n\
1853 Python scripting is not supported in this copy of GDB.\n\
1854 This command is only a placeholder.")
1855 #endif /* HAVE_PYTHON */
1857 add_com_alias ("py", "python", class_obscure
, 1);
1859 /* Add set/show python print-stack. */
1860 add_basic_prefix_cmd ("python", no_class
,
1861 _("Prefix command for python preference settings."),
1862 &user_show_python_list
, "show python ", 0,
1865 add_show_prefix_cmd ("python", no_class
,
1866 _("Prefix command for python preference settings."),
1867 &user_set_python_list
, "set python ", 0,
1870 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1871 &gdbpy_should_print_stack
, _("\
1872 Set mode for Python stack dump on error."), _("\
1873 Show the mode of Python stack printing on error."), _("\
1874 none == no stack or message will be printed.\n\
1875 full == a message and a stack will be printed.\n\
1876 message == an error message without a stack will be printed."),
1878 &user_set_python_list
,
1879 &user_show_python_list
);
1882 if (!do_start_initialization () && PyErr_Occurred ())
1883 gdbpy_print_stack ();
1884 #endif /* HAVE_PYTHON */
1889 /* Helper function for gdbpy_finish_initialization. This does the
1890 work and then returns false if an error has occurred and must be
1891 displayed, or true on success. */
1894 do_finish_initialization (const struct extension_language_defn
*extlang
)
1899 /* Add the initial data-directory to sys.path. */
1901 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1904 sys_path
= PySys_GetObject ("path");
1906 /* If sys.path is not defined yet, define it first. */
1907 if (!(sys_path
&& PyList_Check (sys_path
)))
1910 PySys_SetPath (L
"");
1914 sys_path
= PySys_GetObject ("path");
1916 if (sys_path
&& PyList_Check (sys_path
))
1918 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1919 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1925 /* Import the gdb module to finish the initialization, and
1926 add it to __main__ for convenience. */
1927 m
= PyImport_AddModule ("__main__");
1931 /* Keep the reference to gdb_python_module since it is in a global
1933 gdb_python_module
= PyImport_ImportModule ("gdb");
1934 if (gdb_python_module
== NULL
)
1936 gdbpy_print_stack ();
1937 /* This is passed in one call to warning so that blank lines aren't
1938 inserted between each line of text. */
1940 "Could not load the Python gdb module from `%s'.\n"
1941 "Limited Python support is available from the _gdb module.\n"
1942 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
1943 gdb_pythondir
.c_str ());
1944 /* We return "success" here as we've already emitted the
1949 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1952 /* Perform the remaining python initializations.
1953 These must be done after GDB is at least mostly initialized.
1954 E.g., The "info pretty-printer" command needs the "info" prefix
1956 This is the extension_language_ops.finish_initialization "method". */
1959 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1961 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1963 if (!do_finish_initialization (extlang
))
1965 gdbpy_print_stack ();
1966 warning (_("internal error: Unhandled Python exception"));
1970 /* Return non-zero if Python has successfully initialized.
1971 This is the extension_languages_ops.initialized "method". */
1974 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1976 return gdb_python_initialized
;
1979 #endif /* HAVE_PYTHON */
1985 PyMethodDef python_GdbMethods
[] =
1987 { "history", gdbpy_history
, METH_VARARGS
,
1988 "Get a value from history" },
1989 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1990 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1991 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1992 a Python String containing the output of the command if to_string is\n\
1994 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1995 "Return a gdb parameter's value" },
1997 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1998 "Return a tuple of all breakpoint objects" },
2000 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
2001 "Find the default visualizer for a Value." },
2003 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2004 "Return a sequence of all progspaces." },
2006 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2007 "Return the current Objfile being loaded, or None." },
2009 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2010 "newest_frame () -> gdb.Frame.\n\
2011 Return the newest frame object." },
2012 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2013 "selected_frame () -> gdb.Frame.\n\
2014 Return the selected frame object." },
2015 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2016 "stop_reason_string (Integer) -> String.\n\
2017 Return a string explaining unwind stop reason." },
2019 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2020 "start_recording ([method] [, format]) -> gdb.Record.\n\
2021 Start recording with the given method. If no method is given, will fall back\n\
2022 to the system default method. If no format is given, will fall back to the\n\
2023 default format for the given method."},
2024 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2025 "current_recording () -> gdb.Record.\n\
2026 Return current recording object." },
2027 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2028 "stop_recording () -> None.\n\
2029 Stop current recording." },
2031 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2032 METH_VARARGS
| METH_KEYWORDS
,
2033 "lookup_type (name [, block]) -> type\n\
2034 Return a Type corresponding to the given name." },
2035 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2036 METH_VARARGS
| METH_KEYWORDS
,
2037 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2038 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2039 a boolean indicating if name is a field of the current implied argument\n\
2040 `this' (when the current language is object-oriented)." },
2041 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2042 METH_VARARGS
| METH_KEYWORDS
,
2043 "lookup_global_symbol (name [, domain]) -> symbol\n\
2044 Return the symbol corresponding to the given name (or None)." },
2045 { "lookup_static_symbol", (PyCFunction
) gdbpy_lookup_static_symbol
,
2046 METH_VARARGS
| METH_KEYWORDS
,
2047 "lookup_static_symbol (name [, domain]) -> symbol\n\
2048 Return the static-linkage symbol corresponding to the given name (or None)." },
2049 { "lookup_static_symbols", (PyCFunction
) gdbpy_lookup_static_symbols
,
2050 METH_VARARGS
| METH_KEYWORDS
,
2051 "lookup_static_symbols (name [, domain]) -> symbol\n\
2052 Return a list of all static-linkage symbols corresponding to the given name." },
2054 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2055 METH_VARARGS
| METH_KEYWORDS
,
2056 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2057 Look up the specified objfile.\n\
2058 If by_build_id is True, the objfile is looked up by using name\n\
2059 as its build id." },
2061 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2062 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2063 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2064 The first element contains any unparsed portion of the String parameter\n\
2065 (or None if the string was fully parsed). The second element contains\n\
2066 a tuple that contains all the locations that match, represented as\n\
2067 gdb.Symtab_and_line objects (or None)."},
2068 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2069 "parse_and_eval (String) -> Value.\n\
2070 Parse String as an expression, evaluate it, and return the result as a Value."
2073 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2074 "Post an event into gdb's event loop." },
2076 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2077 "target_charset () -> string.\n\
2078 Return the name of the current target charset." },
2079 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2080 "target_wide_charset () -> string.\n\
2081 Return the name of the current target wide charset." },
2082 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2083 "rbreak (Regex) -> List.\n\
2084 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2085 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2086 "string_to_argv (String) -> Array.\n\
2087 Parse String and return an argv-like array.\n\
2088 Arguments are separate by spaces and may be quoted."
2090 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2091 "Write a string using gdb's filtered stream." },
2092 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2093 "Flush gdb's filtered stdout stream." },
2094 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2095 "selected_thread () -> gdb.InferiorThread.\n\
2096 Return the selected thread object." },
2097 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2098 "selected_inferior () -> gdb.Inferior.\n\
2099 Return the selected inferior object." },
2100 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2101 "inferiors () -> (gdb.Inferior, ...).\n\
2102 Return a tuple containing all inferiors." },
2104 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2105 "invalidate_cached_frames () -> None.\n\
2106 Invalidate any cached frame objects in gdb.\n\
2107 Intended for internal use only." },
2109 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2110 "convenience_variable (NAME) -> value.\n\
2111 Return the value of the convenience variable $NAME,\n\
2112 or None if not set." },
2113 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2114 "convenience_variable (NAME, VALUE) -> None.\n\
2115 Set the value of the convenience variable $NAME." },
2118 { "register_window_type", (PyCFunction
) gdbpy_register_tui_window
,
2119 METH_VARARGS
| METH_KEYWORDS
,
2120 "register_window_type (NAME, CONSTRUCSTOR) -> None\n\
2121 Register a TUI window constructor." },
2124 {NULL
, NULL
, 0, NULL
}
2128 struct PyModuleDef python_GdbModuleDef
=
2130 PyModuleDef_HEAD_INIT
,
2142 /* Define all the event objects. */
2143 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2144 PyTypeObject name##_event_object_type \
2145 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2147 PyVarObject_HEAD_INIT (NULL, 0) \
2148 "gdb." py_name, /* tp_name */ \
2149 sizeof (event_object), /* tp_basicsize */ \
2150 0, /* tp_itemsize */ \
2151 evpy_dealloc, /* tp_dealloc */ \
2153 0, /* tp_getattr */ \
2154 0, /* tp_setattr */ \
2155 0, /* tp_compare */ \
2157 0, /* tp_as_number */ \
2158 0, /* tp_as_sequence */ \
2159 0, /* tp_as_mapping */ \
2163 0, /* tp_getattro */ \
2164 0, /* tp_setattro */ \
2165 0, /* tp_as_buffer */ \
2166 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2168 0, /* tp_traverse */ \
2170 0, /* tp_richcompare */ \
2171 0, /* tp_weaklistoffset */ \
2173 0, /* tp_iternext */ \
2174 0, /* tp_methods */ \
2175 0, /* tp_members */ \
2176 0, /* tp_getset */ \
2177 &base, /* tp_base */ \
2179 0, /* tp_descr_get */ \
2180 0, /* tp_descr_set */ \
2181 0, /* tp_dictoffset */ \
2185 #include "py-event-types.def"
2186 #undef GDB_PY_DEFINE_EVENT_TYPE
2188 #endif /* HAVE_PYTHON */