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_xmethods () < 0
1763 || gdbpy_initialize_unwind () < 0
1764 || gdbpy_initialize_tui () < 0)
1767 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1768 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1770 #include "py-event-types.def"
1771 #undef GDB_PY_DEFINE_EVENT_TYPE
1773 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1774 if (gdbpy_to_string_cst
== NULL
)
1776 gdbpy_children_cst
= PyString_FromString ("children");
1777 if (gdbpy_children_cst
== NULL
)
1779 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1780 if (gdbpy_display_hint_cst
== NULL
)
1782 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1783 if (gdbpy_doc_cst
== NULL
)
1785 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1786 if (gdbpy_enabled_cst
== NULL
)
1788 gdbpy_value_cst
= PyString_FromString ("value");
1789 if (gdbpy_value_cst
== NULL
)
1792 /* Release the GIL while gdb runs. */
1793 PyEval_SaveThread ();
1795 make_final_cleanup (finalize_python
, NULL
);
1797 /* Only set this when initialization has succeeded. */
1798 gdb_python_initialized
= 1;
1802 #endif /* HAVE_PYTHON */
1805 cmd_list_element
*python_cmd_element
= nullptr;
1807 void _initialize_python ();
1809 _initialize_python ()
1811 add_com ("python-interactive", class_obscure
,
1812 python_interactive_command
,
1815 Start an interactive Python prompt.\n\
1817 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1820 Alternatively, a single-line Python command can be given as an\n\
1821 argument, and if the command is an expression, the result will be\n\
1822 printed. For example:\n\
1824 (gdb) python-interactive 2 + 3\n\
1826 #else /* HAVE_PYTHON */
1828 Start a Python interactive prompt.\n\
1830 Python scripting is not supported in this copy of GDB.\n\
1831 This command is only a placeholder.")
1832 #endif /* HAVE_PYTHON */
1834 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1836 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1839 Evaluate a Python command.\n\
1841 The command can be given as an argument, for instance:\n\
1843 python print (23)\n\
1845 If no argument is given, the following lines are read and used\n\
1846 as the Python commands. Type a line containing \"end\" to indicate\n\
1847 the end of the command.")
1848 #else /* HAVE_PYTHON */
1850 Evaluate a Python command.\n\
1852 Python scripting is not supported in this copy of GDB.\n\
1853 This command is only a placeholder.")
1854 #endif /* HAVE_PYTHON */
1856 add_com_alias ("py", "python", class_obscure
, 1);
1858 /* Add set/show python print-stack. */
1859 add_basic_prefix_cmd ("python", no_class
,
1860 _("Prefix command for python preference settings."),
1861 &user_show_python_list
, "show python ", 0,
1864 add_show_prefix_cmd ("python", no_class
,
1865 _("Prefix command for python preference settings."),
1866 &user_set_python_list
, "set python ", 0,
1869 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1870 &gdbpy_should_print_stack
, _("\
1871 Set mode for Python stack dump on error."), _("\
1872 Show the mode of Python stack printing on error."), _("\
1873 none == no stack or message will be printed.\n\
1874 full == a message and a stack will be printed.\n\
1875 message == an error message without a stack will be printed."),
1877 &user_set_python_list
,
1878 &user_show_python_list
);
1881 if (!do_start_initialization () && PyErr_Occurred ())
1882 gdbpy_print_stack ();
1883 #endif /* HAVE_PYTHON */
1888 /* Helper function for gdbpy_finish_initialization. This does the
1889 work and then returns false if an error has occurred and must be
1890 displayed, or true on success. */
1893 do_finish_initialization (const struct extension_language_defn
*extlang
)
1898 /* Add the initial data-directory to sys.path. */
1900 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1903 sys_path
= PySys_GetObject ("path");
1905 /* If sys.path is not defined yet, define it first. */
1906 if (!(sys_path
&& PyList_Check (sys_path
)))
1909 PySys_SetPath (L
"");
1913 sys_path
= PySys_GetObject ("path");
1915 if (sys_path
&& PyList_Check (sys_path
))
1917 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1918 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1924 /* Import the gdb module to finish the initialization, and
1925 add it to __main__ for convenience. */
1926 m
= PyImport_AddModule ("__main__");
1930 /* Keep the reference to gdb_python_module since it is in a global
1932 gdb_python_module
= PyImport_ImportModule ("gdb");
1933 if (gdb_python_module
== NULL
)
1935 gdbpy_print_stack ();
1936 /* This is passed in one call to warning so that blank lines aren't
1937 inserted between each line of text. */
1939 "Could not load the Python gdb module from `%s'.\n"
1940 "Limited Python support is available from the _gdb module.\n"
1941 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
1942 gdb_pythondir
.c_str ());
1943 /* We return "success" here as we've already emitted the
1948 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1951 /* Perform the remaining python initializations.
1952 These must be done after GDB is at least mostly initialized.
1953 E.g., The "info pretty-printer" command needs the "info" prefix
1955 This is the extension_language_ops.finish_initialization "method". */
1958 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1960 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1962 if (!do_finish_initialization (extlang
))
1964 gdbpy_print_stack ();
1965 warning (_("internal error: Unhandled Python exception"));
1969 /* Return non-zero if Python has successfully initialized.
1970 This is the extension_languages_ops.initialized "method". */
1973 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1975 return gdb_python_initialized
;
1978 #endif /* HAVE_PYTHON */
1984 PyMethodDef python_GdbMethods
[] =
1986 { "history", gdbpy_history
, METH_VARARGS
,
1987 "Get a value from history" },
1988 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1989 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1990 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1991 a Python String containing the output of the command if to_string is\n\
1993 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1994 "Return a gdb parameter's value" },
1996 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1997 "Return a tuple of all breakpoint objects" },
1999 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
2000 "Find the default visualizer for a Value." },
2002 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2003 "Return a sequence of all progspaces." },
2005 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2006 "Return the current Objfile being loaded, or None." },
2008 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2009 "newest_frame () -> gdb.Frame.\n\
2010 Return the newest frame object." },
2011 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2012 "selected_frame () -> gdb.Frame.\n\
2013 Return the selected frame object." },
2014 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2015 "stop_reason_string (Integer) -> String.\n\
2016 Return a string explaining unwind stop reason." },
2018 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2019 "start_recording ([method] [, format]) -> gdb.Record.\n\
2020 Start recording with the given method. If no method is given, will fall back\n\
2021 to the system default method. If no format is given, will fall back to the\n\
2022 default format for the given method."},
2023 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2024 "current_recording () -> gdb.Record.\n\
2025 Return current recording object." },
2026 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2027 "stop_recording () -> None.\n\
2028 Stop current recording." },
2030 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2031 METH_VARARGS
| METH_KEYWORDS
,
2032 "lookup_type (name [, block]) -> type\n\
2033 Return a Type corresponding to the given name." },
2034 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2035 METH_VARARGS
| METH_KEYWORDS
,
2036 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2037 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2038 a boolean indicating if name is a field of the current implied argument\n\
2039 `this' (when the current language is object-oriented)." },
2040 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2041 METH_VARARGS
| METH_KEYWORDS
,
2042 "lookup_global_symbol (name [, domain]) -> symbol\n\
2043 Return the symbol corresponding to the given name (or None)." },
2044 { "lookup_static_symbol", (PyCFunction
) gdbpy_lookup_static_symbol
,
2045 METH_VARARGS
| METH_KEYWORDS
,
2046 "lookup_static_symbol (name [, domain]) -> symbol\n\
2047 Return the static-linkage symbol corresponding to the given name (or None)." },
2048 { "lookup_static_symbols", (PyCFunction
) gdbpy_lookup_static_symbols
,
2049 METH_VARARGS
| METH_KEYWORDS
,
2050 "lookup_static_symbols (name [, domain]) -> symbol\n\
2051 Return a list of all static-linkage symbols corresponding to the given name." },
2053 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2054 METH_VARARGS
| METH_KEYWORDS
,
2055 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2056 Look up the specified objfile.\n\
2057 If by_build_id is True, the objfile is looked up by using name\n\
2058 as its build id." },
2060 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2061 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2062 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2063 The first element contains any unparsed portion of the String parameter\n\
2064 (or None if the string was fully parsed). The second element contains\n\
2065 a tuple that contains all the locations that match, represented as\n\
2066 gdb.Symtab_and_line objects (or None)."},
2067 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2068 "parse_and_eval (String) -> Value.\n\
2069 Parse String as an expression, evaluate it, and return the result as a Value."
2072 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2073 "Post an event into gdb's event loop." },
2075 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2076 "target_charset () -> string.\n\
2077 Return the name of the current target charset." },
2078 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2079 "target_wide_charset () -> string.\n\
2080 Return the name of the current target wide charset." },
2081 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2082 "rbreak (Regex) -> List.\n\
2083 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2084 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2085 "string_to_argv (String) -> Array.\n\
2086 Parse String and return an argv-like array.\n\
2087 Arguments are separate by spaces and may be quoted."
2089 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2090 "Write a string using gdb's filtered stream." },
2091 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2092 "Flush gdb's filtered stdout stream." },
2093 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2094 "selected_thread () -> gdb.InferiorThread.\n\
2095 Return the selected thread object." },
2096 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2097 "selected_inferior () -> gdb.Inferior.\n\
2098 Return the selected inferior object." },
2099 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2100 "inferiors () -> (gdb.Inferior, ...).\n\
2101 Return a tuple containing all inferiors." },
2103 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2104 "invalidate_cached_frames () -> None.\n\
2105 Invalidate any cached frame objects in gdb.\n\
2106 Intended for internal use only." },
2108 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2109 "convenience_variable (NAME) -> value.\n\
2110 Return the value of the convenience variable $NAME,\n\
2111 or None if not set." },
2112 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2113 "convenience_variable (NAME, VALUE) -> None.\n\
2114 Set the value of the convenience variable $NAME." },
2117 { "register_window_type", (PyCFunction
) gdbpy_register_tui_window
,
2118 METH_VARARGS
| METH_KEYWORDS
,
2119 "register_window_type (NAME, CONSTRUCSTOR) -> None\n\
2120 Register a TUI window constructor." },
2123 {NULL
, NULL
, 0, NULL
}
2127 struct PyModuleDef python_GdbModuleDef
=
2129 PyModuleDef_HEAD_INIT
,
2141 /* Define all the event objects. */
2142 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2143 PyTypeObject name##_event_object_type \
2144 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2146 PyVarObject_HEAD_INIT (NULL, 0) \
2147 "gdb." py_name, /* tp_name */ \
2148 sizeof (event_object), /* tp_basicsize */ \
2149 0, /* tp_itemsize */ \
2150 evpy_dealloc, /* tp_dealloc */ \
2152 0, /* tp_getattr */ \
2153 0, /* tp_setattr */ \
2154 0, /* tp_compare */ \
2156 0, /* tp_as_number */ \
2157 0, /* tp_as_sequence */ \
2158 0, /* tp_as_mapping */ \
2162 0, /* tp_getattro */ \
2163 0, /* tp_setattro */ \
2164 0, /* tp_as_buffer */ \
2165 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2167 0, /* tp_traverse */ \
2169 0, /* tp_richcompare */ \
2170 0, /* tp_weaklistoffset */ \
2172 0, /* tp_iternext */ \
2173 0, /* tp_methods */ \
2174 0, /* tp_members */ \
2175 0, /* tp_getset */ \
2176 &base, /* tp_base */ \
2178 0, /* tp_descr_get */ \
2179 0, /* tp_descr_set */ \
2180 0, /* tp_dictoffset */ \
2184 #include "py-event-types.def"
2185 #undef GDB_PY_DEFINE_EVENT_TYPE
2187 #endif /* HAVE_PYTHON */