1 /* General python/gdb code
3 Copyright (C) 2008-2018 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 int len
= strlen (arg
);
300 char *script
= (char *) xmalloc (len
+ 2);
302 strcpy (script
, arg
);
304 script
[len
+ 1] = '\0';
305 err
= eval_python_command (script
);
310 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
316 gdbpy_print_stack ();
317 error (_("Error while executing Python code."));
321 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
324 On Windows hosts few users would build Python themselves (this is no
325 trivial task on this platform), and thus use binaries built by
326 someone else instead. There may happen situation where the Python
327 library and GDB are using two different versions of the C runtime
328 library. Python, being built with VC, would use one version of the
329 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
330 A FILE * from one runtime does not necessarily operate correctly in
333 To work around this potential issue, we create on Windows hosts the
334 FILE object using Python routines, thus making sure that it is
335 compatible with the Python library. */
338 python_run_simple_file (FILE *file
, const char *filename
)
342 PyRun_SimpleFile (file
, filename
);
346 /* Because we have a string for a filename, and are using Python to
347 open the file, we need to expand any tilde in the path first. */
348 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
349 gdbpy_ref
<> python_file (PyFile_FromString (full_path
.get (), (char *) "r"));
350 if (python_file
== NULL
)
352 gdbpy_print_stack ();
353 error (_("Error while opening file: %s"), full_path
.get ());
356 PyRun_SimpleFile (PyFile_AsFile (python_file
.get ()), filename
);
361 /* Given a command_line, return a command string suitable for passing
362 to Python. Lines in the string are separated by newlines. */
365 compute_python_string (struct command_line
*l
)
367 struct command_line
*iter
;
370 for (iter
= l
; iter
; iter
= iter
->next
)
372 script
+= iter
->line
;
378 /* Take a command line structure representing a 'python' command, and
379 evaluate its body using the Python interpreter. */
382 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
383 struct command_line
*cmd
)
387 if (cmd
->body_list_1
!= nullptr)
388 error (_("Invalid \"python\" block structure."));
390 gdbpy_enter
enter_py (get_current_arch (), current_language
);
392 std::string script
= compute_python_string (cmd
->body_list_0
.get ());
393 ret
= PyRun_SimpleString (script
.c_str ());
395 error (_("Error while executing Python code."));
398 /* Implementation of the gdb "python" command. */
401 python_command (const char *arg
, int from_tty
)
403 gdbpy_enter
enter_py (get_current_arch (), current_language
);
405 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
407 arg
= skip_spaces (arg
);
410 if (PyRun_SimpleString (arg
))
411 error (_("Error while executing Python code."));
415 counted_command_line l
= get_command_line (python_control
, "");
417 execute_control_command_untraced (l
.get ());
423 /* Transform a gdb parameters's value into a Python value. May return
424 NULL (and set a Python exception) on error. Helper function for
427 gdbpy_parameter_value (enum var_types type
, void *var
)
432 case var_string_noescape
:
433 case var_optional_filename
:
437 const char *str
= *(char **) var
;
441 return host_string_to_python_string (str
).release ();
452 case var_auto_boolean
:
454 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
456 if (ab
== AUTO_BOOLEAN_TRUE
)
458 else if (ab
== AUTO_BOOLEAN_FALSE
)
465 if ((* (int *) var
) == INT_MAX
)
469 case var_zuinteger_unlimited
:
470 return PyLong_FromLong (* (int *) var
);
474 unsigned int val
= * (unsigned int *) var
;
478 return PyLong_FromUnsignedLong (val
);
483 unsigned int val
= * (unsigned int *) var
;
484 return PyLong_FromUnsignedLong (val
);
488 return PyErr_Format (PyExc_RuntimeError
,
489 _("Programmer error: unhandled type."));
492 /* A Python function which returns a gdb parameter's value as a Python
496 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
498 struct gdb_exception except
= exception_none
;
499 struct cmd_list_element
*alias
, *prefix
, *cmd
;
504 if (! PyArg_ParseTuple (args
, "s", &arg
))
507 newarg
= concat ("show ", arg
, (char *) NULL
);
511 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
513 CATCH (ex
, RETURN_MASK_ALL
)
520 GDB_PY_HANDLE_EXCEPTION (except
);
522 return PyErr_Format (PyExc_RuntimeError
,
523 _("Could not find parameter `%s'."), arg
);
526 return PyErr_Format (PyExc_RuntimeError
,
527 _("`%s' is not a parameter."), arg
);
528 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
531 /* Wrapper for target_charset. */
534 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
536 const char *cset
= target_charset (python_gdbarch
);
538 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
541 /* Wrapper for target_wide_charset. */
544 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
546 const char *cset
= target_wide_charset (python_gdbarch
);
548 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
551 /* A Python function which evaluates a string using the gdb CLI. */
554 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
557 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
558 int from_tty
, to_string
;
559 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
561 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
562 &PyBool_Type
, &from_tty_obj
,
563 &PyBool_Type
, &to_string_obj
))
569 int cmp
= PyObject_IsTrue (from_tty_obj
);
578 int cmp
= PyObject_IsTrue (to_string_obj
);
584 std::string to_string_res
;
586 scoped_restore preventer
= prevent_dont_repeat ();
590 struct interp
*interp
;
592 std::string arg_copy
= arg
;
594 char *save_ptr
= nullptr;
598 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
604 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
607 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
610 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
612 /* Use the console interpreter uiout to have the same print format
613 for console or MI. */
614 interp
= interp_lookup (current_ui
, "console");
615 current_uiout
= interp
->interp_ui_out ();
618 to_string_res
= execute_control_commands_to_string (lines
.get (),
621 execute_control_commands (lines
.get (), from_tty
);
624 /* Do any commands attached to breakpoint we stopped at. */
625 bpstat_do_actions ();
627 CATCH (except
, RETURN_MASK_ALL
)
629 GDB_PY_HANDLE_EXCEPTION (except
);
634 return PyString_FromString (to_string_res
.c_str ());
638 /* Implementation of Python rbreak command. Take a REGEX and
639 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
640 Python list that contains newly set breakpoints that match that
641 criteria. REGEX refers to a GDB format standard regex pattern of
642 symbols names to search; MINSYMS is an optional boolean (default
643 False) that indicates if the function should search GDB's minimal
644 symbols; THROTTLE is an optional integer (default unlimited) that
645 indicates the maximum amount of breakpoints allowable before the
646 function exits (note, if the throttle bound is passed, no
647 breakpoints will be set and a runtime error returned); SYMTABS is
648 an optional Python iterable that contains a set of gdb.Symtabs to
649 constrain the search within. */
652 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
654 /* A simple type to ensure clean up of a vector of allocated strings
655 when a C interface demands a const char *array[] type
657 struct symtab_list_type
661 for (const char *elem
: vec
)
662 xfree ((void *) elem
);
664 std::vector
<const char *> vec
;
668 std::vector
<symbol_search
> symbols
;
669 unsigned long count
= 0;
670 PyObject
*symtab_list
= NULL
;
671 PyObject
*minsyms_p_obj
= NULL
;
673 unsigned int throttle
= 0;
674 static const char *keywords
[] = {"regex","minsyms", "throttle",
676 symtab_list_type symtab_paths
;
678 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
679 ®ex
, &PyBool_Type
,
680 &minsyms_p_obj
, &throttle
,
684 /* Parse minsyms keyword. */
685 if (minsyms_p_obj
!= NULL
)
687 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
693 /* The "symtabs" keyword is any Python iterable object that returns
694 a gdb.Symtab on each iteration. If specified, iterate through
695 the provided gdb.Symtabs and extract their full path. As
696 python_string_to_target_string returns a
697 gdb::unique_xmalloc_ptr<char> and a vector containing these types
698 cannot be coerced to a const char **p[] via the vector.data call,
699 release the value from the unique_xmalloc_ptr and place it in a
700 simple type symtab_list_type (which holds the vector and a
701 destructor that frees the contents of the allocated strings. */
702 if (symtab_list
!= NULL
)
704 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
711 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
715 if (PyErr_Occurred ())
720 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
723 if (obj_name
== NULL
)
726 /* Is the object file still valid? */
727 if (obj_name
== Py_None
)
730 gdb::unique_xmalloc_ptr
<char> filename
=
731 python_string_to_target_string (obj_name
.get ());
733 if (filename
== NULL
)
736 /* Make sure there is a definite place to store the value of
737 filename before it is released. */
738 symtab_paths
.vec
.push_back (nullptr);
739 symtab_paths
.vec
.back () = filename
.release ();
745 const char **files
= symtab_paths
.vec
.data ();
747 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
,
748 symtab_paths
.vec
.size (), files
);
751 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, NULL
, 0, NULL
);
753 /* Count the number of symbols (both symbols and optionally minimal
754 symbols) so we can correctly check the throttle limit. */
755 for (const symbol_search
&p
: symbols
)
757 /* Minimal symbols included? */
760 if (p
.msymbol
.minsym
!= NULL
)
764 if (p
.symbol
!= NULL
)
768 /* Check throttle bounds and exit if in excess. */
769 if (throttle
!= 0 && count
> throttle
)
771 PyErr_SetString (PyExc_RuntimeError
,
772 _("Number of breakpoints exceeds throttled maximum."));
776 gdbpy_ref
<> return_list (PyList_New (0));
778 if (return_list
== NULL
)
781 /* Construct full path names for symbols and call the Python
782 breakpoint constructor on the resulting names. Be tolerant of
783 individual breakpoint failures. */
784 for (const symbol_search
&p
: symbols
)
786 std::string symbol_name
;
788 /* Skipping minimal symbols? */
790 if (p
.msymbol
.minsym
!= NULL
)
793 if (p
.msymbol
.minsym
== NULL
)
795 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
796 const char *fullname
= symtab_to_fullname (symtab
);
798 symbol_name
= fullname
;
800 symbol_name
+= SYMBOL_LINKAGE_NAME (p
.symbol
);
803 symbol_name
= MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
);
805 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
806 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
807 &breakpoint_object_type
,
810 /* Tolerate individual breakpoint failures. */
812 gdbpy_print_stack ();
815 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
819 return return_list
.release ();
822 /* A Python function which is a wrapper for decode_line_1. */
825 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
827 const char *arg
= NULL
;
829 gdbpy_ref
<> unparsed
;
830 event_location_up location
;
832 if (! PyArg_ParseTuple (args
, "|s", &arg
))
836 location
= string_to_event_location_basic (&arg
, python_language
,
837 symbol_name_match_type::WILD
);
839 std::vector
<symtab_and_line
> decoded_sals
;
840 symtab_and_line def_sal
;
841 gdb::array_view
<symtab_and_line
> sals
;
844 if (location
!= NULL
)
846 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
851 set_default_source_symtab_and_line ();
852 def_sal
= get_current_source_symtab_and_line ();
856 CATCH (ex
, RETURN_MASK_ALL
)
858 /* We know this will always throw. */
859 gdbpy_convert_exception (ex
);
866 result
.reset (PyTuple_New (sals
.size ()));
869 for (size_t i
= 0; i
< sals
.size (); ++i
)
871 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
875 PyTuple_SetItem (result
.get (), i
, obj
);
879 result
= gdbpy_ref
<>::new_reference (Py_None
);
881 gdbpy_ref
<> return_result (PyTuple_New (2));
882 if (return_result
== NULL
)
885 if (arg
!= NULL
&& strlen (arg
) > 0)
887 unparsed
.reset (PyString_FromString (arg
));
888 if (unparsed
== NULL
)
892 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
894 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
895 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
897 return return_result
.release ();
900 /* Parse a string and evaluate it as an expression. */
902 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
904 const char *expr_str
;
905 struct value
*result
= NULL
;
907 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
912 result
= parse_and_eval (expr_str
);
914 CATCH (except
, RETURN_MASK_ALL
)
916 GDB_PY_HANDLE_EXCEPTION (except
);
920 return value_to_value_object (result
);
923 /* Implementation of gdb.invalidate_cached_frames. */
926 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
928 reinit_frame_cache ();
932 /* Read a file as Python code.
933 This is the extension_language_script_ops.script_sourcer "method".
934 FILE is the file to load. FILENAME is name of the file FILE.
935 This does not throw any errors. If an exception occurs python will print
936 the traceback and clear the error indicator. */
939 gdbpy_source_script (const struct extension_language_defn
*extlang
,
940 FILE *file
, const char *filename
)
942 gdbpy_enter
enter_py (get_current_arch (), current_language
);
943 python_run_simple_file (file
, filename
);
948 /* Posting and handling events. */
950 /* A single event. */
953 /* The Python event. This is just a callable object. */
955 /* The next event. */
956 struct gdbpy_event
*next
;
959 /* All pending events. */
960 static struct gdbpy_event
*gdbpy_event_list
;
961 /* The final link of the event list. */
962 static struct gdbpy_event
**gdbpy_event_list_end
;
964 /* So that we can wake up the main thread even when it is blocked in
966 static struct serial_event
*gdbpy_serial_event
;
968 /* The file handler callback. This reads from the internal pipe, and
969 then processes the Python event queue. This will always be run in
970 the main gdb thread. */
973 gdbpy_run_events (int error
, gdb_client_data client_data
)
975 gdbpy_enter
enter_py (get_current_arch (), current_language
);
977 /* Clear the event fd. Do this before flushing the events list, so
978 that any new event post afterwards is sure to re-awake the event
980 serial_event_clear (gdbpy_serial_event
);
982 while (gdbpy_event_list
)
984 /* Dispatching the event might push a new element onto the event
985 loop, so we update here "atomically enough". */
986 struct gdbpy_event
*item
= gdbpy_event_list
;
987 gdbpy_event_list
= gdbpy_event_list
->next
;
988 if (gdbpy_event_list
== NULL
)
989 gdbpy_event_list_end
= &gdbpy_event_list
;
991 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
992 if (call_result
== NULL
)
993 gdbpy_print_stack ();
995 Py_DECREF (item
->event
);
1000 /* Submit an event to the gdb thread. */
1002 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1004 struct gdbpy_event
*event
;
1008 if (!PyArg_ParseTuple (args
, "O", &func
))
1011 if (!PyCallable_Check (func
))
1013 PyErr_SetString (PyExc_RuntimeError
,
1014 _("Posted event is not callable"));
1020 /* From here until the end of the function, we have the GIL, so we
1021 can operate on our global data structures without worrying. */
1022 wakeup
= gdbpy_event_list
== NULL
;
1024 event
= XNEW (struct gdbpy_event
);
1025 event
->event
= func
;
1027 *gdbpy_event_list_end
= event
;
1028 gdbpy_event_list_end
= &event
->next
;
1030 /* Wake up gdb when needed. */
1032 serial_event_set (gdbpy_serial_event
);
1037 /* Initialize the Python event handler. */
1039 gdbpy_initialize_events (void)
1041 gdbpy_event_list_end
= &gdbpy_event_list
;
1043 gdbpy_serial_event
= make_serial_event ();
1044 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1045 gdbpy_run_events
, NULL
);
1052 /* This is the extension_language_ops.before_prompt "method". */
1054 static enum ext_lang_rc
1055 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1056 const char *current_gdb_prompt
)
1058 if (!gdb_python_initialized
)
1059 return EXT_LANG_RC_NOP
;
1061 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1063 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1064 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1065 return EXT_LANG_RC_ERROR
;
1067 if (gdb_python_module
1068 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1070 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1074 gdbpy_print_stack ();
1075 return EXT_LANG_RC_ERROR
;
1078 if (PyCallable_Check (hook
.get ()))
1080 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1081 if (current_prompt
== NULL
)
1083 gdbpy_print_stack ();
1084 return EXT_LANG_RC_ERROR
;
1088 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1092 gdbpy_print_stack ();
1093 return EXT_LANG_RC_ERROR
;
1096 /* Return type should be None, or a String. If it is None,
1097 fall through, we will not set a prompt. If it is a
1098 string, set PROMPT. Anything else, set an exception. */
1099 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1101 PyErr_Format (PyExc_RuntimeError
,
1102 _("Return from prompt_hook must " \
1103 "be either a Python string, or None"));
1104 gdbpy_print_stack ();
1105 return EXT_LANG_RC_ERROR
;
1108 if (result
!= Py_None
)
1110 gdb::unique_xmalloc_ptr
<char>
1111 prompt (python_string_to_host_string (result
.get ()));
1115 gdbpy_print_stack ();
1116 return EXT_LANG_RC_ERROR
;
1119 set_prompt (prompt
.get ());
1120 return EXT_LANG_RC_OK
;
1125 return EXT_LANG_RC_NOP
;
1132 /* A python function to write a single string using gdb's filtered
1133 output stream . The optional keyword STREAM can be used to write
1134 to a particular stream. The default stream is to gdb_stdout. */
1137 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1140 static const char *keywords
[] = { "text", "stream", NULL
};
1141 int stream_type
= 0;
1143 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1149 switch (stream_type
)
1153 fprintf_filtered (gdb_stderr
, "%s", arg
);
1158 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1162 fprintf_filtered (gdb_stdout
, "%s", arg
);
1165 CATCH (except
, RETURN_MASK_ALL
)
1167 GDB_PY_HANDLE_EXCEPTION (except
);
1174 /* A python function to flush a gdb stream. The optional keyword
1175 STREAM can be used to flush a particular stream. The default stream
1179 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1181 static const char *keywords
[] = { "stream", NULL
};
1182 int stream_type
= 0;
1184 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1188 switch (stream_type
)
1192 gdb_flush (gdb_stderr
);
1197 gdb_flush (gdb_stdlog
);
1201 gdb_flush (gdb_stdout
);
1207 /* Return non-zero if print-stack is not "none". */
1210 gdbpy_print_python_errors_p (void)
1212 return gdbpy_should_print_stack
!= python_excp_none
;
1215 /* Print a python exception trace, print just a message, or print
1216 nothing and clear the python exception, depending on
1217 gdbpy_should_print_stack. Only call this if a python exception is
1220 gdbpy_print_stack (void)
1223 /* Print "none", just clear exception. */
1224 if (gdbpy_should_print_stack
== python_excp_none
)
1228 /* Print "full" message and backtrace. */
1229 else if (gdbpy_should_print_stack
== python_excp_full
)
1232 /* PyErr_Print doesn't necessarily end output with a newline.
1233 This works because Python's stdout/stderr is fed through
1239 CATCH (except
, RETURN_MASK_ALL
)
1244 /* Print "message", just error print message. */
1247 PyObject
*ptype
, *pvalue
, *ptraceback
;
1249 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1251 /* Fetch the error message contained within ptype, pvalue. */
1252 gdb::unique_xmalloc_ptr
<char>
1253 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1254 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1260 /* An error occurred computing the string representation of the
1262 fprintf_filtered (gdb_stderr
,
1263 _("Error occurred computing Python error" \
1267 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1268 type
.get (), msg
.get ());
1270 CATCH (except
, RETURN_MASK_ALL
)
1276 Py_XDECREF (pvalue
);
1277 Py_XDECREF (ptraceback
);
1283 /* Return a sequence holding all the Progspaces. */
1286 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1288 struct program_space
*ps
;
1290 gdbpy_ref
<> list (PyList_New (0));
1296 gdbpy_ref
<> item
= pspace_to_pspace_object (ps
);
1298 if (item
== NULL
|| PyList_Append (list
.get (), item
.get ()) == -1)
1302 return list
.release ();
1307 /* The "current" objfile. This is set when gdb detects that a new
1308 objfile has been loaded. It is only set for the duration of a call to
1309 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1311 static struct objfile
*gdbpy_current_objfile
;
1313 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1314 as Python code. This does not throw any errors. If an exception
1315 occurs python will print the traceback and clear the error indicator.
1316 This is the extension_language_script_ops.objfile_script_sourcer
1320 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1321 struct objfile
*objfile
, FILE *file
,
1322 const char *filename
)
1324 if (!gdb_python_initialized
)
1327 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1328 gdbpy_current_objfile
= objfile
;
1330 python_run_simple_file (file
, filename
);
1332 gdbpy_current_objfile
= NULL
;
1335 /* Set the current objfile to OBJFILE and then execute SCRIPT
1336 as Python code. This does not throw any errors. If an exception
1337 occurs python will print the traceback and clear the error indicator.
1338 This is the extension_language_script_ops.objfile_script_executor
1342 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1343 struct objfile
*objfile
, const char *name
,
1346 if (!gdb_python_initialized
)
1349 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1350 gdbpy_current_objfile
= objfile
;
1352 PyRun_SimpleString (script
);
1354 gdbpy_current_objfile
= NULL
;
1357 /* Return the current Objfile, or None if there isn't one. */
1360 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1362 if (! gdbpy_current_objfile
)
1365 return objfile_to_objfile_object (gdbpy_current_objfile
).release ();
1368 /* Compute the list of active python type printers and store them in
1369 EXT_PRINTERS->py_type_printers. The product of this function is used by
1370 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1371 This is the extension_language_ops.start_type_printers "method". */
1374 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1375 struct ext_lang_type_printers
*ext_printers
)
1377 PyObject
*printers_obj
= NULL
;
1379 if (!gdb_python_initialized
)
1382 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1384 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1385 if (type_module
== NULL
)
1387 gdbpy_print_stack ();
1391 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1392 "get_type_recognizers"));
1395 gdbpy_print_stack ();
1399 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1400 if (printers_obj
== NULL
)
1401 gdbpy_print_stack ();
1403 ext_printers
->py_type_printers
= printers_obj
;
1406 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1407 a newly allocated string holding the type's replacement name, and return
1408 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1409 If there's a Python error return EXT_LANG_RC_ERROR.
1410 Otherwise, return EXT_LANG_RC_NOP.
1411 This is the extension_language_ops.apply_type_printers "method". */
1413 static enum ext_lang_rc
1414 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1415 const struct ext_lang_type_printers
*ext_printers
,
1416 struct type
*type
, char **prettied_type
)
1418 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1419 gdb::unique_xmalloc_ptr
<char> result
;
1421 if (printers_obj
== NULL
)
1422 return EXT_LANG_RC_NOP
;
1424 if (!gdb_python_initialized
)
1425 return EXT_LANG_RC_NOP
;
1427 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1429 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1430 if (type_obj
== NULL
)
1432 gdbpy_print_stack ();
1433 return EXT_LANG_RC_ERROR
;
1436 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1437 if (type_module
== NULL
)
1439 gdbpy_print_stack ();
1440 return EXT_LANG_RC_ERROR
;
1443 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1444 "apply_type_recognizers"));
1447 gdbpy_print_stack ();
1448 return EXT_LANG_RC_ERROR
;
1451 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1455 if (result_obj
== NULL
)
1457 gdbpy_print_stack ();
1458 return EXT_LANG_RC_ERROR
;
1461 if (result_obj
== Py_None
)
1462 return EXT_LANG_RC_NOP
;
1464 result
= python_string_to_host_string (result_obj
.get ());
1467 gdbpy_print_stack ();
1468 return EXT_LANG_RC_ERROR
;
1471 *prettied_type
= result
.release ();
1472 return EXT_LANG_RC_OK
;
1475 /* Free the result of start_type_printers.
1476 This is the extension_language_ops.free_type_printers "method". */
1479 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1480 struct ext_lang_type_printers
*ext_printers
)
1482 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1484 if (printers
== NULL
)
1487 if (!gdb_python_initialized
)
1490 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1491 Py_DECREF (printers
);
1494 #else /* HAVE_PYTHON */
1496 /* Dummy implementation of the gdb "python-interactive" and "python"
1500 python_interactive_command (const char *arg
, int from_tty
)
1502 arg
= skip_spaces (arg
);
1504 error (_("Python scripting is not supported in this copy of GDB."));
1507 counted_command_line l
= get_command_line (python_control
, "");
1509 execute_control_command_untraced (l
.get ());
1514 python_command (const char *arg
, int from_tty
)
1516 python_interactive_command (arg
, from_tty
);
1519 #endif /* HAVE_PYTHON */
1523 /* Lists for 'set python' commands. */
1525 static struct cmd_list_element
*user_set_python_list
;
1526 static struct cmd_list_element
*user_show_python_list
;
1528 /* Function for use by 'set python' prefix command. */
1531 user_set_python (const char *args
, int from_tty
)
1533 help_list (user_set_python_list
, "set python ", all_commands
,
1537 /* Function for use by 'show python' prefix command. */
1540 user_show_python (const char *args
, int from_tty
)
1542 cmd_show_list (user_show_python_list
, from_tty
, "");
1545 /* Initialize the Python code. */
1549 /* This is installed as a final cleanup and cleans up the
1550 interpreter. This lets Python's 'atexit' work. */
1553 finalize_python (void *ignore
)
1555 struct active_ext_lang_state
*previous_active
;
1557 /* We don't use ensure_python_env here because if we ever ran the
1558 cleanup, gdb would crash -- because the cleanup calls into the
1559 Python interpreter, which we are about to destroy. It seems
1560 clearer to make the needed calls explicitly here than to create a
1561 cleanup and then mysteriously discard it. */
1563 /* This is only called as a final cleanup so we can assume the active
1564 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1565 previous_active
= set_active_ext_lang (&extension_language_python
);
1567 (void) PyGILState_Ensure ();
1568 python_gdbarch
= target_gdbarch ();
1569 python_language
= current_language
;
1573 restore_active_ext_lang (previous_active
);
1577 /* This is called via the PyImport_AppendInittab mechanism called
1578 during initialization, to make the built-in _gdb module known to
1581 init__gdb_module (void)
1583 return PyModule_Create (&python_GdbModuleDef
);
1588 do_start_initialization ()
1591 size_t progsize
, count
;
1592 wchar_t *progname_copy
;
1595 #ifdef WITH_PYTHON_PATH
1596 /* Work around problem where python gets confused about where it is,
1597 and then can't find its libraries, etc.
1598 NOTE: Python assumes the following layout:
1600 /foo/lib/pythonX.Y/...
1601 This must be done before calling Py_Initialize. */
1602 gdb::unique_xmalloc_ptr
<char> progname
1603 (concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1604 SLASH_STRING
, "python", (char *) NULL
));
1606 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1607 setlocale (LC_ALL
, "");
1608 progsize
= strlen (progname
.get ());
1609 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1612 fprintf (stderr
, "out of memory\n");
1615 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1616 if (count
== (size_t) -1)
1618 fprintf (stderr
, "Could not convert python path to string\n");
1621 setlocale (LC_ALL
, oldloc
.c_str ());
1623 /* Note that Py_SetProgramName expects the string it is passed to
1624 remain alive for the duration of the program's execution, so
1625 it is not freed after this call. */
1626 Py_SetProgramName (progname_copy
);
1628 /* Define _gdb as a built-in module. */
1629 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1631 Py_SetProgramName (progname
.release ());
1636 PyEval_InitThreads ();
1639 gdb_module
= PyImport_ImportModule ("_gdb");
1641 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1643 if (gdb_module
== NULL
)
1646 /* The casts to (char*) are for python 2.4. */
1647 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1648 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1649 (char*) host_name
) < 0
1650 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1651 (char*) target_name
) < 0)
1654 /* Add stream constants. */
1655 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1656 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1657 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1660 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1661 if (gdbpy_gdb_error
== NULL
1662 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1665 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1666 gdbpy_gdb_error
, NULL
);
1667 if (gdbpy_gdb_memory_error
== NULL
1668 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1669 gdbpy_gdb_memory_error
) < 0)
1672 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1673 if (gdbpy_gdberror_exc
== NULL
1674 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1675 gdbpy_gdberror_exc
) < 0)
1678 gdbpy_initialize_gdb_readline ();
1680 if (gdbpy_initialize_auto_load () < 0
1681 || gdbpy_initialize_values () < 0
1682 || gdbpy_initialize_frames () < 0
1683 || gdbpy_initialize_commands () < 0
1684 || gdbpy_initialize_instruction () < 0
1685 || gdbpy_initialize_record () < 0
1686 || gdbpy_initialize_btrace () < 0
1687 || gdbpy_initialize_symbols () < 0
1688 || gdbpy_initialize_symtabs () < 0
1689 || gdbpy_initialize_blocks () < 0
1690 || gdbpy_initialize_functions () < 0
1691 || gdbpy_initialize_parameters () < 0
1692 || gdbpy_initialize_types () < 0
1693 || gdbpy_initialize_pspace () < 0
1694 || gdbpy_initialize_objfile () < 0
1695 || gdbpy_initialize_breakpoints () < 0
1696 || gdbpy_initialize_finishbreakpoints () < 0
1697 || gdbpy_initialize_lazy_string () < 0
1698 || gdbpy_initialize_linetable () < 0
1699 || gdbpy_initialize_thread () < 0
1700 || gdbpy_initialize_inferior () < 0
1701 || gdbpy_initialize_events () < 0
1702 || gdbpy_initialize_eventregistry () < 0
1703 || gdbpy_initialize_py_events () < 0
1704 || gdbpy_initialize_event () < 0
1705 || gdbpy_initialize_arch () < 0
1706 || gdbpy_initialize_xmethods () < 0
1707 || gdbpy_initialize_unwind () < 0)
1710 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1711 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1713 #include "py-event-types.def"
1714 #undef GDB_PY_DEFINE_EVENT_TYPE
1716 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1717 if (gdbpy_to_string_cst
== NULL
)
1719 gdbpy_children_cst
= PyString_FromString ("children");
1720 if (gdbpy_children_cst
== NULL
)
1722 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1723 if (gdbpy_display_hint_cst
== NULL
)
1725 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1726 if (gdbpy_doc_cst
== NULL
)
1728 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1729 if (gdbpy_enabled_cst
== NULL
)
1731 gdbpy_value_cst
= PyString_FromString ("value");
1732 if (gdbpy_value_cst
== NULL
)
1735 /* Release the GIL while gdb runs. */
1736 PyThreadState_Swap (NULL
);
1737 PyEval_ReleaseLock ();
1739 make_final_cleanup (finalize_python
, NULL
);
1741 /* Only set this when initialization has succeeded. */
1742 gdb_python_initialized
= 1;
1746 #endif /* HAVE_PYTHON */
1749 cmd_list_element
*python_cmd_element
= nullptr;
1752 _initialize_python (void)
1754 add_com ("python-interactive", class_obscure
,
1755 python_interactive_command
,
1758 Start an interactive Python prompt.\n\
1760 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1763 Alternatively, a single-line Python command can be given as an\n\
1764 argument, and if the command is an expression, the result will be\n\
1765 printed. For example:\n\
1767 (gdb) python-interactive 2 + 3\n\
1770 #else /* HAVE_PYTHON */
1772 Start a Python interactive prompt.\n\
1774 Python scripting is not supported in this copy of GDB.\n\
1775 This command is only a placeholder.")
1776 #endif /* HAVE_PYTHON */
1778 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1780 python_cmd_element
= add_com ("python", class_obscure
, python_command
,
1783 Evaluate a Python command.\n\
1785 The command can be given as an argument, for instance:\n\
1787 python print (23)\n\
1789 If no argument is given, the following lines are read and used\n\
1790 as the Python commands. Type a line containing \"end\" to indicate\n\
1791 the end of the command.")
1792 #else /* HAVE_PYTHON */
1794 Evaluate a Python command.\n\
1796 Python scripting is not supported in this copy of GDB.\n\
1797 This command is only a placeholder.")
1798 #endif /* HAVE_PYTHON */
1800 add_com_alias ("py", "python", class_obscure
, 1);
1802 /* Add set/show python print-stack. */
1803 add_prefix_cmd ("python", no_class
, user_show_python
,
1804 _("Prefix command for python preference settings."),
1805 &user_show_python_list
, "show python ", 0,
1808 add_prefix_cmd ("python", no_class
, user_set_python
,
1809 _("Prefix command for python preference settings."),
1810 &user_set_python_list
, "set python ", 0,
1813 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1814 &gdbpy_should_print_stack
, _("\
1815 Set mode for Python stack dump on error."), _("\
1816 Show the mode of Python stack printing on error."), _("\
1817 none == no stack or message will be printed.\n\
1818 full == a message and a stack will be printed.\n\
1819 message == an error message without a stack will be printed."),
1821 &user_set_python_list
,
1822 &user_show_python_list
);
1825 if (!do_start_initialization () && PyErr_Occurred ())
1826 gdbpy_print_stack ();
1827 #endif /* HAVE_PYTHON */
1832 /* Helper function for gdbpy_finish_initialization. This does the
1833 work and then returns false if an error has occurred and must be
1834 displayed, or true on success. */
1837 do_finish_initialization (const struct extension_language_defn
*extlang
)
1842 /* Add the initial data-directory to sys.path. */
1844 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1847 sys_path
= PySys_GetObject ("path");
1849 /* If sys.path is not defined yet, define it first. */
1850 if (!(sys_path
&& PyList_Check (sys_path
)))
1853 PySys_SetPath (L
"");
1857 sys_path
= PySys_GetObject ("path");
1859 if (sys_path
&& PyList_Check (sys_path
))
1861 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1862 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1868 /* Import the gdb module to finish the initialization, and
1869 add it to __main__ for convenience. */
1870 m
= PyImport_AddModule ("__main__");
1874 /* Keep the reference to gdb_python_module since it is in a global
1876 gdb_python_module
= PyImport_ImportModule ("gdb");
1877 if (gdb_python_module
== NULL
)
1879 gdbpy_print_stack ();
1880 /* This is passed in one call to warning so that blank lines aren't
1881 inserted between each line of text. */
1883 "Could not load the Python gdb module from `%s'.\n"
1884 "Limited Python support is available from the _gdb module.\n"
1885 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1886 gdb_pythondir
.c_str ());
1887 /* We return "success" here as we've already emitted the
1892 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1895 /* Perform the remaining python initializations.
1896 These must be done after GDB is at least mostly initialized.
1897 E.g., The "info pretty-printer" command needs the "info" prefix
1899 This is the extension_language_ops.finish_initialization "method". */
1902 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1904 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1906 if (!do_finish_initialization (extlang
))
1908 gdbpy_print_stack ();
1909 warning (_("internal error: Unhandled Python exception"));
1913 /* Return non-zero if Python has successfully initialized.
1914 This is the extension_languages_ops.initialized "method". */
1917 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1919 return gdb_python_initialized
;
1922 #endif /* HAVE_PYTHON */
1928 PyMethodDef python_GdbMethods
[] =
1930 { "history", gdbpy_history
, METH_VARARGS
,
1931 "Get a value from history" },
1932 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1933 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1934 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1935 a Python String containing the output of the command if to_string is\n\
1937 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1938 "Return a gdb parameter's value" },
1940 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1941 "Return a tuple of all breakpoint objects" },
1943 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1944 "Find the default visualizer for a Value." },
1946 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1947 "Return a sequence of all progspaces." },
1949 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1950 "Return the current Objfile being loaded, or None." },
1952 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1953 "newest_frame () -> gdb.Frame.\n\
1954 Return the newest frame object." },
1955 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1956 "selected_frame () -> gdb.Frame.\n\
1957 Return the selected frame object." },
1958 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1959 "stop_reason_string (Integer) -> String.\n\
1960 Return a string explaining unwind stop reason." },
1962 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1963 "start_recording ([method] [, format]) -> gdb.Record.\n\
1964 Start recording with the given method. If no method is given, will fall back\n\
1965 to the system default method. If no format is given, will fall back to the\n\
1966 default format for the given method."},
1967 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1968 "current_recording () -> gdb.Record.\n\
1969 Return current recording object." },
1970 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1971 "stop_recording () -> None.\n\
1972 Stop current recording." },
1974 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1975 METH_VARARGS
| METH_KEYWORDS
,
1976 "lookup_type (name [, block]) -> type\n\
1977 Return a Type corresponding to the given name." },
1978 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1979 METH_VARARGS
| METH_KEYWORDS
,
1980 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1981 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1982 a boolean indicating if name is a field of the current implied argument\n\
1983 `this' (when the current language is object-oriented)." },
1984 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1985 METH_VARARGS
| METH_KEYWORDS
,
1986 "lookup_global_symbol (name [, domain]) -> symbol\n\
1987 Return the symbol corresponding to the given name (or None)." },
1989 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1990 METH_VARARGS
| METH_KEYWORDS
,
1991 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1992 Look up the specified objfile.\n\
1993 If by_build_id is True, the objfile is looked up by using name\n\
1994 as its build id." },
1996 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1997 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1998 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1999 The first element contains any unparsed portion of the String parameter\n\
2000 (or None if the string was fully parsed). The second element contains\n\
2001 a tuple that contains all the locations that match, represented as\n\
2002 gdb.Symtab_and_line objects (or None)."},
2003 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2004 "parse_and_eval (String) -> Value.\n\
2005 Parse String as an expression, evaluate it, and return the result as a Value."
2008 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2009 "Post an event into gdb's event loop." },
2011 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2012 "target_charset () -> string.\n\
2013 Return the name of the current target charset." },
2014 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2015 "target_wide_charset () -> string.\n\
2016 Return the name of the current target wide charset." },
2017 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2018 "rbreak (Regex) -> List.\n\
2019 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2020 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2021 "string_to_argv (String) -> Array.\n\
2022 Parse String and return an argv-like array.\n\
2023 Arguments are separate by spaces and may be quoted."
2025 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2026 "Write a string using gdb's filtered stream." },
2027 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2028 "Flush gdb's filtered stdout stream." },
2029 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2030 "selected_thread () -> gdb.InferiorThread.\n\
2031 Return the selected thread object." },
2032 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2033 "selected_inferior () -> gdb.Inferior.\n\
2034 Return the selected inferior object." },
2035 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2036 "inferiors () -> (gdb.Inferior, ...).\n\
2037 Return a tuple containing all inferiors." },
2039 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2040 "invalidate_cached_frames () -> None.\n\
2041 Invalidate any cached frame objects in gdb.\n\
2042 Intended for internal use only." },
2044 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2045 "convenience_variable (NAME) -> value.\n\
2046 Return the value of the convenience variable $NAME,\n\
2047 or None if not set." },
2048 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2049 "convenience_variable (NAME, VALUE) -> None.\n\
2050 Set the value of the convenience variable $NAME." },
2052 {NULL
, NULL
, 0, NULL
}
2056 struct PyModuleDef python_GdbModuleDef
=
2058 PyModuleDef_HEAD_INIT
,
2070 /* Define all the event objects. */
2071 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2072 PyTypeObject name##_event_object_type \
2073 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2075 PyVarObject_HEAD_INIT (NULL, 0) \
2076 "gdb." py_name, /* tp_name */ \
2077 sizeof (event_object), /* tp_basicsize */ \
2078 0, /* tp_itemsize */ \
2079 evpy_dealloc, /* tp_dealloc */ \
2081 0, /* tp_getattr */ \
2082 0, /* tp_setattr */ \
2083 0, /* tp_compare */ \
2085 0, /* tp_as_number */ \
2086 0, /* tp_as_sequence */ \
2087 0, /* tp_as_mapping */ \
2091 0, /* tp_getattro */ \
2092 0, /* tp_setattro */ \
2093 0, /* tp_as_buffer */ \
2094 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2096 0, /* tp_traverse */ \
2098 0, /* tp_richcompare */ \
2099 0, /* tp_weaklistoffset */ \
2101 0, /* tp_iternext */ \
2102 0, /* tp_methods */ \
2103 0, /* tp_members */ \
2104 0, /* tp_getset */ \
2105 &base, /* tp_base */ \
2107 0, /* tp_descr_get */ \
2108 0, /* tp_descr_set */ \
2109 0, /* tp_dictoffset */ \
2113 #include "py-event-types.def"
2114 #undef GDB_PY_DEFINE_EVENT_TYPE
2116 #endif /* HAVE_PYTHON */