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"
32 #include "readline/tilde.h"
34 #include "extension-priv.h"
35 #include "cli/cli-utils.h"
38 #include "ser-event.h"
40 /* Declared constants and enum for python stack printing. */
41 static const char python_excp_none
[] = "none";
42 static const char python_excp_full
[] = "full";
43 static const char python_excp_message
[] = "message";
45 /* "set python print-stack" choices. */
46 static const char *const python_excp_enums
[] =
54 /* The exception printing variable. 'full' if we want to print the
55 error message and stack, 'none' if we want to print nothing, and
56 'message' if we only want to print the error message. 'message' is
58 static const char *gdbpy_should_print_stack
= python_excp_message
;
61 /* Forward decls, these are defined later. */
62 extern const struct extension_language_script_ops python_extension_script_ops
;
63 extern const struct extension_language_ops python_extension_ops
;
66 /* The main struct describing GDB's interface to the Python
67 extension language. */
68 const struct extension_language_defn extension_language_python
=
80 &python_extension_script_ops
,
90 #include "cli/cli-decode.h"
93 #include "python-internal.h"
96 #include "gdbsupport/version.h"
98 #include "gdbthread.h"
100 #include "event-top.h"
101 #include "py-event.h"
103 /* True if Python has been successfully initialized, false
106 int gdb_python_initialized
;
108 extern PyMethodDef python_GdbMethods
[];
111 extern struct PyModuleDef python_GdbModuleDef
;
114 PyObject
*gdb_module
;
115 PyObject
*gdb_python_module
;
117 /* Some string constants we may wish to use. */
118 PyObject
*gdbpy_to_string_cst
;
119 PyObject
*gdbpy_children_cst
;
120 PyObject
*gdbpy_display_hint_cst
;
121 PyObject
*gdbpy_doc_cst
;
122 PyObject
*gdbpy_enabled_cst
;
123 PyObject
*gdbpy_value_cst
;
125 /* The GdbError exception. */
126 PyObject
*gdbpy_gdberror_exc
;
128 /* The `gdb.error' base class. */
129 PyObject
*gdbpy_gdb_error
;
131 /* The `gdb.MemoryError' exception. */
132 PyObject
*gdbpy_gdb_memory_error
;
134 static script_sourcer_func gdbpy_source_script
;
135 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
136 static objfile_script_executor_func gdbpy_execute_objfile_script
;
137 static void gdbpy_finish_initialization
138 (const struct extension_language_defn
*);
139 static int gdbpy_initialized (const struct extension_language_defn
*);
140 static void gdbpy_eval_from_control_command
141 (const struct extension_language_defn
*, struct command_line
*cmd
);
142 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
143 struct ext_lang_type_printers
*);
144 static enum ext_lang_rc gdbpy_apply_type_printers
145 (const struct extension_language_defn
*,
146 const struct ext_lang_type_printers
*, struct type
*, char **);
147 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
148 struct ext_lang_type_printers
*);
149 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
150 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
151 static enum ext_lang_rc gdbpy_before_prompt_hook
152 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
154 /* The interface between gdb proper and loading of python scripts. */
156 const struct extension_language_script_ops python_extension_script_ops
=
159 gdbpy_source_objfile_script
,
160 gdbpy_execute_objfile_script
,
161 gdbpy_auto_load_enabled
164 /* The interface between gdb proper and python extensions. */
166 const struct extension_language_ops python_extension_ops
=
168 gdbpy_finish_initialization
,
171 gdbpy_eval_from_control_command
,
173 gdbpy_start_type_printers
,
174 gdbpy_apply_type_printers
,
175 gdbpy_free_type_printers
,
177 gdbpy_apply_val_pretty_printer
,
179 gdbpy_apply_frame_filter
,
181 gdbpy_preserve_values
,
183 gdbpy_breakpoint_has_cond
,
184 gdbpy_breakpoint_cond_says_stop
,
187 gdbpy_check_quit_flag
,
189 gdbpy_before_prompt_hook
,
191 gdbpy_get_matching_xmethod_workers
,
194 /* Architecture and language to be used in callbacks from
195 the Python interpreter. */
196 struct gdbarch
*python_gdbarch
;
197 const struct language_defn
*python_language
;
199 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
200 const struct language_defn
*language
)
201 : m_gdbarch (python_gdbarch
),
202 m_language (python_language
)
204 /* We should not ever enter Python unless initialized. */
205 if (!gdb_python_initialized
)
206 error (_("Python not initialized"));
208 m_previous_active
= set_active_ext_lang (&extension_language_python
);
210 m_state
= PyGILState_Ensure ();
212 python_gdbarch
= gdbarch
;
213 python_language
= language
;
215 /* Save it and ensure ! PyErr_Occurred () afterwards. */
219 gdbpy_enter::~gdbpy_enter ()
221 /* Leftover Python error is forbidden by Python Exception Handling. */
222 if (PyErr_Occurred ())
224 /* This order is similar to the one calling error afterwards. */
225 gdbpy_print_stack ();
226 warning (_("internal error: Unhandled Python exception"));
231 PyGILState_Release (m_state
);
232 python_gdbarch
= m_gdbarch
;
233 python_language
= m_language
;
235 restore_active_ext_lang (m_previous_active
);
238 /* Set the quit flag. */
241 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
243 PyErr_SetInterrupt ();
246 /* Return true if the quit flag has been set, false otherwise. */
249 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
251 return PyOS_InterruptOccurred ();
254 /* Evaluate a Python command like PyRun_SimpleString, but uses
255 Py_single_input which prints the result of expressions, and does
256 not automatically print the stack on errors. */
259 eval_python_command (const char *command
)
263 m
= PyImport_AddModule ("__main__");
267 d
= PyModule_GetDict (m
);
270 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
282 /* Implementation of the gdb "python-interactive" command. */
285 python_interactive_command (const char *arg
, int from_tty
)
287 struct ui
*ui
= current_ui
;
290 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
292 arg
= skip_spaces (arg
);
294 gdbpy_enter
enter_py (get_current_arch (), current_language
);
298 std::string script
= std::string (arg
) + "\n";
299 err
= eval_python_command (script
.c_str ());
303 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
309 gdbpy_print_stack ();
310 error (_("Error while executing Python code."));
314 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
317 On Windows hosts few users would build Python themselves (this is no
318 trivial task on this platform), and thus use binaries built by
319 someone else instead. There may happen situation where the Python
320 library and GDB are using two different versions of the C runtime
321 library. Python, being built with VC, would use one version of the
322 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
323 A FILE * from one runtime does not necessarily operate correctly in
326 To work around this potential issue, we run code in Python to load
330 python_run_simple_file (FILE *file
, const char *filename
)
334 PyRun_SimpleFile (file
, filename
);
338 /* Because we have a string for a filename, and are using Python to
339 open the file, we need to expand any tilde in the path first. */
340 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
342 if (gdb_python_module
== nullptr
343 || ! PyObject_HasAttrString (gdb_python_module
, "_execute_file"))
344 error (_("Installation error: gdb._execute_file function is missing"));
346 gdbpy_ref
<> return_value
347 (PyObject_CallMethod (gdb_python_module
, "_execute_file", "s",
349 if (return_value
== nullptr)
351 /* Use PyErr_PrintEx instead of gdbpy_print_stack to better match the
352 behavior of the non-Windows codepath. */
359 /* Given a command_line, return a command string suitable for passing
360 to Python. Lines in the string are separated by newlines. */
363 compute_python_string (struct command_line
*l
)
365 struct command_line
*iter
;
368 for (iter
= l
; iter
; iter
= iter
->next
)
370 script
+= iter
->line
;
376 /* Take a command line structure representing a 'python' command, and
377 evaluate its body using the Python interpreter. */
380 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
381 struct command_line
*cmd
)
385 if (cmd
->body_list_1
!= nullptr)
386 error (_("Invalid \"python\" block structure."));
388 gdbpy_enter
enter_py (get_current_arch (), current_language
);
390 std::string script
= compute_python_string (cmd
->body_list_0
.get ());
391 ret
= PyRun_SimpleString (script
.c_str ());
393 error (_("Error while executing Python code."));
396 /* Implementation of the gdb "python" command. */
399 python_command (const char *arg
, int from_tty
)
401 gdbpy_enter
enter_py (get_current_arch (), current_language
);
403 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
405 arg
= skip_spaces (arg
);
408 if (PyRun_SimpleString (arg
))
409 error (_("Error while executing Python code."));
413 counted_command_line l
= get_command_line (python_control
, "");
415 execute_control_command_untraced (l
.get ());
421 /* Transform a gdb parameters's value into a Python value. May return
422 NULL (and set a Python exception) on error. Helper function for
425 gdbpy_parameter_value (enum var_types type
, void *var
)
430 case var_string_noescape
:
431 case var_optional_filename
:
435 const char *str
= *(char **) var
;
439 return host_string_to_python_string (str
).release ();
450 case var_auto_boolean
:
452 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
454 if (ab
== AUTO_BOOLEAN_TRUE
)
456 else if (ab
== AUTO_BOOLEAN_FALSE
)
463 if ((* (int *) var
) == INT_MAX
)
467 case var_zuinteger_unlimited
:
468 return PyLong_FromLong (* (int *) var
);
472 unsigned int val
= * (unsigned int *) var
;
476 return PyLong_FromUnsignedLong (val
);
481 unsigned int val
= * (unsigned int *) var
;
482 return PyLong_FromUnsignedLong (val
);
486 return PyErr_Format (PyExc_RuntimeError
,
487 _("Programmer error: unhandled type."));
490 /* A Python function which returns a gdb parameter's value as a Python
494 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
496 struct cmd_list_element
*alias
, *prefix
, *cmd
;
500 if (! PyArg_ParseTuple (args
, "s", &arg
))
503 std::string newarg
= std::string ("show ") + arg
;
507 found
= lookup_cmd_composition (newarg
.c_str (), &alias
, &prefix
, &cmd
);
509 catch (const gdb_exception
&ex
)
511 GDB_PY_HANDLE_EXCEPTION (ex
);
515 return PyErr_Format (PyExc_RuntimeError
,
516 _("Could not find parameter `%s'."), arg
);
519 return PyErr_Format (PyExc_RuntimeError
,
520 _("`%s' is not a parameter."), arg
);
521 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
524 /* Wrapper for target_charset. */
527 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
529 const char *cset
= target_charset (python_gdbarch
);
531 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
534 /* Wrapper for target_wide_charset. */
537 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
539 const char *cset
= target_wide_charset (python_gdbarch
);
541 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
544 /* A Python function which evaluates a string using the gdb CLI. */
547 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
550 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
551 int from_tty
, to_string
;
552 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
554 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
555 &PyBool_Type
, &from_tty_obj
,
556 &PyBool_Type
, &to_string_obj
))
562 int cmp
= PyObject_IsTrue (from_tty_obj
);
571 int cmp
= PyObject_IsTrue (to_string_obj
);
577 std::string to_string_res
;
579 scoped_restore preventer
= prevent_dont_repeat ();
583 gdbpy_allow_threads allow_threads
;
585 struct interp
*interp
;
587 std::string arg_copy
= arg
;
589 char *save_ptr
= nullptr;
593 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
599 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
602 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
605 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
607 /* Use the console interpreter uiout to have the same print format
608 for console or MI. */
609 interp
= interp_lookup (current_ui
, "console");
610 current_uiout
= interp
->interp_ui_out ();
613 to_string_res
= execute_control_commands_to_string (lines
.get (),
616 execute_control_commands (lines
.get (), from_tty
);
619 /* Do any commands attached to breakpoint we stopped at. */
620 bpstat_do_actions ();
622 catch (const gdb_exception
&except
)
624 GDB_PY_HANDLE_EXCEPTION (except
);
628 return PyString_FromString (to_string_res
.c_str ());
632 /* Implementation of Python rbreak command. Take a REGEX and
633 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
634 Python list that contains newly set breakpoints that match that
635 criteria. REGEX refers to a GDB format standard regex pattern of
636 symbols names to search; MINSYMS is an optional boolean (default
637 False) that indicates if the function should search GDB's minimal
638 symbols; THROTTLE is an optional integer (default unlimited) that
639 indicates the maximum amount of breakpoints allowable before the
640 function exits (note, if the throttle bound is passed, no
641 breakpoints will be set and a runtime error returned); SYMTABS is
642 an optional Python iterable that contains a set of gdb.Symtabs to
643 constrain the search within. */
646 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
648 /* A simple type to ensure clean up of a vector of allocated strings
649 when a C interface demands a const char *array[] type
651 struct symtab_list_type
655 for (const char *elem
: vec
)
656 xfree ((void *) elem
);
658 std::vector
<const char *> vec
;
662 std::vector
<symbol_search
> symbols
;
663 unsigned long count
= 0;
664 PyObject
*symtab_list
= NULL
;
665 PyObject
*minsyms_p_obj
= NULL
;
667 unsigned int throttle
= 0;
668 static const char *keywords
[] = {"regex","minsyms", "throttle",
670 symtab_list_type symtab_paths
;
672 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
673 ®ex
, &PyBool_Type
,
674 &minsyms_p_obj
, &throttle
,
678 /* Parse minsyms keyword. */
679 if (minsyms_p_obj
!= NULL
)
681 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
687 /* The "symtabs" keyword is any Python iterable object that returns
688 a gdb.Symtab on each iteration. If specified, iterate through
689 the provided gdb.Symtabs and extract their full path. As
690 python_string_to_target_string returns a
691 gdb::unique_xmalloc_ptr<char> and a vector containing these types
692 cannot be coerced to a const char **p[] via the vector.data call,
693 release the value from the unique_xmalloc_ptr and place it in a
694 simple type symtab_list_type (which holds the vector and a
695 destructor that frees the contents of the allocated strings. */
696 if (symtab_list
!= NULL
)
698 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
705 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
709 if (PyErr_Occurred ())
714 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
717 if (obj_name
== NULL
)
720 /* Is the object file still valid? */
721 if (obj_name
== Py_None
)
724 gdb::unique_xmalloc_ptr
<char> filename
=
725 python_string_to_target_string (obj_name
.get ());
727 if (filename
== NULL
)
730 /* Make sure there is a definite place to store the value of
731 filename before it is released. */
732 symtab_paths
.vec
.push_back (nullptr);
733 symtab_paths
.vec
.back () = filename
.release ();
739 const char **files
= symtab_paths
.vec
.data ();
741 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
,
742 symtab_paths
.vec
.size (), files
, false);
745 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
, 0, NULL
, false);
747 /* Count the number of symbols (both symbols and optionally minimal
748 symbols) so we can correctly check the throttle limit. */
749 for (const symbol_search
&p
: symbols
)
751 /* Minimal symbols included? */
754 if (p
.msymbol
.minsym
!= NULL
)
758 if (p
.symbol
!= NULL
)
762 /* Check throttle bounds and exit if in excess. */
763 if (throttle
!= 0 && count
> throttle
)
765 PyErr_SetString (PyExc_RuntimeError
,
766 _("Number of breakpoints exceeds throttled maximum."));
770 gdbpy_ref
<> return_list (PyList_New (0));
772 if (return_list
== NULL
)
775 /* Construct full path names for symbols and call the Python
776 breakpoint constructor on the resulting names. Be tolerant of
777 individual breakpoint failures. */
778 for (const symbol_search
&p
: symbols
)
780 std::string symbol_name
;
782 /* Skipping minimal symbols? */
784 if (p
.msymbol
.minsym
!= NULL
)
787 if (p
.msymbol
.minsym
== NULL
)
789 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
790 const char *fullname
= symtab_to_fullname (symtab
);
792 symbol_name
= fullname
;
794 symbol_name
+= SYMBOL_LINKAGE_NAME (p
.symbol
);
797 symbol_name
= MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
);
799 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
800 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
801 &breakpoint_object_type
,
804 /* Tolerate individual breakpoint failures. */
806 gdbpy_print_stack ();
809 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
813 return return_list
.release ();
816 /* A Python function which is a wrapper for decode_line_1. */
819 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
821 const char *arg
= NULL
;
823 gdbpy_ref
<> unparsed
;
824 event_location_up location
;
826 if (! PyArg_ParseTuple (args
, "|s", &arg
))
830 location
= string_to_event_location_basic (&arg
, python_language
,
831 symbol_name_match_type::WILD
);
833 std::vector
<symtab_and_line
> decoded_sals
;
834 symtab_and_line def_sal
;
835 gdb::array_view
<symtab_and_line
> sals
;
838 if (location
!= NULL
)
840 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
845 set_default_source_symtab_and_line ();
846 def_sal
= get_current_source_symtab_and_line ();
850 catch (const gdb_exception
&ex
)
852 /* We know this will always throw. */
853 gdbpy_convert_exception (ex
);
859 result
.reset (PyTuple_New (sals
.size ()));
862 for (size_t i
= 0; i
< sals
.size (); ++i
)
864 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
868 PyTuple_SetItem (result
.get (), i
, obj
);
872 result
= gdbpy_ref
<>::new_reference (Py_None
);
874 gdbpy_ref
<> return_result (PyTuple_New (2));
875 if (return_result
== NULL
)
878 if (arg
!= NULL
&& strlen (arg
) > 0)
880 unparsed
.reset (PyString_FromString (arg
));
881 if (unparsed
== NULL
)
885 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
887 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
888 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
890 return return_result
.release ();
893 /* Parse a string and evaluate it as an expression. */
895 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
897 const char *expr_str
;
898 struct value
*result
= NULL
;
900 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
905 gdbpy_allow_threads allow_threads
;
906 result
= parse_and_eval (expr_str
);
908 catch (const gdb_exception
&except
)
910 GDB_PY_HANDLE_EXCEPTION (except
);
913 return value_to_value_object (result
);
916 /* Implementation of gdb.invalidate_cached_frames. */
919 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
921 reinit_frame_cache ();
925 /* Read a file as Python code.
926 This is the extension_language_script_ops.script_sourcer "method".
927 FILE is the file to load. FILENAME is name of the file FILE.
928 This does not throw any errors. If an exception occurs python will print
929 the traceback and clear the error indicator. */
932 gdbpy_source_script (const struct extension_language_defn
*extlang
,
933 FILE *file
, const char *filename
)
935 gdbpy_enter
enter_py (get_current_arch (), current_language
);
936 python_run_simple_file (file
, filename
);
941 /* Posting and handling events. */
943 /* A single event. */
946 /* The Python event. This is just a callable object. */
948 /* The next event. */
949 struct gdbpy_event
*next
;
952 /* All pending events. */
953 static struct gdbpy_event
*gdbpy_event_list
;
954 /* The final link of the event list. */
955 static struct gdbpy_event
**gdbpy_event_list_end
;
957 /* So that we can wake up the main thread even when it is blocked in
959 static struct serial_event
*gdbpy_serial_event
;
961 /* The file handler callback. This reads from the internal pipe, and
962 then processes the Python event queue. This will always be run in
963 the main gdb thread. */
966 gdbpy_run_events (int error
, gdb_client_data client_data
)
968 gdbpy_enter
enter_py (get_current_arch (), current_language
);
970 /* Clear the event fd. Do this before flushing the events list, so
971 that any new event post afterwards is sure to re-awake the event
973 serial_event_clear (gdbpy_serial_event
);
975 while (gdbpy_event_list
)
977 /* Dispatching the event might push a new element onto the event
978 loop, so we update here "atomically enough". */
979 struct gdbpy_event
*item
= gdbpy_event_list
;
980 gdbpy_event_list
= gdbpy_event_list
->next
;
981 if (gdbpy_event_list
== NULL
)
982 gdbpy_event_list_end
= &gdbpy_event_list
;
984 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
985 if (call_result
== NULL
)
986 gdbpy_print_stack ();
988 Py_DECREF (item
->event
);
993 /* Submit an event to the gdb thread. */
995 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
997 struct gdbpy_event
*event
;
1001 if (!PyArg_ParseTuple (args
, "O", &func
))
1004 if (!PyCallable_Check (func
))
1006 PyErr_SetString (PyExc_RuntimeError
,
1007 _("Posted event is not callable"));
1013 /* From here until the end of the function, we have the GIL, so we
1014 can operate on our global data structures without worrying. */
1015 wakeup
= gdbpy_event_list
== NULL
;
1017 event
= XNEW (struct gdbpy_event
);
1018 event
->event
= func
;
1020 *gdbpy_event_list_end
= event
;
1021 gdbpy_event_list_end
= &event
->next
;
1023 /* Wake up gdb when needed. */
1025 serial_event_set (gdbpy_serial_event
);
1030 /* Initialize the Python event handler. */
1032 gdbpy_initialize_events (void)
1034 gdbpy_event_list_end
= &gdbpy_event_list
;
1036 gdbpy_serial_event
= make_serial_event ();
1037 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1038 gdbpy_run_events
, NULL
);
1045 /* This is the extension_language_ops.before_prompt "method". */
1047 static enum ext_lang_rc
1048 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1049 const char *current_gdb_prompt
)
1051 if (!gdb_python_initialized
)
1052 return EXT_LANG_RC_NOP
;
1054 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1056 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1057 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1058 return EXT_LANG_RC_ERROR
;
1060 if (gdb_python_module
1061 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1063 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1067 gdbpy_print_stack ();
1068 return EXT_LANG_RC_ERROR
;
1071 if (PyCallable_Check (hook
.get ()))
1073 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1074 if (current_prompt
== NULL
)
1076 gdbpy_print_stack ();
1077 return EXT_LANG_RC_ERROR
;
1081 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1085 gdbpy_print_stack ();
1086 return EXT_LANG_RC_ERROR
;
1089 /* Return type should be None, or a String. If it is None,
1090 fall through, we will not set a prompt. If it is a
1091 string, set PROMPT. Anything else, set an exception. */
1092 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1094 PyErr_Format (PyExc_RuntimeError
,
1095 _("Return from prompt_hook must " \
1096 "be either a Python string, or None"));
1097 gdbpy_print_stack ();
1098 return EXT_LANG_RC_ERROR
;
1101 if (result
!= Py_None
)
1103 gdb::unique_xmalloc_ptr
<char>
1104 prompt (python_string_to_host_string (result
.get ()));
1108 gdbpy_print_stack ();
1109 return EXT_LANG_RC_ERROR
;
1112 set_prompt (prompt
.get ());
1113 return EXT_LANG_RC_OK
;
1118 return EXT_LANG_RC_NOP
;
1125 /* A python function to write a single string using gdb's filtered
1126 output stream . The optional keyword STREAM can be used to write
1127 to a particular stream. The default stream is to gdb_stdout. */
1130 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1133 static const char *keywords
[] = { "text", "stream", NULL
};
1134 int stream_type
= 0;
1136 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1142 switch (stream_type
)
1146 fprintf_filtered (gdb_stderr
, "%s", arg
);
1151 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1155 fprintf_filtered (gdb_stdout
, "%s", arg
);
1158 catch (const gdb_exception
&except
)
1160 GDB_PY_HANDLE_EXCEPTION (except
);
1166 /* A python function to flush a gdb stream. The optional keyword
1167 STREAM can be used to flush a particular stream. The default stream
1171 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1173 static const char *keywords
[] = { "stream", NULL
};
1174 int stream_type
= 0;
1176 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1180 switch (stream_type
)
1184 gdb_flush (gdb_stderr
);
1189 gdb_flush (gdb_stdlog
);
1193 gdb_flush (gdb_stdout
);
1199 /* Return non-zero if print-stack is not "none". */
1202 gdbpy_print_python_errors_p (void)
1204 return gdbpy_should_print_stack
!= python_excp_none
;
1207 /* Print a python exception trace, print just a message, or print
1208 nothing and clear the python exception, depending on
1209 gdbpy_should_print_stack. Only call this if a python exception is
1212 gdbpy_print_stack (void)
1215 /* Print "none", just clear exception. */
1216 if (gdbpy_should_print_stack
== python_excp_none
)
1220 /* Print "full" message and backtrace. */
1221 else if (gdbpy_should_print_stack
== python_excp_full
)
1224 /* PyErr_Print doesn't necessarily end output with a newline.
1225 This works because Python's stdout/stderr is fed through
1231 catch (const gdb_exception
&except
)
1235 /* Print "message", just error print message. */
1238 gdbpy_err_fetch fetched_error
;
1240 gdb::unique_xmalloc_ptr
<char> msg
= fetched_error
.to_string ();
1241 gdb::unique_xmalloc_ptr
<char> type
;
1242 /* Don't compute TYPE if MSG already indicates that there is an
1245 type
= fetched_error
.type_to_string ();
1249 if (msg
== NULL
|| type
== NULL
)
1251 /* An error occurred computing the string representation of the
1253 fprintf_filtered (gdb_stderr
,
1254 _("Error occurred computing Python error" \
1259 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1260 type
.get (), msg
.get ());
1262 catch (const gdb_exception
&except
)
1268 /* Like gdbpy_print_stack, but if the exception is a
1269 KeyboardException, throw a gdb "quit" instead. */
1272 gdbpy_print_stack_or_quit ()
1274 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1277 throw_quit ("Quit");
1279 gdbpy_print_stack ();
1284 /* Return a sequence holding all the Progspaces. */
1287 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1289 struct program_space
*ps
;
1291 gdbpy_ref
<> list (PyList_New (0));
1297 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1299 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1303 return list
.release ();
1308 /* The "current" objfile. This is set when gdb detects that a new
1309 objfile has been loaded. It is only set for the duration of a call to
1310 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1312 static struct objfile
*gdbpy_current_objfile
;
1314 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1315 as Python code. This does not throw any errors. If an exception
1316 occurs python will print the traceback and clear the error indicator.
1317 This is the extension_language_script_ops.objfile_script_sourcer
1321 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1322 struct objfile
*objfile
, FILE *file
,
1323 const char *filename
)
1325 if (!gdb_python_initialized
)
1328 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1329 gdbpy_current_objfile
= objfile
;
1331 python_run_simple_file (file
, filename
);
1333 gdbpy_current_objfile
= NULL
;
1336 /* Set the current objfile to OBJFILE and then execute SCRIPT
1337 as Python code. This does not throw any errors. If an exception
1338 occurs python will print the traceback and clear the error indicator.
1339 This is the extension_language_script_ops.objfile_script_executor
1343 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1344 struct objfile
*objfile
, const char *name
,
1347 if (!gdb_python_initialized
)
1350 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1351 gdbpy_current_objfile
= objfile
;
1353 PyRun_SimpleString (script
);
1355 gdbpy_current_objfile
= NULL
;
1358 /* Return the current Objfile, or None if there isn't one. */
1361 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1363 if (! gdbpy_current_objfile
)
1366 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1369 /* Compute the list of active python type printers and store them in
1370 EXT_PRINTERS->py_type_printers. The product of this function is used by
1371 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1372 This is the extension_language_ops.start_type_printers "method". */
1375 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1376 struct ext_lang_type_printers
*ext_printers
)
1378 PyObject
*printers_obj
= NULL
;
1380 if (!gdb_python_initialized
)
1383 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1385 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1386 if (type_module
== NULL
)
1388 gdbpy_print_stack ();
1392 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1393 "get_type_recognizers"));
1396 gdbpy_print_stack ();
1400 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1401 if (printers_obj
== NULL
)
1402 gdbpy_print_stack ();
1404 ext_printers
->py_type_printers
= printers_obj
;
1407 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1408 a newly allocated string holding the type's replacement name, and return
1409 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1410 If there's a Python error return EXT_LANG_RC_ERROR.
1411 Otherwise, return EXT_LANG_RC_NOP.
1412 This is the extension_language_ops.apply_type_printers "method". */
1414 static enum ext_lang_rc
1415 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1416 const struct ext_lang_type_printers
*ext_printers
,
1417 struct type
*type
, char **prettied_type
)
1419 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1420 gdb::unique_xmalloc_ptr
<char> result
;
1422 if (printers_obj
== NULL
)
1423 return EXT_LANG_RC_NOP
;
1425 if (!gdb_python_initialized
)
1426 return EXT_LANG_RC_NOP
;
1428 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1430 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1431 if (type_obj
== NULL
)
1433 gdbpy_print_stack ();
1434 return EXT_LANG_RC_ERROR
;
1437 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1438 if (type_module
== NULL
)
1440 gdbpy_print_stack ();
1441 return EXT_LANG_RC_ERROR
;
1444 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1445 "apply_type_recognizers"));
1448 gdbpy_print_stack ();
1449 return EXT_LANG_RC_ERROR
;
1452 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1456 if (result_obj
== NULL
)
1458 gdbpy_print_stack ();
1459 return EXT_LANG_RC_ERROR
;
1462 if (result_obj
== Py_None
)
1463 return EXT_LANG_RC_NOP
;
1465 result
= python_string_to_host_string (result_obj
.get ());
1468 gdbpy_print_stack ();
1469 return EXT_LANG_RC_ERROR
;
1472 *prettied_type
= result
.release ();
1473 return EXT_LANG_RC_OK
;
1476 /* Free the result of start_type_printers.
1477 This is the extension_language_ops.free_type_printers "method". */
1480 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1481 struct ext_lang_type_printers
*ext_printers
)
1483 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1485 if (printers
== NULL
)
1488 if (!gdb_python_initialized
)
1491 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1492 Py_DECREF (printers
);
1495 #else /* HAVE_PYTHON */
1497 /* Dummy implementation of the gdb "python-interactive" and "python"
1501 python_interactive_command (const char *arg
, int from_tty
)
1503 arg
= skip_spaces (arg
);
1505 error (_("Python scripting is not supported in this copy of GDB."));
1508 counted_command_line l
= get_command_line (python_control
, "");
1510 execute_control_command_untraced (l
.get ());
1515 python_command (const char *arg
, int from_tty
)
1517 python_interactive_command (arg
, from_tty
);
1520 #endif /* HAVE_PYTHON */
1524 /* Lists for 'set python' commands. */
1526 static struct cmd_list_element
*user_set_python_list
;
1527 static struct cmd_list_element
*user_show_python_list
;
1529 /* Function for use by 'set python' prefix command. */
1532 user_set_python (const char *args
, int from_tty
)
1534 help_list (user_set_python_list
, "set python ", all_commands
,
1538 /* Function for use by 'show python' prefix command. */
1541 user_show_python (const char *args
, int from_tty
)
1543 cmd_show_list (user_show_python_list
, from_tty
, "");
1546 /* Initialize the Python code. */
1550 /* This is installed as a final cleanup and cleans up the
1551 interpreter. This lets Python's 'atexit' work. */
1554 finalize_python (void *ignore
)
1556 struct active_ext_lang_state
*previous_active
;
1558 /* We don't use ensure_python_env here because if we ever ran the
1559 cleanup, gdb would crash -- because the cleanup calls into the
1560 Python interpreter, which we are about to destroy. It seems
1561 clearer to make the needed calls explicitly here than to create a
1562 cleanup and then mysteriously discard it. */
1564 /* This is only called as a final cleanup so we can assume the active
1565 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1566 previous_active
= set_active_ext_lang (&extension_language_python
);
1568 (void) PyGILState_Ensure ();
1569 python_gdbarch
= target_gdbarch ();
1570 python_language
= current_language
;
1574 restore_active_ext_lang (previous_active
);
1578 /* This is called via the PyImport_AppendInittab mechanism called
1579 during initialization, to make the built-in _gdb module known to
1582 init__gdb_module (void)
1584 return PyModule_Create (&python_GdbModuleDef
);
1589 do_start_initialization ()
1592 size_t progsize
, count
;
1593 /* Python documentation indicates that the memory given
1594 to Py_SetProgramName cannot be freed. However, it seems that
1595 at least Python 3.7.4 Py_SetProgramName takes a copy of the
1596 given program_name. Making progname_copy static and not release
1597 the memory avoids a leak report for Python versions that duplicate
1598 program_name, and respect the requirement of Py_SetProgramName
1599 for Python versions that do not duplicate program_name. */
1600 static wchar_t *progname_copy
;
1603 #ifdef WITH_PYTHON_PATH
1604 /* Work around problem where python gets confused about where it is,
1605 and then can't find its libraries, etc.
1606 NOTE: Python assumes the following layout:
1608 /foo/lib/pythonX.Y/...
1609 This must be done before calling Py_Initialize. */
1610 gdb::unique_xmalloc_ptr
<char> progname
1611 (concat (ldirname (python_libdir
.c_str ()).c_str (), SLASH_STRING
, "bin",
1612 SLASH_STRING
, "python", (char *) NULL
));
1614 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1615 setlocale (LC_ALL
, "");
1616 progsize
= strlen (progname
.get ());
1617 progname_copy
= (wchar_t *) xmalloc ((progsize
+ 1) * sizeof (wchar_t));
1620 fprintf (stderr
, "out of memory\n");
1623 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1624 if (count
== (size_t) -1)
1626 fprintf (stderr
, "Could not convert python path to string\n");
1629 setlocale (LC_ALL
, oldloc
.c_str ());
1631 /* Note that Py_SetProgramName expects the string it is passed to
1632 remain alive for the duration of the program's execution, so
1633 it is not freed after this call. */
1634 Py_SetProgramName (progname_copy
);
1636 /* Define _gdb as a built-in module. */
1637 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1639 Py_SetProgramName (progname
.release ());
1644 PyEval_InitThreads ();
1647 gdb_module
= PyImport_ImportModule ("_gdb");
1649 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1651 if (gdb_module
== NULL
)
1654 if (PyModule_AddStringConstant (gdb_module
, "VERSION", version
) < 0
1655 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", host_name
) < 0
1656 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1660 /* Add stream constants. */
1661 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1662 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1663 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1666 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1667 if (gdbpy_gdb_error
== NULL
1668 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1671 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1672 gdbpy_gdb_error
, NULL
);
1673 if (gdbpy_gdb_memory_error
== NULL
1674 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1675 gdbpy_gdb_memory_error
) < 0)
1678 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1679 if (gdbpy_gdberror_exc
== NULL
1680 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1681 gdbpy_gdberror_exc
) < 0)
1684 gdbpy_initialize_gdb_readline ();
1686 if (gdbpy_initialize_auto_load () < 0
1687 || gdbpy_initialize_values () < 0
1688 || gdbpy_initialize_frames () < 0
1689 || gdbpy_initialize_commands () < 0
1690 || gdbpy_initialize_instruction () < 0
1691 || gdbpy_initialize_record () < 0
1692 || gdbpy_initialize_btrace () < 0
1693 || gdbpy_initialize_symbols () < 0
1694 || gdbpy_initialize_symtabs () < 0
1695 || gdbpy_initialize_blocks () < 0
1696 || gdbpy_initialize_functions () < 0
1697 || gdbpy_initialize_parameters () < 0
1698 || gdbpy_initialize_types () < 0
1699 || gdbpy_initialize_pspace () < 0
1700 || gdbpy_initialize_objfile () < 0
1701 || gdbpy_initialize_breakpoints () < 0
1702 || gdbpy_initialize_finishbreakpoints () < 0
1703 || gdbpy_initialize_lazy_string () < 0
1704 || gdbpy_initialize_linetable () < 0
1705 || gdbpy_initialize_thread () < 0
1706 || gdbpy_initialize_inferior () < 0
1707 || gdbpy_initialize_events () < 0
1708 || gdbpy_initialize_eventregistry () < 0
1709 || gdbpy_initialize_py_events () < 0
1710 || gdbpy_initialize_event () < 0
1711 || gdbpy_initialize_arch () < 0
1712 || gdbpy_initialize_xmethods () < 0
1713 || gdbpy_initialize_unwind () < 0)
1716 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1717 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1719 #include "py-event-types.def"
1720 #undef GDB_PY_DEFINE_EVENT_TYPE
1722 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1723 if (gdbpy_to_string_cst
== NULL
)
1725 gdbpy_children_cst
= PyString_FromString ("children");
1726 if (gdbpy_children_cst
== NULL
)
1728 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1729 if (gdbpy_display_hint_cst
== NULL
)
1731 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1732 if (gdbpy_doc_cst
== NULL
)
1734 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1735 if (gdbpy_enabled_cst
== NULL
)
1737 gdbpy_value_cst
= PyString_FromString ("value");
1738 if (gdbpy_value_cst
== NULL
)
1741 /* Release the GIL while gdb runs. */
1742 PyThreadState_Swap (NULL
);
1743 PyEval_ReleaseLock ();
1745 make_final_cleanup (finalize_python
, NULL
);
1747 /* Only set this when initialization has succeeded. */
1748 gdb_python_initialized
= 1;
1752 #endif /* HAVE_PYTHON */
1755 cmd_list_element
*python_cmd_element
= nullptr;
1758 _initialize_python (void)
1760 add_com ("python-interactive", class_obscure
,
1761 python_interactive_command
,
1764 Start an interactive Python prompt.\n\
1766 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1769 Alternatively, a single-line Python command can be given as an\n\
1770 argument, and if the command is an expression, the result will be\n\
1771 printed. For example:\n\
1773 (gdb) python-interactive 2 + 3\n\
1775 #else /* HAVE_PYTHON */
1777 Start a Python interactive prompt.\n\
1779 Python scripting is not supported in this copy of GDB.\n\
1780 This command is only a placeholder.")
1781 #endif /* HAVE_PYTHON */
1783 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1785 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1788 Evaluate a Python command.\n\
1790 The command can be given as an argument, for instance:\n\
1792 python print (23)\n\
1794 If no argument is given, the following lines are read and used\n\
1795 as the Python commands. Type a line containing \"end\" to indicate\n\
1796 the end of the command.")
1797 #else /* HAVE_PYTHON */
1799 Evaluate a Python command.\n\
1801 Python scripting is not supported in this copy of GDB.\n\
1802 This command is only a placeholder.")
1803 #endif /* HAVE_PYTHON */
1805 add_com_alias ("py", "python", class_obscure
, 1);
1807 /* Add set/show python print-stack. */
1808 add_prefix_cmd ("python", no_class
, user_show_python
,
1809 _("Prefix command for python preference settings."),
1810 &user_show_python_list
, "show python ", 0,
1813 add_prefix_cmd ("python", no_class
, user_set_python
,
1814 _("Prefix command for python preference settings."),
1815 &user_set_python_list
, "set python ", 0,
1818 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1819 &gdbpy_should_print_stack
, _("\
1820 Set mode for Python stack dump on error."), _("\
1821 Show the mode of Python stack printing on error."), _("\
1822 none == no stack or message will be printed.\n\
1823 full == a message and a stack will be printed.\n\
1824 message == an error message without a stack will be printed."),
1826 &user_set_python_list
,
1827 &user_show_python_list
);
1830 if (!do_start_initialization () && PyErr_Occurred ())
1831 gdbpy_print_stack ();
1832 #endif /* HAVE_PYTHON */
1837 /* Helper function for gdbpy_finish_initialization. This does the
1838 work and then returns false if an error has occurred and must be
1839 displayed, or true on success. */
1842 do_finish_initialization (const struct extension_language_defn
*extlang
)
1847 /* Add the initial data-directory to sys.path. */
1849 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1852 sys_path
= PySys_GetObject ("path");
1854 /* If sys.path is not defined yet, define it first. */
1855 if (!(sys_path
&& PyList_Check (sys_path
)))
1858 PySys_SetPath (L
"");
1862 sys_path
= PySys_GetObject ("path");
1864 if (sys_path
&& PyList_Check (sys_path
))
1866 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1867 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1873 /* Import the gdb module to finish the initialization, and
1874 add it to __main__ for convenience. */
1875 m
= PyImport_AddModule ("__main__");
1879 /* Keep the reference to gdb_python_module since it is in a global
1881 gdb_python_module
= PyImport_ImportModule ("gdb");
1882 if (gdb_python_module
== NULL
)
1884 gdbpy_print_stack ();
1885 /* This is passed in one call to warning so that blank lines aren't
1886 inserted between each line of text. */
1888 "Could not load the Python gdb module from `%s'.\n"
1889 "Limited Python support is available from the _gdb module.\n"
1890 "Suggest passing --data-directory=/path/to/gdb/data-directory."),
1891 gdb_pythondir
.c_str ());
1892 /* We return "success" here as we've already emitted the
1897 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1900 /* Perform the remaining python initializations.
1901 These must be done after GDB is at least mostly initialized.
1902 E.g., The "info pretty-printer" command needs the "info" prefix
1904 This is the extension_language_ops.finish_initialization "method". */
1907 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1909 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1911 if (!do_finish_initialization (extlang
))
1913 gdbpy_print_stack ();
1914 warning (_("internal error: Unhandled Python exception"));
1918 /* Return non-zero if Python has successfully initialized.
1919 This is the extension_languages_ops.initialized "method". */
1922 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1924 return gdb_python_initialized
;
1927 #endif /* HAVE_PYTHON */
1933 PyMethodDef python_GdbMethods
[] =
1935 { "history", gdbpy_history
, METH_VARARGS
,
1936 "Get a value from history" },
1937 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1938 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1939 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1940 a Python String containing the output of the command if to_string is\n\
1942 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1943 "Return a gdb parameter's value" },
1945 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1946 "Return a tuple of all breakpoint objects" },
1948 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1949 "Find the default visualizer for a Value." },
1951 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1952 "Return a sequence of all progspaces." },
1954 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1955 "Return the current Objfile being loaded, or None." },
1957 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1958 "newest_frame () -> gdb.Frame.\n\
1959 Return the newest frame object." },
1960 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1961 "selected_frame () -> gdb.Frame.\n\
1962 Return the selected frame object." },
1963 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1964 "stop_reason_string (Integer) -> String.\n\
1965 Return a string explaining unwind stop reason." },
1967 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1968 "start_recording ([method] [, format]) -> gdb.Record.\n\
1969 Start recording with the given method. If no method is given, will fall back\n\
1970 to the system default method. If no format is given, will fall back to the\n\
1971 default format for the given method."},
1972 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1973 "current_recording () -> gdb.Record.\n\
1974 Return current recording object." },
1975 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1976 "stop_recording () -> None.\n\
1977 Stop current recording." },
1979 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1980 METH_VARARGS
| METH_KEYWORDS
,
1981 "lookup_type (name [, block]) -> type\n\
1982 Return a Type corresponding to the given name." },
1983 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1984 METH_VARARGS
| METH_KEYWORDS
,
1985 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1986 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1987 a boolean indicating if name is a field of the current implied argument\n\
1988 `this' (when the current language is object-oriented)." },
1989 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1990 METH_VARARGS
| METH_KEYWORDS
,
1991 "lookup_global_symbol (name [, domain]) -> symbol\n\
1992 Return the symbol corresponding to the given name (or None)." },
1993 { "lookup_static_symbol", (PyCFunction
) gdbpy_lookup_static_symbol
,
1994 METH_VARARGS
| METH_KEYWORDS
,
1995 "lookup_static_symbol (name [, domain]) -> symbol\n\
1996 Return the static-linkage symbol corresponding to the given name (or None)." },
1997 { "lookup_static_symbols", (PyCFunction
) gdbpy_lookup_static_symbols
,
1998 METH_VARARGS
| METH_KEYWORDS
,
1999 "lookup_static_symbols (name [, domain]) -> symbol\n\
2000 Return a list of all static-linkage symbols corresponding to the given name." },
2002 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2003 METH_VARARGS
| METH_KEYWORDS
,
2004 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2005 Look up the specified objfile.\n\
2006 If by_build_id is True, the objfile is looked up by using name\n\
2007 as its build id." },
2009 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2010 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2011 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2012 The first element contains any unparsed portion of the String parameter\n\
2013 (or None if the string was fully parsed). The second element contains\n\
2014 a tuple that contains all the locations that match, represented as\n\
2015 gdb.Symtab_and_line objects (or None)."},
2016 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2017 "parse_and_eval (String) -> Value.\n\
2018 Parse String as an expression, evaluate it, and return the result as a Value."
2021 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2022 "Post an event into gdb's event loop." },
2024 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2025 "target_charset () -> string.\n\
2026 Return the name of the current target charset." },
2027 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2028 "target_wide_charset () -> string.\n\
2029 Return the name of the current target wide charset." },
2030 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2031 "rbreak (Regex) -> List.\n\
2032 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2033 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2034 "string_to_argv (String) -> Array.\n\
2035 Parse String and return an argv-like array.\n\
2036 Arguments are separate by spaces and may be quoted."
2038 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2039 "Write a string using gdb's filtered stream." },
2040 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2041 "Flush gdb's filtered stdout stream." },
2042 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2043 "selected_thread () -> gdb.InferiorThread.\n\
2044 Return the selected thread object." },
2045 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2046 "selected_inferior () -> gdb.Inferior.\n\
2047 Return the selected inferior object." },
2048 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2049 "inferiors () -> (gdb.Inferior, ...).\n\
2050 Return a tuple containing all inferiors." },
2052 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2053 "invalidate_cached_frames () -> None.\n\
2054 Invalidate any cached frame objects in gdb.\n\
2055 Intended for internal use only." },
2057 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2058 "convenience_variable (NAME) -> value.\n\
2059 Return the value of the convenience variable $NAME,\n\
2060 or None if not set." },
2061 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2062 "convenience_variable (NAME, VALUE) -> None.\n\
2063 Set the value of the convenience variable $NAME." },
2065 {NULL
, NULL
, 0, NULL
}
2069 struct PyModuleDef python_GdbModuleDef
=
2071 PyModuleDef_HEAD_INIT
,
2083 /* Define all the event objects. */
2084 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2085 PyTypeObject name##_event_object_type \
2086 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2088 PyVarObject_HEAD_INIT (NULL, 0) \
2089 "gdb." py_name, /* tp_name */ \
2090 sizeof (event_object), /* tp_basicsize */ \
2091 0, /* tp_itemsize */ \
2092 evpy_dealloc, /* tp_dealloc */ \
2094 0, /* tp_getattr */ \
2095 0, /* tp_setattr */ \
2096 0, /* tp_compare */ \
2098 0, /* tp_as_number */ \
2099 0, /* tp_as_sequence */ \
2100 0, /* tp_as_mapping */ \
2104 0, /* tp_getattro */ \
2105 0, /* tp_setattro */ \
2106 0, /* tp_as_buffer */ \
2107 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2109 0, /* tp_traverse */ \
2111 0, /* tp_richcompare */ \
2112 0, /* tp_weaklistoffset */ \
2114 0, /* tp_iternext */ \
2115 0, /* tp_methods */ \
2116 0, /* tp_members */ \
2117 0, /* tp_getset */ \
2118 &base, /* tp_base */ \
2120 0, /* tp_descr_get */ \
2121 0, /* tp_descr_set */ \
2122 0, /* tp_dictoffset */ \
2126 #include "py-event-types.def"
2127 #undef GDB_PY_DEFINE_EVENT_TYPE
2129 #endif /* HAVE_PYTHON */