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
)
647 /* A simple type to ensure clean up of a vector of allocated strings
648 when a C interface demands a const char *array[] type
650 struct symtab_list_type
654 for (const char *elem
: vec
)
655 xfree ((void *) elem
);
657 std::vector
<const char *> vec
;
661 std::vector
<symbol_search
> symbols
;
662 unsigned long count
= 0;
663 PyObject
*symtab_list
= NULL
;
664 PyObject
*minsyms_p_obj
= NULL
;
666 unsigned int throttle
= 0;
667 static const char *keywords
[] = {"regex","minsyms", "throttle",
669 symtab_list_type symtab_paths
;
671 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
672 ®ex
, &PyBool_Type
,
673 &minsyms_p_obj
, &throttle
,
677 /* Parse minsyms keyword. */
678 if (minsyms_p_obj
!= NULL
)
680 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
686 /* The "symtabs" keyword is any Python iterable object that returns
687 a gdb.Symtab on each iteration. If specified, iterate through
688 the provided gdb.Symtabs and extract their full path. As
689 python_string_to_target_string returns a
690 gdb::unique_xmalloc_ptr<char> and a vector containing these types
691 cannot be coerced to a const char **p[] via the vector.data call,
692 release the value from the unique_xmalloc_ptr and place it in a
693 simple type symtab_list_type (which holds the vector and a
694 destructor that frees the contents of the allocated strings. */
695 if (symtab_list
!= NULL
)
697 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
704 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
708 if (PyErr_Occurred ())
713 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
716 if (obj_name
== NULL
)
719 /* Is the object file still valid? */
720 if (obj_name
== Py_None
)
723 gdb::unique_xmalloc_ptr
<char> filename
=
724 python_string_to_target_string (obj_name
.get ());
726 if (filename
== NULL
)
729 /* Make sure there is a definite place to store the value of
730 filename before it is released. */
731 symtab_paths
.vec
.push_back (nullptr);
732 symtab_paths
.vec
.back () = filename
.release ();
738 const char **files
= symtab_paths
.vec
.data ();
740 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
,
741 symtab_paths
.vec
.size (), files
, false);
744 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
, 0, NULL
, false);
746 /* Count the number of symbols (both symbols and optionally minimal
747 symbols) so we can correctly check the throttle limit. */
748 for (const symbol_search
&p
: symbols
)
750 /* Minimal symbols included? */
753 if (p
.msymbol
.minsym
!= NULL
)
757 if (p
.symbol
!= NULL
)
761 /* Check throttle bounds and exit if in excess. */
762 if (throttle
!= 0 && count
> throttle
)
764 PyErr_SetString (PyExc_RuntimeError
,
765 _("Number of breakpoints exceeds throttled maximum."));
769 gdbpy_ref
<> return_list (PyList_New (0));
771 if (return_list
== NULL
)
774 /* Construct full path names for symbols and call the Python
775 breakpoint constructor on the resulting names. Be tolerant of
776 individual breakpoint failures. */
777 for (const symbol_search
&p
: symbols
)
779 std::string symbol_name
;
781 /* Skipping minimal symbols? */
783 if (p
.msymbol
.minsym
!= NULL
)
786 if (p
.msymbol
.minsym
== NULL
)
788 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
789 const char *fullname
= symtab_to_fullname (symtab
);
791 symbol_name
= fullname
;
793 symbol_name
+= p
.symbol
->linkage_name ();
796 symbol_name
= p
.msymbol
.minsym
->linkage_name ();
798 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
799 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
800 &breakpoint_object_type
,
803 /* Tolerate individual breakpoint failures. */
805 gdbpy_print_stack ();
808 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
812 return return_list
.release ();
815 /* A Python function which is a wrapper for decode_line_1. */
818 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
820 const char *arg
= NULL
;
822 gdbpy_ref
<> unparsed
;
823 event_location_up location
;
825 if (! PyArg_ParseTuple (args
, "|s", &arg
))
829 location
= string_to_event_location_basic (&arg
, python_language
,
830 symbol_name_match_type::WILD
);
832 std::vector
<symtab_and_line
> decoded_sals
;
833 symtab_and_line def_sal
;
834 gdb::array_view
<symtab_and_line
> sals
;
837 if (location
!= NULL
)
839 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
844 set_default_source_symtab_and_line ();
845 def_sal
= get_current_source_symtab_and_line ();
849 catch (const gdb_exception
&ex
)
851 /* We know this will always throw. */
852 gdbpy_convert_exception (ex
);
858 result
.reset (PyTuple_New (sals
.size ()));
861 for (size_t i
= 0; i
< sals
.size (); ++i
)
863 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
867 PyTuple_SetItem (result
.get (), i
, obj
);
871 result
= gdbpy_ref
<>::new_reference (Py_None
);
873 gdbpy_ref
<> return_result (PyTuple_New (2));
874 if (return_result
== NULL
)
877 if (arg
!= NULL
&& strlen (arg
) > 0)
879 unparsed
.reset (PyString_FromString (arg
));
880 if (unparsed
== NULL
)
884 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
886 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
887 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
889 return return_result
.release ();
892 /* Parse a string and evaluate it as an expression. */
894 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
896 const char *expr_str
;
897 struct value
*result
= NULL
;
899 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
904 gdbpy_allow_threads allow_threads
;
905 result
= parse_and_eval (expr_str
);
907 catch (const gdb_exception
&except
)
909 GDB_PY_HANDLE_EXCEPTION (except
);
912 return value_to_value_object (result
);
915 /* Implementation of gdb.invalidate_cached_frames. */
918 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
920 reinit_frame_cache ();
924 /* Read a file as Python code.
925 This is the extension_language_script_ops.script_sourcer "method".
926 FILE is the file to load. FILENAME is name of the file FILE.
927 This does not throw any errors. If an exception occurs python will print
928 the traceback and clear the error indicator. */
931 gdbpy_source_script (const struct extension_language_defn
*extlang
,
932 FILE *file
, const char *filename
)
934 gdbpy_enter
enter_py (get_current_arch (), current_language
);
935 python_run_simple_file (file
, filename
);
940 /* Posting and handling events. */
942 /* A helper class to save and restore the GIL, but without touching
943 the other globals that are handled by gdbpy_enter. */
950 : m_state (PyGILState_Ensure ())
956 PyGILState_Release (m_state
);
959 DISABLE_COPY_AND_ASSIGN (gdbpy_gil
);
963 PyGILState_STATE m_state
;
966 /* A single event. */
969 gdbpy_event (gdbpy_ref
<> &&func
)
970 : m_func (func
.release ())
974 gdbpy_event (gdbpy_event
&&other
)
975 : m_func (other
.m_func
)
977 other
.m_func
= nullptr;
980 gdbpy_event (const gdbpy_event
&other
)
981 : m_func (other
.m_func
)
993 gdbpy_event
&operator= (const gdbpy_event
&other
) = delete;
997 gdbpy_enter
enter_py (get_current_arch (), current_language
);
999 gdbpy_ref
<> call_result (PyObject_CallObject (m_func
, NULL
));
1000 if (call_result
== NULL
)
1001 gdbpy_print_stack ();
1006 /* The Python event. This is just a callable object. Note that
1007 this is not a gdbpy_ref<>, because we have to take particular
1008 care to only destroy the reference when holding the GIL. */
1012 /* Submit an event to the gdb thread. */
1014 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1018 if (!PyArg_ParseTuple (args
, "O", &func
))
1021 if (!PyCallable_Check (func
))
1023 PyErr_SetString (PyExc_RuntimeError
,
1024 _("Posted event is not callable"));
1028 gdbpy_ref
<> func_ref
= gdbpy_ref
<>::new_reference (func
);
1029 gdbpy_event
event (std::move (func_ref
));
1030 run_on_main_thread (event
);
1037 /* This is the extension_language_ops.before_prompt "method". */
1039 static enum ext_lang_rc
1040 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1041 const char *current_gdb_prompt
)
1043 if (!gdb_python_initialized
)
1044 return EXT_LANG_RC_NOP
;
1046 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1048 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1049 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1050 return EXT_LANG_RC_ERROR
;
1052 if (gdb_python_module
1053 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1055 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1059 gdbpy_print_stack ();
1060 return EXT_LANG_RC_ERROR
;
1063 if (PyCallable_Check (hook
.get ()))
1065 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1066 if (current_prompt
== NULL
)
1068 gdbpy_print_stack ();
1069 return EXT_LANG_RC_ERROR
;
1073 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1077 gdbpy_print_stack ();
1078 return EXT_LANG_RC_ERROR
;
1081 /* Return type should be None, or a String. If it is None,
1082 fall through, we will not set a prompt. If it is a
1083 string, set PROMPT. Anything else, set an exception. */
1084 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1086 PyErr_Format (PyExc_RuntimeError
,
1087 _("Return from prompt_hook must " \
1088 "be either a Python string, or None"));
1089 gdbpy_print_stack ();
1090 return EXT_LANG_RC_ERROR
;
1093 if (result
!= Py_None
)
1095 gdb::unique_xmalloc_ptr
<char>
1096 prompt (python_string_to_host_string (result
.get ()));
1100 gdbpy_print_stack ();
1101 return EXT_LANG_RC_ERROR
;
1104 set_prompt (prompt
.get ());
1105 return EXT_LANG_RC_OK
;
1110 return EXT_LANG_RC_NOP
;
1117 /* A python function to write a single string using gdb's filtered
1118 output stream . The optional keyword STREAM can be used to write
1119 to a particular stream. The default stream is to gdb_stdout. */
1122 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1125 static const char *keywords
[] = { "text", "stream", NULL
};
1126 int stream_type
= 0;
1128 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1134 switch (stream_type
)
1138 fprintf_filtered (gdb_stderr
, "%s", arg
);
1143 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1147 fprintf_filtered (gdb_stdout
, "%s", arg
);
1150 catch (const gdb_exception
&except
)
1152 GDB_PY_HANDLE_EXCEPTION (except
);
1158 /* A python function to flush a gdb stream. The optional keyword
1159 STREAM can be used to flush a particular stream. The default stream
1163 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1165 static const char *keywords
[] = { "stream", NULL
};
1166 int stream_type
= 0;
1168 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1172 switch (stream_type
)
1176 gdb_flush (gdb_stderr
);
1181 gdb_flush (gdb_stdlog
);
1185 gdb_flush (gdb_stdout
);
1191 /* Return non-zero if print-stack is not "none". */
1194 gdbpy_print_python_errors_p (void)
1196 return gdbpy_should_print_stack
!= python_excp_none
;
1199 /* Print a python exception trace, print just a message, or print
1200 nothing and clear the python exception, depending on
1201 gdbpy_should_print_stack. Only call this if a python exception is
1204 gdbpy_print_stack (void)
1207 /* Print "none", just clear exception. */
1208 if (gdbpy_should_print_stack
== python_excp_none
)
1212 /* Print "full" message and backtrace. */
1213 else if (gdbpy_should_print_stack
== python_excp_full
)
1216 /* PyErr_Print doesn't necessarily end output with a newline.
1217 This works because Python's stdout/stderr is fed through
1223 catch (const gdb_exception
&except
)
1227 /* Print "message", just error print message. */
1230 gdbpy_err_fetch fetched_error
;
1232 gdb::unique_xmalloc_ptr
<char> msg
= fetched_error
.to_string ();
1233 gdb::unique_xmalloc_ptr
<char> type
;
1234 /* Don't compute TYPE if MSG already indicates that there is an
1237 type
= fetched_error
.type_to_string ();
1241 if (msg
== NULL
|| type
== NULL
)
1243 /* An error occurred computing the string representation of the
1245 fprintf_filtered (gdb_stderr
,
1246 _("Error occurred computing Python error" \
1251 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1252 type
.get (), msg
.get ());
1254 catch (const gdb_exception
&except
)
1260 /* Like gdbpy_print_stack, but if the exception is a
1261 KeyboardException, throw a gdb "quit" instead. */
1264 gdbpy_print_stack_or_quit ()
1266 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1269 throw_quit ("Quit");
1271 gdbpy_print_stack ();
1276 /* Return a sequence holding all the Progspaces. */
1279 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1281 struct program_space
*ps
;
1283 gdbpy_ref
<> list (PyList_New (0));
1289 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1291 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1295 return list
.release ();
1300 /* The "current" objfile. This is set when gdb detects that a new
1301 objfile has been loaded. It is only set for the duration of a call to
1302 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1304 static struct objfile
*gdbpy_current_objfile
;
1306 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1307 as Python code. This does not throw any errors. If an exception
1308 occurs python will print the traceback and clear the error indicator.
1309 This is the extension_language_script_ops.objfile_script_sourcer
1313 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1314 struct objfile
*objfile
, FILE *file
,
1315 const char *filename
)
1317 if (!gdb_python_initialized
)
1320 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1321 gdbpy_current_objfile
= objfile
;
1323 python_run_simple_file (file
, filename
);
1325 gdbpy_current_objfile
= NULL
;
1328 /* Set the current objfile to OBJFILE and then execute SCRIPT
1329 as Python code. This does not throw any errors. If an exception
1330 occurs python will print the traceback and clear the error indicator.
1331 This is the extension_language_script_ops.objfile_script_executor
1335 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1336 struct objfile
*objfile
, const char *name
,
1339 if (!gdb_python_initialized
)
1342 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1343 gdbpy_current_objfile
= objfile
;
1345 PyRun_SimpleString (script
);
1347 gdbpy_current_objfile
= NULL
;
1350 /* Return the current Objfile, or None if there isn't one. */
1353 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1355 if (! gdbpy_current_objfile
)
1358 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1361 /* Compute the list of active python type printers and store them in
1362 EXT_PRINTERS->py_type_printers. The product of this function is used by
1363 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1364 This is the extension_language_ops.start_type_printers "method". */
1367 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1368 struct ext_lang_type_printers
*ext_printers
)
1370 PyObject
*printers_obj
= NULL
;
1372 if (!gdb_python_initialized
)
1375 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1377 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1378 if (type_module
== NULL
)
1380 gdbpy_print_stack ();
1384 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1385 "get_type_recognizers"));
1388 gdbpy_print_stack ();
1392 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1393 if (printers_obj
== NULL
)
1394 gdbpy_print_stack ();
1396 ext_printers
->py_type_printers
= printers_obj
;
1399 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1400 a newly allocated string holding the type's replacement name, and return
1401 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1402 If there's a Python error return EXT_LANG_RC_ERROR.
1403 Otherwise, return EXT_LANG_RC_NOP.
1404 This is the extension_language_ops.apply_type_printers "method". */
1406 static enum ext_lang_rc
1407 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1408 const struct ext_lang_type_printers
*ext_printers
,
1409 struct type
*type
, char **prettied_type
)
1411 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1412 gdb::unique_xmalloc_ptr
<char> result
;
1414 if (printers_obj
== NULL
)
1415 return EXT_LANG_RC_NOP
;
1417 if (!gdb_python_initialized
)
1418 return EXT_LANG_RC_NOP
;
1420 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1422 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1423 if (type_obj
== NULL
)
1425 gdbpy_print_stack ();
1426 return EXT_LANG_RC_ERROR
;
1429 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1430 if (type_module
== NULL
)
1432 gdbpy_print_stack ();
1433 return EXT_LANG_RC_ERROR
;
1436 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1437 "apply_type_recognizers"));
1440 gdbpy_print_stack ();
1441 return EXT_LANG_RC_ERROR
;
1444 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1448 if (result_obj
== NULL
)
1450 gdbpy_print_stack ();
1451 return EXT_LANG_RC_ERROR
;
1454 if (result_obj
== Py_None
)
1455 return EXT_LANG_RC_NOP
;
1457 result
= python_string_to_host_string (result_obj
.get ());
1460 gdbpy_print_stack ();
1461 return EXT_LANG_RC_ERROR
;
1464 *prettied_type
= result
.release ();
1465 return EXT_LANG_RC_OK
;
1468 /* Free the result of start_type_printers.
1469 This is the extension_language_ops.free_type_printers "method". */
1472 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1473 struct ext_lang_type_printers
*ext_printers
)
1475 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1477 if (printers
== NULL
)
1480 if (!gdb_python_initialized
)
1483 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1484 Py_DECREF (printers
);
1487 #else /* HAVE_PYTHON */
1489 /* Dummy implementation of the gdb "python-interactive" and "python"
1493 python_interactive_command (const char *arg
, int from_tty
)
1495 arg
= skip_spaces (arg
);
1497 error (_("Python scripting is not supported in this copy of GDB."));
1500 counted_command_line l
= get_command_line (python_control
, "");
1502 execute_control_command_untraced (l
.get ());
1507 python_command (const char *arg
, int from_tty
)
1509 python_interactive_command (arg
, from_tty
);
1512 #endif /* HAVE_PYTHON */
1516 /* Lists for 'set python' commands. */
1518 static struct cmd_list_element
*user_set_python_list
;
1519 static struct cmd_list_element
*user_show_python_list
;
1521 /* Function for use by 'set python' prefix command. */
1524 user_set_python (const char *args
, int from_tty
)
1526 help_list (user_set_python_list
, "set python ", all_commands
,
1530 /* Function for use by 'show python' prefix command. */
1533 user_show_python (const char *args
, int from_tty
)
1535 cmd_show_list (user_show_python_list
, from_tty
, "");
1538 /* Initialize the Python code. */
1542 /* This is installed as a final cleanup and cleans up the
1543 interpreter. This lets Python's 'atexit' work. */
1546 finalize_python (void *ignore
)
1548 struct active_ext_lang_state
*previous_active
;
1550 /* We don't use ensure_python_env here because if we ever ran the
1551 cleanup, gdb would crash -- because the cleanup calls into the
1552 Python interpreter, which we are about to destroy. It seems
1553 clearer to make the needed calls explicitly here than to create a
1554 cleanup and then mysteriously discard it. */
1556 /* This is only called as a final cleanup so we can assume the active
1557 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1558 previous_active
= set_active_ext_lang (&extension_language_python
);
1560 (void) PyGILState_Ensure ();
1561 python_gdbarch
= target_gdbarch ();
1562 python_language
= current_language
;
1566 restore_active_ext_lang (previous_active
);
1570 /* This is called via the PyImport_AppendInittab mechanism called
1571 during initialization, to make the built-in _gdb module known to
1574 init__gdb_module (void)
1576 return PyModule_Create (&python_GdbModuleDef
);
1581 do_start_initialization ()
1584 size_t progsize
, count
;
1585 /* Python documentation indicates that the memory given
1586 to Py_SetProgramName cannot be freed. However, it seems that
1587 at least Python 3.7.4 Py_SetProgramName takes a copy of the
1588 given program_name. Making progname_copy static and not release
1589 the memory avoids a leak report for Python versions that duplicate
1590 program_name, and respect the requirement of Py_SetProgramName
1591 for Python versions that do not duplicate program_name. */
1592 static wchar_t *progname_copy
;
1595 #ifdef WITH_PYTHON_PATH
1596 /* Work around problem where python gets confused about where it is,
1597 and then can't find its libraries, etc.
1598 NOTE: Python assumes the following layout:
1600 /foo/lib/pythonX.Y/...
1601 This must be done before calling Py_Initialize. */
1602 gdb::unique_xmalloc_ptr
<char> progname
1603 (concat (ldirname (python_libdir
.c_str ()).c_str (), SLASH_STRING
, "bin",
1604 SLASH_STRING
, "python", (char *) NULL
));
1606 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1607 setlocale (LC_ALL
, "");
1608 progsize
= strlen (progname
.get ());
1609 progname_copy
= (wchar_t *) xmalloc ((progsize
+ 1) * sizeof (wchar_t));
1612 fprintf (stderr
, "out of memory\n");
1615 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1616 if (count
== (size_t) -1)
1618 fprintf (stderr
, "Could not convert python path to string\n");
1621 setlocale (LC_ALL
, oldloc
.c_str ());
1623 /* Note that Py_SetProgramName expects the string it is passed to
1624 remain alive for the duration of the program's execution, so
1625 it is not freed after this call. */
1626 Py_SetProgramName (progname_copy
);
1628 /* Define _gdb as a built-in module. */
1629 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1631 Py_SetProgramName (progname
.release ());
1636 PyEval_InitThreads ();
1639 gdb_module
= PyImport_ImportModule ("_gdb");
1641 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1643 if (gdb_module
== NULL
)
1646 if (PyModule_AddStringConstant (gdb_module
, "VERSION", version
) < 0
1647 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", host_name
) < 0
1648 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1652 /* Add stream constants. */
1653 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1654 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1655 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1658 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1659 if (gdbpy_gdb_error
== NULL
1660 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1663 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1664 gdbpy_gdb_error
, NULL
);
1665 if (gdbpy_gdb_memory_error
== NULL
1666 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1667 gdbpy_gdb_memory_error
) < 0)
1670 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1671 if (gdbpy_gdberror_exc
== NULL
1672 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1673 gdbpy_gdberror_exc
) < 0)
1676 gdbpy_initialize_gdb_readline ();
1678 if (gdbpy_initialize_auto_load () < 0
1679 || gdbpy_initialize_values () < 0
1680 || gdbpy_initialize_frames () < 0
1681 || gdbpy_initialize_commands () < 0
1682 || gdbpy_initialize_instruction () < 0
1683 || gdbpy_initialize_record () < 0
1684 || gdbpy_initialize_btrace () < 0
1685 || gdbpy_initialize_symbols () < 0
1686 || gdbpy_initialize_symtabs () < 0
1687 || gdbpy_initialize_blocks () < 0
1688 || gdbpy_initialize_functions () < 0
1689 || gdbpy_initialize_parameters () < 0
1690 || gdbpy_initialize_types () < 0
1691 || gdbpy_initialize_pspace () < 0
1692 || gdbpy_initialize_objfile () < 0
1693 || gdbpy_initialize_breakpoints () < 0
1694 || gdbpy_initialize_finishbreakpoints () < 0
1695 || gdbpy_initialize_lazy_string () < 0
1696 || gdbpy_initialize_linetable () < 0
1697 || gdbpy_initialize_thread () < 0
1698 || gdbpy_initialize_inferior () < 0
1699 || gdbpy_initialize_eventregistry () < 0
1700 || gdbpy_initialize_py_events () < 0
1701 || gdbpy_initialize_event () < 0
1702 || gdbpy_initialize_arch () < 0
1703 || gdbpy_initialize_xmethods () < 0
1704 || gdbpy_initialize_unwind () < 0)
1707 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1708 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1710 #include "py-event-types.def"
1711 #undef GDB_PY_DEFINE_EVENT_TYPE
1713 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1714 if (gdbpy_to_string_cst
== NULL
)
1716 gdbpy_children_cst
= PyString_FromString ("children");
1717 if (gdbpy_children_cst
== NULL
)
1719 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1720 if (gdbpy_display_hint_cst
== NULL
)
1722 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1723 if (gdbpy_doc_cst
== NULL
)
1725 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1726 if (gdbpy_enabled_cst
== NULL
)
1728 gdbpy_value_cst
= PyString_FromString ("value");
1729 if (gdbpy_value_cst
== NULL
)
1732 /* Release the GIL while gdb runs. */
1733 PyThreadState_Swap (NULL
);
1734 PyEval_ReleaseLock ();
1736 make_final_cleanup (finalize_python
, NULL
);
1738 /* Only set this when initialization has succeeded. */
1739 gdb_python_initialized
= 1;
1743 #endif /* HAVE_PYTHON */
1746 cmd_list_element
*python_cmd_element
= nullptr;
1749 _initialize_python (void)
1751 add_com ("python-interactive", class_obscure
,
1752 python_interactive_command
,
1755 Start an interactive Python prompt.\n\
1757 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1760 Alternatively, a single-line Python command can be given as an\n\
1761 argument, and if the command is an expression, the result will be\n\
1762 printed. For example:\n\
1764 (gdb) python-interactive 2 + 3\n\
1766 #else /* HAVE_PYTHON */
1768 Start a Python interactive prompt.\n\
1770 Python scripting is not supported in this copy of GDB.\n\
1771 This command is only a placeholder.")
1772 #endif /* HAVE_PYTHON */
1774 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1776 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1779 Evaluate a Python command.\n\
1781 The command can be given as an argument, for instance:\n\
1783 python print (23)\n\
1785 If no argument is given, the following lines are read and used\n\
1786 as the Python commands. Type a line containing \"end\" to indicate\n\
1787 the end of the command.")
1788 #else /* HAVE_PYTHON */
1790 Evaluate a Python command.\n\
1792 Python scripting is not supported in this copy of GDB.\n\
1793 This command is only a placeholder.")
1794 #endif /* HAVE_PYTHON */
1796 add_com_alias ("py", "python", class_obscure
, 1);
1798 /* Add set/show python print-stack. */
1799 add_prefix_cmd ("python", no_class
, user_show_python
,
1800 _("Prefix command for python preference settings."),
1801 &user_show_python_list
, "show python ", 0,
1804 add_prefix_cmd ("python", no_class
, user_set_python
,
1805 _("Prefix command for python preference settings."),
1806 &user_set_python_list
, "set python ", 0,
1809 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1810 &gdbpy_should_print_stack
, _("\
1811 Set mode for Python stack dump on error."), _("\
1812 Show the mode of Python stack printing on error."), _("\
1813 none == no stack or message will be printed.\n\
1814 full == a message and a stack will be printed.\n\
1815 message == an error message without a stack will be printed."),
1817 &user_set_python_list
,
1818 &user_show_python_list
);
1821 if (!do_start_initialization () && PyErr_Occurred ())
1822 gdbpy_print_stack ();
1823 #endif /* HAVE_PYTHON */
1828 /* Helper function for gdbpy_finish_initialization. This does the
1829 work and then returns false if an error has occurred and must be
1830 displayed, or true on success. */
1833 do_finish_initialization (const struct extension_language_defn
*extlang
)
1838 /* Add the initial data-directory to sys.path. */
1840 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1843 sys_path
= PySys_GetObject ("path");
1845 /* If sys.path is not defined yet, define it first. */
1846 if (!(sys_path
&& PyList_Check (sys_path
)))
1849 PySys_SetPath (L
"");
1853 sys_path
= PySys_GetObject ("path");
1855 if (sys_path
&& PyList_Check (sys_path
))
1857 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1858 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1864 /* Import the gdb module to finish the initialization, and
1865 add it to __main__ for convenience. */
1866 m
= PyImport_AddModule ("__main__");
1870 /* Keep the reference to gdb_python_module since it is in a global
1872 gdb_python_module
= PyImport_ImportModule ("gdb");
1873 if (gdb_python_module
== NULL
)
1875 gdbpy_print_stack ();
1876 /* This is passed in one call to warning so that blank lines aren't
1877 inserted between each line of text. */
1879 "Could not load the Python gdb module from `%s'.\n"
1880 "Limited Python support is available from the _gdb module.\n"
1881 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
1882 gdb_pythondir
.c_str ());
1883 /* We return "success" here as we've already emitted the
1888 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1891 /* Perform the remaining python initializations.
1892 These must be done after GDB is at least mostly initialized.
1893 E.g., The "info pretty-printer" command needs the "info" prefix
1895 This is the extension_language_ops.finish_initialization "method". */
1898 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1900 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1902 if (!do_finish_initialization (extlang
))
1904 gdbpy_print_stack ();
1905 warning (_("internal error: Unhandled Python exception"));
1909 /* Return non-zero if Python has successfully initialized.
1910 This is the extension_languages_ops.initialized "method". */
1913 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1915 return gdb_python_initialized
;
1918 #endif /* HAVE_PYTHON */
1924 PyMethodDef python_GdbMethods
[] =
1926 { "history", gdbpy_history
, METH_VARARGS
,
1927 "Get a value from history" },
1928 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1929 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1930 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1931 a Python String containing the output of the command if to_string is\n\
1933 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1934 "Return a gdb parameter's value" },
1936 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1937 "Return a tuple of all breakpoint objects" },
1939 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1940 "Find the default visualizer for a Value." },
1942 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1943 "Return a sequence of all progspaces." },
1945 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1946 "Return the current Objfile being loaded, or None." },
1948 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1949 "newest_frame () -> gdb.Frame.\n\
1950 Return the newest frame object." },
1951 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1952 "selected_frame () -> gdb.Frame.\n\
1953 Return the selected frame object." },
1954 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1955 "stop_reason_string (Integer) -> String.\n\
1956 Return a string explaining unwind stop reason." },
1958 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1959 "start_recording ([method] [, format]) -> gdb.Record.\n\
1960 Start recording with the given method. If no method is given, will fall back\n\
1961 to the system default method. If no format is given, will fall back to the\n\
1962 default format for the given method."},
1963 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1964 "current_recording () -> gdb.Record.\n\
1965 Return current recording object." },
1966 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1967 "stop_recording () -> None.\n\
1968 Stop current recording." },
1970 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1971 METH_VARARGS
| METH_KEYWORDS
,
1972 "lookup_type (name [, block]) -> type\n\
1973 Return a Type corresponding to the given name." },
1974 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1975 METH_VARARGS
| METH_KEYWORDS
,
1976 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1977 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1978 a boolean indicating if name is a field of the current implied argument\n\
1979 `this' (when the current language is object-oriented)." },
1980 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1981 METH_VARARGS
| METH_KEYWORDS
,
1982 "lookup_global_symbol (name [, domain]) -> symbol\n\
1983 Return the symbol corresponding to the given name (or None)." },
1984 { "lookup_static_symbol", (PyCFunction
) gdbpy_lookup_static_symbol
,
1985 METH_VARARGS
| METH_KEYWORDS
,
1986 "lookup_static_symbol (name [, domain]) -> symbol\n\
1987 Return the static-linkage symbol corresponding to the given name (or None)." },
1988 { "lookup_static_symbols", (PyCFunction
) gdbpy_lookup_static_symbols
,
1989 METH_VARARGS
| METH_KEYWORDS
,
1990 "lookup_static_symbols (name [, domain]) -> symbol\n\
1991 Return a list of all static-linkage symbols corresponding to the given name." },
1993 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1994 METH_VARARGS
| METH_KEYWORDS
,
1995 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1996 Look up the specified objfile.\n\
1997 If by_build_id is True, the objfile is looked up by using name\n\
1998 as its build id." },
2000 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2001 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2002 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2003 The first element contains any unparsed portion of the String parameter\n\
2004 (or None if the string was fully parsed). The second element contains\n\
2005 a tuple that contains all the locations that match, represented as\n\
2006 gdb.Symtab_and_line objects (or None)."},
2007 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2008 "parse_and_eval (String) -> Value.\n\
2009 Parse String as an expression, evaluate it, and return the result as a Value."
2012 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2013 "Post an event into gdb's event loop." },
2015 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2016 "target_charset () -> string.\n\
2017 Return the name of the current target charset." },
2018 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2019 "target_wide_charset () -> string.\n\
2020 Return the name of the current target wide charset." },
2021 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2022 "rbreak (Regex) -> List.\n\
2023 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2024 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2025 "string_to_argv (String) -> Array.\n\
2026 Parse String and return an argv-like array.\n\
2027 Arguments are separate by spaces and may be quoted."
2029 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2030 "Write a string using gdb's filtered stream." },
2031 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2032 "Flush gdb's filtered stdout stream." },
2033 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2034 "selected_thread () -> gdb.InferiorThread.\n\
2035 Return the selected thread object." },
2036 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2037 "selected_inferior () -> gdb.Inferior.\n\
2038 Return the selected inferior object." },
2039 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2040 "inferiors () -> (gdb.Inferior, ...).\n\
2041 Return a tuple containing all inferiors." },
2043 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2044 "invalidate_cached_frames () -> None.\n\
2045 Invalidate any cached frame objects in gdb.\n\
2046 Intended for internal use only." },
2048 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2049 "convenience_variable (NAME) -> value.\n\
2050 Return the value of the convenience variable $NAME,\n\
2051 or None if not set." },
2052 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2053 "convenience_variable (NAME, VALUE) -> None.\n\
2054 Set the value of the convenience variable $NAME." },
2056 {NULL
, NULL
, 0, NULL
}
2060 struct PyModuleDef python_GdbModuleDef
=
2062 PyModuleDef_HEAD_INIT
,
2074 /* Define all the event objects. */
2075 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2076 PyTypeObject name##_event_object_type \
2077 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2079 PyVarObject_HEAD_INIT (NULL, 0) \
2080 "gdb." py_name, /* tp_name */ \
2081 sizeof (event_object), /* tp_basicsize */ \
2082 0, /* tp_itemsize */ \
2083 evpy_dealloc, /* tp_dealloc */ \
2085 0, /* tp_getattr */ \
2086 0, /* tp_setattr */ \
2087 0, /* tp_compare */ \
2089 0, /* tp_as_number */ \
2090 0, /* tp_as_sequence */ \
2091 0, /* tp_as_mapping */ \
2095 0, /* tp_getattro */ \
2096 0, /* tp_setattro */ \
2097 0, /* tp_as_buffer */ \
2098 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2100 0, /* tp_traverse */ \
2102 0, /* tp_richcompare */ \
2103 0, /* tp_weaklistoffset */ \
2105 0, /* tp_iternext */ \
2106 0, /* tp_methods */ \
2107 0, /* tp_members */ \
2108 0, /* tp_getset */ \
2109 &base, /* tp_base */ \
2111 0, /* tp_descr_get */ \
2112 0, /* tp_descr_set */ \
2113 0, /* tp_dictoffset */ \
2117 #include "py-event-types.def"
2118 #undef GDB_PY_DEFINE_EVENT_TYPE
2120 #endif /* HAVE_PYTHON */