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 "common/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 create on Windows hosts the
327 FILE object using Python routines, thus making sure that it is
328 compatible with the Python library. */
331 python_run_simple_file (FILE *file
, const char *filename
)
335 PyRun_SimpleFile (file
, filename
);
339 /* Because we have a string for a filename, and are using Python to
340 open the file, we need to expand any tilde in the path first. */
341 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
342 gdbpy_ref
<> python_file (PyFile_FromString (full_path
.get (), (char *) "r"));
343 if (python_file
== NULL
)
345 gdbpy_print_stack ();
346 error (_("Error while opening file: %s"), full_path
.get ());
349 PyRun_SimpleFile (PyFile_AsFile (python_file
.get ()), filename
);
354 /* Given a command_line, return a command string suitable for passing
355 to Python. Lines in the string are separated by newlines. */
358 compute_python_string (struct command_line
*l
)
360 struct command_line
*iter
;
363 for (iter
= l
; iter
; iter
= iter
->next
)
365 script
+= iter
->line
;
371 /* Take a command line structure representing a 'python' command, and
372 evaluate its body using the Python interpreter. */
375 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
376 struct command_line
*cmd
)
380 if (cmd
->body_list_1
!= nullptr)
381 error (_("Invalid \"python\" block structure."));
383 gdbpy_enter
enter_py (get_current_arch (), current_language
);
385 std::string script
= compute_python_string (cmd
->body_list_0
.get ());
386 ret
= PyRun_SimpleString (script
.c_str ());
388 error (_("Error while executing Python code."));
391 /* Implementation of the gdb "python" command. */
394 python_command (const char *arg
, int from_tty
)
396 gdbpy_enter
enter_py (get_current_arch (), current_language
);
398 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
400 arg
= skip_spaces (arg
);
403 if (PyRun_SimpleString (arg
))
404 error (_("Error while executing Python code."));
408 counted_command_line l
= get_command_line (python_control
, "");
410 execute_control_command_untraced (l
.get ());
416 /* Transform a gdb parameters's value into a Python value. May return
417 NULL (and set a Python exception) on error. Helper function for
420 gdbpy_parameter_value (enum var_types type
, void *var
)
425 case var_string_noescape
:
426 case var_optional_filename
:
430 const char *str
= *(char **) var
;
434 return host_string_to_python_string (str
).release ();
445 case var_auto_boolean
:
447 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
449 if (ab
== AUTO_BOOLEAN_TRUE
)
451 else if (ab
== AUTO_BOOLEAN_FALSE
)
458 if ((* (int *) var
) == INT_MAX
)
462 case var_zuinteger_unlimited
:
463 return PyLong_FromLong (* (int *) var
);
467 unsigned int val
= * (unsigned int *) var
;
471 return PyLong_FromUnsignedLong (val
);
476 unsigned int val
= * (unsigned int *) var
;
477 return PyLong_FromUnsignedLong (val
);
481 return PyErr_Format (PyExc_RuntimeError
,
482 _("Programmer error: unhandled type."));
485 /* A Python function which returns a gdb parameter's value as a Python
489 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
491 struct cmd_list_element
*alias
, *prefix
, *cmd
;
495 if (! PyArg_ParseTuple (args
, "s", &arg
))
498 std::string newarg
= std::string ("show ") + arg
;
502 found
= lookup_cmd_composition (newarg
.c_str (), &alias
, &prefix
, &cmd
);
504 CATCH (ex
, RETURN_MASK_ALL
)
506 GDB_PY_HANDLE_EXCEPTION (ex
);
511 return PyErr_Format (PyExc_RuntimeError
,
512 _("Could not find parameter `%s'."), arg
);
515 return PyErr_Format (PyExc_RuntimeError
,
516 _("`%s' is not a parameter."), arg
);
517 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
520 /* Wrapper for target_charset. */
523 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
525 const char *cset
= target_charset (python_gdbarch
);
527 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
530 /* Wrapper for target_wide_charset. */
533 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
535 const char *cset
= target_wide_charset (python_gdbarch
);
537 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
540 /* A Python function which evaluates a string using the gdb CLI. */
543 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
546 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
547 int from_tty
, to_string
;
548 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
550 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
551 &PyBool_Type
, &from_tty_obj
,
552 &PyBool_Type
, &to_string_obj
))
558 int cmp
= PyObject_IsTrue (from_tty_obj
);
567 int cmp
= PyObject_IsTrue (to_string_obj
);
573 std::string to_string_res
;
575 scoped_restore preventer
= prevent_dont_repeat ();
579 gdbpy_allow_threads allow_threads
;
581 struct interp
*interp
;
583 std::string arg_copy
= arg
;
585 char *save_ptr
= nullptr;
589 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
595 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
598 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
601 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
603 /* Use the console interpreter uiout to have the same print format
604 for console or MI. */
605 interp
= interp_lookup (current_ui
, "console");
606 current_uiout
= interp
->interp_ui_out ();
609 to_string_res
= execute_control_commands_to_string (lines
.get (),
612 execute_control_commands (lines
.get (), from_tty
);
615 /* Do any commands attached to breakpoint we stopped at. */
616 bpstat_do_actions ();
618 CATCH (except
, RETURN_MASK_ALL
)
620 GDB_PY_HANDLE_EXCEPTION (except
);
625 return PyString_FromString (to_string_res
.c_str ());
629 /* Implementation of Python rbreak command. Take a REGEX and
630 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
631 Python list that contains newly set breakpoints that match that
632 criteria. REGEX refers to a GDB format standard regex pattern of
633 symbols names to search; MINSYMS is an optional boolean (default
634 False) that indicates if the function should search GDB's minimal
635 symbols; THROTTLE is an optional integer (default unlimited) that
636 indicates the maximum amount of breakpoints allowable before the
637 function exits (note, if the throttle bound is passed, no
638 breakpoints will be set and a runtime error returned); SYMTABS is
639 an optional Python iterable that contains a set of gdb.Symtabs to
640 constrain the search within. */
643 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
645 /* A simple type to ensure clean up of a vector of allocated strings
646 when a C interface demands a const char *array[] type
648 struct symtab_list_type
652 for (const char *elem
: vec
)
653 xfree ((void *) elem
);
655 std::vector
<const char *> vec
;
659 std::vector
<symbol_search
> symbols
;
660 unsigned long count
= 0;
661 PyObject
*symtab_list
= NULL
;
662 PyObject
*minsyms_p_obj
= NULL
;
664 unsigned int throttle
= 0;
665 static const char *keywords
[] = {"regex","minsyms", "throttle",
667 symtab_list_type symtab_paths
;
669 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
670 ®ex
, &PyBool_Type
,
671 &minsyms_p_obj
, &throttle
,
675 /* Parse minsyms keyword. */
676 if (minsyms_p_obj
!= NULL
)
678 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
684 /* The "symtabs" keyword is any Python iterable object that returns
685 a gdb.Symtab on each iteration. If specified, iterate through
686 the provided gdb.Symtabs and extract their full path. As
687 python_string_to_target_string returns a
688 gdb::unique_xmalloc_ptr<char> and a vector containing these types
689 cannot be coerced to a const char **p[] via the vector.data call,
690 release the value from the unique_xmalloc_ptr and place it in a
691 simple type symtab_list_type (which holds the vector and a
692 destructor that frees the contents of the allocated strings. */
693 if (symtab_list
!= NULL
)
695 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
702 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
706 if (PyErr_Occurred ())
711 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
714 if (obj_name
== NULL
)
717 /* Is the object file still valid? */
718 if (obj_name
== Py_None
)
721 gdb::unique_xmalloc_ptr
<char> filename
=
722 python_string_to_target_string (obj_name
.get ());
724 if (filename
== NULL
)
727 /* Make sure there is a definite place to store the value of
728 filename before it is released. */
729 symtab_paths
.vec
.push_back (nullptr);
730 symtab_paths
.vec
.back () = filename
.release ();
736 const char **files
= symtab_paths
.vec
.data ();
738 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
,
739 symtab_paths
.vec
.size (), files
);
742 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
, 0, NULL
);
744 /* Count the number of symbols (both symbols and optionally minimal
745 symbols) so we can correctly check the throttle limit. */
746 for (const symbol_search
&p
: symbols
)
748 /* Minimal symbols included? */
751 if (p
.msymbol
.minsym
!= NULL
)
755 if (p
.symbol
!= NULL
)
759 /* Check throttle bounds and exit if in excess. */
760 if (throttle
!= 0 && count
> throttle
)
762 PyErr_SetString (PyExc_RuntimeError
,
763 _("Number of breakpoints exceeds throttled maximum."));
767 gdbpy_ref
<> return_list (PyList_New (0));
769 if (return_list
== NULL
)
772 /* Construct full path names for symbols and call the Python
773 breakpoint constructor on the resulting names. Be tolerant of
774 individual breakpoint failures. */
775 for (const symbol_search
&p
: symbols
)
777 std::string symbol_name
;
779 /* Skipping minimal symbols? */
781 if (p
.msymbol
.minsym
!= NULL
)
784 if (p
.msymbol
.minsym
== NULL
)
786 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
787 const char *fullname
= symtab_to_fullname (symtab
);
789 symbol_name
= fullname
;
791 symbol_name
+= SYMBOL_LINKAGE_NAME (p
.symbol
);
794 symbol_name
= MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
);
796 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
797 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
798 &breakpoint_object_type
,
801 /* Tolerate individual breakpoint failures. */
803 gdbpy_print_stack ();
806 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
810 return return_list
.release ();
813 /* A Python function which is a wrapper for decode_line_1. */
816 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
818 const char *arg
= NULL
;
820 gdbpy_ref
<> unparsed
;
821 event_location_up location
;
823 if (! PyArg_ParseTuple (args
, "|s", &arg
))
827 location
= string_to_event_location_basic (&arg
, python_language
,
828 symbol_name_match_type::WILD
);
830 std::vector
<symtab_and_line
> decoded_sals
;
831 symtab_and_line def_sal
;
832 gdb::array_view
<symtab_and_line
> sals
;
835 if (location
!= NULL
)
837 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
842 set_default_source_symtab_and_line ();
843 def_sal
= get_current_source_symtab_and_line ();
847 CATCH (ex
, RETURN_MASK_ALL
)
849 /* We know this will always throw. */
850 gdbpy_convert_exception (ex
);
857 result
.reset (PyTuple_New (sals
.size ()));
860 for (size_t i
= 0; i
< sals
.size (); ++i
)
862 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
866 PyTuple_SetItem (result
.get (), i
, obj
);
870 result
= gdbpy_ref
<>::new_reference (Py_None
);
872 gdbpy_ref
<> return_result (PyTuple_New (2));
873 if (return_result
== NULL
)
876 if (arg
!= NULL
&& strlen (arg
) > 0)
878 unparsed
.reset (PyString_FromString (arg
));
879 if (unparsed
== NULL
)
883 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
885 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
886 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
888 return return_result
.release ();
891 /* Parse a string and evaluate it as an expression. */
893 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
895 const char *expr_str
;
896 struct value
*result
= NULL
;
898 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
903 gdbpy_allow_threads allow_threads
;
904 result
= parse_and_eval (expr_str
);
906 CATCH (except
, RETURN_MASK_ALL
)
908 GDB_PY_HANDLE_EXCEPTION (except
);
912 return value_to_value_object (result
);
915 /* Implementation of gdb.invalidate_cached_frames. */
918 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
920 reinit_frame_cache ();
924 /* Read a file as Python code.
925 This is the extension_language_script_ops.script_sourcer "method".
926 FILE is the file to load. FILENAME is name of the file FILE.
927 This does not throw any errors. If an exception occurs python will print
928 the traceback and clear the error indicator. */
931 gdbpy_source_script (const struct extension_language_defn
*extlang
,
932 FILE *file
, const char *filename
)
934 gdbpy_enter
enter_py (get_current_arch (), current_language
);
935 python_run_simple_file (file
, filename
);
940 /* Posting and handling events. */
942 /* A single event. */
945 /* The Python event. This is just a callable object. */
947 /* The next event. */
948 struct gdbpy_event
*next
;
951 /* All pending events. */
952 static struct gdbpy_event
*gdbpy_event_list
;
953 /* The final link of the event list. */
954 static struct gdbpy_event
**gdbpy_event_list_end
;
956 /* So that we can wake up the main thread even when it is blocked in
958 static struct serial_event
*gdbpy_serial_event
;
960 /* The file handler callback. This reads from the internal pipe, and
961 then processes the Python event queue. This will always be run in
962 the main gdb thread. */
965 gdbpy_run_events (int error
, gdb_client_data client_data
)
967 gdbpy_enter
enter_py (get_current_arch (), current_language
);
969 /* Clear the event fd. Do this before flushing the events list, so
970 that any new event post afterwards is sure to re-awake the event
972 serial_event_clear (gdbpy_serial_event
);
974 while (gdbpy_event_list
)
976 /* Dispatching the event might push a new element onto the event
977 loop, so we update here "atomically enough". */
978 struct gdbpy_event
*item
= gdbpy_event_list
;
979 gdbpy_event_list
= gdbpy_event_list
->next
;
980 if (gdbpy_event_list
== NULL
)
981 gdbpy_event_list_end
= &gdbpy_event_list
;
983 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
984 if (call_result
== NULL
)
985 gdbpy_print_stack ();
987 Py_DECREF (item
->event
);
992 /* Submit an event to the gdb thread. */
994 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
996 struct gdbpy_event
*event
;
1000 if (!PyArg_ParseTuple (args
, "O", &func
))
1003 if (!PyCallable_Check (func
))
1005 PyErr_SetString (PyExc_RuntimeError
,
1006 _("Posted event is not callable"));
1012 /* From here until the end of the function, we have the GIL, so we
1013 can operate on our global data structures without worrying. */
1014 wakeup
= gdbpy_event_list
== NULL
;
1016 event
= XNEW (struct gdbpy_event
);
1017 event
->event
= func
;
1019 *gdbpy_event_list_end
= event
;
1020 gdbpy_event_list_end
= &event
->next
;
1022 /* Wake up gdb when needed. */
1024 serial_event_set (gdbpy_serial_event
);
1029 /* Initialize the Python event handler. */
1031 gdbpy_initialize_events (void)
1033 gdbpy_event_list_end
= &gdbpy_event_list
;
1035 gdbpy_serial_event
= make_serial_event ();
1036 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1037 gdbpy_run_events
, NULL
);
1044 /* This is the extension_language_ops.before_prompt "method". */
1046 static enum ext_lang_rc
1047 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1048 const char *current_gdb_prompt
)
1050 if (!gdb_python_initialized
)
1051 return EXT_LANG_RC_NOP
;
1053 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1055 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1056 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1057 return EXT_LANG_RC_ERROR
;
1059 if (gdb_python_module
1060 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1062 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1066 gdbpy_print_stack ();
1067 return EXT_LANG_RC_ERROR
;
1070 if (PyCallable_Check (hook
.get ()))
1072 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1073 if (current_prompt
== NULL
)
1075 gdbpy_print_stack ();
1076 return EXT_LANG_RC_ERROR
;
1080 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1084 gdbpy_print_stack ();
1085 return EXT_LANG_RC_ERROR
;
1088 /* Return type should be None, or a String. If it is None,
1089 fall through, we will not set a prompt. If it is a
1090 string, set PROMPT. Anything else, set an exception. */
1091 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1093 PyErr_Format (PyExc_RuntimeError
,
1094 _("Return from prompt_hook must " \
1095 "be either a Python string, or None"));
1096 gdbpy_print_stack ();
1097 return EXT_LANG_RC_ERROR
;
1100 if (result
!= Py_None
)
1102 gdb::unique_xmalloc_ptr
<char>
1103 prompt (python_string_to_host_string (result
.get ()));
1107 gdbpy_print_stack ();
1108 return EXT_LANG_RC_ERROR
;
1111 set_prompt (prompt
.get ());
1112 return EXT_LANG_RC_OK
;
1117 return EXT_LANG_RC_NOP
;
1124 /* A python function to write a single string using gdb's filtered
1125 output stream . The optional keyword STREAM can be used to write
1126 to a particular stream. The default stream is to gdb_stdout. */
1129 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1132 static const char *keywords
[] = { "text", "stream", NULL
};
1133 int stream_type
= 0;
1135 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1141 switch (stream_type
)
1145 fprintf_filtered (gdb_stderr
, "%s", arg
);
1150 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1154 fprintf_filtered (gdb_stdout
, "%s", arg
);
1157 CATCH (except
, RETURN_MASK_ALL
)
1159 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 (except
, RETURN_MASK_ALL
)
1236 /* Print "message", just error print message. */
1239 gdbpy_err_fetch fetched_error
;
1241 gdb::unique_xmalloc_ptr
<char> msg
= fetched_error
.to_string ();
1242 gdb::unique_xmalloc_ptr
<char> type
;
1243 /* Don't compute TYPE if MSG already indicates that there is an
1246 type
= fetched_error
.type_to_string ();
1250 if (msg
== NULL
|| type
== NULL
)
1252 /* An error occurred computing the string representation of the
1254 fprintf_filtered (gdb_stderr
,
1255 _("Error occurred computing Python error" \
1260 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1261 type
.get (), msg
.get ());
1263 CATCH (except
, RETURN_MASK_ALL
)
1270 /* Like gdbpy_print_stack, but if the exception is a
1271 KeyboardException, throw a gdb "quit" instead. */
1274 gdbpy_print_stack_or_quit ()
1276 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1279 throw_quit ("Quit");
1281 gdbpy_print_stack ();
1286 /* Return a sequence holding all the Progspaces. */
1289 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1291 struct program_space
*ps
;
1293 gdbpy_ref
<> list (PyList_New (0));
1299 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1301 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1305 return list
.release ();
1310 /* The "current" objfile. This is set when gdb detects that a new
1311 objfile has been loaded. It is only set for the duration of a call to
1312 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1314 static struct objfile
*gdbpy_current_objfile
;
1316 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1317 as Python code. This does not throw any errors. If an exception
1318 occurs python will print the traceback and clear the error indicator.
1319 This is the extension_language_script_ops.objfile_script_sourcer
1323 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1324 struct objfile
*objfile
, FILE *file
,
1325 const char *filename
)
1327 if (!gdb_python_initialized
)
1330 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1331 gdbpy_current_objfile
= objfile
;
1333 python_run_simple_file (file
, filename
);
1335 gdbpy_current_objfile
= NULL
;
1338 /* Set the current objfile to OBJFILE and then execute SCRIPT
1339 as Python code. This does not throw any errors. If an exception
1340 occurs python will print the traceback and clear the error indicator.
1341 This is the extension_language_script_ops.objfile_script_executor
1345 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1346 struct objfile
*objfile
, const char *name
,
1349 if (!gdb_python_initialized
)
1352 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1353 gdbpy_current_objfile
= objfile
;
1355 PyRun_SimpleString (script
);
1357 gdbpy_current_objfile
= NULL
;
1360 /* Return the current Objfile, or None if there isn't one. */
1363 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1365 if (! gdbpy_current_objfile
)
1368 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1371 /* Compute the list of active python type printers and store them in
1372 EXT_PRINTERS->py_type_printers. The product of this function is used by
1373 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1374 This is the extension_language_ops.start_type_printers "method". */
1377 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1378 struct ext_lang_type_printers
*ext_printers
)
1380 PyObject
*printers_obj
= NULL
;
1382 if (!gdb_python_initialized
)
1385 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1387 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1388 if (type_module
== NULL
)
1390 gdbpy_print_stack ();
1394 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1395 "get_type_recognizers"));
1398 gdbpy_print_stack ();
1402 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1403 if (printers_obj
== NULL
)
1404 gdbpy_print_stack ();
1406 ext_printers
->py_type_printers
= printers_obj
;
1409 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1410 a newly allocated string holding the type's replacement name, and return
1411 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1412 If there's a Python error return EXT_LANG_RC_ERROR.
1413 Otherwise, return EXT_LANG_RC_NOP.
1414 This is the extension_language_ops.apply_type_printers "method". */
1416 static enum ext_lang_rc
1417 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1418 const struct ext_lang_type_printers
*ext_printers
,
1419 struct type
*type
, char **prettied_type
)
1421 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1422 gdb::unique_xmalloc_ptr
<char> result
;
1424 if (printers_obj
== NULL
)
1425 return EXT_LANG_RC_NOP
;
1427 if (!gdb_python_initialized
)
1428 return EXT_LANG_RC_NOP
;
1430 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1432 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1433 if (type_obj
== NULL
)
1435 gdbpy_print_stack ();
1436 return EXT_LANG_RC_ERROR
;
1439 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1440 if (type_module
== NULL
)
1442 gdbpy_print_stack ();
1443 return EXT_LANG_RC_ERROR
;
1446 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1447 "apply_type_recognizers"));
1450 gdbpy_print_stack ();
1451 return EXT_LANG_RC_ERROR
;
1454 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1458 if (result_obj
== NULL
)
1460 gdbpy_print_stack ();
1461 return EXT_LANG_RC_ERROR
;
1464 if (result_obj
== Py_None
)
1465 return EXT_LANG_RC_NOP
;
1467 result
= python_string_to_host_string (result_obj
.get ());
1470 gdbpy_print_stack ();
1471 return EXT_LANG_RC_ERROR
;
1474 *prettied_type
= result
.release ();
1475 return EXT_LANG_RC_OK
;
1478 /* Free the result of start_type_printers.
1479 This is the extension_language_ops.free_type_printers "method". */
1482 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1483 struct ext_lang_type_printers
*ext_printers
)
1485 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1487 if (printers
== NULL
)
1490 if (!gdb_python_initialized
)
1493 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1494 Py_DECREF (printers
);
1497 #else /* HAVE_PYTHON */
1499 /* Dummy implementation of the gdb "python-interactive" and "python"
1503 python_interactive_command (const char *arg
, int from_tty
)
1505 arg
= skip_spaces (arg
);
1507 error (_("Python scripting is not supported in this copy of GDB."));
1510 counted_command_line l
= get_command_line (python_control
, "");
1512 execute_control_command_untraced (l
.get ());
1517 python_command (const char *arg
, int from_tty
)
1519 python_interactive_command (arg
, from_tty
);
1522 #endif /* HAVE_PYTHON */
1526 /* Lists for 'set python' commands. */
1528 static struct cmd_list_element
*user_set_python_list
;
1529 static struct cmd_list_element
*user_show_python_list
;
1531 /* Function for use by 'set python' prefix command. */
1534 user_set_python (const char *args
, int from_tty
)
1536 help_list (user_set_python_list
, "set python ", all_commands
,
1540 /* Function for use by 'show python' prefix command. */
1543 user_show_python (const char *args
, int from_tty
)
1545 cmd_show_list (user_show_python_list
, from_tty
, "");
1548 /* Initialize the Python code. */
1552 /* This is installed as a final cleanup and cleans up the
1553 interpreter. This lets Python's 'atexit' work. */
1556 finalize_python (void *ignore
)
1558 struct active_ext_lang_state
*previous_active
;
1560 /* We don't use ensure_python_env here because if we ever ran the
1561 cleanup, gdb would crash -- because the cleanup calls into the
1562 Python interpreter, which we are about to destroy. It seems
1563 clearer to make the needed calls explicitly here than to create a
1564 cleanup and then mysteriously discard it. */
1566 /* This is only called as a final cleanup so we can assume the active
1567 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1568 previous_active
= set_active_ext_lang (&extension_language_python
);
1570 (void) PyGILState_Ensure ();
1571 python_gdbarch
= target_gdbarch ();
1572 python_language
= current_language
;
1576 restore_active_ext_lang (previous_active
);
1580 /* This is called via the PyImport_AppendInittab mechanism called
1581 during initialization, to make the built-in _gdb module known to
1584 init__gdb_module (void)
1586 return PyModule_Create (&python_GdbModuleDef
);
1591 do_start_initialization ()
1594 size_t progsize
, count
;
1595 wchar_t *progname_copy
;
1598 #ifdef WITH_PYTHON_PATH
1599 /* Work around problem where python gets confused about where it is,
1600 and then can't find its libraries, etc.
1601 NOTE: Python assumes the following layout:
1603 /foo/lib/pythonX.Y/...
1604 This must be done before calling Py_Initialize. */
1605 gdb::unique_xmalloc_ptr
<char> progname
1606 (concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1607 SLASH_STRING
, "python", (char *) NULL
));
1609 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1610 setlocale (LC_ALL
, "");
1611 progsize
= strlen (progname
.get ());
1612 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1615 fprintf (stderr
, "out of memory\n");
1618 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1619 if (count
== (size_t) -1)
1621 fprintf (stderr
, "Could not convert python path to string\n");
1624 setlocale (LC_ALL
, oldloc
.c_str ());
1626 /* Note that Py_SetProgramName expects the string it is passed to
1627 remain alive for the duration of the program's execution, so
1628 it is not freed after this call. */
1629 Py_SetProgramName (progname_copy
);
1631 /* Define _gdb as a built-in module. */
1632 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1634 Py_SetProgramName (progname
.release ());
1639 PyEval_InitThreads ();
1642 gdb_module
= PyImport_ImportModule ("_gdb");
1644 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1646 if (gdb_module
== NULL
)
1649 if (PyModule_AddStringConstant (gdb_module
, "VERSION", version
) < 0
1650 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG", host_name
) < 0
1651 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1655 /* Add stream constants. */
1656 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1657 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1658 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1661 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1662 if (gdbpy_gdb_error
== NULL
1663 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1666 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1667 gdbpy_gdb_error
, NULL
);
1668 if (gdbpy_gdb_memory_error
== NULL
1669 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1670 gdbpy_gdb_memory_error
) < 0)
1673 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1674 if (gdbpy_gdberror_exc
== NULL
1675 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1676 gdbpy_gdberror_exc
) < 0)
1679 gdbpy_initialize_gdb_readline ();
1681 if (gdbpy_initialize_auto_load () < 0
1682 || gdbpy_initialize_values () < 0
1683 || gdbpy_initialize_frames () < 0
1684 || gdbpy_initialize_commands () < 0
1685 || gdbpy_initialize_instruction () < 0
1686 || gdbpy_initialize_record () < 0
1687 || gdbpy_initialize_btrace () < 0
1688 || gdbpy_initialize_symbols () < 0
1689 || gdbpy_initialize_symtabs () < 0
1690 || gdbpy_initialize_blocks () < 0
1691 || gdbpy_initialize_functions () < 0
1692 || gdbpy_initialize_parameters () < 0
1693 || gdbpy_initialize_types () < 0
1694 || gdbpy_initialize_pspace () < 0
1695 || gdbpy_initialize_objfile () < 0
1696 || gdbpy_initialize_breakpoints () < 0
1697 || gdbpy_initialize_finishbreakpoints () < 0
1698 || gdbpy_initialize_lazy_string () < 0
1699 || gdbpy_initialize_linetable () < 0
1700 || gdbpy_initialize_thread () < 0
1701 || gdbpy_initialize_inferior () < 0
1702 || gdbpy_initialize_events () < 0
1703 || gdbpy_initialize_eventregistry () < 0
1704 || gdbpy_initialize_py_events () < 0
1705 || gdbpy_initialize_event () < 0
1706 || gdbpy_initialize_arch () < 0
1707 || gdbpy_initialize_xmethods () < 0
1708 || gdbpy_initialize_unwind () < 0)
1711 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1712 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1714 #include "py-event-types.def"
1715 #undef GDB_PY_DEFINE_EVENT_TYPE
1717 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1718 if (gdbpy_to_string_cst
== NULL
)
1720 gdbpy_children_cst
= PyString_FromString ("children");
1721 if (gdbpy_children_cst
== NULL
)
1723 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1724 if (gdbpy_display_hint_cst
== NULL
)
1726 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1727 if (gdbpy_doc_cst
== NULL
)
1729 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1730 if (gdbpy_enabled_cst
== NULL
)
1732 gdbpy_value_cst
= PyString_FromString ("value");
1733 if (gdbpy_value_cst
== NULL
)
1736 /* Release the GIL while gdb runs. */
1737 PyThreadState_Swap (NULL
);
1738 PyEval_ReleaseLock ();
1740 make_final_cleanup (finalize_python
, NULL
);
1742 /* Only set this when initialization has succeeded. */
1743 gdb_python_initialized
= 1;
1747 #endif /* HAVE_PYTHON */
1750 cmd_list_element
*python_cmd_element
= nullptr;
1753 _initialize_python (void)
1755 add_com ("python-interactive", class_obscure
,
1756 python_interactive_command
,
1759 Start an interactive Python prompt.\n\
1761 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1764 Alternatively, a single-line Python command can be given as an\n\
1765 argument, and if the command is an expression, the result will be\n\
1766 printed. For example:\n\
1768 (gdb) python-interactive 2 + 3\n\
1771 #else /* HAVE_PYTHON */
1773 Start a Python interactive prompt.\n\
1775 Python scripting is not supported in this copy of GDB.\n\
1776 This command is only a placeholder.")
1777 #endif /* HAVE_PYTHON */
1779 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1781 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1784 Evaluate a Python command.\n\
1786 The command can be given as an argument, for instance:\n\
1788 python print (23)\n\
1790 If no argument is given, the following lines are read and used\n\
1791 as the Python commands. Type a line containing \"end\" to indicate\n\
1792 the end of the command.")
1793 #else /* HAVE_PYTHON */
1795 Evaluate a Python command.\n\
1797 Python scripting is not supported in this copy of GDB.\n\
1798 This command is only a placeholder.")
1799 #endif /* HAVE_PYTHON */
1801 add_com_alias ("py", "python", class_obscure
, 1);
1803 /* Add set/show python print-stack. */
1804 add_prefix_cmd ("python", no_class
, user_show_python
,
1805 _("Prefix command for python preference settings."),
1806 &user_show_python_list
, "show python ", 0,
1809 add_prefix_cmd ("python", no_class
, user_set_python
,
1810 _("Prefix command for python preference settings."),
1811 &user_set_python_list
, "set python ", 0,
1814 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1815 &gdbpy_should_print_stack
, _("\
1816 Set mode for Python stack dump on error."), _("\
1817 Show the mode of Python stack printing on error."), _("\
1818 none == no stack or message will be printed.\n\
1819 full == a message and a stack will be printed.\n\
1820 message == an error message without a stack will be printed."),
1822 &user_set_python_list
,
1823 &user_show_python_list
);
1826 if (!do_start_initialization () && PyErr_Occurred ())
1827 gdbpy_print_stack ();
1828 #endif /* HAVE_PYTHON */
1833 /* Helper function for gdbpy_finish_initialization. This does the
1834 work and then returns false if an error has occurred and must be
1835 displayed, or true on success. */
1838 do_finish_initialization (const struct extension_language_defn
*extlang
)
1843 /* Add the initial data-directory to sys.path. */
1845 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1848 sys_path
= PySys_GetObject ("path");
1850 /* If sys.path is not defined yet, define it first. */
1851 if (!(sys_path
&& PyList_Check (sys_path
)))
1854 PySys_SetPath (L
"");
1858 sys_path
= PySys_GetObject ("path");
1860 if (sys_path
&& PyList_Check (sys_path
))
1862 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1863 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1869 /* Import the gdb module to finish the initialization, and
1870 add it to __main__ for convenience. */
1871 m
= PyImport_AddModule ("__main__");
1875 /* Keep the reference to gdb_python_module since it is in a global
1877 gdb_python_module
= PyImport_ImportModule ("gdb");
1878 if (gdb_python_module
== NULL
)
1880 gdbpy_print_stack ();
1881 /* This is passed in one call to warning so that blank lines aren't
1882 inserted between each line of text. */
1884 "Could not load the Python gdb module from `%s'.\n"
1885 "Limited Python support is available from the _gdb module.\n"
1886 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1887 gdb_pythondir
.c_str ());
1888 /* We return "success" here as we've already emitted the
1893 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1896 /* Perform the remaining python initializations.
1897 These must be done after GDB is at least mostly initialized.
1898 E.g., The "info pretty-printer" command needs the "info" prefix
1900 This is the extension_language_ops.finish_initialization "method". */
1903 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1905 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1907 if (!do_finish_initialization (extlang
))
1909 gdbpy_print_stack ();
1910 warning (_("internal error: Unhandled Python exception"));
1914 /* Return non-zero if Python has successfully initialized.
1915 This is the extension_languages_ops.initialized "method". */
1918 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1920 return gdb_python_initialized
;
1923 #endif /* HAVE_PYTHON */
1929 PyMethodDef python_GdbMethods
[] =
1931 { "history", gdbpy_history
, METH_VARARGS
,
1932 "Get a value from history" },
1933 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1934 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1935 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1936 a Python String containing the output of the command if to_string is\n\
1938 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1939 "Return a gdb parameter's value" },
1941 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1942 "Return a tuple of all breakpoint objects" },
1944 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1945 "Find the default visualizer for a Value." },
1947 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1948 "Return a sequence of all progspaces." },
1950 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1951 "Return the current Objfile being loaded, or None." },
1953 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1954 "newest_frame () -> gdb.Frame.\n\
1955 Return the newest frame object." },
1956 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1957 "selected_frame () -> gdb.Frame.\n\
1958 Return the selected frame object." },
1959 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1960 "stop_reason_string (Integer) -> String.\n\
1961 Return a string explaining unwind stop reason." },
1963 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1964 "start_recording ([method] [, format]) -> gdb.Record.\n\
1965 Start recording with the given method. If no method is given, will fall back\n\
1966 to the system default method. If no format is given, will fall back to the\n\
1967 default format for the given method."},
1968 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1969 "current_recording () -> gdb.Record.\n\
1970 Return current recording object." },
1971 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1972 "stop_recording () -> None.\n\
1973 Stop current recording." },
1975 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1976 METH_VARARGS
| METH_KEYWORDS
,
1977 "lookup_type (name [, block]) -> type\n\
1978 Return a Type corresponding to the given name." },
1979 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1980 METH_VARARGS
| METH_KEYWORDS
,
1981 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1982 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1983 a boolean indicating if name is a field of the current implied argument\n\
1984 `this' (when the current language is object-oriented)." },
1985 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1986 METH_VARARGS
| METH_KEYWORDS
,
1987 "lookup_global_symbol (name [, domain]) -> symbol\n\
1988 Return the symbol corresponding to the given name (or None)." },
1990 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1991 METH_VARARGS
| METH_KEYWORDS
,
1992 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1993 Look up the specified objfile.\n\
1994 If by_build_id is True, the objfile is looked up by using name\n\
1995 as its build id." },
1997 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1998 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1999 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2000 The first element contains any unparsed portion of the String parameter\n\
2001 (or None if the string was fully parsed). The second element contains\n\
2002 a tuple that contains all the locations that match, represented as\n\
2003 gdb.Symtab_and_line objects (or None)."},
2004 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2005 "parse_and_eval (String) -> Value.\n\
2006 Parse String as an expression, evaluate it, and return the result as a Value."
2009 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2010 "Post an event into gdb's event loop." },
2012 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2013 "target_charset () -> string.\n\
2014 Return the name of the current target charset." },
2015 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2016 "target_wide_charset () -> string.\n\
2017 Return the name of the current target wide charset." },
2018 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2019 "rbreak (Regex) -> List.\n\
2020 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2021 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2022 "string_to_argv (String) -> Array.\n\
2023 Parse String and return an argv-like array.\n\
2024 Arguments are separate by spaces and may be quoted."
2026 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2027 "Write a string using gdb's filtered stream." },
2028 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2029 "Flush gdb's filtered stdout stream." },
2030 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2031 "selected_thread () -> gdb.InferiorThread.\n\
2032 Return the selected thread object." },
2033 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2034 "selected_inferior () -> gdb.Inferior.\n\
2035 Return the selected inferior object." },
2036 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2037 "inferiors () -> (gdb.Inferior, ...).\n\
2038 Return a tuple containing all inferiors." },
2040 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2041 "invalidate_cached_frames () -> None.\n\
2042 Invalidate any cached frame objects in gdb.\n\
2043 Intended for internal use only." },
2045 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2046 "convenience_variable (NAME) -> value.\n\
2047 Return the value of the convenience variable $NAME,\n\
2048 or None if not set." },
2049 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2050 "convenience_variable (NAME, VALUE) -> None.\n\
2051 Set the value of the convenience variable $NAME." },
2053 {NULL
, NULL
, 0, NULL
}
2057 struct PyModuleDef python_GdbModuleDef
=
2059 PyModuleDef_HEAD_INIT
,
2071 /* Define all the event objects. */
2072 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2073 PyTypeObject name##_event_object_type \
2074 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2076 PyVarObject_HEAD_INIT (NULL, 0) \
2077 "gdb." py_name, /* tp_name */ \
2078 sizeof (event_object), /* tp_basicsize */ \
2079 0, /* tp_itemsize */ \
2080 evpy_dealloc, /* tp_dealloc */ \
2082 0, /* tp_getattr */ \
2083 0, /* tp_setattr */ \
2084 0, /* tp_compare */ \
2086 0, /* tp_as_number */ \
2087 0, /* tp_as_sequence */ \
2088 0, /* tp_as_mapping */ \
2092 0, /* tp_getattro */ \
2093 0, /* tp_setattro */ \
2094 0, /* tp_as_buffer */ \
2095 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2097 0, /* tp_traverse */ \
2099 0, /* tp_richcompare */ \
2100 0, /* tp_weaklistoffset */ \
2102 0, /* tp_iternext */ \
2103 0, /* tp_methods */ \
2104 0, /* tp_members */ \
2105 0, /* tp_getset */ \
2106 &base, /* tp_base */ \
2108 0, /* tp_descr_get */ \
2109 0, /* tp_descr_set */ \
2110 0, /* tp_dictoffset */ \
2114 #include "py-event-types.def"
2115 #undef GDB_PY_DEFINE_EVENT_TYPE
2117 #endif /* HAVE_PYTHON */