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
);
880 result
.reset (Py_None
);
884 gdbpy_ref
<> return_result (PyTuple_New (2));
885 if (return_result
== NULL
)
888 if (arg
!= NULL
&& strlen (arg
) > 0)
890 unparsed
.reset (PyString_FromString (arg
));
891 if (unparsed
== NULL
)
896 unparsed
.reset (Py_None
);
900 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
901 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
903 return return_result
.release ();
906 /* Parse a string and evaluate it as an expression. */
908 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
910 const char *expr_str
;
911 struct value
*result
= NULL
;
913 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
918 result
= parse_and_eval (expr_str
);
920 CATCH (except
, RETURN_MASK_ALL
)
922 GDB_PY_HANDLE_EXCEPTION (except
);
926 return value_to_value_object (result
);
929 /* Implementation of gdb.find_pc_line function.
930 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
933 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
935 gdb_py_ulongest pc_llu
;
936 PyObject
*result
= NULL
; /* init for gcc -Wall */
938 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
943 struct symtab_and_line sal
;
946 pc
= (CORE_ADDR
) pc_llu
;
947 sal
= find_pc_line (pc
, 0);
948 result
= symtab_and_line_to_sal_object (sal
);
950 CATCH (except
, RETURN_MASK_ALL
)
952 GDB_PY_HANDLE_EXCEPTION (except
);
959 /* Implementation of gdb.invalidate_cached_frames. */
962 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
964 reinit_frame_cache ();
968 /* Read a file as Python code.
969 This is the extension_language_script_ops.script_sourcer "method".
970 FILE is the file to load. FILENAME is name of the file FILE.
971 This does not throw any errors. If an exception occurs python will print
972 the traceback and clear the error indicator. */
975 gdbpy_source_script (const struct extension_language_defn
*extlang
,
976 FILE *file
, const char *filename
)
978 gdbpy_enter
enter_py (get_current_arch (), current_language
);
979 python_run_simple_file (file
, filename
);
984 /* Posting and handling events. */
986 /* A single event. */
989 /* The Python event. This is just a callable object. */
991 /* The next event. */
992 struct gdbpy_event
*next
;
995 /* All pending events. */
996 static struct gdbpy_event
*gdbpy_event_list
;
997 /* The final link of the event list. */
998 static struct gdbpy_event
**gdbpy_event_list_end
;
1000 /* So that we can wake up the main thread even when it is blocked in
1002 static struct serial_event
*gdbpy_serial_event
;
1004 /* The file handler callback. This reads from the internal pipe, and
1005 then processes the Python event queue. This will always be run in
1006 the main gdb thread. */
1009 gdbpy_run_events (int error
, gdb_client_data client_data
)
1011 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1013 /* Clear the event fd. Do this before flushing the events list, so
1014 that any new event post afterwards is sure to re-awake the event
1016 serial_event_clear (gdbpy_serial_event
);
1018 while (gdbpy_event_list
)
1020 /* Dispatching the event might push a new element onto the event
1021 loop, so we update here "atomically enough". */
1022 struct gdbpy_event
*item
= gdbpy_event_list
;
1023 gdbpy_event_list
= gdbpy_event_list
->next
;
1024 if (gdbpy_event_list
== NULL
)
1025 gdbpy_event_list_end
= &gdbpy_event_list
;
1027 /* Ignore errors. */
1028 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
1029 if (call_result
== NULL
)
1032 Py_DECREF (item
->event
);
1037 /* Submit an event to the gdb thread. */
1039 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1041 struct gdbpy_event
*event
;
1045 if (!PyArg_ParseTuple (args
, "O", &func
))
1048 if (!PyCallable_Check (func
))
1050 PyErr_SetString (PyExc_RuntimeError
,
1051 _("Posted event is not callable"));
1057 /* From here until the end of the function, we have the GIL, so we
1058 can operate on our global data structures without worrying. */
1059 wakeup
= gdbpy_event_list
== NULL
;
1061 event
= XNEW (struct gdbpy_event
);
1062 event
->event
= func
;
1064 *gdbpy_event_list_end
= event
;
1065 gdbpy_event_list_end
= &event
->next
;
1067 /* Wake up gdb when needed. */
1069 serial_event_set (gdbpy_serial_event
);
1074 /* Initialize the Python event handler. */
1076 gdbpy_initialize_events (void)
1078 gdbpy_event_list_end
= &gdbpy_event_list
;
1080 gdbpy_serial_event
= make_serial_event ();
1081 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1082 gdbpy_run_events
, NULL
);
1089 /* This is the extension_language_ops.before_prompt "method". */
1091 static enum ext_lang_rc
1092 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1093 const char *current_gdb_prompt
)
1095 if (!gdb_python_initialized
)
1096 return EXT_LANG_RC_NOP
;
1098 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1100 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1101 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1102 return EXT_LANG_RC_ERROR
;
1104 if (gdb_python_module
1105 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1107 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1111 gdbpy_print_stack ();
1112 return EXT_LANG_RC_ERROR
;
1115 if (PyCallable_Check (hook
.get ()))
1117 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1118 if (current_prompt
== NULL
)
1120 gdbpy_print_stack ();
1121 return EXT_LANG_RC_ERROR
;
1125 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1129 gdbpy_print_stack ();
1130 return EXT_LANG_RC_ERROR
;
1133 /* Return type should be None, or a String. If it is None,
1134 fall through, we will not set a prompt. If it is a
1135 string, set PROMPT. Anything else, set an exception. */
1136 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1138 PyErr_Format (PyExc_RuntimeError
,
1139 _("Return from prompt_hook must " \
1140 "be either a Python string, or None"));
1141 gdbpy_print_stack ();
1142 return EXT_LANG_RC_ERROR
;
1145 if (result
!= Py_None
)
1147 gdb::unique_xmalloc_ptr
<char>
1148 prompt (python_string_to_host_string (result
.get ()));
1152 gdbpy_print_stack ();
1153 return EXT_LANG_RC_ERROR
;
1156 set_prompt (prompt
.get ());
1157 return EXT_LANG_RC_OK
;
1162 return EXT_LANG_RC_NOP
;
1169 /* A python function to write a single string using gdb's filtered
1170 output stream . The optional keyword STREAM can be used to write
1171 to a particular stream. The default stream is to gdb_stdout. */
1174 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1177 static const char *keywords
[] = { "text", "stream", NULL
};
1178 int stream_type
= 0;
1180 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1186 switch (stream_type
)
1190 fprintf_filtered (gdb_stderr
, "%s", arg
);
1195 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1199 fprintf_filtered (gdb_stdout
, "%s", arg
);
1202 CATCH (except
, RETURN_MASK_ALL
)
1204 GDB_PY_HANDLE_EXCEPTION (except
);
1211 /* A python function to flush a gdb stream. The optional keyword
1212 STREAM can be used to flush a particular stream. The default stream
1216 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1218 static const char *keywords
[] = { "stream", NULL
};
1219 int stream_type
= 0;
1221 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1225 switch (stream_type
)
1229 gdb_flush (gdb_stderr
);
1234 gdb_flush (gdb_stdlog
);
1238 gdb_flush (gdb_stdout
);
1244 /* Return non-zero if print-stack is not "none". */
1247 gdbpy_print_python_errors_p (void)
1249 return gdbpy_should_print_stack
!= python_excp_none
;
1252 /* Print a python exception trace, print just a message, or print
1253 nothing and clear the python exception, depending on
1254 gdbpy_should_print_stack. Only call this if a python exception is
1257 gdbpy_print_stack (void)
1260 /* Print "none", just clear exception. */
1261 if (gdbpy_should_print_stack
== python_excp_none
)
1265 /* Print "full" message and backtrace. */
1266 else if (gdbpy_should_print_stack
== python_excp_full
)
1269 /* PyErr_Print doesn't necessarily end output with a newline.
1270 This works because Python's stdout/stderr is fed through
1276 CATCH (except
, RETURN_MASK_ALL
)
1281 /* Print "message", just error print message. */
1284 PyObject
*ptype
, *pvalue
, *ptraceback
;
1286 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1288 /* Fetch the error message contained within ptype, pvalue. */
1289 gdb::unique_xmalloc_ptr
<char>
1290 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1291 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1297 /* An error occurred computing the string representation of the
1299 fprintf_filtered (gdb_stderr
,
1300 _("Error occurred computing Python error" \
1304 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1305 type
.get (), msg
.get ());
1307 CATCH (except
, RETURN_MASK_ALL
)
1313 Py_XDECREF (pvalue
);
1314 Py_XDECREF (ptraceback
);
1320 /* Return the current Progspace.
1321 There always is one. */
1324 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1328 result
= pspace_to_pspace_object (current_program_space
);
1334 /* Return a sequence holding all the Progspaces. */
1337 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1339 struct program_space
*ps
;
1341 gdbpy_ref
<> list (PyList_New (0));
1347 PyObject
*item
= pspace_to_pspace_object (ps
);
1349 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1353 return list
.release ();
1358 /* The "current" objfile. This is set when gdb detects that a new
1359 objfile has been loaded. It is only set for the duration of a call to
1360 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1362 static struct objfile
*gdbpy_current_objfile
;
1364 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1365 as Python code. This does not throw any errors. If an exception
1366 occurs python will print the traceback and clear the error indicator.
1367 This is the extension_language_script_ops.objfile_script_sourcer
1371 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1372 struct objfile
*objfile
, FILE *file
,
1373 const char *filename
)
1375 if (!gdb_python_initialized
)
1378 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1379 gdbpy_current_objfile
= objfile
;
1381 python_run_simple_file (file
, filename
);
1383 gdbpy_current_objfile
= NULL
;
1386 /* Set the current objfile to OBJFILE and then execute SCRIPT
1387 as Python code. This does not throw any errors. If an exception
1388 occurs python will print the traceback and clear the error indicator.
1389 This is the extension_language_script_ops.objfile_script_executor
1393 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1394 struct objfile
*objfile
, const char *name
,
1397 if (!gdb_python_initialized
)
1400 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1401 gdbpy_current_objfile
= objfile
;
1403 PyRun_SimpleString (script
);
1405 gdbpy_current_objfile
= NULL
;
1408 /* Return the current Objfile, or None if there isn't one. */
1411 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1415 if (! gdbpy_current_objfile
)
1418 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1424 /* Return a sequence holding all the Objfiles. */
1427 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1429 struct objfile
*objf
;
1431 gdbpy_ref
<> list (PyList_New (0));
1437 PyObject
*item
= objfile_to_objfile_object (objf
);
1439 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1443 return list
.release ();
1446 /* Compute the list of active python type printers and store them in
1447 EXT_PRINTERS->py_type_printers. The product of this function is used by
1448 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1449 This is the extension_language_ops.start_type_printers "method". */
1452 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1453 struct ext_lang_type_printers
*ext_printers
)
1455 PyObject
*printers_obj
= NULL
;
1457 if (!gdb_python_initialized
)
1460 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1462 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1463 if (type_module
== NULL
)
1465 gdbpy_print_stack ();
1469 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1470 "get_type_recognizers"));
1473 gdbpy_print_stack ();
1477 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1478 if (printers_obj
== NULL
)
1479 gdbpy_print_stack ();
1481 ext_printers
->py_type_printers
= printers_obj
;
1484 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1485 a newly allocated string holding the type's replacement name, and return
1486 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1487 If there's a Python error return EXT_LANG_RC_ERROR.
1488 Otherwise, return EXT_LANG_RC_NOP.
1489 This is the extension_language_ops.apply_type_printers "method". */
1491 static enum ext_lang_rc
1492 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1493 const struct ext_lang_type_printers
*ext_printers
,
1494 struct type
*type
, char **prettied_type
)
1496 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1497 gdb::unique_xmalloc_ptr
<char> result
;
1499 if (printers_obj
== NULL
)
1500 return EXT_LANG_RC_NOP
;
1502 if (!gdb_python_initialized
)
1503 return EXT_LANG_RC_NOP
;
1505 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1507 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1508 if (type_obj
== NULL
)
1510 gdbpy_print_stack ();
1511 return EXT_LANG_RC_ERROR
;
1514 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1515 if (type_module
== NULL
)
1517 gdbpy_print_stack ();
1518 return EXT_LANG_RC_ERROR
;
1521 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1522 "apply_type_recognizers"));
1525 gdbpy_print_stack ();
1526 return EXT_LANG_RC_ERROR
;
1529 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1533 if (result_obj
== NULL
)
1535 gdbpy_print_stack ();
1536 return EXT_LANG_RC_ERROR
;
1539 if (result_obj
== Py_None
)
1540 return EXT_LANG_RC_NOP
;
1542 result
= python_string_to_host_string (result_obj
.get ());
1545 gdbpy_print_stack ();
1546 return EXT_LANG_RC_ERROR
;
1549 *prettied_type
= result
.release ();
1550 return EXT_LANG_RC_OK
;
1553 /* Free the result of start_type_printers.
1554 This is the extension_language_ops.free_type_printers "method". */
1557 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1558 struct ext_lang_type_printers
*ext_printers
)
1560 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1562 if (printers
== NULL
)
1565 if (!gdb_python_initialized
)
1568 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1569 Py_DECREF (printers
);
1572 #else /* HAVE_PYTHON */
1574 /* Dummy implementation of the gdb "python-interactive" and "python"
1578 python_interactive_command (const char *arg
, int from_tty
)
1580 arg
= skip_spaces (arg
);
1582 error (_("Python scripting is not supported in this copy of GDB."));
1585 command_line_up l
= get_command_line (python_control
, "");
1587 execute_control_command_untraced (l
.get ());
1592 python_command (const char *arg
, int from_tty
)
1594 python_interactive_command (arg
, from_tty
);
1597 #endif /* HAVE_PYTHON */
1601 /* Lists for 'set python' commands. */
1603 static struct cmd_list_element
*user_set_python_list
;
1604 static struct cmd_list_element
*user_show_python_list
;
1606 /* Function for use by 'set python' prefix command. */
1609 user_set_python (const char *args
, int from_tty
)
1611 help_list (user_set_python_list
, "set python ", all_commands
,
1615 /* Function for use by 'show python' prefix command. */
1618 user_show_python (const char *args
, int from_tty
)
1620 cmd_show_list (user_show_python_list
, from_tty
, "");
1623 /* Initialize the Python code. */
1627 /* This is installed as a final cleanup and cleans up the
1628 interpreter. This lets Python's 'atexit' work. */
1631 finalize_python (void *ignore
)
1633 struct active_ext_lang_state
*previous_active
;
1635 /* We don't use ensure_python_env here because if we ever ran the
1636 cleanup, gdb would crash -- because the cleanup calls into the
1637 Python interpreter, which we are about to destroy. It seems
1638 clearer to make the needed calls explicitly here than to create a
1639 cleanup and then mysteriously discard it. */
1641 /* This is only called as a final cleanup so we can assume the active
1642 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1643 previous_active
= set_active_ext_lang (&extension_language_python
);
1645 (void) PyGILState_Ensure ();
1646 python_gdbarch
= target_gdbarch ();
1647 python_language
= current_language
;
1651 restore_active_ext_lang (previous_active
);
1655 do_start_initialization ()
1658 size_t progsize
, count
;
1659 wchar_t *progname_copy
;
1662 #ifdef WITH_PYTHON_PATH
1663 /* Work around problem where python gets confused about where it is,
1664 and then can't find its libraries, etc.
1665 NOTE: Python assumes the following layout:
1667 /foo/lib/pythonX.Y/...
1668 This must be done before calling Py_Initialize. */
1669 gdb::unique_xmalloc_ptr
<char> progname
1670 (concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1671 SLASH_STRING
, "python", (char *) NULL
));
1673 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1674 setlocale (LC_ALL
, "");
1675 progsize
= strlen (progname
.get ());
1676 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1679 fprintf (stderr
, "out of memory\n");
1682 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1683 if (count
== (size_t) -1)
1685 fprintf (stderr
, "Could not convert python path to string\n");
1688 setlocale (LC_ALL
, oldloc
.c_str ());
1690 /* Note that Py_SetProgramName expects the string it is passed to
1691 remain alive for the duration of the program's execution, so
1692 it is not freed after this call. */
1693 Py_SetProgramName (progname_copy
);
1695 Py_SetProgramName (progname
.release ());
1700 PyEval_InitThreads ();
1703 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1704 /* Add _gdb module to the list of known built-in modules. */
1705 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1707 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1709 if (gdb_module
== NULL
)
1712 /* The casts to (char*) are for python 2.4. */
1713 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1714 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1715 (char*) host_name
) < 0
1716 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1717 (char*) target_name
) < 0)
1720 /* Add stream constants. */
1721 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1722 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1723 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1726 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1727 if (gdbpy_gdb_error
== NULL
1728 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1731 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1732 gdbpy_gdb_error
, NULL
);
1733 if (gdbpy_gdb_memory_error
== NULL
1734 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1735 gdbpy_gdb_memory_error
) < 0)
1738 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1739 if (gdbpy_gdberror_exc
== NULL
1740 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1741 gdbpy_gdberror_exc
) < 0)
1744 gdbpy_initialize_gdb_readline ();
1746 if (gdbpy_initialize_auto_load () < 0
1747 || gdbpy_initialize_values () < 0
1748 || gdbpy_initialize_frames () < 0
1749 || gdbpy_initialize_commands () < 0
1750 || gdbpy_initialize_instruction () < 0
1751 || gdbpy_initialize_record () < 0
1752 || gdbpy_initialize_btrace () < 0
1753 || gdbpy_initialize_symbols () < 0
1754 || gdbpy_initialize_symtabs () < 0
1755 || gdbpy_initialize_blocks () < 0
1756 || gdbpy_initialize_functions () < 0
1757 || gdbpy_initialize_parameters () < 0
1758 || gdbpy_initialize_types () < 0
1759 || gdbpy_initialize_pspace () < 0
1760 || gdbpy_initialize_objfile () < 0
1761 || gdbpy_initialize_breakpoints () < 0
1762 || gdbpy_initialize_finishbreakpoints () < 0
1763 || gdbpy_initialize_lazy_string () < 0
1764 || gdbpy_initialize_linetable () < 0
1765 || gdbpy_initialize_thread () < 0
1766 || gdbpy_initialize_inferior () < 0
1767 || gdbpy_initialize_events () < 0
1768 || gdbpy_initialize_eventregistry () < 0
1769 || gdbpy_initialize_py_events () < 0
1770 || gdbpy_initialize_event () < 0
1771 || gdbpy_initialize_arch () < 0
1772 || gdbpy_initialize_xmethods () < 0
1773 || gdbpy_initialize_unwind () < 0)
1776 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1777 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1779 #include "py-event-types.def"
1780 #undef GDB_PY_DEFINE_EVENT_TYPE
1782 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1783 if (gdbpy_to_string_cst
== NULL
)
1785 gdbpy_children_cst
= PyString_FromString ("children");
1786 if (gdbpy_children_cst
== NULL
)
1788 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1789 if (gdbpy_display_hint_cst
== NULL
)
1791 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1792 if (gdbpy_doc_cst
== NULL
)
1794 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1795 if (gdbpy_enabled_cst
== NULL
)
1797 gdbpy_value_cst
= PyString_FromString ("value");
1798 if (gdbpy_value_cst
== NULL
)
1801 /* Release the GIL while gdb runs. */
1802 PyThreadState_Swap (NULL
);
1803 PyEval_ReleaseLock ();
1805 make_final_cleanup (finalize_python
, NULL
);
1807 /* Only set this when initialization has succeeded. */
1808 gdb_python_initialized
= 1;
1812 #endif /* HAVE_PYTHON */
1815 _initialize_python (void)
1817 add_com ("python-interactive", class_obscure
,
1818 python_interactive_command
,
1821 Start an interactive Python prompt.\n\
1823 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1826 Alternatively, a single-line Python command can be given as an\n\
1827 argument, and if the command is an expression, the result will be\n\
1828 printed. For example:\n\
1830 (gdb) python-interactive 2 + 3\n\
1833 #else /* HAVE_PYTHON */
1835 Start a Python interactive prompt.\n\
1837 Python scripting is not supported in this copy of GDB.\n\
1838 This command is only a placeholder.")
1839 #endif /* HAVE_PYTHON */
1841 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1843 add_com ("python", class_obscure
, python_command
,
1846 Evaluate a Python command.\n\
1848 The command can be given as an argument, for instance:\n\
1852 If no argument is given, the following lines are read and used\n\
1853 as the Python commands. Type a line containing \"end\" to indicate\n\
1854 the end of the command.")
1855 #else /* HAVE_PYTHON */
1857 Evaluate a Python command.\n\
1859 Python scripting is not supported in this copy of GDB.\n\
1860 This command is only a placeholder.")
1861 #endif /* HAVE_PYTHON */
1863 add_com_alias ("py", "python", class_obscure
, 1);
1865 /* Add set/show python print-stack. */
1866 add_prefix_cmd ("python", no_class
, user_show_python
,
1867 _("Prefix command for python preference settings."),
1868 &user_show_python_list
, "show python ", 0,
1871 add_prefix_cmd ("python", no_class
, user_set_python
,
1872 _("Prefix command for python preference settings."),
1873 &user_set_python_list
, "set python ", 0,
1876 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1877 &gdbpy_should_print_stack
, _("\
1878 Set mode for Python stack dump on error."), _("\
1879 Show the mode of Python stack printing on error."), _("\
1880 none == no stack or message will be printed.\n\
1881 full == a message and a stack will be printed.\n\
1882 message == an error message without a stack will be printed."),
1884 &user_set_python_list
,
1885 &user_show_python_list
);
1888 if (!do_start_initialization () && PyErr_Occurred ())
1889 gdbpy_print_stack ();
1890 #endif /* HAVE_PYTHON */
1895 /* Helper function for gdbpy_finish_initialization. This does the
1896 work and then returns false if an error has occurred and must be
1897 displayed, or true on success. */
1900 do_finish_initialization (const struct extension_language_defn
*extlang
)
1905 /* Add the initial data-directory to sys.path. */
1907 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1910 sys_path
= PySys_GetObject ("path");
1912 /* If sys.path is not defined yet, define it first. */
1913 if (!(sys_path
&& PyList_Check (sys_path
)))
1916 PySys_SetPath (L
"");
1920 sys_path
= PySys_GetObject ("path");
1922 if (sys_path
&& PyList_Check (sys_path
))
1924 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1925 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1931 /* Import the gdb module to finish the initialization, and
1932 add it to __main__ for convenience. */
1933 m
= PyImport_AddModule ("__main__");
1937 /* Keep the reference to gdb_python_module since it is in a global
1939 gdb_python_module
= PyImport_ImportModule ("gdb");
1940 if (gdb_python_module
== NULL
)
1942 gdbpy_print_stack ();
1943 /* This is passed in one call to warning so that blank lines aren't
1944 inserted between each line of text. */
1946 "Could not load the Python gdb module from `%s'.\n"
1947 "Limited Python support is available from the _gdb module.\n"
1948 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1949 gdb_pythondir
.c_str ());
1950 /* We return "success" here as we've already emitted the
1955 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1958 /* Perform the remaining python initializations.
1959 These must be done after GDB is at least mostly initialized.
1960 E.g., The "info pretty-printer" command needs the "info" prefix
1962 This is the extension_language_ops.finish_initialization "method". */
1965 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1967 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1969 if (!do_finish_initialization (extlang
))
1971 gdbpy_print_stack ();
1972 warning (_("internal error: Unhandled Python exception"));
1976 /* Return non-zero if Python has successfully initialized.
1977 This is the extension_languages_ops.initialized "method". */
1980 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1982 return gdb_python_initialized
;
1985 #endif /* HAVE_PYTHON */
1991 PyMethodDef python_GdbMethods
[] =
1993 { "history", gdbpy_history
, METH_VARARGS
,
1994 "Get a value from history" },
1995 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1996 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1997 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1998 a Python String containing the output of the command if to_string is\n\
2000 { "parameter", gdbpy_parameter
, METH_VARARGS
,
2001 "Return a gdb parameter's value" },
2003 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
2004 "Return a tuple of all breakpoint objects" },
2006 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
2007 "Find the default visualizer for a Value." },
2009 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
2010 "Return the current Progspace." },
2011 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2012 "Return a sequence of all progspaces." },
2014 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2015 "Return the current Objfile being loaded, or None." },
2016 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
2017 "Return a sequence of all loaded objfiles." },
2019 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2020 "newest_frame () -> gdb.Frame.\n\
2021 Return the newest frame object." },
2022 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2023 "selected_frame () -> gdb.Frame.\n\
2024 Return the selected frame object." },
2025 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2026 "stop_reason_string (Integer) -> String.\n\
2027 Return a string explaining unwind stop reason." },
2029 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2030 "start_recording ([method] [, format]) -> gdb.Record.\n\
2031 Start recording with the given method. If no method is given, will fall back\n\
2032 to the system default method. If no format is given, will fall back to the\n\
2033 default format for the given method."},
2034 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2035 "current_recording () -> gdb.Record.\n\
2036 Return current recording object." },
2037 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2038 "stop_recording () -> None.\n\
2039 Stop current recording." },
2041 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2042 METH_VARARGS
| METH_KEYWORDS
,
2043 "lookup_type (name [, block]) -> type\n\
2044 Return a Type corresponding to the given name." },
2045 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2046 METH_VARARGS
| METH_KEYWORDS
,
2047 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2048 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2049 a boolean indicating if name is a field of the current implied argument\n\
2050 `this' (when the current language is object-oriented)." },
2051 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2052 METH_VARARGS
| METH_KEYWORDS
,
2053 "lookup_global_symbol (name [, domain]) -> symbol\n\
2054 Return the symbol corresponding to the given name (or None)." },
2056 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2057 METH_VARARGS
| METH_KEYWORDS
,
2058 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2059 Look up the specified objfile.\n\
2060 If by_build_id is True, the objfile is looked up by using name\n\
2061 as its build id." },
2063 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2064 "Return the block containing the given pc value, or None." },
2065 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2066 "solib_name (Long) -> String.\n\
2067 Return the name of the shared library holding a given address, or None." },
2068 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2069 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2070 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2071 The first element contains any unparsed portion of the String parameter\n\
2072 (or None if the string was fully parsed). The second element contains\n\
2073 a tuple that contains all the locations that match, represented as\n\
2074 gdb.Symtab_and_line objects (or None)."},
2075 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2076 "parse_and_eval (String) -> Value.\n\
2077 Parse String as an expression, evaluate it, and return the result as a Value."
2079 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2080 "find_pc_line (pc) -> Symtab_and_line.\n\
2081 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2083 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2084 "Post an event into gdb's event loop." },
2086 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2087 "target_charset () -> string.\n\
2088 Return the name of the current target charset." },
2089 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2090 "target_wide_charset () -> string.\n\
2091 Return the name of the current target wide charset." },
2092 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2093 "rbreak (Regex) -> List.\n\
2094 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2095 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2096 "string_to_argv (String) -> Array.\n\
2097 Parse String and return an argv-like array.\n\
2098 Arguments are separate by spaces and may be quoted."
2100 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2101 "Write a string using gdb's filtered stream." },
2102 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2103 "Flush gdb's filtered stdout stream." },
2104 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2105 "selected_thread () -> gdb.InferiorThread.\n\
2106 Return the selected thread object." },
2107 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2108 "selected_inferior () -> gdb.Inferior.\n\
2109 Return the selected inferior object." },
2110 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2111 "inferiors () -> (gdb.Inferior, ...).\n\
2112 Return a tuple containing all inferiors." },
2114 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2115 "invalidate_cached_frames () -> None.\n\
2116 Invalidate any cached frame objects in gdb.\n\
2117 Intended for internal use only." },
2119 {NULL
, NULL
, 0, NULL
}
2123 struct PyModuleDef python_GdbModuleDef
=
2125 PyModuleDef_HEAD_INIT
,
2137 /* Define all the event objects. */
2138 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2139 PyTypeObject name##_event_object_type \
2140 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2142 PyVarObject_HEAD_INIT (NULL, 0) \
2143 "gdb." py_name, /* tp_name */ \
2144 sizeof (event_object), /* tp_basicsize */ \
2145 0, /* tp_itemsize */ \
2146 evpy_dealloc, /* tp_dealloc */ \
2148 0, /* tp_getattr */ \
2149 0, /* tp_setattr */ \
2150 0, /* tp_compare */ \
2152 0, /* tp_as_number */ \
2153 0, /* tp_as_sequence */ \
2154 0, /* tp_as_mapping */ \
2158 0, /* tp_getattro */ \
2159 0, /* tp_setattro */ \
2160 0, /* tp_as_buffer */ \
2161 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2163 0, /* tp_traverse */ \
2165 0, /* tp_richcompare */ \
2166 0, /* tp_weaklistoffset */ \
2168 0, /* tp_iternext */ \
2169 0, /* tp_methods */ \
2170 0, /* tp_members */ \
2171 0, /* tp_getset */ \
2172 &base, /* tp_base */ \
2174 0, /* tp_descr_get */ \
2175 0, /* tp_descr_set */ \
2176 0, /* tp_dictoffset */ \
2180 #include "py-event-types.def"
2181 #undef GDB_PY_DEFINE_EVENT_TYPE
2183 #endif /* HAVE_PYTHON */