1 /* General python/gdb code
3 Copyright (C) 2008-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
24 #include "cli/cli-script.h"
26 #include "progspace.h"
30 #include "event-loop.h"
31 #include "readline/tilde.h"
33 #include "extension-priv.h"
34 #include "cli/cli-utils.h"
37 #include "run-on-main-thread.h"
39 /* Declared constants and enum for python stack printing. */
40 static const char python_excp_none
[] = "none";
41 static const char python_excp_full
[] = "full";
42 static const char python_excp_message
[] = "message";
44 /* "set python print-stack" choices. */
45 static const char *const python_excp_enums
[] =
53 /* The exception printing variable. 'full' if we want to print the
54 error message and stack, 'none' if we want to print nothing, and
55 'message' if we only want to print the error message. 'message' is
57 static const char *gdbpy_should_print_stack
= python_excp_message
;
60 /* Forward decls, these are defined later. */
61 extern const struct extension_language_script_ops python_extension_script_ops
;
62 extern const struct extension_language_ops python_extension_ops
;
65 /* The main struct describing GDB's interface to the Python
66 extension language. */
67 const struct extension_language_defn extension_language_python
=
79 &python_extension_script_ops
,
89 #include "cli/cli-decode.h"
92 #include "python-internal.h"
95 #include "gdbsupport/version.h"
97 #include "gdbthread.h"
99 #include "event-top.h"
100 #include "py-event.h"
102 /* True if Python has been successfully initialized, false
105 int gdb_python_initialized
;
107 extern PyMethodDef python_GdbMethods
[];
110 extern struct PyModuleDef python_GdbModuleDef
;
113 PyObject
*gdb_module
;
114 PyObject
*gdb_python_module
;
116 /* Some string constants we may wish to use. */
117 PyObject
*gdbpy_to_string_cst
;
118 PyObject
*gdbpy_children_cst
;
119 PyObject
*gdbpy_display_hint_cst
;
120 PyObject
*gdbpy_doc_cst
;
121 PyObject
*gdbpy_enabled_cst
;
122 PyObject
*gdbpy_value_cst
;
124 /* The GdbError exception. */
125 PyObject
*gdbpy_gdberror_exc
;
127 /* The `gdb.error' base class. */
128 PyObject
*gdbpy_gdb_error
;
130 /* The `gdb.MemoryError' exception. */
131 PyObject
*gdbpy_gdb_memory_error
;
133 static script_sourcer_func gdbpy_source_script
;
134 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
135 static objfile_script_executor_func gdbpy_execute_objfile_script
;
136 static void gdbpy_finish_initialization
137 (const struct extension_language_defn
*);
138 static int gdbpy_initialized (const struct extension_language_defn
*);
139 static void gdbpy_eval_from_control_command
140 (const struct extension_language_defn
*, struct command_line
*cmd
);
141 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
142 struct ext_lang_type_printers
*);
143 static enum ext_lang_rc gdbpy_apply_type_printers
144 (const struct extension_language_defn
*,
145 const struct ext_lang_type_printers
*, struct type
*, char **);
146 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
147 struct ext_lang_type_printers
*);
148 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
149 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
150 static enum ext_lang_rc gdbpy_before_prompt_hook
151 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
153 /* The interface between gdb proper and loading of python scripts. */
155 const struct extension_language_script_ops python_extension_script_ops
=
158 gdbpy_source_objfile_script
,
159 gdbpy_execute_objfile_script
,
160 gdbpy_auto_load_enabled
163 /* The interface between gdb proper and python extensions. */
165 const struct extension_language_ops python_extension_ops
=
167 gdbpy_finish_initialization
,
170 gdbpy_eval_from_control_command
,
172 gdbpy_start_type_printers
,
173 gdbpy_apply_type_printers
,
174 gdbpy_free_type_printers
,
176 gdbpy_apply_val_pretty_printer
,
178 gdbpy_apply_frame_filter
,
180 gdbpy_preserve_values
,
182 gdbpy_breakpoint_has_cond
,
183 gdbpy_breakpoint_cond_says_stop
,
186 gdbpy_check_quit_flag
,
188 gdbpy_before_prompt_hook
,
190 gdbpy_get_matching_xmethod_workers
,
193 /* Architecture and language to be used in callbacks from
194 the Python interpreter. */
195 struct gdbarch
*python_gdbarch
;
196 const struct language_defn
*python_language
;
198 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
199 const struct language_defn
*language
)
200 : m_gdbarch (python_gdbarch
),
201 m_language (python_language
)
203 /* We should not ever enter Python unless initialized. */
204 if (!gdb_python_initialized
)
205 error (_("Python not initialized"));
207 m_previous_active
= set_active_ext_lang (&extension_language_python
);
209 m_state
= PyGILState_Ensure ();
211 python_gdbarch
= gdbarch
;
212 python_language
= language
;
214 /* Save it and ensure ! PyErr_Occurred () afterwards. */
218 gdbpy_enter::~gdbpy_enter ()
220 /* Leftover Python error is forbidden by Python Exception Handling. */
221 if (PyErr_Occurred ())
223 /* This order is similar to the one calling error afterwards. */
224 gdbpy_print_stack ();
225 warning (_("internal error: Unhandled Python exception"));
230 python_gdbarch
= m_gdbarch
;
231 python_language
= m_language
;
233 restore_active_ext_lang (m_previous_active
);
234 PyGILState_Release (m_state
);
237 /* Set the quit flag. */
240 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
242 PyErr_SetInterrupt ();
245 /* Return true if the quit flag has been set, false otherwise. */
248 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
250 return PyOS_InterruptOccurred ();
253 /* Evaluate a Python command like PyRun_SimpleString, but uses
254 Py_single_input which prints the result of expressions, and does
255 not automatically print the stack on errors. */
258 eval_python_command (const char *command
)
262 m
= PyImport_AddModule ("__main__");
266 d
= PyModule_GetDict (m
);
269 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
281 /* Implementation of the gdb "python-interactive" command. */
284 python_interactive_command (const char *arg
, int from_tty
)
286 struct ui
*ui
= current_ui
;
289 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
291 arg
= skip_spaces (arg
);
293 gdbpy_enter
enter_py (get_current_arch (), current_language
);
297 std::string script
= std::string (arg
) + "\n";
298 err
= eval_python_command (script
.c_str ());
302 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
308 gdbpy_print_stack ();
309 error (_("Error while executing Python code."));
313 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
316 On Windows hosts few users would build Python themselves (this is no
317 trivial task on this platform), and thus use binaries built by
318 someone else instead. There may happen situation where the Python
319 library and GDB are using two different versions of the C runtime
320 library. Python, being built with VC, would use one version of the
321 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
322 A FILE * from one runtime does not necessarily operate correctly in
325 To work around this potential issue, we run code in Python to load
329 python_run_simple_file (FILE *file
, const char *filename
)
333 PyRun_SimpleFile (file
, filename
);
337 /* Because we have a string for a filename, and are using Python to
338 open the file, we need to expand any tilde in the path first. */
339 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
341 if (gdb_python_module
== nullptr
342 || ! PyObject_HasAttrString (gdb_python_module
, "_execute_file"))
343 error (_("Installation error: gdb._execute_file function is missing"));
345 gdbpy_ref
<> return_value
346 (PyObject_CallMethod (gdb_python_module
, "_execute_file", "s",
348 if (return_value
== nullptr)
350 /* Use PyErr_PrintEx instead of gdbpy_print_stack to better match the
351 behavior of the non-Windows codepath. */
358 /* Given a command_line, return a command string suitable for passing
359 to Python. Lines in the string are separated by newlines. */
362 compute_python_string (struct command_line
*l
)
364 struct command_line
*iter
;
367 for (iter
= l
; iter
; iter
= iter
->next
)
369 script
+= iter
->line
;
375 /* Take a command line structure representing a 'python' command, and
376 evaluate its body using the Python interpreter. */
379 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
380 struct command_line
*cmd
)
384 if (cmd
->body_list_1
!= nullptr)
385 error (_("Invalid \"python\" block structure."));
387 gdbpy_enter
enter_py (get_current_arch (), current_language
);
389 std::string script
= compute_python_string (cmd
->body_list_0
.get ());
390 ret
= PyRun_SimpleString (script
.c_str ());
392 error (_("Error while executing Python code."));
395 /* Implementation of the gdb "python" command. */
398 python_command (const char *arg
, int from_tty
)
400 gdbpy_enter
enter_py (get_current_arch (), current_language
);
402 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
404 arg
= skip_spaces (arg
);
407 if (PyRun_SimpleString (arg
))
408 error (_("Error while executing Python code."));
412 counted_command_line l
= get_command_line (python_control
, "");
414 execute_control_command_untraced (l
.get ());
420 /* Transform a gdb parameters's value into a Python value. May return
421 NULL (and set a Python exception) on error. Helper function for
424 gdbpy_parameter_value (enum var_types type
, void *var
)
429 case var_string_noescape
:
430 case var_optional_filename
:
434 const char *str
= *(char **) var
;
438 return host_string_to_python_string (str
).release ();
449 case var_auto_boolean
:
451 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
453 if (ab
== AUTO_BOOLEAN_TRUE
)
455 else if (ab
== AUTO_BOOLEAN_FALSE
)
462 if ((* (int *) var
) == INT_MAX
)
466 case var_zuinteger_unlimited
:
467 return PyLong_FromLong (* (int *) var
);
471 unsigned int val
= * (unsigned int *) var
;
475 return PyLong_FromUnsignedLong (val
);
480 unsigned int val
= * (unsigned int *) var
;
481 return PyLong_FromUnsignedLong (val
);
485 return PyErr_Format (PyExc_RuntimeError
,
486 _("Programmer error: unhandled type."));
489 /* A Python function which returns a gdb parameter's value as a Python
493 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
495 struct cmd_list_element
*alias
, *prefix
, *cmd
;
499 if (! PyArg_ParseTuple (args
, "s", &arg
))
502 std::string newarg
= std::string ("show ") + arg
;
506 found
= lookup_cmd_composition (newarg
.c_str (), &alias
, &prefix
, &cmd
);
508 catch (const gdb_exception
&ex
)
510 GDB_PY_HANDLE_EXCEPTION (ex
);
514 return PyErr_Format (PyExc_RuntimeError
,
515 _("Could not find parameter `%s'."), arg
);
518 return PyErr_Format (PyExc_RuntimeError
,
519 _("`%s' is not a parameter."), arg
);
520 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
523 /* Wrapper for target_charset. */
526 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
528 const char *cset
= target_charset (python_gdbarch
);
530 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
533 /* Wrapper for target_wide_charset. */
536 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
538 const char *cset
= target_wide_charset (python_gdbarch
);
540 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
543 /* A Python function which evaluates a string using the gdb CLI. */
546 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
549 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
550 int from_tty
, to_string
;
551 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
553 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
554 &PyBool_Type
, &from_tty_obj
,
555 &PyBool_Type
, &to_string_obj
))
561 int cmp
= PyObject_IsTrue (from_tty_obj
);
570 int cmp
= PyObject_IsTrue (to_string_obj
);
576 std::string to_string_res
;
578 scoped_restore preventer
= prevent_dont_repeat ();
582 gdbpy_allow_threads allow_threads
;
584 struct interp
*interp
;
586 std::string arg_copy
= arg
;
588 char *save_ptr
= nullptr;
592 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
598 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
601 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
604 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
606 /* Use the console interpreter uiout to have the same print format
607 for console or MI. */
608 interp
= interp_lookup (current_ui
, "console");
609 current_uiout
= interp
->interp_ui_out ();
612 to_string_res
= execute_control_commands_to_string (lines
.get (),
615 execute_control_commands (lines
.get (), from_tty
);
618 /* Do any commands attached to breakpoint we stopped at. */
619 bpstat_do_actions ();
621 catch (const gdb_exception
&except
)
623 GDB_PY_HANDLE_EXCEPTION (except
);
627 return PyString_FromString (to_string_res
.c_str ());
631 /* Implementation of Python rbreak command. Take a REGEX and
632 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
633 Python list that contains newly set breakpoints that match that
634 criteria. REGEX refers to a GDB format standard regex pattern of
635 symbols names to search; MINSYMS is an optional boolean (default
636 False) that indicates if the function should search GDB's minimal
637 symbols; THROTTLE is an optional integer (default unlimited) that
638 indicates the maximum amount of breakpoints allowable before the
639 function exits (note, if the throttle bound is passed, no
640 breakpoints will be set and a runtime error returned); SYMTABS is
641 an optional Python iterable that contains a set of gdb.Symtabs to
642 constrain the search within. */
645 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
648 std::vector
<symbol_search
> symbols
;
649 unsigned long count
= 0;
650 PyObject
*symtab_list
= NULL
;
651 PyObject
*minsyms_p_obj
= NULL
;
653 unsigned int throttle
= 0;
654 static const char *keywords
[] = {"regex","minsyms", "throttle",
657 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
658 ®ex
, &PyBool_Type
,
659 &minsyms_p_obj
, &throttle
,
663 /* Parse minsyms keyword. */
664 if (minsyms_p_obj
!= NULL
)
666 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
672 global_symbol_searcher
spec (FUNCTIONS_DOMAIN
, regex
);
674 for (const char *elem
: spec
.filenames
)
675 xfree ((void *) elem
);
678 /* The "symtabs" keyword is any Python iterable object that returns
679 a gdb.Symtab on each iteration. If specified, iterate through
680 the provided gdb.Symtabs and extract their full path. As
681 python_string_to_target_string returns a
682 gdb::unique_xmalloc_ptr<char> and a vector containing these types
683 cannot be coerced to a const char **p[] via the vector.data call,
684 release the value from the unique_xmalloc_ptr and place it in a
685 simple type symtab_list_type (which holds the vector and a
686 destructor that frees the contents of the allocated strings. */
687 if (symtab_list
!= NULL
)
689 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
696 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
700 if (PyErr_Occurred ())
705 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
708 if (obj_name
== NULL
)
711 /* Is the object file still valid? */
712 if (obj_name
== Py_None
)
715 gdb::unique_xmalloc_ptr
<char> filename
=
716 python_string_to_target_string (obj_name
.get ());
718 if (filename
== NULL
)
721 /* Make sure there is a definite place to store the value of
722 filename before it is released. */
723 spec
.filenames
.push_back (nullptr);
724 spec
.filenames
.back () = filename
.release ();
728 /* The search spec. */
729 symbols
= spec
.search ();
731 /* Count the number of symbols (both symbols and optionally minimal
732 symbols) so we can correctly check the throttle limit. */
733 for (const symbol_search
&p
: symbols
)
735 /* Minimal symbols included? */
738 if (p
.msymbol
.minsym
!= NULL
)
742 if (p
.symbol
!= NULL
)
746 /* Check throttle bounds and exit if in excess. */
747 if (throttle
!= 0 && count
> throttle
)
749 PyErr_SetString (PyExc_RuntimeError
,
750 _("Number of breakpoints exceeds throttled maximum."));
754 gdbpy_ref
<> return_list (PyList_New (0));
756 if (return_list
== NULL
)
759 /* Construct full path names for symbols and call the Python
760 breakpoint constructor on the resulting names. Be tolerant of
761 individual breakpoint failures. */
762 for (const symbol_search
&p
: symbols
)
764 std::string symbol_name
;
766 /* Skipping minimal symbols? */
768 if (p
.msymbol
.minsym
!= NULL
)
771 if (p
.msymbol
.minsym
== NULL
)
773 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
774 const char *fullname
= symtab_to_fullname (symtab
);
776 symbol_name
= fullname
;
778 symbol_name
+= p
.symbol
->linkage_name ();
781 symbol_name
= p
.msymbol
.minsym
->linkage_name ();
783 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
784 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
785 &breakpoint_object_type
,
788 /* Tolerate individual breakpoint failures. */
790 gdbpy_print_stack ();
793 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
797 return return_list
.release ();
800 /* A Python function which is a wrapper for decode_line_1. */
803 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
805 const char *arg
= NULL
;
807 gdbpy_ref
<> unparsed
;
808 event_location_up location
;
810 if (! PyArg_ParseTuple (args
, "|s", &arg
))
814 location
= string_to_event_location_basic (&arg
, python_language
,
815 symbol_name_match_type::WILD
);
817 std::vector
<symtab_and_line
> decoded_sals
;
818 symtab_and_line def_sal
;
819 gdb::array_view
<symtab_and_line
> sals
;
822 if (location
!= NULL
)
824 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
829 set_default_source_symtab_and_line ();
830 def_sal
= get_current_source_symtab_and_line ();
834 catch (const gdb_exception
&ex
)
836 /* We know this will always throw. */
837 gdbpy_convert_exception (ex
);
843 result
.reset (PyTuple_New (sals
.size ()));
846 for (size_t i
= 0; i
< sals
.size (); ++i
)
848 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
852 PyTuple_SetItem (result
.get (), i
, obj
);
856 result
= gdbpy_ref
<>::new_reference (Py_None
);
858 gdbpy_ref
<> return_result (PyTuple_New (2));
859 if (return_result
== NULL
)
862 if (arg
!= NULL
&& strlen (arg
) > 0)
864 unparsed
.reset (PyString_FromString (arg
));
865 if (unparsed
== NULL
)
869 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
871 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
872 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
874 return return_result
.release ();
877 /* Parse a string and evaluate it as an expression. */
879 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
881 const char *expr_str
;
882 struct value
*result
= NULL
;
884 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
889 gdbpy_allow_threads allow_threads
;
890 result
= parse_and_eval (expr_str
);
892 catch (const gdb_exception
&except
)
894 GDB_PY_HANDLE_EXCEPTION (except
);
897 return value_to_value_object (result
);
900 /* Implementation of gdb.invalidate_cached_frames. */
903 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
905 reinit_frame_cache ();
909 /* Read a file as Python code.
910 This is the extension_language_script_ops.script_sourcer "method".
911 FILE is the file to load. FILENAME is name of the file FILE.
912 This does not throw any errors. If an exception occurs python will print
913 the traceback and clear the error indicator. */
916 gdbpy_source_script (const struct extension_language_defn
*extlang
,
917 FILE *file
, const char *filename
)
919 gdbpy_enter
enter_py (get_current_arch (), current_language
);
920 python_run_simple_file (file
, filename
);
925 /* Posting and handling events. */
927 /* A helper class to save and restore the GIL, but without touching
928 the other globals that are handled by gdbpy_enter. */
935 : m_state (PyGILState_Ensure ())
941 PyGILState_Release (m_state
);
944 DISABLE_COPY_AND_ASSIGN (gdbpy_gil
);
948 PyGILState_STATE m_state
;
951 /* A single event. */
954 gdbpy_event (gdbpy_ref
<> &&func
)
955 : m_func (func
.release ())
959 gdbpy_event (gdbpy_event
&&other
)
960 : m_func (other
.m_func
)
962 other
.m_func
= nullptr;
965 gdbpy_event (const gdbpy_event
&other
)
966 : m_func (other
.m_func
)
978 gdbpy_event
&operator= (const gdbpy_event
&other
) = delete;
982 gdbpy_enter
enter_py (get_current_arch (), current_language
);
984 gdbpy_ref
<> call_result (PyObject_CallObject (m_func
, NULL
));
985 if (call_result
== NULL
)
986 gdbpy_print_stack ();
991 /* The Python event. This is just a callable object. Note that
992 this is not a gdbpy_ref<>, because we have to take particular
993 care to only destroy the reference when holding the GIL. */
997 /* Submit an event to the gdb thread. */
999 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1003 if (!PyArg_ParseTuple (args
, "O", &func
))
1006 if (!PyCallable_Check (func
))
1008 PyErr_SetString (PyExc_RuntimeError
,
1009 _("Posted event is not callable"));
1013 gdbpy_ref
<> func_ref
= gdbpy_ref
<>::new_reference (func
);
1014 gdbpy_event
event (std::move (func_ref
));
1015 run_on_main_thread (event
);
1022 /* This is the extension_language_ops.before_prompt "method". */
1024 static enum ext_lang_rc
1025 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1026 const char *current_gdb_prompt
)
1028 if (!gdb_python_initialized
)
1029 return EXT_LANG_RC_NOP
;
1031 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1033 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1034 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1035 return EXT_LANG_RC_ERROR
;
1037 if (gdb_python_module
1038 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1040 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1044 gdbpy_print_stack ();
1045 return EXT_LANG_RC_ERROR
;
1048 if (PyCallable_Check (hook
.get ()))
1050 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1051 if (current_prompt
== NULL
)
1053 gdbpy_print_stack ();
1054 return EXT_LANG_RC_ERROR
;
1058 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1062 gdbpy_print_stack ();
1063 return EXT_LANG_RC_ERROR
;
1066 /* Return type should be None, or a String. If it is None,
1067 fall through, we will not set a prompt. If it is a
1068 string, set PROMPT. Anything else, set an exception. */
1069 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1071 PyErr_Format (PyExc_RuntimeError
,
1072 _("Return from prompt_hook must " \
1073 "be either a Python string, or None"));
1074 gdbpy_print_stack ();
1075 return EXT_LANG_RC_ERROR
;
1078 if (result
!= Py_None
)
1080 gdb::unique_xmalloc_ptr
<char>
1081 prompt (python_string_to_host_string (result
.get ()));
1085 gdbpy_print_stack ();
1086 return EXT_LANG_RC_ERROR
;
1089 set_prompt (prompt
.get ());
1090 return EXT_LANG_RC_OK
;
1095 return EXT_LANG_RC_NOP
;
1102 /* A python function to write a single string using gdb's filtered
1103 output stream . The optional keyword STREAM can be used to write
1104 to a particular stream. The default stream is to gdb_stdout. */
1107 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1110 static const char *keywords
[] = { "text", "stream", NULL
};
1111 int stream_type
= 0;
1113 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1119 switch (stream_type
)
1123 fprintf_filtered (gdb_stderr
, "%s", arg
);
1128 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1132 fprintf_filtered (gdb_stdout
, "%s", arg
);
1135 catch (const gdb_exception
&except
)
1137 GDB_PY_HANDLE_EXCEPTION (except
);
1143 /* A python function to flush a gdb stream. The optional keyword
1144 STREAM can be used to flush a particular stream. The default stream
1148 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1150 static const char *keywords
[] = { "stream", NULL
};
1151 int stream_type
= 0;
1153 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1157 switch (stream_type
)
1161 gdb_flush (gdb_stderr
);
1166 gdb_flush (gdb_stdlog
);
1170 gdb_flush (gdb_stdout
);
1176 /* Return non-zero if print-stack is not "none". */
1179 gdbpy_print_python_errors_p (void)
1181 return gdbpy_should_print_stack
!= python_excp_none
;
1184 /* Print a python exception trace, print just a message, or print
1185 nothing and clear the python exception, depending on
1186 gdbpy_should_print_stack. Only call this if a python exception is
1189 gdbpy_print_stack (void)
1192 /* Print "none", just clear exception. */
1193 if (gdbpy_should_print_stack
== python_excp_none
)
1197 /* Print "full" message and backtrace. */
1198 else if (gdbpy_should_print_stack
== python_excp_full
)
1201 /* PyErr_Print doesn't necessarily end output with a newline.
1202 This works because Python's stdout/stderr is fed through
1208 catch (const gdb_exception
&except
)
1212 /* Print "message", just error print message. */
1215 gdbpy_err_fetch fetched_error
;
1217 gdb::unique_xmalloc_ptr
<char> msg
= fetched_error
.to_string ();
1218 gdb::unique_xmalloc_ptr
<char> type
;
1219 /* Don't compute TYPE if MSG already indicates that there is an
1222 type
= fetched_error
.type_to_string ();
1226 if (msg
== NULL
|| type
== NULL
)
1228 /* An error occurred computing the string representation of the
1230 fprintf_filtered (gdb_stderr
,
1231 _("Error occurred computing Python error" \
1236 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1237 type
.get (), msg
.get ());
1239 catch (const gdb_exception
&except
)
1245 /* Like gdbpy_print_stack, but if the exception is a
1246 KeyboardException, throw a gdb "quit" instead. */
1249 gdbpy_print_stack_or_quit ()
1251 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1254 throw_quit ("Quit");
1256 gdbpy_print_stack ();
1261 /* Return a sequence holding all the Progspaces. */
1264 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1266 struct program_space
*ps
;
1268 gdbpy_ref
<> list (PyList_New (0));
1274 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1276 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1280 return list
.release ();
1285 /* The "current" objfile. This is set when gdb detects that a new
1286 objfile has been loaded. It is only set for the duration of a call to
1287 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1289 static struct objfile
*gdbpy_current_objfile
;
1291 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1292 as Python code. This does not throw any errors. If an exception
1293 occurs python will print the traceback and clear the error indicator.
1294 This is the extension_language_script_ops.objfile_script_sourcer
1298 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1299 struct objfile
*objfile
, FILE *file
,
1300 const char *filename
)
1302 if (!gdb_python_initialized
)
1305 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1306 gdbpy_current_objfile
= objfile
;
1308 python_run_simple_file (file
, filename
);
1310 gdbpy_current_objfile
= NULL
;
1313 /* Set the current objfile to OBJFILE and then execute SCRIPT
1314 as Python code. This does not throw any errors. If an exception
1315 occurs python will print the traceback and clear the error indicator.
1316 This is the extension_language_script_ops.objfile_script_executor
1320 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1321 struct objfile
*objfile
, const char *name
,
1324 if (!gdb_python_initialized
)
1327 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1328 gdbpy_current_objfile
= objfile
;
1330 PyRun_SimpleString (script
);
1332 gdbpy_current_objfile
= NULL
;
1335 /* Return the current Objfile, or None if there isn't one. */
1338 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1340 if (! gdbpy_current_objfile
)
1343 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1346 /* Compute the list of active python type printers and store them in
1347 EXT_PRINTERS->py_type_printers. The product of this function is used by
1348 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1349 This is the extension_language_ops.start_type_printers "method". */
1352 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1353 struct ext_lang_type_printers
*ext_printers
)
1355 PyObject
*printers_obj
= NULL
;
1357 if (!gdb_python_initialized
)
1360 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1362 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1363 if (type_module
== NULL
)
1365 gdbpy_print_stack ();
1369 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1370 "get_type_recognizers"));
1373 gdbpy_print_stack ();
1377 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1378 if (printers_obj
== NULL
)
1379 gdbpy_print_stack ();
1381 ext_printers
->py_type_printers
= printers_obj
;
1384 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1385 a newly allocated string holding the type's replacement name, and return
1386 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1387 If there's a Python error return EXT_LANG_RC_ERROR.
1388 Otherwise, return EXT_LANG_RC_NOP.
1389 This is the extension_language_ops.apply_type_printers "method". */
1391 static enum ext_lang_rc
1392 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1393 const struct ext_lang_type_printers
*ext_printers
,
1394 struct type
*type
, char **prettied_type
)
1396 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1397 gdb::unique_xmalloc_ptr
<char> result
;
1399 if (printers_obj
== NULL
)
1400 return EXT_LANG_RC_NOP
;
1402 if (!gdb_python_initialized
)
1403 return EXT_LANG_RC_NOP
;
1405 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1407 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1408 if (type_obj
== NULL
)
1410 gdbpy_print_stack ();
1411 return EXT_LANG_RC_ERROR
;
1414 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1415 if (type_module
== NULL
)
1417 gdbpy_print_stack ();
1418 return EXT_LANG_RC_ERROR
;
1421 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1422 "apply_type_recognizers"));
1425 gdbpy_print_stack ();
1426 return EXT_LANG_RC_ERROR
;
1429 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1433 if (result_obj
== NULL
)
1435 gdbpy_print_stack ();
1436 return EXT_LANG_RC_ERROR
;
1439 if (result_obj
== Py_None
)
1440 return EXT_LANG_RC_NOP
;
1442 result
= python_string_to_host_string (result_obj
.get ());
1445 gdbpy_print_stack ();
1446 return EXT_LANG_RC_ERROR
;
1449 *prettied_type
= result
.release ();
1450 return EXT_LANG_RC_OK
;
1453 /* Free the result of start_type_printers.
1454 This is the extension_language_ops.free_type_printers "method". */
1457 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1458 struct ext_lang_type_printers
*ext_printers
)
1460 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1462 if (printers
== NULL
)
1465 if (!gdb_python_initialized
)
1468 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1469 Py_DECREF (printers
);
1472 #else /* HAVE_PYTHON */
1474 /* Dummy implementation of the gdb "python-interactive" and "python"
1478 python_interactive_command (const char *arg
, int from_tty
)
1480 arg
= skip_spaces (arg
);
1482 error (_("Python scripting is not supported in this copy of GDB."));
1485 counted_command_line l
= get_command_line (python_control
, "");
1487 execute_control_command_untraced (l
.get ());
1492 python_command (const char *arg
, int from_tty
)
1494 python_interactive_command (arg
, from_tty
);
1497 #endif /* HAVE_PYTHON */
1501 /* Lists for 'set python' commands. */
1503 static struct cmd_list_element
*user_set_python_list
;
1504 static struct cmd_list_element
*user_show_python_list
;
1506 /* Function for use by 'set python' prefix command. */
1509 user_set_python (const char *args
, int from_tty
)
1511 help_list (user_set_python_list
, "set python ", all_commands
,
1515 /* Function for use by 'show python' prefix command. */
1518 user_show_python (const char *args
, int from_tty
)
1520 cmd_show_list (user_show_python_list
, from_tty
, "");
1523 /* Initialize the Python code. */
1527 /* This is installed as a final cleanup and cleans up the
1528 interpreter. This lets Python's 'atexit' work. */
1531 finalize_python (void *ignore
)
1533 struct active_ext_lang_state
*previous_active
;
1535 /* We don't use ensure_python_env here because if we ever ran the
1536 cleanup, gdb would crash -- because the cleanup calls into the
1537 Python interpreter, which we are about to destroy. It seems
1538 clearer to make the needed calls explicitly here than to create a
1539 cleanup and then mysteriously discard it. */
1541 /* This is only called as a final cleanup so we can assume the active
1542 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1543 previous_active
= set_active_ext_lang (&extension_language_python
);
1545 (void) PyGILState_Ensure ();
1546 python_gdbarch
= target_gdbarch ();
1547 python_language
= current_language
;
1551 restore_active_ext_lang (previous_active
);
1555 /* This is called via the PyImport_AppendInittab mechanism called
1556 during initialization, to make the built-in _gdb module known to
1559 init__gdb_module (void)
1561 return PyModule_Create (&python_GdbModuleDef
);
1566 do_start_initialization ()
1569 size_t progsize
, count
;
1570 /* Python documentation indicates that the memory given
1571 to Py_SetProgramName cannot be freed. However, it seems that
1572 at least Python 3.7.4 Py_SetProgramName takes a copy of the
1573 given program_name. Making progname_copy static and not release
1574 the memory avoids a leak report for Python versions that duplicate
1575 program_name, and respect the requirement of Py_SetProgramName
1576 for Python versions that do not duplicate program_name. */
1577 static wchar_t *progname_copy
;
1580 #ifdef WITH_PYTHON_PATH
1581 /* Work around problem where python gets confused about where it is,
1582 and then can't find its libraries, etc.
1583 NOTE: Python assumes the following layout:
1585 /foo/lib/pythonX.Y/...
1586 This must be done before calling Py_Initialize. */
1587 gdb::unique_xmalloc_ptr
<char> progname
1588 (concat (ldirname (python_libdir
.c_str ()).c_str (), SLASH_STRING
, "bin",
1589 SLASH_STRING
, "python", (char *) NULL
));
1591 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1592 setlocale (LC_ALL
, "");
1593 progsize
= strlen (progname
.get ());
1594 progname_copy
= (wchar_t *) xmalloc ((progsize
+ 1) * sizeof (wchar_t));
1597 fprintf (stderr
, "out of memory\n");
1600 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1601 if (count
== (size_t) -1)
1603 fprintf (stderr
, "Could not convert python path to string\n");
1606 setlocale (LC_ALL
, oldloc
.c_str ());
1608 /* Note that Py_SetProgramName expects the string it is passed to
1609 remain alive for the duration of the program's execution, so
1610 it is not freed after this call. */
1611 Py_SetProgramName (progname_copy
);
1613 /* Define _gdb as a built-in module. */
1614 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1616 Py_SetProgramName (progname
.release ());
1621 PyEval_InitThreads ();
1624 gdb_module
= PyImport_ImportModule ("_gdb");
1626 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1628 if (gdb_module
== NULL
)
1631 if (PyModule_AddStringConstant (gdb_module
, "VERSION", version
) < 0
1632 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", host_name
) < 0
1633 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1637 /* Add stream constants. */
1638 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1639 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1640 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1643 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1644 if (gdbpy_gdb_error
== NULL
1645 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1648 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1649 gdbpy_gdb_error
, NULL
);
1650 if (gdbpy_gdb_memory_error
== NULL
1651 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1652 gdbpy_gdb_memory_error
) < 0)
1655 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1656 if (gdbpy_gdberror_exc
== NULL
1657 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1658 gdbpy_gdberror_exc
) < 0)
1661 gdbpy_initialize_gdb_readline ();
1663 if (gdbpy_initialize_auto_load () < 0
1664 || gdbpy_initialize_values () < 0
1665 || gdbpy_initialize_frames () < 0
1666 || gdbpy_initialize_commands () < 0
1667 || gdbpy_initialize_instruction () < 0
1668 || gdbpy_initialize_record () < 0
1669 || gdbpy_initialize_btrace () < 0
1670 || gdbpy_initialize_symbols () < 0
1671 || gdbpy_initialize_symtabs () < 0
1672 || gdbpy_initialize_blocks () < 0
1673 || gdbpy_initialize_functions () < 0
1674 || gdbpy_initialize_parameters () < 0
1675 || gdbpy_initialize_types () < 0
1676 || gdbpy_initialize_pspace () < 0
1677 || gdbpy_initialize_objfile () < 0
1678 || gdbpy_initialize_breakpoints () < 0
1679 || gdbpy_initialize_finishbreakpoints () < 0
1680 || gdbpy_initialize_lazy_string () < 0
1681 || gdbpy_initialize_linetable () < 0
1682 || gdbpy_initialize_thread () < 0
1683 || gdbpy_initialize_inferior () < 0
1684 || gdbpy_initialize_eventregistry () < 0
1685 || gdbpy_initialize_py_events () < 0
1686 || gdbpy_initialize_event () < 0
1687 || gdbpy_initialize_arch () < 0
1688 || gdbpy_initialize_xmethods () < 0
1689 || gdbpy_initialize_unwind () < 0)
1692 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1693 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1695 #include "py-event-types.def"
1696 #undef GDB_PY_DEFINE_EVENT_TYPE
1698 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1699 if (gdbpy_to_string_cst
== NULL
)
1701 gdbpy_children_cst
= PyString_FromString ("children");
1702 if (gdbpy_children_cst
== NULL
)
1704 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1705 if (gdbpy_display_hint_cst
== NULL
)
1707 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1708 if (gdbpy_doc_cst
== NULL
)
1710 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1711 if (gdbpy_enabled_cst
== NULL
)
1713 gdbpy_value_cst
= PyString_FromString ("value");
1714 if (gdbpy_value_cst
== NULL
)
1717 /* Release the GIL while gdb runs. */
1718 PyThreadState_Swap (NULL
);
1719 PyEval_ReleaseLock ();
1721 make_final_cleanup (finalize_python
, NULL
);
1723 /* Only set this when initialization has succeeded. */
1724 gdb_python_initialized
= 1;
1728 #endif /* HAVE_PYTHON */
1731 cmd_list_element
*python_cmd_element
= nullptr;
1734 _initialize_python (void)
1736 add_com ("python-interactive", class_obscure
,
1737 python_interactive_command
,
1740 Start an interactive Python prompt.\n\
1742 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1745 Alternatively, a single-line Python command can be given as an\n\
1746 argument, and if the command is an expression, the result will be\n\
1747 printed. For example:\n\
1749 (gdb) python-interactive 2 + 3\n\
1751 #else /* HAVE_PYTHON */
1753 Start a Python interactive prompt.\n\
1755 Python scripting is not supported in this copy of GDB.\n\
1756 This command is only a placeholder.")
1757 #endif /* HAVE_PYTHON */
1759 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1761 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1764 Evaluate a Python command.\n\
1766 The command can be given as an argument, for instance:\n\
1768 python print (23)\n\
1770 If no argument is given, the following lines are read and used\n\
1771 as the Python commands. Type a line containing \"end\" to indicate\n\
1772 the end of the command.")
1773 #else /* HAVE_PYTHON */
1775 Evaluate a Python command.\n\
1777 Python scripting is not supported in this copy of GDB.\n\
1778 This command is only a placeholder.")
1779 #endif /* HAVE_PYTHON */
1781 add_com_alias ("py", "python", class_obscure
, 1);
1783 /* Add set/show python print-stack. */
1784 add_prefix_cmd ("python", no_class
, user_show_python
,
1785 _("Prefix command for python preference settings."),
1786 &user_show_python_list
, "show python ", 0,
1789 add_prefix_cmd ("python", no_class
, user_set_python
,
1790 _("Prefix command for python preference settings."),
1791 &user_set_python_list
, "set python ", 0,
1794 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1795 &gdbpy_should_print_stack
, _("\
1796 Set mode for Python stack dump on error."), _("\
1797 Show the mode of Python stack printing on error."), _("\
1798 none == no stack or message will be printed.\n\
1799 full == a message and a stack will be printed.\n\
1800 message == an error message without a stack will be printed."),
1802 &user_set_python_list
,
1803 &user_show_python_list
);
1806 if (!do_start_initialization () && PyErr_Occurred ())
1807 gdbpy_print_stack ();
1808 #endif /* HAVE_PYTHON */
1813 /* Helper function for gdbpy_finish_initialization. This does the
1814 work and then returns false if an error has occurred and must be
1815 displayed, or true on success. */
1818 do_finish_initialization (const struct extension_language_defn
*extlang
)
1823 /* Add the initial data-directory to sys.path. */
1825 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1828 sys_path
= PySys_GetObject ("path");
1830 /* If sys.path is not defined yet, define it first. */
1831 if (!(sys_path
&& PyList_Check (sys_path
)))
1834 PySys_SetPath (L
"");
1838 sys_path
= PySys_GetObject ("path");
1840 if (sys_path
&& PyList_Check (sys_path
))
1842 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1843 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1849 /* Import the gdb module to finish the initialization, and
1850 add it to __main__ for convenience. */
1851 m
= PyImport_AddModule ("__main__");
1855 /* Keep the reference to gdb_python_module since it is in a global
1857 gdb_python_module
= PyImport_ImportModule ("gdb");
1858 if (gdb_python_module
== NULL
)
1860 gdbpy_print_stack ();
1861 /* This is passed in one call to warning so that blank lines aren't
1862 inserted between each line of text. */
1864 "Could not load the Python gdb module from `%s'.\n"
1865 "Limited Python support is available from the _gdb module.\n"
1866 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
1867 gdb_pythondir
.c_str ());
1868 /* We return "success" here as we've already emitted the
1873 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1876 /* Perform the remaining python initializations.
1877 These must be done after GDB is at least mostly initialized.
1878 E.g., The "info pretty-printer" command needs the "info" prefix
1880 This is the extension_language_ops.finish_initialization "method". */
1883 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1885 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1887 if (!do_finish_initialization (extlang
))
1889 gdbpy_print_stack ();
1890 warning (_("internal error: Unhandled Python exception"));
1894 /* Return non-zero if Python has successfully initialized.
1895 This is the extension_languages_ops.initialized "method". */
1898 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1900 return gdb_python_initialized
;
1903 #endif /* HAVE_PYTHON */
1909 PyMethodDef python_GdbMethods
[] =
1911 { "history", gdbpy_history
, METH_VARARGS
,
1912 "Get a value from history" },
1913 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1914 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1915 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1916 a Python String containing the output of the command if to_string is\n\
1918 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1919 "Return a gdb parameter's value" },
1921 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1922 "Return a tuple of all breakpoint objects" },
1924 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1925 "Find the default visualizer for a Value." },
1927 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1928 "Return a sequence of all progspaces." },
1930 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1931 "Return the current Objfile being loaded, or None." },
1933 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1934 "newest_frame () -> gdb.Frame.\n\
1935 Return the newest frame object." },
1936 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1937 "selected_frame () -> gdb.Frame.\n\
1938 Return the selected frame object." },
1939 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1940 "stop_reason_string (Integer) -> String.\n\
1941 Return a string explaining unwind stop reason." },
1943 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1944 "start_recording ([method] [, format]) -> gdb.Record.\n\
1945 Start recording with the given method. If no method is given, will fall back\n\
1946 to the system default method. If no format is given, will fall back to the\n\
1947 default format for the given method."},
1948 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1949 "current_recording () -> gdb.Record.\n\
1950 Return current recording object." },
1951 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1952 "stop_recording () -> None.\n\
1953 Stop current recording." },
1955 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1956 METH_VARARGS
| METH_KEYWORDS
,
1957 "lookup_type (name [, block]) -> type\n\
1958 Return a Type corresponding to the given name." },
1959 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1960 METH_VARARGS
| METH_KEYWORDS
,
1961 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1962 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1963 a boolean indicating if name is a field of the current implied argument\n\
1964 `this' (when the current language is object-oriented)." },
1965 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1966 METH_VARARGS
| METH_KEYWORDS
,
1967 "lookup_global_symbol (name [, domain]) -> symbol\n\
1968 Return the symbol corresponding to the given name (or None)." },
1969 { "lookup_static_symbol", (PyCFunction
) gdbpy_lookup_static_symbol
,
1970 METH_VARARGS
| METH_KEYWORDS
,
1971 "lookup_static_symbol (name [, domain]) -> symbol\n\
1972 Return the static-linkage symbol corresponding to the given name (or None)." },
1973 { "lookup_static_symbols", (PyCFunction
) gdbpy_lookup_static_symbols
,
1974 METH_VARARGS
| METH_KEYWORDS
,
1975 "lookup_static_symbols (name [, domain]) -> symbol\n\
1976 Return a list of all static-linkage symbols corresponding to the given name." },
1978 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1979 METH_VARARGS
| METH_KEYWORDS
,
1980 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1981 Look up the specified objfile.\n\
1982 If by_build_id is True, the objfile is looked up by using name\n\
1983 as its build id." },
1985 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1986 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1987 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1988 The first element contains any unparsed portion of the String parameter\n\
1989 (or None if the string was fully parsed). The second element contains\n\
1990 a tuple that contains all the locations that match, represented as\n\
1991 gdb.Symtab_and_line objects (or None)."},
1992 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1993 "parse_and_eval (String) -> Value.\n\
1994 Parse String as an expression, evaluate it, and return the result as a Value."
1997 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1998 "Post an event into gdb's event loop." },
2000 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2001 "target_charset () -> string.\n\
2002 Return the name of the current target charset." },
2003 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2004 "target_wide_charset () -> string.\n\
2005 Return the name of the current target wide charset." },
2006 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2007 "rbreak (Regex) -> List.\n\
2008 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2009 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2010 "string_to_argv (String) -> Array.\n\
2011 Parse String and return an argv-like array.\n\
2012 Arguments are separate by spaces and may be quoted."
2014 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2015 "Write a string using gdb's filtered stream." },
2016 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2017 "Flush gdb's filtered stdout stream." },
2018 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2019 "selected_thread () -> gdb.InferiorThread.\n\
2020 Return the selected thread object." },
2021 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2022 "selected_inferior () -> gdb.Inferior.\n\
2023 Return the selected inferior object." },
2024 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2025 "inferiors () -> (gdb.Inferior, ...).\n\
2026 Return a tuple containing all inferiors." },
2028 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2029 "invalidate_cached_frames () -> None.\n\
2030 Invalidate any cached frame objects in gdb.\n\
2031 Intended for internal use only." },
2033 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2034 "convenience_variable (NAME) -> value.\n\
2035 Return the value of the convenience variable $NAME,\n\
2036 or None if not set." },
2037 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2038 "convenience_variable (NAME, VALUE) -> None.\n\
2039 Set the value of the convenience variable $NAME." },
2041 {NULL
, NULL
, 0, NULL
}
2045 struct PyModuleDef python_GdbModuleDef
=
2047 PyModuleDef_HEAD_INIT
,
2059 /* Define all the event objects. */
2060 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2061 PyTypeObject name##_event_object_type \
2062 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2064 PyVarObject_HEAD_INIT (NULL, 0) \
2065 "gdb." py_name, /* tp_name */ \
2066 sizeof (event_object), /* tp_basicsize */ \
2067 0, /* tp_itemsize */ \
2068 evpy_dealloc, /* tp_dealloc */ \
2070 0, /* tp_getattr */ \
2071 0, /* tp_setattr */ \
2072 0, /* tp_compare */ \
2074 0, /* tp_as_number */ \
2075 0, /* tp_as_sequence */ \
2076 0, /* tp_as_mapping */ \
2080 0, /* tp_getattro */ \
2081 0, /* tp_setattro */ \
2082 0, /* tp_as_buffer */ \
2083 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2085 0, /* tp_traverse */ \
2087 0, /* tp_richcompare */ \
2088 0, /* tp_weaklistoffset */ \
2090 0, /* tp_iternext */ \
2091 0, /* tp_methods */ \
2092 0, /* tp_members */ \
2093 0, /* tp_getset */ \
2094 &base, /* tp_base */ \
2096 0, /* tp_descr_get */ \
2097 0, /* tp_descr_set */ \
2098 0, /* tp_dictoffset */ \
2102 #include "py-event-types.def"
2103 #undef GDB_PY_DEFINE_EVENT_TYPE
2105 #endif /* HAVE_PYTHON */