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"
98 #include "gdbthread.h"
100 #include "event-top.h"
102 #include "py-event.h"
104 /* True if Python has been successfully initialized, false
107 int gdb_python_initialized
;
109 extern PyMethodDef python_GdbMethods
[];
112 extern struct PyModuleDef python_GdbModuleDef
;
115 PyObject
*gdb_module
;
116 PyObject
*gdb_python_module
;
118 /* Some string constants we may wish to use. */
119 PyObject
*gdbpy_to_string_cst
;
120 PyObject
*gdbpy_children_cst
;
121 PyObject
*gdbpy_display_hint_cst
;
122 PyObject
*gdbpy_doc_cst
;
123 PyObject
*gdbpy_enabled_cst
;
124 PyObject
*gdbpy_value_cst
;
126 /* The GdbError exception. */
127 PyObject
*gdbpy_gdberror_exc
;
129 /* The `gdb.error' base class. */
130 PyObject
*gdbpy_gdb_error
;
132 /* The `gdb.MemoryError' exception. */
133 PyObject
*gdbpy_gdb_memory_error
;
135 static script_sourcer_func gdbpy_source_script
;
136 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
137 static objfile_script_executor_func gdbpy_execute_objfile_script
;
138 static void gdbpy_finish_initialization
139 (const struct extension_language_defn
*);
140 static int gdbpy_initialized (const struct extension_language_defn
*);
141 static void gdbpy_eval_from_control_command
142 (const struct extension_language_defn
*, struct command_line
*cmd
);
143 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
144 struct ext_lang_type_printers
*);
145 static enum ext_lang_rc gdbpy_apply_type_printers
146 (const struct extension_language_defn
*,
147 const struct ext_lang_type_printers
*, struct type
*, char **);
148 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
149 struct ext_lang_type_printers
*);
150 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
151 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
152 static enum ext_lang_rc gdbpy_before_prompt_hook
153 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
155 /* The interface between gdb proper and loading of python scripts. */
157 const struct extension_language_script_ops python_extension_script_ops
=
160 gdbpy_source_objfile_script
,
161 gdbpy_execute_objfile_script
,
162 gdbpy_auto_load_enabled
165 /* The interface between gdb proper and python extensions. */
167 const struct extension_language_ops python_extension_ops
=
169 gdbpy_finish_initialization
,
172 gdbpy_eval_from_control_command
,
174 gdbpy_start_type_printers
,
175 gdbpy_apply_type_printers
,
176 gdbpy_free_type_printers
,
178 gdbpy_apply_val_pretty_printer
,
180 gdbpy_apply_frame_filter
,
182 gdbpy_preserve_values
,
184 gdbpy_breakpoint_has_cond
,
185 gdbpy_breakpoint_cond_says_stop
,
188 gdbpy_check_quit_flag
,
190 gdbpy_before_prompt_hook
,
192 gdbpy_get_matching_xmethod_workers
,
195 /* Architecture and language to be used in callbacks from
196 the Python interpreter. */
197 struct gdbarch
*python_gdbarch
;
198 const struct language_defn
*python_language
;
200 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
201 const struct language_defn
*language
)
202 : m_gdbarch (python_gdbarch
),
203 m_language (python_language
)
205 /* We should not ever enter Python unless initialized. */
206 if (!gdb_python_initialized
)
207 error (_("Python not initialized"));
209 m_previous_active
= set_active_ext_lang (&extension_language_python
);
211 m_state
= PyGILState_Ensure ();
213 python_gdbarch
= gdbarch
;
214 python_language
= language
;
216 /* Save it and ensure ! PyErr_Occurred () afterwards. */
217 PyErr_Fetch (&m_error_type
, &m_error_value
, &m_error_traceback
);
220 gdbpy_enter::~gdbpy_enter ()
222 /* Leftover Python error is forbidden by Python Exception Handling. */
223 if (PyErr_Occurred ())
225 /* This order is similar to the one calling error afterwards. */
226 gdbpy_print_stack ();
227 warning (_("internal error: Unhandled Python exception"));
230 PyErr_Restore (m_error_type
, m_error_value
, m_error_traceback
);
232 PyGILState_Release (m_state
);
233 python_gdbarch
= m_gdbarch
;
234 python_language
= m_language
;
236 restore_active_ext_lang (m_previous_active
);
239 /* Set the quit flag. */
242 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
244 PyErr_SetInterrupt ();
247 /* Return true if the quit flag has been set, false otherwise. */
250 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
252 return PyOS_InterruptOccurred ();
255 /* Evaluate a Python command like PyRun_SimpleString, but uses
256 Py_single_input which prints the result of expressions, and does
257 not automatically print the stack on errors. */
260 eval_python_command (const char *command
)
264 m
= PyImport_AddModule ("__main__");
268 d
= PyModule_GetDict (m
);
271 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
283 /* Implementation of the gdb "python-interactive" command. */
286 python_interactive_command (const char *arg
, int from_tty
)
288 struct ui
*ui
= current_ui
;
291 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
293 arg
= skip_spaces (arg
);
295 gdbpy_enter
enter_py (get_current_arch (), current_language
);
299 std::string script
= std::string (arg
) + "\n";
300 err
= eval_python_command (script
.c_str ());
304 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
310 gdbpy_print_stack ();
311 error (_("Error while executing Python code."));
315 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
318 On Windows hosts few users would build Python themselves (this is no
319 trivial task on this platform), and thus use binaries built by
320 someone else instead. There may happen situation where the Python
321 library and GDB are using two different versions of the C runtime
322 library. Python, being built with VC, would use one version of the
323 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
324 A FILE * from one runtime does not necessarily operate correctly in
327 To work around this potential issue, we create on Windows hosts the
328 FILE object using Python routines, thus making sure that it is
329 compatible with the Python library. */
332 python_run_simple_file (FILE *file
, const char *filename
)
336 PyRun_SimpleFile (file
, filename
);
340 /* Because we have a string for a filename, and are using Python to
341 open the file, we need to expand any tilde in the path first. */
342 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
343 gdbpy_ref
<> python_file (PyFile_FromString (full_path
.get (), (char *) "r"));
344 if (python_file
== NULL
)
346 gdbpy_print_stack ();
347 error (_("Error while opening file: %s"), full_path
.get ());
350 PyRun_SimpleFile (PyFile_AsFile (python_file
.get ()), filename
);
355 /* Given a command_line, return a command string suitable for passing
356 to Python. Lines in the string are separated by newlines. */
359 compute_python_string (struct command_line
*l
)
361 struct command_line
*iter
;
364 for (iter
= l
; iter
; iter
= iter
->next
)
366 script
+= iter
->line
;
372 /* Take a command line structure representing a 'python' command, and
373 evaluate its body using the Python interpreter. */
376 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
377 struct command_line
*cmd
)
381 if (cmd
->body_list_1
!= nullptr)
382 error (_("Invalid \"python\" block structure."));
384 gdbpy_enter
enter_py (get_current_arch (), current_language
);
386 std::string script
= compute_python_string (cmd
->body_list_0
.get ());
387 ret
= PyRun_SimpleString (script
.c_str ());
389 error (_("Error while executing Python code."));
392 /* Implementation of the gdb "python" command. */
395 python_command (const char *arg
, int from_tty
)
397 gdbpy_enter
enter_py (get_current_arch (), current_language
);
399 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
401 arg
= skip_spaces (arg
);
404 if (PyRun_SimpleString (arg
))
405 error (_("Error while executing Python code."));
409 counted_command_line l
= get_command_line (python_control
, "");
411 execute_control_command_untraced (l
.get ());
417 /* Transform a gdb parameters's value into a Python value. May return
418 NULL (and set a Python exception) on error. Helper function for
421 gdbpy_parameter_value (enum var_types type
, void *var
)
426 case var_string_noescape
:
427 case var_optional_filename
:
431 const char *str
= *(char **) var
;
435 return host_string_to_python_string (str
).release ();
446 case var_auto_boolean
:
448 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
450 if (ab
== AUTO_BOOLEAN_TRUE
)
452 else if (ab
== AUTO_BOOLEAN_FALSE
)
459 if ((* (int *) var
) == INT_MAX
)
463 case var_zuinteger_unlimited
:
464 return PyLong_FromLong (* (int *) var
);
468 unsigned int val
= * (unsigned int *) var
;
472 return PyLong_FromUnsignedLong (val
);
477 unsigned int val
= * (unsigned int *) var
;
478 return PyLong_FromUnsignedLong (val
);
482 return PyErr_Format (PyExc_RuntimeError
,
483 _("Programmer error: unhandled type."));
486 /* A Python function which returns a gdb parameter's value as a Python
490 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
492 struct cmd_list_element
*alias
, *prefix
, *cmd
;
496 if (! PyArg_ParseTuple (args
, "s", &arg
))
499 std::string newarg
= std::string ("show ") + arg
;
503 found
= lookup_cmd_composition (newarg
.c_str (), &alias
, &prefix
, &cmd
);
505 CATCH (ex
, RETURN_MASK_ALL
)
507 GDB_PY_HANDLE_EXCEPTION (ex
);
512 return PyErr_Format (PyExc_RuntimeError
,
513 _("Could not find parameter `%s'."), arg
);
516 return PyErr_Format (PyExc_RuntimeError
,
517 _("`%s' is not a parameter."), arg
);
518 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
521 /* Wrapper for target_charset. */
524 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
526 const char *cset
= target_charset (python_gdbarch
);
528 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
531 /* Wrapper for target_wide_charset. */
534 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
536 const char *cset
= target_wide_charset (python_gdbarch
);
538 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
541 /* A Python function which evaluates a string using the gdb CLI. */
544 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
547 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
548 int from_tty
, to_string
;
549 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
551 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
552 &PyBool_Type
, &from_tty_obj
,
553 &PyBool_Type
, &to_string_obj
))
559 int cmp
= PyObject_IsTrue (from_tty_obj
);
568 int cmp
= PyObject_IsTrue (to_string_obj
);
574 std::string to_string_res
;
576 scoped_restore preventer
= prevent_dont_repeat ();
580 struct interp
*interp
;
582 std::string arg_copy
= arg
;
584 char *save_ptr
= nullptr;
588 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
594 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
597 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
600 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
602 /* Use the console interpreter uiout to have the same print format
603 for console or MI. */
604 interp
= interp_lookup (current_ui
, "console");
605 current_uiout
= interp
->interp_ui_out ();
608 to_string_res
= execute_control_commands_to_string (lines
.get (),
611 execute_control_commands (lines
.get (), from_tty
);
614 /* Do any commands attached to breakpoint we stopped at. */
615 bpstat_do_actions ();
617 CATCH (except
, RETURN_MASK_ALL
)
619 GDB_PY_HANDLE_EXCEPTION (except
);
624 return PyString_FromString (to_string_res
.c_str ());
628 /* Implementation of Python rbreak command. Take a REGEX and
629 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
630 Python list that contains newly set breakpoints that match that
631 criteria. REGEX refers to a GDB format standard regex pattern of
632 symbols names to search; MINSYMS is an optional boolean (default
633 False) that indicates if the function should search GDB's minimal
634 symbols; THROTTLE is an optional integer (default unlimited) that
635 indicates the maximum amount of breakpoints allowable before the
636 function exits (note, if the throttle bound is passed, no
637 breakpoints will be set and a runtime error returned); SYMTABS is
638 an optional Python iterable that contains a set of gdb.Symtabs to
639 constrain the search within. */
642 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
644 /* A simple type to ensure clean up of a vector of allocated strings
645 when a C interface demands a const char *array[] type
647 struct symtab_list_type
651 for (const char *elem
: vec
)
652 xfree ((void *) elem
);
654 std::vector
<const char *> vec
;
658 std::vector
<symbol_search
> symbols
;
659 unsigned long count
= 0;
660 PyObject
*symtab_list
= NULL
;
661 PyObject
*minsyms_p_obj
= NULL
;
663 unsigned int throttle
= 0;
664 static const char *keywords
[] = {"regex","minsyms", "throttle",
666 symtab_list_type symtab_paths
;
668 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
669 ®ex
, &PyBool_Type
,
670 &minsyms_p_obj
, &throttle
,
674 /* Parse minsyms keyword. */
675 if (minsyms_p_obj
!= NULL
)
677 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
683 /* The "symtabs" keyword is any Python iterable object that returns
684 a gdb.Symtab on each iteration. If specified, iterate through
685 the provided gdb.Symtabs and extract their full path. As
686 python_string_to_target_string returns a
687 gdb::unique_xmalloc_ptr<char> and a vector containing these types
688 cannot be coerced to a const char **p[] via the vector.data call,
689 release the value from the unique_xmalloc_ptr and place it in a
690 simple type symtab_list_type (which holds the vector and a
691 destructor that frees the contents of the allocated strings. */
692 if (symtab_list
!= NULL
)
694 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
701 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
705 if (PyErr_Occurred ())
710 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
713 if (obj_name
== NULL
)
716 /* Is the object file still valid? */
717 if (obj_name
== Py_None
)
720 gdb::unique_xmalloc_ptr
<char> filename
=
721 python_string_to_target_string (obj_name
.get ());
723 if (filename
== NULL
)
726 /* Make sure there is a definite place to store the value of
727 filename before it is released. */
728 symtab_paths
.vec
.push_back (nullptr);
729 symtab_paths
.vec
.back () = filename
.release ();
735 const char **files
= symtab_paths
.vec
.data ();
737 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
,
738 symtab_paths
.vec
.size (), files
);
741 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
, 0, NULL
);
743 /* Count the number of symbols (both symbols and optionally minimal
744 symbols) so we can correctly check the throttle limit. */
745 for (const symbol_search
&p
: symbols
)
747 /* Minimal symbols included? */
750 if (p
.msymbol
.minsym
!= NULL
)
754 if (p
.symbol
!= NULL
)
758 /* Check throttle bounds and exit if in excess. */
759 if (throttle
!= 0 && count
> throttle
)
761 PyErr_SetString (PyExc_RuntimeError
,
762 _("Number of breakpoints exceeds throttled maximum."));
766 gdbpy_ref
<> return_list (PyList_New (0));
768 if (return_list
== NULL
)
771 /* Construct full path names for symbols and call the Python
772 breakpoint constructor on the resulting names. Be tolerant of
773 individual breakpoint failures. */
774 for (const symbol_search
&p
: symbols
)
776 std::string symbol_name
;
778 /* Skipping minimal symbols? */
780 if (p
.msymbol
.minsym
!= NULL
)
783 if (p
.msymbol
.minsym
== NULL
)
785 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
786 const char *fullname
= symtab_to_fullname (symtab
);
788 symbol_name
= fullname
;
790 symbol_name
+= SYMBOL_LINKAGE_NAME (p
.symbol
);
793 symbol_name
= MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
);
795 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
796 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
797 &breakpoint_object_type
,
800 /* Tolerate individual breakpoint failures. */
802 gdbpy_print_stack ();
805 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
809 return return_list
.release ();
812 /* A Python function which is a wrapper for decode_line_1. */
815 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
817 const char *arg
= NULL
;
819 gdbpy_ref
<> unparsed
;
820 event_location_up location
;
822 if (! PyArg_ParseTuple (args
, "|s", &arg
))
826 location
= string_to_event_location_basic (&arg
, python_language
,
827 symbol_name_match_type::WILD
);
829 std::vector
<symtab_and_line
> decoded_sals
;
830 symtab_and_line def_sal
;
831 gdb::array_view
<symtab_and_line
> sals
;
834 if (location
!= NULL
)
836 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
841 set_default_source_symtab_and_line ();
842 def_sal
= get_current_source_symtab_and_line ();
846 CATCH (ex
, RETURN_MASK_ALL
)
848 /* We know this will always throw. */
849 gdbpy_convert_exception (ex
);
856 result
.reset (PyTuple_New (sals
.size ()));
859 for (size_t i
= 0; i
< sals
.size (); ++i
)
861 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
865 PyTuple_SetItem (result
.get (), i
, obj
);
869 result
= gdbpy_ref
<>::new_reference (Py_None
);
871 gdbpy_ref
<> return_result (PyTuple_New (2));
872 if (return_result
== NULL
)
875 if (arg
!= NULL
&& strlen (arg
) > 0)
877 unparsed
.reset (PyString_FromString (arg
));
878 if (unparsed
== NULL
)
882 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
884 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
885 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
887 return return_result
.release ();
890 /* Parse a string and evaluate it as an expression. */
892 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
894 const char *expr_str
;
895 struct value
*result
= NULL
;
897 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
902 result
= parse_and_eval (expr_str
);
904 CATCH (except
, RETURN_MASK_ALL
)
906 GDB_PY_HANDLE_EXCEPTION (except
);
910 return value_to_value_object (result
);
913 /* Implementation of gdb.invalidate_cached_frames. */
916 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
918 reinit_frame_cache ();
922 /* Read a file as Python code.
923 This is the extension_language_script_ops.script_sourcer "method".
924 FILE is the file to load. FILENAME is name of the file FILE.
925 This does not throw any errors. If an exception occurs python will print
926 the traceback and clear the error indicator. */
929 gdbpy_source_script (const struct extension_language_defn
*extlang
,
930 FILE *file
, const char *filename
)
932 gdbpy_enter
enter_py (get_current_arch (), current_language
);
933 python_run_simple_file (file
, filename
);
938 /* Posting and handling events. */
940 /* A single event. */
943 /* The Python event. This is just a callable object. */
945 /* The next event. */
946 struct gdbpy_event
*next
;
949 /* All pending events. */
950 static struct gdbpy_event
*gdbpy_event_list
;
951 /* The final link of the event list. */
952 static struct gdbpy_event
**gdbpy_event_list_end
;
954 /* So that we can wake up the main thread even when it is blocked in
956 static struct serial_event
*gdbpy_serial_event
;
958 /* The file handler callback. This reads from the internal pipe, and
959 then processes the Python event queue. This will always be run in
960 the main gdb thread. */
963 gdbpy_run_events (int error
, gdb_client_data client_data
)
965 gdbpy_enter
enter_py (get_current_arch (), current_language
);
967 /* Clear the event fd. Do this before flushing the events list, so
968 that any new event post afterwards is sure to re-awake the event
970 serial_event_clear (gdbpy_serial_event
);
972 while (gdbpy_event_list
)
974 /* Dispatching the event might push a new element onto the event
975 loop, so we update here "atomically enough". */
976 struct gdbpy_event
*item
= gdbpy_event_list
;
977 gdbpy_event_list
= gdbpy_event_list
->next
;
978 if (gdbpy_event_list
== NULL
)
979 gdbpy_event_list_end
= &gdbpy_event_list
;
981 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
982 if (call_result
== NULL
)
983 gdbpy_print_stack ();
985 Py_DECREF (item
->event
);
990 /* Submit an event to the gdb thread. */
992 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
994 struct gdbpy_event
*event
;
998 if (!PyArg_ParseTuple (args
, "O", &func
))
1001 if (!PyCallable_Check (func
))
1003 PyErr_SetString (PyExc_RuntimeError
,
1004 _("Posted event is not callable"));
1010 /* From here until the end of the function, we have the GIL, so we
1011 can operate on our global data structures without worrying. */
1012 wakeup
= gdbpy_event_list
== NULL
;
1014 event
= XNEW (struct gdbpy_event
);
1015 event
->event
= func
;
1017 *gdbpy_event_list_end
= event
;
1018 gdbpy_event_list_end
= &event
->next
;
1020 /* Wake up gdb when needed. */
1022 serial_event_set (gdbpy_serial_event
);
1027 /* Initialize the Python event handler. */
1029 gdbpy_initialize_events (void)
1031 gdbpy_event_list_end
= &gdbpy_event_list
;
1033 gdbpy_serial_event
= make_serial_event ();
1034 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1035 gdbpy_run_events
, NULL
);
1042 /* This is the extension_language_ops.before_prompt "method". */
1044 static enum ext_lang_rc
1045 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1046 const char *current_gdb_prompt
)
1048 if (!gdb_python_initialized
)
1049 return EXT_LANG_RC_NOP
;
1051 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1053 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1054 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1055 return EXT_LANG_RC_ERROR
;
1057 if (gdb_python_module
1058 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1060 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1064 gdbpy_print_stack ();
1065 return EXT_LANG_RC_ERROR
;
1068 if (PyCallable_Check (hook
.get ()))
1070 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1071 if (current_prompt
== NULL
)
1073 gdbpy_print_stack ();
1074 return EXT_LANG_RC_ERROR
;
1078 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1082 gdbpy_print_stack ();
1083 return EXT_LANG_RC_ERROR
;
1086 /* Return type should be None, or a String. If it is None,
1087 fall through, we will not set a prompt. If it is a
1088 string, set PROMPT. Anything else, set an exception. */
1089 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1091 PyErr_Format (PyExc_RuntimeError
,
1092 _("Return from prompt_hook must " \
1093 "be either a Python string, or None"));
1094 gdbpy_print_stack ();
1095 return EXT_LANG_RC_ERROR
;
1098 if (result
!= Py_None
)
1100 gdb::unique_xmalloc_ptr
<char>
1101 prompt (python_string_to_host_string (result
.get ()));
1105 gdbpy_print_stack ();
1106 return EXT_LANG_RC_ERROR
;
1109 set_prompt (prompt
.get ());
1110 return EXT_LANG_RC_OK
;
1115 return EXT_LANG_RC_NOP
;
1122 /* A python function to write a single string using gdb's filtered
1123 output stream . The optional keyword STREAM can be used to write
1124 to a particular stream. The default stream is to gdb_stdout. */
1127 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1130 static const char *keywords
[] = { "text", "stream", NULL
};
1131 int stream_type
= 0;
1133 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1139 switch (stream_type
)
1143 fprintf_filtered (gdb_stderr
, "%s", arg
);
1148 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1152 fprintf_filtered (gdb_stdout
, "%s", arg
);
1155 CATCH (except
, RETURN_MASK_ALL
)
1157 GDB_PY_HANDLE_EXCEPTION (except
);
1164 /* A python function to flush a gdb stream. The optional keyword
1165 STREAM can be used to flush a particular stream. The default stream
1169 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1171 static const char *keywords
[] = { "stream", NULL
};
1172 int stream_type
= 0;
1174 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1178 switch (stream_type
)
1182 gdb_flush (gdb_stderr
);
1187 gdb_flush (gdb_stdlog
);
1191 gdb_flush (gdb_stdout
);
1197 /* Return non-zero if print-stack is not "none". */
1200 gdbpy_print_python_errors_p (void)
1202 return gdbpy_should_print_stack
!= python_excp_none
;
1205 /* Print a python exception trace, print just a message, or print
1206 nothing and clear the python exception, depending on
1207 gdbpy_should_print_stack. Only call this if a python exception is
1210 gdbpy_print_stack (void)
1213 /* Print "none", just clear exception. */
1214 if (gdbpy_should_print_stack
== python_excp_none
)
1218 /* Print "full" message and backtrace. */
1219 else if (gdbpy_should_print_stack
== python_excp_full
)
1222 /* PyErr_Print doesn't necessarily end output with a newline.
1223 This works because Python's stdout/stderr is fed through
1229 CATCH (except
, RETURN_MASK_ALL
)
1234 /* Print "message", just error print message. */
1237 PyObject
*ptype
, *pvalue
, *ptraceback
;
1239 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1241 /* Fetch the error message contained within ptype, pvalue. */
1242 gdb::unique_xmalloc_ptr
<char>
1243 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1244 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1250 /* An error occurred computing the string representation of the
1252 fprintf_filtered (gdb_stderr
,
1253 _("Error occurred computing Python error" \
1257 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1258 type
.get (), msg
.get ());
1260 CATCH (except
, RETURN_MASK_ALL
)
1266 Py_XDECREF (pvalue
);
1267 Py_XDECREF (ptraceback
);
1271 /* Like gdbpy_print_stack, but if the exception is a
1272 KeyboardException, throw a gdb "quit" instead. */
1275 gdbpy_print_stack_or_quit ()
1277 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1280 throw_quit ("Quit");
1282 gdbpy_print_stack ();
1287 /* Return a sequence holding all the Progspaces. */
1290 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1292 struct program_space
*ps
;
1294 gdbpy_ref
<> list (PyList_New (0));
1300 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1302 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1306 return list
.release ();
1311 /* The "current" objfile. This is set when gdb detects that a new
1312 objfile has been loaded. It is only set for the duration of a call to
1313 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1315 static struct objfile
*gdbpy_current_objfile
;
1317 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1318 as Python code. This does not throw any errors. If an exception
1319 occurs python will print the traceback and clear the error indicator.
1320 This is the extension_language_script_ops.objfile_script_sourcer
1324 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1325 struct objfile
*objfile
, FILE *file
,
1326 const char *filename
)
1328 if (!gdb_python_initialized
)
1331 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1332 gdbpy_current_objfile
= objfile
;
1334 python_run_simple_file (file
, filename
);
1336 gdbpy_current_objfile
= NULL
;
1339 /* Set the current objfile to OBJFILE and then execute SCRIPT
1340 as Python code. This does not throw any errors. If an exception
1341 occurs python will print the traceback and clear the error indicator.
1342 This is the extension_language_script_ops.objfile_script_executor
1346 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1347 struct objfile
*objfile
, const char *name
,
1350 if (!gdb_python_initialized
)
1353 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1354 gdbpy_current_objfile
= objfile
;
1356 PyRun_SimpleString (script
);
1358 gdbpy_current_objfile
= NULL
;
1361 /* Return the current Objfile, or None if there isn't one. */
1364 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1366 if (! gdbpy_current_objfile
)
1369 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1372 /* Compute the list of active python type printers and store them in
1373 EXT_PRINTERS->py_type_printers. The product of this function is used by
1374 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1375 This is the extension_language_ops.start_type_printers "method". */
1378 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1379 struct ext_lang_type_printers
*ext_printers
)
1381 PyObject
*printers_obj
= NULL
;
1383 if (!gdb_python_initialized
)
1386 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1388 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1389 if (type_module
== NULL
)
1391 gdbpy_print_stack ();
1395 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1396 "get_type_recognizers"));
1399 gdbpy_print_stack ();
1403 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1404 if (printers_obj
== NULL
)
1405 gdbpy_print_stack ();
1407 ext_printers
->py_type_printers
= printers_obj
;
1410 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1411 a newly allocated string holding the type's replacement name, and return
1412 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1413 If there's a Python error return EXT_LANG_RC_ERROR.
1414 Otherwise, return EXT_LANG_RC_NOP.
1415 This is the extension_language_ops.apply_type_printers "method". */
1417 static enum ext_lang_rc
1418 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1419 const struct ext_lang_type_printers
*ext_printers
,
1420 struct type
*type
, char **prettied_type
)
1422 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1423 gdb::unique_xmalloc_ptr
<char> result
;
1425 if (printers_obj
== NULL
)
1426 return EXT_LANG_RC_NOP
;
1428 if (!gdb_python_initialized
)
1429 return EXT_LANG_RC_NOP
;
1431 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1433 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1434 if (type_obj
== NULL
)
1436 gdbpy_print_stack ();
1437 return EXT_LANG_RC_ERROR
;
1440 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1441 if (type_module
== NULL
)
1443 gdbpy_print_stack ();
1444 return EXT_LANG_RC_ERROR
;
1447 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1448 "apply_type_recognizers"));
1451 gdbpy_print_stack ();
1452 return EXT_LANG_RC_ERROR
;
1455 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1459 if (result_obj
== NULL
)
1461 gdbpy_print_stack ();
1462 return EXT_LANG_RC_ERROR
;
1465 if (result_obj
== Py_None
)
1466 return EXT_LANG_RC_NOP
;
1468 result
= python_string_to_host_string (result_obj
.get ());
1471 gdbpy_print_stack ();
1472 return EXT_LANG_RC_ERROR
;
1475 *prettied_type
= result
.release ();
1476 return EXT_LANG_RC_OK
;
1479 /* Free the result of start_type_printers.
1480 This is the extension_language_ops.free_type_printers "method". */
1483 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1484 struct ext_lang_type_printers
*ext_printers
)
1486 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1488 if (printers
== NULL
)
1491 if (!gdb_python_initialized
)
1494 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1495 Py_DECREF (printers
);
1498 #else /* HAVE_PYTHON */
1500 /* Dummy implementation of the gdb "python-interactive" and "python"
1504 python_interactive_command (const char *arg
, int from_tty
)
1506 arg
= skip_spaces (arg
);
1508 error (_("Python scripting is not supported in this copy of GDB."));
1511 counted_command_line l
= get_command_line (python_control
, "");
1513 execute_control_command_untraced (l
.get ());
1518 python_command (const char *arg
, int from_tty
)
1520 python_interactive_command (arg
, from_tty
);
1523 #endif /* HAVE_PYTHON */
1527 /* Lists for 'set python' commands. */
1529 static struct cmd_list_element
*user_set_python_list
;
1530 static struct cmd_list_element
*user_show_python_list
;
1532 /* Function for use by 'set python' prefix command. */
1535 user_set_python (const char *args
, int from_tty
)
1537 help_list (user_set_python_list
, "set python ", all_commands
,
1541 /* Function for use by 'show python' prefix command. */
1544 user_show_python (const char *args
, int from_tty
)
1546 cmd_show_list (user_show_python_list
, from_tty
, "");
1549 /* Initialize the Python code. */
1553 /* This is installed as a final cleanup and cleans up the
1554 interpreter. This lets Python's 'atexit' work. */
1557 finalize_python (void *ignore
)
1559 struct active_ext_lang_state
*previous_active
;
1561 /* We don't use ensure_python_env here because if we ever ran the
1562 cleanup, gdb would crash -- because the cleanup calls into the
1563 Python interpreter, which we are about to destroy. It seems
1564 clearer to make the needed calls explicitly here than to create a
1565 cleanup and then mysteriously discard it. */
1567 /* This is only called as a final cleanup so we can assume the active
1568 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1569 previous_active
= set_active_ext_lang (&extension_language_python
);
1571 (void) PyGILState_Ensure ();
1572 python_gdbarch
= target_gdbarch ();
1573 python_language
= current_language
;
1577 restore_active_ext_lang (previous_active
);
1581 /* This is called via the PyImport_AppendInittab mechanism called
1582 during initialization, to make the built-in _gdb module known to
1585 init__gdb_module (void)
1587 return PyModule_Create (&python_GdbModuleDef
);
1592 do_start_initialization ()
1595 size_t progsize
, count
;
1596 wchar_t *progname_copy
;
1599 #ifdef WITH_PYTHON_PATH
1600 /* Work around problem where python gets confused about where it is,
1601 and then can't find its libraries, etc.
1602 NOTE: Python assumes the following layout:
1604 /foo/lib/pythonX.Y/...
1605 This must be done before calling Py_Initialize. */
1606 gdb::unique_xmalloc_ptr
<char> progname
1607 (concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1608 SLASH_STRING
, "python", (char *) NULL
));
1610 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1611 setlocale (LC_ALL
, "");
1612 progsize
= strlen (progname
.get ());
1613 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1616 fprintf (stderr
, "out of memory\n");
1619 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1620 if (count
== (size_t) -1)
1622 fprintf (stderr
, "Could not convert python path to string\n");
1625 setlocale (LC_ALL
, oldloc
.c_str ());
1627 /* Note that Py_SetProgramName expects the string it is passed to
1628 remain alive for the duration of the program's execution, so
1629 it is not freed after this call. */
1630 Py_SetProgramName (progname_copy
);
1632 /* Define _gdb as a built-in module. */
1633 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1635 Py_SetProgramName (progname
.release ());
1640 PyEval_InitThreads ();
1643 gdb_module
= PyImport_ImportModule ("_gdb");
1645 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1647 if (gdb_module
== NULL
)
1650 /* The casts to (char*) are for python 2.4. */
1651 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1652 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1653 (char*) host_name
) < 0
1654 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1655 (char*) target_name
) < 0)
1658 /* Add stream constants. */
1659 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1660 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1661 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1664 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1665 if (gdbpy_gdb_error
== NULL
1666 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1669 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1670 gdbpy_gdb_error
, NULL
);
1671 if (gdbpy_gdb_memory_error
== NULL
1672 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1673 gdbpy_gdb_memory_error
) < 0)
1676 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1677 if (gdbpy_gdberror_exc
== NULL
1678 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1679 gdbpy_gdberror_exc
) < 0)
1682 gdbpy_initialize_gdb_readline ();
1684 if (gdbpy_initialize_auto_load () < 0
1685 || gdbpy_initialize_values () < 0
1686 || gdbpy_initialize_frames () < 0
1687 || gdbpy_initialize_commands () < 0
1688 || gdbpy_initialize_instruction () < 0
1689 || gdbpy_initialize_record () < 0
1690 || gdbpy_initialize_btrace () < 0
1691 || gdbpy_initialize_symbols () < 0
1692 || gdbpy_initialize_symtabs () < 0
1693 || gdbpy_initialize_blocks () < 0
1694 || gdbpy_initialize_functions () < 0
1695 || gdbpy_initialize_parameters () < 0
1696 || gdbpy_initialize_types () < 0
1697 || gdbpy_initialize_pspace () < 0
1698 || gdbpy_initialize_objfile () < 0
1699 || gdbpy_initialize_breakpoints () < 0
1700 || gdbpy_initialize_finishbreakpoints () < 0
1701 || gdbpy_initialize_lazy_string () < 0
1702 || gdbpy_initialize_linetable () < 0
1703 || gdbpy_initialize_thread () < 0
1704 || gdbpy_initialize_inferior () < 0
1705 || gdbpy_initialize_events () < 0
1706 || gdbpy_initialize_eventregistry () < 0
1707 || gdbpy_initialize_py_events () < 0
1708 || gdbpy_initialize_event () < 0
1709 || gdbpy_initialize_arch () < 0
1710 || gdbpy_initialize_xmethods () < 0
1711 || gdbpy_initialize_unwind () < 0)
1714 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1715 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1717 #include "py-event-types.def"
1718 #undef GDB_PY_DEFINE_EVENT_TYPE
1720 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1721 if (gdbpy_to_string_cst
== NULL
)
1723 gdbpy_children_cst
= PyString_FromString ("children");
1724 if (gdbpy_children_cst
== NULL
)
1726 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1727 if (gdbpy_display_hint_cst
== NULL
)
1729 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1730 if (gdbpy_doc_cst
== NULL
)
1732 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1733 if (gdbpy_enabled_cst
== NULL
)
1735 gdbpy_value_cst
= PyString_FromString ("value");
1736 if (gdbpy_value_cst
== NULL
)
1739 /* Release the GIL while gdb runs. */
1740 PyThreadState_Swap (NULL
);
1741 PyEval_ReleaseLock ();
1743 make_final_cleanup (finalize_python
, NULL
);
1745 /* Only set this when initialization has succeeded. */
1746 gdb_python_initialized
= 1;
1750 #endif /* HAVE_PYTHON */
1753 cmd_list_element
*python_cmd_element
= nullptr;
1756 _initialize_python (void)
1758 add_com ("python-interactive", class_obscure
,
1759 python_interactive_command
,
1762 Start an interactive Python prompt.\n\
1764 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1767 Alternatively, a single-line Python command can be given as an\n\
1768 argument, and if the command is an expression, the result will be\n\
1769 printed. For example:\n\
1771 (gdb) python-interactive 2 + 3\n\
1774 #else /* HAVE_PYTHON */
1776 Start a Python interactive prompt.\n\
1778 Python scripting is not supported in this copy of GDB.\n\
1779 This command is only a placeholder.")
1780 #endif /* HAVE_PYTHON */
1782 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1784 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1787 Evaluate a Python command.\n\
1789 The command can be given as an argument, for instance:\n\
1791 python print (23)\n\
1793 If no argument is given, the following lines are read and used\n\
1794 as the Python commands. Type a line containing \"end\" to indicate\n\
1795 the end of the command.")
1796 #else /* HAVE_PYTHON */
1798 Evaluate a Python command.\n\
1800 Python scripting is not supported in this copy of GDB.\n\
1801 This command is only a placeholder.")
1802 #endif /* HAVE_PYTHON */
1804 add_com_alias ("py", "python", class_obscure
, 1);
1806 /* Add set/show python print-stack. */
1807 add_prefix_cmd ("python", no_class
, user_show_python
,
1808 _("Prefix command for python preference settings."),
1809 &user_show_python_list
, "show python ", 0,
1812 add_prefix_cmd ("python", no_class
, user_set_python
,
1813 _("Prefix command for python preference settings."),
1814 &user_set_python_list
, "set python ", 0,
1817 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1818 &gdbpy_should_print_stack
, _("\
1819 Set mode for Python stack dump on error."), _("\
1820 Show the mode of Python stack printing on error."), _("\
1821 none == no stack or message will be printed.\n\
1822 full == a message and a stack will be printed.\n\
1823 message == an error message without a stack will be printed."),
1825 &user_set_python_list
,
1826 &user_show_python_list
);
1829 if (!do_start_initialization () && PyErr_Occurred ())
1830 gdbpy_print_stack ();
1831 #endif /* HAVE_PYTHON */
1836 /* Helper function for gdbpy_finish_initialization. This does the
1837 work and then returns false if an error has occurred and must be
1838 displayed, or true on success. */
1841 do_finish_initialization (const struct extension_language_defn
*extlang
)
1846 /* Add the initial data-directory to sys.path. */
1848 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1851 sys_path
= PySys_GetObject ("path");
1853 /* If sys.path is not defined yet, define it first. */
1854 if (!(sys_path
&& PyList_Check (sys_path
)))
1857 PySys_SetPath (L
"");
1861 sys_path
= PySys_GetObject ("path");
1863 if (sys_path
&& PyList_Check (sys_path
))
1865 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1866 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1872 /* Import the gdb module to finish the initialization, and
1873 add it to __main__ for convenience. */
1874 m
= PyImport_AddModule ("__main__");
1878 /* Keep the reference to gdb_python_module since it is in a global
1880 gdb_python_module
= PyImport_ImportModule ("gdb");
1881 if (gdb_python_module
== NULL
)
1883 gdbpy_print_stack ();
1884 /* This is passed in one call to warning so that blank lines aren't
1885 inserted between each line of text. */
1887 "Could not load the Python gdb module from `%s'.\n"
1888 "Limited Python support is available from the _gdb module.\n"
1889 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1890 gdb_pythondir
.c_str ());
1891 /* We return "success" here as we've already emitted the
1896 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1899 /* Perform the remaining python initializations.
1900 These must be done after GDB is at least mostly initialized.
1901 E.g., The "info pretty-printer" command needs the "info" prefix
1903 This is the extension_language_ops.finish_initialization "method". */
1906 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1908 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1910 if (!do_finish_initialization (extlang
))
1912 gdbpy_print_stack ();
1913 warning (_("internal error: Unhandled Python exception"));
1917 /* Return non-zero if Python has successfully initialized.
1918 This is the extension_languages_ops.initialized "method". */
1921 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1923 return gdb_python_initialized
;
1926 #endif /* HAVE_PYTHON */
1932 PyMethodDef python_GdbMethods
[] =
1934 { "history", gdbpy_history
, METH_VARARGS
,
1935 "Get a value from history" },
1936 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1937 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1938 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1939 a Python String containing the output of the command if to_string is\n\
1941 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1942 "Return a gdb parameter's value" },
1944 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1945 "Return a tuple of all breakpoint objects" },
1947 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1948 "Find the default visualizer for a Value." },
1950 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1951 "Return a sequence of all progspaces." },
1953 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1954 "Return the current Objfile being loaded, or None." },
1956 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1957 "newest_frame () -> gdb.Frame.\n\
1958 Return the newest frame object." },
1959 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1960 "selected_frame () -> gdb.Frame.\n\
1961 Return the selected frame object." },
1962 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1963 "stop_reason_string (Integer) -> String.\n\
1964 Return a string explaining unwind stop reason." },
1966 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1967 "start_recording ([method] [, format]) -> gdb.Record.\n\
1968 Start recording with the given method. If no method is given, will fall back\n\
1969 to the system default method. If no format is given, will fall back to the\n\
1970 default format for the given method."},
1971 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1972 "current_recording () -> gdb.Record.\n\
1973 Return current recording object." },
1974 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1975 "stop_recording () -> None.\n\
1976 Stop current recording." },
1978 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1979 METH_VARARGS
| METH_KEYWORDS
,
1980 "lookup_type (name [, block]) -> type\n\
1981 Return a Type corresponding to the given name." },
1982 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1983 METH_VARARGS
| METH_KEYWORDS
,
1984 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1985 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1986 a boolean indicating if name is a field of the current implied argument\n\
1987 `this' (when the current language is object-oriented)." },
1988 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1989 METH_VARARGS
| METH_KEYWORDS
,
1990 "lookup_global_symbol (name [, domain]) -> symbol\n\
1991 Return the symbol corresponding to the given name (or None)." },
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 */