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"
94 #include "python-internal.h"
99 #include "gdbthread.h"
101 #include "event-top.h"
103 #include "py-event.h"
105 /* True if Python has been successfully initialized, false
108 int gdb_python_initialized
;
110 extern PyMethodDef python_GdbMethods
[];
113 extern struct PyModuleDef python_GdbModuleDef
;
116 PyObject
*gdb_module
;
117 PyObject
*gdb_python_module
;
119 /* Some string constants we may wish to use. */
120 PyObject
*gdbpy_to_string_cst
;
121 PyObject
*gdbpy_children_cst
;
122 PyObject
*gdbpy_display_hint_cst
;
123 PyObject
*gdbpy_doc_cst
;
124 PyObject
*gdbpy_enabled_cst
;
125 PyObject
*gdbpy_value_cst
;
127 /* The GdbError exception. */
128 PyObject
*gdbpy_gdberror_exc
;
130 /* The `gdb.error' base class. */
131 PyObject
*gdbpy_gdb_error
;
133 /* The `gdb.MemoryError' exception. */
134 PyObject
*gdbpy_gdb_memory_error
;
136 static script_sourcer_func gdbpy_source_script
;
137 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
138 static objfile_script_executor_func gdbpy_execute_objfile_script
;
139 static void gdbpy_finish_initialization
140 (const struct extension_language_defn
*);
141 static int gdbpy_initialized (const struct extension_language_defn
*);
142 static void gdbpy_eval_from_control_command
143 (const struct extension_language_defn
*, struct command_line
*cmd
);
144 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
145 struct ext_lang_type_printers
*);
146 static enum ext_lang_rc gdbpy_apply_type_printers
147 (const struct extension_language_defn
*,
148 const struct ext_lang_type_printers
*, struct type
*, char **);
149 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
150 struct ext_lang_type_printers
*);
151 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
152 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
153 static enum ext_lang_rc gdbpy_before_prompt_hook
154 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
156 /* The interface between gdb proper and loading of python scripts. */
158 const struct extension_language_script_ops python_extension_script_ops
=
161 gdbpy_source_objfile_script
,
162 gdbpy_execute_objfile_script
,
163 gdbpy_auto_load_enabled
166 /* The interface between gdb proper and python extensions. */
168 const struct extension_language_ops python_extension_ops
=
170 gdbpy_finish_initialization
,
173 gdbpy_eval_from_control_command
,
175 gdbpy_start_type_printers
,
176 gdbpy_apply_type_printers
,
177 gdbpy_free_type_printers
,
179 gdbpy_apply_val_pretty_printer
,
181 gdbpy_apply_frame_filter
,
183 gdbpy_preserve_values
,
185 gdbpy_breakpoint_has_cond
,
186 gdbpy_breakpoint_cond_says_stop
,
189 gdbpy_check_quit_flag
,
191 gdbpy_before_prompt_hook
,
193 gdbpy_get_matching_xmethod_workers
,
196 /* Architecture and language to be used in callbacks from
197 the Python interpreter. */
198 struct gdbarch
*python_gdbarch
;
199 const struct language_defn
*python_language
;
201 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
202 const struct language_defn
*language
)
203 : m_gdbarch (python_gdbarch
),
204 m_language (python_language
)
206 /* We should not ever enter Python unless initialized. */
207 if (!gdb_python_initialized
)
208 error (_("Python not initialized"));
210 m_previous_active
= set_active_ext_lang (&extension_language_python
);
212 m_state
= PyGILState_Ensure ();
214 python_gdbarch
= gdbarch
;
215 python_language
= language
;
217 /* Save it and ensure ! PyErr_Occurred () afterwards. */
218 PyErr_Fetch (&m_error_type
, &m_error_value
, &m_error_traceback
);
221 gdbpy_enter::~gdbpy_enter ()
223 /* Leftover Python error is forbidden by Python Exception Handling. */
224 if (PyErr_Occurred ())
226 /* This order is similar to the one calling error afterwards. */
227 gdbpy_print_stack ();
228 warning (_("internal error: Unhandled Python exception"));
231 PyErr_Restore (m_error_type
, m_error_value
, m_error_traceback
);
233 PyGILState_Release (m_state
);
234 python_gdbarch
= m_gdbarch
;
235 python_language
= m_language
;
237 restore_active_ext_lang (m_previous_active
);
240 /* Set the quit flag. */
243 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
245 PyErr_SetInterrupt ();
248 /* Return true if the quit flag has been set, false otherwise. */
251 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
253 return PyOS_InterruptOccurred ();
256 /* Evaluate a Python command like PyRun_SimpleString, but uses
257 Py_single_input which prints the result of expressions, and does
258 not automatically print the stack on errors. */
261 eval_python_command (const char *command
)
265 m
= PyImport_AddModule ("__main__");
269 d
= PyModule_GetDict (m
);
272 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
284 /* Implementation of the gdb "python-interactive" command. */
287 python_interactive_command (const char *arg
, int from_tty
)
289 struct ui
*ui
= current_ui
;
292 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
294 arg
= skip_spaces (arg
);
296 gdbpy_enter
enter_py (get_current_arch (), current_language
);
300 int len
= strlen (arg
);
301 char *script
= (char *) xmalloc (len
+ 2);
303 strcpy (script
, arg
);
305 script
[len
+ 1] = '\0';
306 err
= eval_python_command (script
);
311 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
317 gdbpy_print_stack ();
318 error (_("Error while executing Python code."));
322 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
325 On Windows hosts few users would build Python themselves (this is no
326 trivial task on this platform), and thus use binaries built by
327 someone else instead. There may happen situation where the Python
328 library and GDB are using two different versions of the C runtime
329 library. Python, being built with VC, would use one version of the
330 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
331 A FILE * from one runtime does not necessarily operate correctly in
334 To work around this potential issue, we create on Windows hosts the
335 FILE object using Python routines, thus making sure that it is
336 compatible with the Python library. */
339 python_run_simple_file (FILE *file
, const char *filename
)
343 PyRun_SimpleFile (file
, filename
);
347 /* Because we have a string for a filename, and are using Python to
348 open the file, we need to expand any tilde in the path first. */
349 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
350 gdbpy_ref
<> python_file (PyFile_FromString (full_path
.get (), (char *) "r"));
351 if (python_file
== NULL
)
353 gdbpy_print_stack ();
354 error (_("Error while opening file: %s"), full_path
.get ());
357 PyRun_SimpleFile (PyFile_AsFile (python_file
.get ()), filename
);
362 /* Given a command_line, return a command string suitable for passing
363 to Python. Lines in the string are separated by newlines. */
366 compute_python_string (struct command_line
*l
)
368 struct command_line
*iter
;
371 for (iter
= l
; iter
; iter
= iter
->next
)
373 script
+= iter
->line
;
379 /* Take a command line structure representing a 'python' command, and
380 evaluate its body using the Python interpreter. */
383 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
384 struct command_line
*cmd
)
388 if (cmd
->body_count
!= 1)
389 error (_("Invalid \"python\" block structure."));
391 gdbpy_enter
enter_py (get_current_arch (), current_language
);
393 std::string script
= compute_python_string (cmd
->body_list
[0]);
394 ret
= PyRun_SimpleString (script
.c_str ());
396 error (_("Error while executing Python code."));
399 /* Implementation of the gdb "python" command. */
402 python_command (const char *arg
, int from_tty
)
404 gdbpy_enter
enter_py (get_current_arch (), current_language
);
406 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
408 arg
= skip_spaces (arg
);
411 if (PyRun_SimpleString (arg
))
412 error (_("Error while executing Python code."));
416 command_line_up l
= get_command_line (python_control
, "");
418 execute_control_command_untraced (l
.get ());
424 /* Transform a gdb parameters's value into a Python value. May return
425 NULL (and set a Python exception) on error. Helper function for
428 gdbpy_parameter_value (enum var_types type
, void *var
)
433 case var_string_noescape
:
434 case var_optional_filename
:
438 const char *str
= *(char **) var
;
442 return host_string_to_python_string (str
);
453 case var_auto_boolean
:
455 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
457 if (ab
== AUTO_BOOLEAN_TRUE
)
459 else if (ab
== AUTO_BOOLEAN_FALSE
)
466 if ((* (int *) var
) == INT_MAX
)
470 return PyLong_FromLong (* (int *) var
);
474 unsigned int val
= * (unsigned int *) var
;
478 return PyLong_FromUnsignedLong (val
);
482 return PyErr_Format (PyExc_RuntimeError
,
483 _("Programmer error: unhandled type."));
486 /* A Python function which returns a gdb parameter's value as a Python
490 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
492 struct gdb_exception except
= exception_none
;
493 struct cmd_list_element
*alias
, *prefix
, *cmd
;
498 if (! PyArg_ParseTuple (args
, "s", &arg
))
501 newarg
= concat ("show ", arg
, (char *) NULL
);
505 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
507 CATCH (ex
, RETURN_MASK_ALL
)
514 GDB_PY_HANDLE_EXCEPTION (except
);
516 return PyErr_Format (PyExc_RuntimeError
,
517 _("Could not find parameter `%s'."), arg
);
520 return PyErr_Format (PyExc_RuntimeError
,
521 _("`%s' is not a parameter."), arg
);
522 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
525 /* Wrapper for target_charset. */
528 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
530 const char *cset
= target_charset (python_gdbarch
);
532 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
535 /* Wrapper for target_wide_charset. */
538 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
540 const char *cset
= target_wide_charset (python_gdbarch
);
542 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
545 /* A Python function which evaluates a string using the gdb CLI. */
548 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
551 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
552 int from_tty
, to_string
;
553 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
555 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
556 &PyBool_Type
, &from_tty_obj
,
557 &PyBool_Type
, &to_string_obj
))
563 int cmp
= PyObject_IsTrue (from_tty_obj
);
572 int cmp
= PyObject_IsTrue (to_string_obj
);
578 std::string to_string_res
;
582 struct interp
*interp
;
584 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
586 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
588 /* Use the console interpreter uiout to have the same print format
589 for console or MI. */
590 interp
= interp_lookup (current_ui
, "console");
591 current_uiout
= interp_ui_out (interp
);
593 scoped_restore preventer
= prevent_dont_repeat ();
595 to_string_res
= execute_command_to_string (arg
, from_tty
);
597 execute_command (arg
, from_tty
);
599 CATCH (except
, RETURN_MASK_ALL
)
601 GDB_PY_HANDLE_EXCEPTION (except
);
605 /* Do any commands attached to breakpoint we stopped at. */
606 bpstat_do_actions ();
609 return PyString_FromString (to_string_res
.c_str ());
613 /* Implementation of gdb.solib_name (Long) -> String.
614 Returns the name of the shared library holding a given address, or None. */
617 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
623 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
626 soname
= solib_name_from_address (current_program_space
, pc
);
628 str_obj
= host_string_to_python_string (soname
);
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
,
748 symtab_paths
.vec
.size (), files
);
751 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, 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.find_pc_line function.
924 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
927 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
929 gdb_py_ulongest pc_llu
;
930 PyObject
*result
= NULL
; /* init for gcc -Wall */
932 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
937 struct symtab_and_line sal
;
940 pc
= (CORE_ADDR
) pc_llu
;
941 sal
= find_pc_line (pc
, 0);
942 result
= symtab_and_line_to_sal_object (sal
);
944 CATCH (except
, RETURN_MASK_ALL
)
946 GDB_PY_HANDLE_EXCEPTION (except
);
953 /* Implementation of gdb.invalidate_cached_frames. */
956 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
958 reinit_frame_cache ();
962 /* Read a file as Python code.
963 This is the extension_language_script_ops.script_sourcer "method".
964 FILE is the file to load. FILENAME is name of the file FILE.
965 This does not throw any errors. If an exception occurs python will print
966 the traceback and clear the error indicator. */
969 gdbpy_source_script (const struct extension_language_defn
*extlang
,
970 FILE *file
, const char *filename
)
972 gdbpy_enter
enter_py (get_current_arch (), current_language
);
973 python_run_simple_file (file
, filename
);
978 /* Posting and handling events. */
980 /* A single event. */
983 /* The Python event. This is just a callable object. */
985 /* The next event. */
986 struct gdbpy_event
*next
;
989 /* All pending events. */
990 static struct gdbpy_event
*gdbpy_event_list
;
991 /* The final link of the event list. */
992 static struct gdbpy_event
**gdbpy_event_list_end
;
994 /* So that we can wake up the main thread even when it is blocked in
996 static struct serial_event
*gdbpy_serial_event
;
998 /* The file handler callback. This reads from the internal pipe, and
999 then processes the Python event queue. This will always be run in
1000 the main gdb thread. */
1003 gdbpy_run_events (int error
, gdb_client_data client_data
)
1005 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1007 /* Clear the event fd. Do this before flushing the events list, so
1008 that any new event post afterwards is sure to re-awake the event
1010 serial_event_clear (gdbpy_serial_event
);
1012 while (gdbpy_event_list
)
1014 /* Dispatching the event might push a new element onto the event
1015 loop, so we update here "atomically enough". */
1016 struct gdbpy_event
*item
= gdbpy_event_list
;
1017 gdbpy_event_list
= gdbpy_event_list
->next
;
1018 if (gdbpy_event_list
== NULL
)
1019 gdbpy_event_list_end
= &gdbpy_event_list
;
1021 /* Ignore errors. */
1022 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
1023 if (call_result
== NULL
)
1026 Py_DECREF (item
->event
);
1031 /* Submit an event to the gdb thread. */
1033 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1035 struct gdbpy_event
*event
;
1039 if (!PyArg_ParseTuple (args
, "O", &func
))
1042 if (!PyCallable_Check (func
))
1044 PyErr_SetString (PyExc_RuntimeError
,
1045 _("Posted event is not callable"));
1051 /* From here until the end of the function, we have the GIL, so we
1052 can operate on our global data structures without worrying. */
1053 wakeup
= gdbpy_event_list
== NULL
;
1055 event
= XNEW (struct gdbpy_event
);
1056 event
->event
= func
;
1058 *gdbpy_event_list_end
= event
;
1059 gdbpy_event_list_end
= &event
->next
;
1061 /* Wake up gdb when needed. */
1063 serial_event_set (gdbpy_serial_event
);
1068 /* Initialize the Python event handler. */
1070 gdbpy_initialize_events (void)
1072 gdbpy_event_list_end
= &gdbpy_event_list
;
1074 gdbpy_serial_event
= make_serial_event ();
1075 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1076 gdbpy_run_events
, NULL
);
1083 /* This is the extension_language_ops.before_prompt "method". */
1085 static enum ext_lang_rc
1086 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1087 const char *current_gdb_prompt
)
1089 if (!gdb_python_initialized
)
1090 return EXT_LANG_RC_NOP
;
1092 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1094 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1095 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1096 return EXT_LANG_RC_ERROR
;
1098 if (gdb_python_module
1099 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1101 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1105 gdbpy_print_stack ();
1106 return EXT_LANG_RC_ERROR
;
1109 if (PyCallable_Check (hook
.get ()))
1111 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1112 if (current_prompt
== NULL
)
1114 gdbpy_print_stack ();
1115 return EXT_LANG_RC_ERROR
;
1119 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1123 gdbpy_print_stack ();
1124 return EXT_LANG_RC_ERROR
;
1127 /* Return type should be None, or a String. If it is None,
1128 fall through, we will not set a prompt. If it is a
1129 string, set PROMPT. Anything else, set an exception. */
1130 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1132 PyErr_Format (PyExc_RuntimeError
,
1133 _("Return from prompt_hook must " \
1134 "be either a Python string, or None"));
1135 gdbpy_print_stack ();
1136 return EXT_LANG_RC_ERROR
;
1139 if (result
!= Py_None
)
1141 gdb::unique_xmalloc_ptr
<char>
1142 prompt (python_string_to_host_string (result
.get ()));
1146 gdbpy_print_stack ();
1147 return EXT_LANG_RC_ERROR
;
1150 set_prompt (prompt
.get ());
1151 return EXT_LANG_RC_OK
;
1156 return EXT_LANG_RC_NOP
;
1163 /* A python function to write a single string using gdb's filtered
1164 output stream . The optional keyword STREAM can be used to write
1165 to a particular stream. The default stream is to gdb_stdout. */
1168 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1171 static const char *keywords
[] = { "text", "stream", NULL
};
1172 int stream_type
= 0;
1174 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1180 switch (stream_type
)
1184 fprintf_filtered (gdb_stderr
, "%s", arg
);
1189 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1193 fprintf_filtered (gdb_stdout
, "%s", arg
);
1196 CATCH (except
, RETURN_MASK_ALL
)
1198 GDB_PY_HANDLE_EXCEPTION (except
);
1205 /* A python function to flush a gdb stream. The optional keyword
1206 STREAM can be used to flush a particular stream. The default stream
1210 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1212 static const char *keywords
[] = { "stream", NULL
};
1213 int stream_type
= 0;
1215 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1219 switch (stream_type
)
1223 gdb_flush (gdb_stderr
);
1228 gdb_flush (gdb_stdlog
);
1232 gdb_flush (gdb_stdout
);
1238 /* Return non-zero if print-stack is not "none". */
1241 gdbpy_print_python_errors_p (void)
1243 return gdbpy_should_print_stack
!= python_excp_none
;
1246 /* Print a python exception trace, print just a message, or print
1247 nothing and clear the python exception, depending on
1248 gdbpy_should_print_stack. Only call this if a python exception is
1251 gdbpy_print_stack (void)
1254 /* Print "none", just clear exception. */
1255 if (gdbpy_should_print_stack
== python_excp_none
)
1259 /* Print "full" message and backtrace. */
1260 else if (gdbpy_should_print_stack
== python_excp_full
)
1263 /* PyErr_Print doesn't necessarily end output with a newline.
1264 This works because Python's stdout/stderr is fed through
1270 CATCH (except
, RETURN_MASK_ALL
)
1275 /* Print "message", just error print message. */
1278 PyObject
*ptype
, *pvalue
, *ptraceback
;
1280 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1282 /* Fetch the error message contained within ptype, pvalue. */
1283 gdb::unique_xmalloc_ptr
<char>
1284 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1285 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1291 /* An error occurred computing the string representation of the
1293 fprintf_filtered (gdb_stderr
,
1294 _("Error occurred computing Python error" \
1298 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1299 type
.get (), msg
.get ());
1301 CATCH (except
, RETURN_MASK_ALL
)
1307 Py_XDECREF (pvalue
);
1308 Py_XDECREF (ptraceback
);
1314 /* Return the current Progspace.
1315 There always is one. */
1318 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1322 result
= pspace_to_pspace_object (current_program_space
);
1328 /* Return a sequence holding all the Progspaces. */
1331 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1333 struct program_space
*ps
;
1335 gdbpy_ref
<> list (PyList_New (0));
1341 PyObject
*item
= pspace_to_pspace_object (ps
);
1343 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1347 return list
.release ();
1352 /* The "current" objfile. This is set when gdb detects that a new
1353 objfile has been loaded. It is only set for the duration of a call to
1354 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1356 static struct objfile
*gdbpy_current_objfile
;
1358 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1359 as Python code. This does not throw any errors. If an exception
1360 occurs python will print the traceback and clear the error indicator.
1361 This is the extension_language_script_ops.objfile_script_sourcer
1365 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1366 struct objfile
*objfile
, FILE *file
,
1367 const char *filename
)
1369 if (!gdb_python_initialized
)
1372 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1373 gdbpy_current_objfile
= objfile
;
1375 python_run_simple_file (file
, filename
);
1377 gdbpy_current_objfile
= NULL
;
1380 /* Set the current objfile to OBJFILE and then execute SCRIPT
1381 as Python code. This does not throw any errors. If an exception
1382 occurs python will print the traceback and clear the error indicator.
1383 This is the extension_language_script_ops.objfile_script_executor
1387 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1388 struct objfile
*objfile
, const char *name
,
1391 if (!gdb_python_initialized
)
1394 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1395 gdbpy_current_objfile
= objfile
;
1397 PyRun_SimpleString (script
);
1399 gdbpy_current_objfile
= NULL
;
1402 /* Return the current Objfile, or None if there isn't one. */
1405 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1409 if (! gdbpy_current_objfile
)
1412 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1418 /* Return a sequence holding all the Objfiles. */
1421 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1423 struct objfile
*objf
;
1425 gdbpy_ref
<> list (PyList_New (0));
1431 PyObject
*item
= objfile_to_objfile_object (objf
);
1433 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1437 return list
.release ();
1440 /* Compute the list of active python type printers and store them in
1441 EXT_PRINTERS->py_type_printers. The product of this function is used by
1442 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1443 This is the extension_language_ops.start_type_printers "method". */
1446 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1447 struct ext_lang_type_printers
*ext_printers
)
1449 PyObject
*printers_obj
= NULL
;
1451 if (!gdb_python_initialized
)
1454 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1456 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1457 if (type_module
== NULL
)
1459 gdbpy_print_stack ();
1463 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1464 "get_type_recognizers"));
1467 gdbpy_print_stack ();
1471 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1472 if (printers_obj
== NULL
)
1473 gdbpy_print_stack ();
1475 ext_printers
->py_type_printers
= printers_obj
;
1478 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1479 a newly allocated string holding the type's replacement name, and return
1480 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1481 If there's a Python error return EXT_LANG_RC_ERROR.
1482 Otherwise, return EXT_LANG_RC_NOP.
1483 This is the extension_language_ops.apply_type_printers "method". */
1485 static enum ext_lang_rc
1486 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1487 const struct ext_lang_type_printers
*ext_printers
,
1488 struct type
*type
, char **prettied_type
)
1490 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1491 gdb::unique_xmalloc_ptr
<char> result
;
1493 if (printers_obj
== NULL
)
1494 return EXT_LANG_RC_NOP
;
1496 if (!gdb_python_initialized
)
1497 return EXT_LANG_RC_NOP
;
1499 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1501 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1502 if (type_obj
== NULL
)
1504 gdbpy_print_stack ();
1505 return EXT_LANG_RC_ERROR
;
1508 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1509 if (type_module
== NULL
)
1511 gdbpy_print_stack ();
1512 return EXT_LANG_RC_ERROR
;
1515 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1516 "apply_type_recognizers"));
1519 gdbpy_print_stack ();
1520 return EXT_LANG_RC_ERROR
;
1523 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1527 if (result_obj
== NULL
)
1529 gdbpy_print_stack ();
1530 return EXT_LANG_RC_ERROR
;
1533 if (result_obj
== Py_None
)
1534 return EXT_LANG_RC_NOP
;
1536 result
= python_string_to_host_string (result_obj
.get ());
1539 gdbpy_print_stack ();
1540 return EXT_LANG_RC_ERROR
;
1543 *prettied_type
= result
.release ();
1544 return EXT_LANG_RC_OK
;
1547 /* Free the result of start_type_printers.
1548 This is the extension_language_ops.free_type_printers "method". */
1551 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1552 struct ext_lang_type_printers
*ext_printers
)
1554 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1556 if (printers
== NULL
)
1559 if (!gdb_python_initialized
)
1562 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1563 Py_DECREF (printers
);
1566 #else /* HAVE_PYTHON */
1568 /* Dummy implementation of the gdb "python-interactive" and "python"
1572 python_interactive_command (const char *arg
, int from_tty
)
1574 arg
= skip_spaces (arg
);
1576 error (_("Python scripting is not supported in this copy of GDB."));
1579 command_line_up l
= get_command_line (python_control
, "");
1581 execute_control_command_untraced (l
.get ());
1586 python_command (const char *arg
, int from_tty
)
1588 python_interactive_command (arg
, from_tty
);
1591 #endif /* HAVE_PYTHON */
1595 /* Lists for 'set python' commands. */
1597 static struct cmd_list_element
*user_set_python_list
;
1598 static struct cmd_list_element
*user_show_python_list
;
1600 /* Function for use by 'set python' prefix command. */
1603 user_set_python (const char *args
, int from_tty
)
1605 help_list (user_set_python_list
, "set python ", all_commands
,
1609 /* Function for use by 'show python' prefix command. */
1612 user_show_python (const char *args
, int from_tty
)
1614 cmd_show_list (user_show_python_list
, from_tty
, "");
1617 /* Initialize the Python code. */
1621 /* This is installed as a final cleanup and cleans up the
1622 interpreter. This lets Python's 'atexit' work. */
1625 finalize_python (void *ignore
)
1627 struct active_ext_lang_state
*previous_active
;
1629 /* We don't use ensure_python_env here because if we ever ran the
1630 cleanup, gdb would crash -- because the cleanup calls into the
1631 Python interpreter, which we are about to destroy. It seems
1632 clearer to make the needed calls explicitly here than to create a
1633 cleanup and then mysteriously discard it. */
1635 /* This is only called as a final cleanup so we can assume the active
1636 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1637 previous_active
= set_active_ext_lang (&extension_language_python
);
1639 (void) PyGILState_Ensure ();
1640 python_gdbarch
= target_gdbarch ();
1641 python_language
= current_language
;
1645 restore_active_ext_lang (previous_active
);
1649 do_start_initialization ()
1652 size_t progsize
, count
;
1653 wchar_t *progname_copy
;
1656 #ifdef WITH_PYTHON_PATH
1657 /* Work around problem where python gets confused about where it is,
1658 and then can't find its libraries, etc.
1659 NOTE: Python assumes the following layout:
1661 /foo/lib/pythonX.Y/...
1662 This must be done before calling Py_Initialize. */
1663 gdb::unique_xmalloc_ptr
<char> progname
1664 (concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1665 SLASH_STRING
, "python", (char *) NULL
));
1667 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1668 setlocale (LC_ALL
, "");
1669 progsize
= strlen (progname
.get ());
1670 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1673 fprintf (stderr
, "out of memory\n");
1676 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1677 if (count
== (size_t) -1)
1679 fprintf (stderr
, "Could not convert python path to string\n");
1682 setlocale (LC_ALL
, oldloc
.c_str ());
1684 /* Note that Py_SetProgramName expects the string it is passed to
1685 remain alive for the duration of the program's execution, so
1686 it is not freed after this call. */
1687 Py_SetProgramName (progname_copy
);
1689 Py_SetProgramName (progname
.release ());
1694 PyEval_InitThreads ();
1697 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1698 /* Add _gdb module to the list of known built-in modules. */
1699 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1701 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1703 if (gdb_module
== NULL
)
1706 /* The casts to (char*) are for python 2.4. */
1707 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1708 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1709 (char*) host_name
) < 0
1710 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1711 (char*) target_name
) < 0)
1714 /* Add stream constants. */
1715 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1716 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1717 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1720 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1721 if (gdbpy_gdb_error
== NULL
1722 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1725 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1726 gdbpy_gdb_error
, NULL
);
1727 if (gdbpy_gdb_memory_error
== NULL
1728 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1729 gdbpy_gdb_memory_error
) < 0)
1732 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1733 if (gdbpy_gdberror_exc
== NULL
1734 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1735 gdbpy_gdberror_exc
) < 0)
1738 gdbpy_initialize_gdb_readline ();
1740 if (gdbpy_initialize_auto_load () < 0
1741 || gdbpy_initialize_values () < 0
1742 || gdbpy_initialize_frames () < 0
1743 || gdbpy_initialize_commands () < 0
1744 || gdbpy_initialize_instruction () < 0
1745 || gdbpy_initialize_record () < 0
1746 || gdbpy_initialize_btrace () < 0
1747 || gdbpy_initialize_symbols () < 0
1748 || gdbpy_initialize_symtabs () < 0
1749 || gdbpy_initialize_blocks () < 0
1750 || gdbpy_initialize_functions () < 0
1751 || gdbpy_initialize_parameters () < 0
1752 || gdbpy_initialize_types () < 0
1753 || gdbpy_initialize_pspace () < 0
1754 || gdbpy_initialize_objfile () < 0
1755 || gdbpy_initialize_breakpoints () < 0
1756 || gdbpy_initialize_finishbreakpoints () < 0
1757 || gdbpy_initialize_lazy_string () < 0
1758 || gdbpy_initialize_linetable () < 0
1759 || gdbpy_initialize_thread () < 0
1760 || gdbpy_initialize_inferior () < 0
1761 || gdbpy_initialize_events () < 0
1762 || gdbpy_initialize_eventregistry () < 0
1763 || gdbpy_initialize_py_events () < 0
1764 || gdbpy_initialize_event () < 0
1765 || gdbpy_initialize_arch () < 0
1766 || gdbpy_initialize_xmethods () < 0
1767 || gdbpy_initialize_unwind () < 0)
1770 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1771 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1773 #include "py-event-types.def"
1774 #undef GDB_PY_DEFINE_EVENT_TYPE
1776 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1777 if (gdbpy_to_string_cst
== NULL
)
1779 gdbpy_children_cst
= PyString_FromString ("children");
1780 if (gdbpy_children_cst
== NULL
)
1782 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1783 if (gdbpy_display_hint_cst
== NULL
)
1785 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1786 if (gdbpy_doc_cst
== NULL
)
1788 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1789 if (gdbpy_enabled_cst
== NULL
)
1791 gdbpy_value_cst
= PyString_FromString ("value");
1792 if (gdbpy_value_cst
== NULL
)
1795 /* Release the GIL while gdb runs. */
1796 PyThreadState_Swap (NULL
);
1797 PyEval_ReleaseLock ();
1799 make_final_cleanup (finalize_python
, NULL
);
1801 /* Only set this when initialization has succeeded. */
1802 gdb_python_initialized
= 1;
1806 #endif /* HAVE_PYTHON */
1809 _initialize_python (void)
1811 add_com ("python-interactive", class_obscure
,
1812 python_interactive_command
,
1815 Start an interactive Python prompt.\n\
1817 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1820 Alternatively, a single-line Python command can be given as an\n\
1821 argument, and if the command is an expression, the result will be\n\
1822 printed. For example:\n\
1824 (gdb) python-interactive 2 + 3\n\
1827 #else /* HAVE_PYTHON */
1829 Start a Python interactive prompt.\n\
1831 Python scripting is not supported in this copy of GDB.\n\
1832 This command is only a placeholder.")
1833 #endif /* HAVE_PYTHON */
1835 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1837 add_com ("python", class_obscure
, python_command
,
1840 Evaluate a Python command.\n\
1842 The command can be given as an argument, for instance:\n\
1846 If no argument is given, the following lines are read and used\n\
1847 as the Python commands. Type a line containing \"end\" to indicate\n\
1848 the end of the command.")
1849 #else /* HAVE_PYTHON */
1851 Evaluate a Python command.\n\
1853 Python scripting is not supported in this copy of GDB.\n\
1854 This command is only a placeholder.")
1855 #endif /* HAVE_PYTHON */
1857 add_com_alias ("py", "python", class_obscure
, 1);
1859 /* Add set/show python print-stack. */
1860 add_prefix_cmd ("python", no_class
, user_show_python
,
1861 _("Prefix command for python preference settings."),
1862 &user_show_python_list
, "show python ", 0,
1865 add_prefix_cmd ("python", no_class
, user_set_python
,
1866 _("Prefix command for python preference settings."),
1867 &user_set_python_list
, "set python ", 0,
1870 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1871 &gdbpy_should_print_stack
, _("\
1872 Set mode for Python stack dump on error."), _("\
1873 Show the mode of Python stack printing on error."), _("\
1874 none == no stack or message will be printed.\n\
1875 full == a message and a stack will be printed.\n\
1876 message == an error message without a stack will be printed."),
1878 &user_set_python_list
,
1879 &user_show_python_list
);
1882 if (!do_start_initialization () && PyErr_Occurred ())
1883 gdbpy_print_stack ();
1884 #endif /* HAVE_PYTHON */
1889 /* Helper function for gdbpy_finish_initialization. This does the
1890 work and then returns false if an error has occurred and must be
1891 displayed, or true on success. */
1894 do_finish_initialization (const struct extension_language_defn
*extlang
)
1899 /* Add the initial data-directory to sys.path. */
1901 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1904 sys_path
= PySys_GetObject ("path");
1906 /* If sys.path is not defined yet, define it first. */
1907 if (!(sys_path
&& PyList_Check (sys_path
)))
1910 PySys_SetPath (L
"");
1914 sys_path
= PySys_GetObject ("path");
1916 if (sys_path
&& PyList_Check (sys_path
))
1918 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1919 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1925 /* Import the gdb module to finish the initialization, and
1926 add it to __main__ for convenience. */
1927 m
= PyImport_AddModule ("__main__");
1931 /* Keep the reference to gdb_python_module since it is in a global
1933 gdb_python_module
= PyImport_ImportModule ("gdb");
1934 if (gdb_python_module
== NULL
)
1936 gdbpy_print_stack ();
1937 /* This is passed in one call to warning so that blank lines aren't
1938 inserted between each line of text. */
1940 "Could not load the Python gdb module from `%s'.\n"
1941 "Limited Python support is available from the _gdb module.\n"
1942 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1943 gdb_pythondir
.c_str ());
1944 /* We return "success" here as we've already emitted the
1949 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1952 /* Perform the remaining python initializations.
1953 These must be done after GDB is at least mostly initialized.
1954 E.g., The "info pretty-printer" command needs the "info" prefix
1956 This is the extension_language_ops.finish_initialization "method". */
1959 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1961 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1963 if (!do_finish_initialization (extlang
))
1965 gdbpy_print_stack ();
1966 warning (_("internal error: Unhandled Python exception"));
1970 /* Return non-zero if Python has successfully initialized.
1971 This is the extension_languages_ops.initialized "method". */
1974 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1976 return gdb_python_initialized
;
1979 #endif /* HAVE_PYTHON */
1985 PyMethodDef python_GdbMethods
[] =
1987 { "history", gdbpy_history
, METH_VARARGS
,
1988 "Get a value from history" },
1989 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1990 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1991 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1992 a Python String containing the output of the command if to_string is\n\
1994 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1995 "Return a gdb parameter's value" },
1997 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1998 "Return a tuple of all breakpoint objects" },
2000 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
2001 "Find the default visualizer for a Value." },
2003 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
2004 "Return the current Progspace." },
2005 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2006 "Return a sequence of all progspaces." },
2008 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2009 "Return the current Objfile being loaded, or None." },
2010 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
2011 "Return a sequence of all loaded objfiles." },
2013 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2014 "newest_frame () -> gdb.Frame.\n\
2015 Return the newest frame object." },
2016 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2017 "selected_frame () -> gdb.Frame.\n\
2018 Return the selected frame object." },
2019 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2020 "stop_reason_string (Integer) -> String.\n\
2021 Return a string explaining unwind stop reason." },
2023 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2024 "start_recording ([method] [, format]) -> gdb.Record.\n\
2025 Start recording with the given method. If no method is given, will fall back\n\
2026 to the system default method. If no format is given, will fall back to the\n\
2027 default format for the given method."},
2028 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2029 "current_recording () -> gdb.Record.\n\
2030 Return current recording object." },
2031 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2032 "stop_recording () -> None.\n\
2033 Stop current recording." },
2035 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2036 METH_VARARGS
| METH_KEYWORDS
,
2037 "lookup_type (name [, block]) -> type\n\
2038 Return a Type corresponding to the given name." },
2039 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2040 METH_VARARGS
| METH_KEYWORDS
,
2041 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2042 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2043 a boolean indicating if name is a field of the current implied argument\n\
2044 `this' (when the current language is object-oriented)." },
2045 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2046 METH_VARARGS
| METH_KEYWORDS
,
2047 "lookup_global_symbol (name [, domain]) -> symbol\n\
2048 Return the symbol corresponding to the given name (or None)." },
2050 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2051 METH_VARARGS
| METH_KEYWORDS
,
2052 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2053 Look up the specified objfile.\n\
2054 If by_build_id is True, the objfile is looked up by using name\n\
2055 as its build id." },
2057 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2058 "Return the block containing the given pc value, or None." },
2059 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2060 "solib_name (Long) -> String.\n\
2061 Return the name of the shared library holding a given address, or None." },
2062 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2063 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2064 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2065 The first element contains any unparsed portion of the String parameter\n\
2066 (or None if the string was fully parsed). The second element contains\n\
2067 a tuple that contains all the locations that match, represented as\n\
2068 gdb.Symtab_and_line objects (or None)."},
2069 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2070 "parse_and_eval (String) -> Value.\n\
2071 Parse String as an expression, evaluate it, and return the result as a Value."
2073 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2074 "find_pc_line (pc) -> Symtab_and_line.\n\
2075 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2077 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2078 "Post an event into gdb's event loop." },
2080 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2081 "target_charset () -> string.\n\
2082 Return the name of the current target charset." },
2083 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2084 "target_wide_charset () -> string.\n\
2085 Return the name of the current target wide charset." },
2086 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2087 "rbreak (Regex) -> List.\n\
2088 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2089 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2090 "string_to_argv (String) -> Array.\n\
2091 Parse String and return an argv-like array.\n\
2092 Arguments are separate by spaces and may be quoted."
2094 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2095 "Write a string using gdb's filtered stream." },
2096 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2097 "Flush gdb's filtered stdout stream." },
2098 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2099 "selected_thread () -> gdb.InferiorThread.\n\
2100 Return the selected thread object." },
2101 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2102 "selected_inferior () -> gdb.Inferior.\n\
2103 Return the selected inferior object." },
2104 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2105 "inferiors () -> (gdb.Inferior, ...).\n\
2106 Return a tuple containing all inferiors." },
2108 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2109 "invalidate_cached_frames () -> None.\n\
2110 Invalidate any cached frame objects in gdb.\n\
2111 Intended for internal use only." },
2113 {NULL
, NULL
, 0, NULL
}
2117 struct PyModuleDef python_GdbModuleDef
=
2119 PyModuleDef_HEAD_INIT
,
2131 /* Define all the event objects. */
2132 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2133 PyTypeObject name##_event_object_type \
2134 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2136 PyVarObject_HEAD_INIT (NULL, 0) \
2137 "gdb." py_name, /* tp_name */ \
2138 sizeof (event_object), /* tp_basicsize */ \
2139 0, /* tp_itemsize */ \
2140 evpy_dealloc, /* tp_dealloc */ \
2142 0, /* tp_getattr */ \
2143 0, /* tp_setattr */ \
2144 0, /* tp_compare */ \
2146 0, /* tp_as_number */ \
2147 0, /* tp_as_sequence */ \
2148 0, /* tp_as_mapping */ \
2152 0, /* tp_getattro */ \
2153 0, /* tp_setattro */ \
2154 0, /* tp_as_buffer */ \
2155 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2157 0, /* tp_traverse */ \
2159 0, /* tp_richcompare */ \
2160 0, /* tp_weaklistoffset */ \
2162 0, /* tp_iternext */ \
2163 0, /* tp_methods */ \
2164 0, /* tp_members */ \
2165 0, /* tp_getset */ \
2166 &base, /* tp_base */ \
2168 0, /* tp_descr_get */ \
2169 0, /* tp_descr_set */ \
2170 0, /* tp_dictoffset */ \
2174 #include "py-event-types.def"
2175 #undef GDB_PY_DEFINE_EVENT_TYPE
2177 #endif /* HAVE_PYTHON */