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_list_1
!= nullptr)
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
.get ());
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 counted_command_line 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 case var_zuinteger_unlimited
:
471 return PyLong_FromLong (* (int *) var
);
475 unsigned int val
= * (unsigned int *) var
;
479 return PyLong_FromUnsignedLong (val
);
484 unsigned int val
= * (unsigned int *) var
;
485 return PyLong_FromUnsignedLong (val
);
489 return PyErr_Format (PyExc_RuntimeError
,
490 _("Programmer error: unhandled type."));
493 /* A Python function which returns a gdb parameter's value as a Python
497 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
499 struct gdb_exception except
= exception_none
;
500 struct cmd_list_element
*alias
, *prefix
, *cmd
;
505 if (! PyArg_ParseTuple (args
, "s", &arg
))
508 newarg
= concat ("show ", arg
, (char *) NULL
);
512 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
514 CATCH (ex
, RETURN_MASK_ALL
)
521 GDB_PY_HANDLE_EXCEPTION (except
);
523 return PyErr_Format (PyExc_RuntimeError
,
524 _("Could not find parameter `%s'."), arg
);
527 return PyErr_Format (PyExc_RuntimeError
,
528 _("`%s' is not a parameter."), arg
);
529 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
532 /* Wrapper for target_charset. */
535 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
537 const char *cset
= target_charset (python_gdbarch
);
539 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
542 /* Wrapper for target_wide_charset. */
545 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
547 const char *cset
= target_wide_charset (python_gdbarch
);
549 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
552 /* A Python function which evaluates a string using the gdb CLI. */
555 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
558 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
559 int from_tty
, to_string
;
560 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
562 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
563 &PyBool_Type
, &from_tty_obj
,
564 &PyBool_Type
, &to_string_obj
))
570 int cmp
= PyObject_IsTrue (from_tty_obj
);
579 int cmp
= PyObject_IsTrue (to_string_obj
);
585 std::string to_string_res
;
589 struct interp
*interp
;
591 std::string arg_copy
= arg
;
593 char *save_ptr
= nullptr;
597 const char *result
= strtok_r (first
? &arg_copy
[0] : nullptr,
603 counted_command_line lines
= read_command_lines_1 (reader
, 1, nullptr);
606 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
,
609 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
611 /* Use the console interpreter uiout to have the same print format
612 for console or MI. */
613 interp
= interp_lookup (current_ui
, "console");
614 current_uiout
= interp
->interp_ui_out ();
616 scoped_restore preventer
= prevent_dont_repeat ();
618 to_string_res
= execute_control_commands_to_string (lines
.get (),
621 execute_control_commands (lines
.get (), from_tty
);
624 /* Do any commands attached to breakpoint we stopped at. */
625 bpstat_do_actions ();
627 CATCH (except
, RETURN_MASK_ALL
)
629 GDB_PY_HANDLE_EXCEPTION (except
);
634 return PyString_FromString (to_string_res
.c_str ());
638 /* Implementation of gdb.solib_name (Long) -> String.
639 Returns the name of the shared library holding a given address, or None. */
642 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
648 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
651 soname
= solib_name_from_address (current_program_space
, pc
);
653 str_obj
= host_string_to_python_string (soname
);
663 /* Implementation of Python rbreak command. Take a REGEX and
664 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
665 Python list that contains newly set breakpoints that match that
666 criteria. REGEX refers to a GDB format standard regex pattern of
667 symbols names to search; MINSYMS is an optional boolean (default
668 False) that indicates if the function should search GDB's minimal
669 symbols; THROTTLE is an optional integer (default unlimited) that
670 indicates the maximum amount of breakpoints allowable before the
671 function exits (note, if the throttle bound is passed, no
672 breakpoints will be set and a runtime error returned); SYMTABS is
673 an optional Python iterable that contains a set of gdb.Symtabs to
674 constrain the search within. */
677 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
679 /* A simple type to ensure clean up of a vector of allocated strings
680 when a C interface demands a const char *array[] type
682 struct symtab_list_type
686 for (const char *elem
: vec
)
687 xfree ((void *) elem
);
689 std::vector
<const char *> vec
;
693 std::vector
<symbol_search
> symbols
;
694 unsigned long count
= 0;
695 PyObject
*symtab_list
= NULL
;
696 PyObject
*minsyms_p_obj
= NULL
;
698 unsigned int throttle
= 0;
699 static const char *keywords
[] = {"regex","minsyms", "throttle",
701 symtab_list_type symtab_paths
;
703 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
704 ®ex
, &PyBool_Type
,
705 &minsyms_p_obj
, &throttle
,
709 /* Parse minsyms keyword. */
710 if (minsyms_p_obj
!= NULL
)
712 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
718 /* The "symtabs" keyword is any Python iterable object that returns
719 a gdb.Symtab on each iteration. If specified, iterate through
720 the provided gdb.Symtabs and extract their full path. As
721 python_string_to_target_string returns a
722 gdb::unique_xmalloc_ptr<char> and a vector containing these types
723 cannot be coerced to a const char **p[] via the vector.data call,
724 release the value from the unique_xmalloc_ptr and place it in a
725 simple type symtab_list_type (which holds the vector and a
726 destructor that frees the contents of the allocated strings. */
727 if (symtab_list
!= NULL
)
729 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
736 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
740 if (PyErr_Occurred ())
745 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
748 if (obj_name
== NULL
)
751 /* Is the object file still valid? */
752 if (obj_name
== Py_None
)
755 gdb::unique_xmalloc_ptr
<char> filename
=
756 python_string_to_target_string (obj_name
.get ());
758 if (filename
== NULL
)
761 /* Make sure there is a definite place to store the value of
762 filename before it is released. */
763 symtab_paths
.vec
.push_back (nullptr);
764 symtab_paths
.vec
.back () = filename
.release ();
770 const char **files
= symtab_paths
.vec
.data ();
772 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
,
773 symtab_paths
.vec
.size (), files
);
776 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, 0, NULL
);
778 /* Count the number of symbols (both symbols and optionally minimal
779 symbols) so we can correctly check the throttle limit. */
780 for (const symbol_search
&p
: symbols
)
782 /* Minimal symbols included? */
785 if (p
.msymbol
.minsym
!= NULL
)
789 if (p
.symbol
!= NULL
)
793 /* Check throttle bounds and exit if in excess. */
794 if (throttle
!= 0 && count
> throttle
)
796 PyErr_SetString (PyExc_RuntimeError
,
797 _("Number of breakpoints exceeds throttled maximum."));
801 gdbpy_ref
<> return_list (PyList_New (0));
803 if (return_list
== NULL
)
806 /* Construct full path names for symbols and call the Python
807 breakpoint constructor on the resulting names. Be tolerant of
808 individual breakpoint failures. */
809 for (const symbol_search
&p
: symbols
)
811 std::string symbol_name
;
813 /* Skipping minimal symbols? */
815 if (p
.msymbol
.minsym
!= NULL
)
818 if (p
.msymbol
.minsym
== NULL
)
820 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
821 const char *fullname
= symtab_to_fullname (symtab
);
823 symbol_name
= fullname
;
825 symbol_name
+= SYMBOL_LINKAGE_NAME (p
.symbol
);
828 symbol_name
= MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
);
830 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
831 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
832 &breakpoint_object_type
,
835 /* Tolerate individual breakpoint failures. */
837 gdbpy_print_stack ();
840 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
844 return return_list
.release ();
847 /* A Python function which is a wrapper for decode_line_1. */
850 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
852 const char *arg
= NULL
;
854 gdbpy_ref
<> unparsed
;
855 event_location_up location
;
857 if (! PyArg_ParseTuple (args
, "|s", &arg
))
861 location
= string_to_event_location_basic (&arg
, python_language
,
862 symbol_name_match_type::WILD
);
864 std::vector
<symtab_and_line
> decoded_sals
;
865 symtab_and_line def_sal
;
866 gdb::array_view
<symtab_and_line
> sals
;
869 if (location
!= NULL
)
871 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
876 set_default_source_symtab_and_line ();
877 def_sal
= get_current_source_symtab_and_line ();
881 CATCH (ex
, RETURN_MASK_ALL
)
883 /* We know this will always throw. */
884 gdbpy_convert_exception (ex
);
891 result
.reset (PyTuple_New (sals
.size ()));
894 for (size_t i
= 0; i
< sals
.size (); ++i
)
896 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
900 PyTuple_SetItem (result
.get (), i
, obj
);
904 result
= gdbpy_ref
<>::new_reference (Py_None
);
906 gdbpy_ref
<> return_result (PyTuple_New (2));
907 if (return_result
== NULL
)
910 if (arg
!= NULL
&& strlen (arg
) > 0)
912 unparsed
.reset (PyString_FromString (arg
));
913 if (unparsed
== NULL
)
917 unparsed
= gdbpy_ref
<>::new_reference (Py_None
);
919 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
920 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
922 return return_result
.release ();
925 /* Parse a string and evaluate it as an expression. */
927 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
929 const char *expr_str
;
930 struct value
*result
= NULL
;
932 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
937 result
= parse_and_eval (expr_str
);
939 CATCH (except
, RETURN_MASK_ALL
)
941 GDB_PY_HANDLE_EXCEPTION (except
);
945 return value_to_value_object (result
);
948 /* Implementation of gdb.find_pc_line function.
949 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
952 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
954 gdb_py_ulongest pc_llu
;
955 PyObject
*result
= NULL
; /* init for gcc -Wall */
957 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
962 struct symtab_and_line sal
;
965 pc
= (CORE_ADDR
) pc_llu
;
966 sal
= find_pc_line (pc
, 0);
967 result
= symtab_and_line_to_sal_object (sal
);
969 CATCH (except
, RETURN_MASK_ALL
)
971 GDB_PY_HANDLE_EXCEPTION (except
);
978 /* Implementation of gdb.invalidate_cached_frames. */
981 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
983 reinit_frame_cache ();
987 /* Read a file as Python code.
988 This is the extension_language_script_ops.script_sourcer "method".
989 FILE is the file to load. FILENAME is name of the file FILE.
990 This does not throw any errors. If an exception occurs python will print
991 the traceback and clear the error indicator. */
994 gdbpy_source_script (const struct extension_language_defn
*extlang
,
995 FILE *file
, const char *filename
)
997 gdbpy_enter
enter_py (get_current_arch (), current_language
);
998 python_run_simple_file (file
, filename
);
1003 /* Posting and handling events. */
1005 /* A single event. */
1008 /* The Python event. This is just a callable object. */
1010 /* The next event. */
1011 struct gdbpy_event
*next
;
1014 /* All pending events. */
1015 static struct gdbpy_event
*gdbpy_event_list
;
1016 /* The final link of the event list. */
1017 static struct gdbpy_event
**gdbpy_event_list_end
;
1019 /* So that we can wake up the main thread even when it is blocked in
1021 static struct serial_event
*gdbpy_serial_event
;
1023 /* The file handler callback. This reads from the internal pipe, and
1024 then processes the Python event queue. This will always be run in
1025 the main gdb thread. */
1028 gdbpy_run_events (int error
, gdb_client_data client_data
)
1030 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1032 /* Clear the event fd. Do this before flushing the events list, so
1033 that any new event post afterwards is sure to re-awake the event
1035 serial_event_clear (gdbpy_serial_event
);
1037 while (gdbpy_event_list
)
1039 /* Dispatching the event might push a new element onto the event
1040 loop, so we update here "atomically enough". */
1041 struct gdbpy_event
*item
= gdbpy_event_list
;
1042 gdbpy_event_list
= gdbpy_event_list
->next
;
1043 if (gdbpy_event_list
== NULL
)
1044 gdbpy_event_list_end
= &gdbpy_event_list
;
1046 /* Ignore errors. */
1047 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
1048 if (call_result
== NULL
)
1051 Py_DECREF (item
->event
);
1056 /* Submit an event to the gdb thread. */
1058 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1060 struct gdbpy_event
*event
;
1064 if (!PyArg_ParseTuple (args
, "O", &func
))
1067 if (!PyCallable_Check (func
))
1069 PyErr_SetString (PyExc_RuntimeError
,
1070 _("Posted event is not callable"));
1076 /* From here until the end of the function, we have the GIL, so we
1077 can operate on our global data structures without worrying. */
1078 wakeup
= gdbpy_event_list
== NULL
;
1080 event
= XNEW (struct gdbpy_event
);
1081 event
->event
= func
;
1083 *gdbpy_event_list_end
= event
;
1084 gdbpy_event_list_end
= &event
->next
;
1086 /* Wake up gdb when needed. */
1088 serial_event_set (gdbpy_serial_event
);
1093 /* Initialize the Python event handler. */
1095 gdbpy_initialize_events (void)
1097 gdbpy_event_list_end
= &gdbpy_event_list
;
1099 gdbpy_serial_event
= make_serial_event ();
1100 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1101 gdbpy_run_events
, NULL
);
1108 /* This is the extension_language_ops.before_prompt "method". */
1110 static enum ext_lang_rc
1111 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1112 const char *current_gdb_prompt
)
1114 if (!gdb_python_initialized
)
1115 return EXT_LANG_RC_NOP
;
1117 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1119 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1120 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1121 return EXT_LANG_RC_ERROR
;
1123 if (gdb_python_module
1124 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1126 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1130 gdbpy_print_stack ();
1131 return EXT_LANG_RC_ERROR
;
1134 if (PyCallable_Check (hook
.get ()))
1136 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1137 if (current_prompt
== NULL
)
1139 gdbpy_print_stack ();
1140 return EXT_LANG_RC_ERROR
;
1144 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1148 gdbpy_print_stack ();
1149 return EXT_LANG_RC_ERROR
;
1152 /* Return type should be None, or a String. If it is None,
1153 fall through, we will not set a prompt. If it is a
1154 string, set PROMPT. Anything else, set an exception. */
1155 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1157 PyErr_Format (PyExc_RuntimeError
,
1158 _("Return from prompt_hook must " \
1159 "be either a Python string, or None"));
1160 gdbpy_print_stack ();
1161 return EXT_LANG_RC_ERROR
;
1164 if (result
!= Py_None
)
1166 gdb::unique_xmalloc_ptr
<char>
1167 prompt (python_string_to_host_string (result
.get ()));
1171 gdbpy_print_stack ();
1172 return EXT_LANG_RC_ERROR
;
1175 set_prompt (prompt
.get ());
1176 return EXT_LANG_RC_OK
;
1181 return EXT_LANG_RC_NOP
;
1188 /* A python function to write a single string using gdb's filtered
1189 output stream . The optional keyword STREAM can be used to write
1190 to a particular stream. The default stream is to gdb_stdout. */
1193 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1196 static const char *keywords
[] = { "text", "stream", NULL
};
1197 int stream_type
= 0;
1199 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1205 switch (stream_type
)
1209 fprintf_filtered (gdb_stderr
, "%s", arg
);
1214 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1218 fprintf_filtered (gdb_stdout
, "%s", arg
);
1221 CATCH (except
, RETURN_MASK_ALL
)
1223 GDB_PY_HANDLE_EXCEPTION (except
);
1230 /* A python function to flush a gdb stream. The optional keyword
1231 STREAM can be used to flush a particular stream. The default stream
1235 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1237 static const char *keywords
[] = { "stream", NULL
};
1238 int stream_type
= 0;
1240 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1244 switch (stream_type
)
1248 gdb_flush (gdb_stderr
);
1253 gdb_flush (gdb_stdlog
);
1257 gdb_flush (gdb_stdout
);
1263 /* Return non-zero if print-stack is not "none". */
1266 gdbpy_print_python_errors_p (void)
1268 return gdbpy_should_print_stack
!= python_excp_none
;
1271 /* Print a python exception trace, print just a message, or print
1272 nothing and clear the python exception, depending on
1273 gdbpy_should_print_stack. Only call this if a python exception is
1276 gdbpy_print_stack (void)
1279 /* Print "none", just clear exception. */
1280 if (gdbpy_should_print_stack
== python_excp_none
)
1284 /* Print "full" message and backtrace. */
1285 else if (gdbpy_should_print_stack
== python_excp_full
)
1288 /* PyErr_Print doesn't necessarily end output with a newline.
1289 This works because Python's stdout/stderr is fed through
1295 CATCH (except
, RETURN_MASK_ALL
)
1300 /* Print "message", just error print message. */
1303 PyObject
*ptype
, *pvalue
, *ptraceback
;
1305 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1307 /* Fetch the error message contained within ptype, pvalue. */
1308 gdb::unique_xmalloc_ptr
<char>
1309 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1310 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1316 /* An error occurred computing the string representation of the
1318 fprintf_filtered (gdb_stderr
,
1319 _("Error occurred computing Python error" \
1323 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1324 type
.get (), msg
.get ());
1326 CATCH (except
, RETURN_MASK_ALL
)
1332 Py_XDECREF (pvalue
);
1333 Py_XDECREF (ptraceback
);
1339 /* Return the current Progspace.
1340 There always is one. */
1343 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1347 result
= pspace_to_pspace_object (current_program_space
);
1353 /* Return a sequence holding all the Progspaces. */
1356 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1358 struct program_space
*ps
;
1360 gdbpy_ref
<> list (PyList_New (0));
1366 PyObject
*item
= pspace_to_pspace_object (ps
);
1368 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1372 return list
.release ();
1377 /* The "current" objfile. This is set when gdb detects that a new
1378 objfile has been loaded. It is only set for the duration of a call to
1379 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1381 static struct objfile
*gdbpy_current_objfile
;
1383 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1384 as Python code. This does not throw any errors. If an exception
1385 occurs python will print the traceback and clear the error indicator.
1386 This is the extension_language_script_ops.objfile_script_sourcer
1390 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1391 struct objfile
*objfile
, FILE *file
,
1392 const char *filename
)
1394 if (!gdb_python_initialized
)
1397 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1398 gdbpy_current_objfile
= objfile
;
1400 python_run_simple_file (file
, filename
);
1402 gdbpy_current_objfile
= NULL
;
1405 /* Set the current objfile to OBJFILE and then execute SCRIPT
1406 as Python code. This does not throw any errors. If an exception
1407 occurs python will print the traceback and clear the error indicator.
1408 This is the extension_language_script_ops.objfile_script_executor
1412 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1413 struct objfile
*objfile
, const char *name
,
1416 if (!gdb_python_initialized
)
1419 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1420 gdbpy_current_objfile
= objfile
;
1422 PyRun_SimpleString (script
);
1424 gdbpy_current_objfile
= NULL
;
1427 /* Return the current Objfile, or None if there isn't one. */
1430 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1434 if (! gdbpy_current_objfile
)
1437 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1443 /* See python-internal.h. */
1446 build_objfiles_list (program_space
*pspace
)
1448 struct objfile
*objf
;
1450 gdbpy_ref
<> list (PyList_New (0));
1454 ALL_PSPACE_OBJFILES (pspace
, objf
)
1456 PyObject
*item
= objfile_to_objfile_object (objf
);
1458 if (item
== nullptr || PyList_Append (list
.get (), item
) == -1)
1465 /* Return a sequence holding all the Objfiles. */
1468 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1470 return build_objfiles_list (current_program_space
).release ();
1473 /* Compute the list of active python type printers and store them in
1474 EXT_PRINTERS->py_type_printers. The product of this function is used by
1475 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1476 This is the extension_language_ops.start_type_printers "method". */
1479 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1480 struct ext_lang_type_printers
*ext_printers
)
1482 PyObject
*printers_obj
= NULL
;
1484 if (!gdb_python_initialized
)
1487 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1489 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1490 if (type_module
== NULL
)
1492 gdbpy_print_stack ();
1496 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1497 "get_type_recognizers"));
1500 gdbpy_print_stack ();
1504 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1505 if (printers_obj
== NULL
)
1506 gdbpy_print_stack ();
1508 ext_printers
->py_type_printers
= printers_obj
;
1511 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1512 a newly allocated string holding the type's replacement name, and return
1513 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1514 If there's a Python error return EXT_LANG_RC_ERROR.
1515 Otherwise, return EXT_LANG_RC_NOP.
1516 This is the extension_language_ops.apply_type_printers "method". */
1518 static enum ext_lang_rc
1519 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1520 const struct ext_lang_type_printers
*ext_printers
,
1521 struct type
*type
, char **prettied_type
)
1523 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1524 gdb::unique_xmalloc_ptr
<char> result
;
1526 if (printers_obj
== NULL
)
1527 return EXT_LANG_RC_NOP
;
1529 if (!gdb_python_initialized
)
1530 return EXT_LANG_RC_NOP
;
1532 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1534 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1535 if (type_obj
== NULL
)
1537 gdbpy_print_stack ();
1538 return EXT_LANG_RC_ERROR
;
1541 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1542 if (type_module
== NULL
)
1544 gdbpy_print_stack ();
1545 return EXT_LANG_RC_ERROR
;
1548 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1549 "apply_type_recognizers"));
1552 gdbpy_print_stack ();
1553 return EXT_LANG_RC_ERROR
;
1556 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1560 if (result_obj
== NULL
)
1562 gdbpy_print_stack ();
1563 return EXT_LANG_RC_ERROR
;
1566 if (result_obj
== Py_None
)
1567 return EXT_LANG_RC_NOP
;
1569 result
= python_string_to_host_string (result_obj
.get ());
1572 gdbpy_print_stack ();
1573 return EXT_LANG_RC_ERROR
;
1576 *prettied_type
= result
.release ();
1577 return EXT_LANG_RC_OK
;
1580 /* Free the result of start_type_printers.
1581 This is the extension_language_ops.free_type_printers "method". */
1584 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1585 struct ext_lang_type_printers
*ext_printers
)
1587 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1589 if (printers
== NULL
)
1592 if (!gdb_python_initialized
)
1595 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1596 Py_DECREF (printers
);
1599 #else /* HAVE_PYTHON */
1601 /* Dummy implementation of the gdb "python-interactive" and "python"
1605 python_interactive_command (const char *arg
, int from_tty
)
1607 arg
= skip_spaces (arg
);
1609 error (_("Python scripting is not supported in this copy of GDB."));
1612 counted_command_line l
= get_command_line (python_control
, "");
1614 execute_control_command_untraced (l
.get ());
1619 python_command (const char *arg
, int from_tty
)
1621 python_interactive_command (arg
, from_tty
);
1624 #endif /* HAVE_PYTHON */
1628 /* Lists for 'set python' commands. */
1630 static struct cmd_list_element
*user_set_python_list
;
1631 static struct cmd_list_element
*user_show_python_list
;
1633 /* Function for use by 'set python' prefix command. */
1636 user_set_python (const char *args
, int from_tty
)
1638 help_list (user_set_python_list
, "set python ", all_commands
,
1642 /* Function for use by 'show python' prefix command. */
1645 user_show_python (const char *args
, int from_tty
)
1647 cmd_show_list (user_show_python_list
, from_tty
, "");
1650 /* Initialize the Python code. */
1654 /* This is installed as a final cleanup and cleans up the
1655 interpreter. This lets Python's 'atexit' work. */
1658 finalize_python (void *ignore
)
1660 struct active_ext_lang_state
*previous_active
;
1662 /* We don't use ensure_python_env here because if we ever ran the
1663 cleanup, gdb would crash -- because the cleanup calls into the
1664 Python interpreter, which we are about to destroy. It seems
1665 clearer to make the needed calls explicitly here than to create a
1666 cleanup and then mysteriously discard it. */
1668 /* This is only called as a final cleanup so we can assume the active
1669 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1670 previous_active
= set_active_ext_lang (&extension_language_python
);
1672 (void) PyGILState_Ensure ();
1673 python_gdbarch
= target_gdbarch ();
1674 python_language
= current_language
;
1678 restore_active_ext_lang (previous_active
);
1682 /* This is called via the PyImport_AppendInittab mechanism called
1683 during initialization, to make the built-in _gdb module known to
1686 init__gdb_module (void)
1688 return PyModule_Create (&python_GdbModuleDef
);
1693 do_start_initialization ()
1696 size_t progsize
, count
;
1697 wchar_t *progname_copy
;
1700 #ifdef WITH_PYTHON_PATH
1701 /* Work around problem where python gets confused about where it is,
1702 and then can't find its libraries, etc.
1703 NOTE: Python assumes the following layout:
1705 /foo/lib/pythonX.Y/...
1706 This must be done before calling Py_Initialize. */
1707 gdb::unique_xmalloc_ptr
<char> progname
1708 (concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1709 SLASH_STRING
, "python", (char *) NULL
));
1711 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1712 setlocale (LC_ALL
, "");
1713 progsize
= strlen (progname
.get ());
1714 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1717 fprintf (stderr
, "out of memory\n");
1720 count
= mbstowcs (progname_copy
, progname
.get (), progsize
+ 1);
1721 if (count
== (size_t) -1)
1723 fprintf (stderr
, "Could not convert python path to string\n");
1726 setlocale (LC_ALL
, oldloc
.c_str ());
1728 /* Note that Py_SetProgramName expects the string it is passed to
1729 remain alive for the duration of the program's execution, so
1730 it is not freed after this call. */
1731 Py_SetProgramName (progname_copy
);
1733 /* Define _gdb as a built-in module. */
1734 PyImport_AppendInittab ("_gdb", init__gdb_module
);
1736 Py_SetProgramName (progname
.release ());
1741 PyEval_InitThreads ();
1744 gdb_module
= PyImport_ImportModule ("_gdb");
1746 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1748 if (gdb_module
== NULL
)
1751 /* The casts to (char*) are for python 2.4. */
1752 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1753 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1754 (char*) host_name
) < 0
1755 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1756 (char*) target_name
) < 0)
1759 /* Add stream constants. */
1760 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1761 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1762 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1765 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1766 if (gdbpy_gdb_error
== NULL
1767 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1770 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1771 gdbpy_gdb_error
, NULL
);
1772 if (gdbpy_gdb_memory_error
== NULL
1773 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1774 gdbpy_gdb_memory_error
) < 0)
1777 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1778 if (gdbpy_gdberror_exc
== NULL
1779 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1780 gdbpy_gdberror_exc
) < 0)
1783 gdbpy_initialize_gdb_readline ();
1785 if (gdbpy_initialize_auto_load () < 0
1786 || gdbpy_initialize_values () < 0
1787 || gdbpy_initialize_frames () < 0
1788 || gdbpy_initialize_commands () < 0
1789 || gdbpy_initialize_instruction () < 0
1790 || gdbpy_initialize_record () < 0
1791 || gdbpy_initialize_btrace () < 0
1792 || gdbpy_initialize_symbols () < 0
1793 || gdbpy_initialize_symtabs () < 0
1794 || gdbpy_initialize_blocks () < 0
1795 || gdbpy_initialize_functions () < 0
1796 || gdbpy_initialize_parameters () < 0
1797 || gdbpy_initialize_types () < 0
1798 || gdbpy_initialize_pspace () < 0
1799 || gdbpy_initialize_objfile () < 0
1800 || gdbpy_initialize_breakpoints () < 0
1801 || gdbpy_initialize_finishbreakpoints () < 0
1802 || gdbpy_initialize_lazy_string () < 0
1803 || gdbpy_initialize_linetable () < 0
1804 || gdbpy_initialize_thread () < 0
1805 || gdbpy_initialize_inferior () < 0
1806 || gdbpy_initialize_events () < 0
1807 || gdbpy_initialize_eventregistry () < 0
1808 || gdbpy_initialize_py_events () < 0
1809 || gdbpy_initialize_event () < 0
1810 || gdbpy_initialize_arch () < 0
1811 || gdbpy_initialize_xmethods () < 0
1812 || gdbpy_initialize_unwind () < 0)
1815 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1816 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1818 #include "py-event-types.def"
1819 #undef GDB_PY_DEFINE_EVENT_TYPE
1821 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1822 if (gdbpy_to_string_cst
== NULL
)
1824 gdbpy_children_cst
= PyString_FromString ("children");
1825 if (gdbpy_children_cst
== NULL
)
1827 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1828 if (gdbpy_display_hint_cst
== NULL
)
1830 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1831 if (gdbpy_doc_cst
== NULL
)
1833 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1834 if (gdbpy_enabled_cst
== NULL
)
1836 gdbpy_value_cst
= PyString_FromString ("value");
1837 if (gdbpy_value_cst
== NULL
)
1840 /* Release the GIL while gdb runs. */
1841 PyThreadState_Swap (NULL
);
1842 PyEval_ReleaseLock ();
1844 make_final_cleanup (finalize_python
, NULL
);
1846 /* Only set this when initialization has succeeded. */
1847 gdb_python_initialized
= 1;
1851 #endif /* HAVE_PYTHON */
1854 _initialize_python (void)
1856 add_com ("python-interactive", class_obscure
,
1857 python_interactive_command
,
1860 Start an interactive Python prompt.\n\
1862 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1865 Alternatively, a single-line Python command can be given as an\n\
1866 argument, and if the command is an expression, the result will be\n\
1867 printed. For example:\n\
1869 (gdb) python-interactive 2 + 3\n\
1872 #else /* HAVE_PYTHON */
1874 Start a Python interactive prompt.\n\
1876 Python scripting is not supported in this copy of GDB.\n\
1877 This command is only a placeholder.")
1878 #endif /* HAVE_PYTHON */
1880 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1882 add_com ("python", class_obscure
, python_command
,
1885 Evaluate a Python command.\n\
1887 The command can be given as an argument, for instance:\n\
1889 python print (23)\n\
1891 If no argument is given, the following lines are read and used\n\
1892 as the Python commands. Type a line containing \"end\" to indicate\n\
1893 the end of the command.")
1894 #else /* HAVE_PYTHON */
1896 Evaluate a Python command.\n\
1898 Python scripting is not supported in this copy of GDB.\n\
1899 This command is only a placeholder.")
1900 #endif /* HAVE_PYTHON */
1902 add_com_alias ("py", "python", class_obscure
, 1);
1904 /* Add set/show python print-stack. */
1905 add_prefix_cmd ("python", no_class
, user_show_python
,
1906 _("Prefix command for python preference settings."),
1907 &user_show_python_list
, "show python ", 0,
1910 add_prefix_cmd ("python", no_class
, user_set_python
,
1911 _("Prefix command for python preference settings."),
1912 &user_set_python_list
, "set python ", 0,
1915 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1916 &gdbpy_should_print_stack
, _("\
1917 Set mode for Python stack dump on error."), _("\
1918 Show the mode of Python stack printing on error."), _("\
1919 none == no stack or message will be printed.\n\
1920 full == a message and a stack will be printed.\n\
1921 message == an error message without a stack will be printed."),
1923 &user_set_python_list
,
1924 &user_show_python_list
);
1927 if (!do_start_initialization () && PyErr_Occurred ())
1928 gdbpy_print_stack ();
1929 #endif /* HAVE_PYTHON */
1934 /* Helper function for gdbpy_finish_initialization. This does the
1935 work and then returns false if an error has occurred and must be
1936 displayed, or true on success. */
1939 do_finish_initialization (const struct extension_language_defn
*extlang
)
1944 /* Add the initial data-directory to sys.path. */
1946 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1949 sys_path
= PySys_GetObject ("path");
1951 /* If sys.path is not defined yet, define it first. */
1952 if (!(sys_path
&& PyList_Check (sys_path
)))
1955 PySys_SetPath (L
"");
1959 sys_path
= PySys_GetObject ("path");
1961 if (sys_path
&& PyList_Check (sys_path
))
1963 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1964 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1970 /* Import the gdb module to finish the initialization, and
1971 add it to __main__ for convenience. */
1972 m
= PyImport_AddModule ("__main__");
1976 /* Keep the reference to gdb_python_module since it is in a global
1978 gdb_python_module
= PyImport_ImportModule ("gdb");
1979 if (gdb_python_module
== NULL
)
1981 gdbpy_print_stack ();
1982 /* This is passed in one call to warning so that blank lines aren't
1983 inserted between each line of text. */
1985 "Could not load the Python gdb module from `%s'.\n"
1986 "Limited Python support is available from the _gdb module.\n"
1987 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1988 gdb_pythondir
.c_str ());
1989 /* We return "success" here as we've already emitted the
1994 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1997 /* Perform the remaining python initializations.
1998 These must be done after GDB is at least mostly initialized.
1999 E.g., The "info pretty-printer" command needs the "info" prefix
2001 This is the extension_language_ops.finish_initialization "method". */
2004 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
2006 gdbpy_enter
enter_py (get_current_arch (), current_language
);
2008 if (!do_finish_initialization (extlang
))
2010 gdbpy_print_stack ();
2011 warning (_("internal error: Unhandled Python exception"));
2015 /* Return non-zero if Python has successfully initialized.
2016 This is the extension_languages_ops.initialized "method". */
2019 gdbpy_initialized (const struct extension_language_defn
*extlang
)
2021 return gdb_python_initialized
;
2024 #endif /* HAVE_PYTHON */
2030 PyMethodDef python_GdbMethods
[] =
2032 { "history", gdbpy_history
, METH_VARARGS
,
2033 "Get a value from history" },
2034 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
2035 "execute (command [, from_tty] [, to_string]) -> [String]\n\
2036 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
2037 a Python String containing the output of the command if to_string is\n\
2039 { "parameter", gdbpy_parameter
, METH_VARARGS
,
2040 "Return a gdb parameter's value" },
2042 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
2043 "Return a tuple of all breakpoint objects" },
2045 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
2046 "Find the default visualizer for a Value." },
2048 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
2049 "Return the current Progspace." },
2050 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2051 "Return a sequence of all progspaces." },
2053 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2054 "Return the current Objfile being loaded, or None." },
2055 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
2056 "Return a sequence of all loaded objfiles." },
2058 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2059 "newest_frame () -> gdb.Frame.\n\
2060 Return the newest frame object." },
2061 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2062 "selected_frame () -> gdb.Frame.\n\
2063 Return the selected frame object." },
2064 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2065 "stop_reason_string (Integer) -> String.\n\
2066 Return a string explaining unwind stop reason." },
2068 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2069 "start_recording ([method] [, format]) -> gdb.Record.\n\
2070 Start recording with the given method. If no method is given, will fall back\n\
2071 to the system default method. If no format is given, will fall back to the\n\
2072 default format for the given method."},
2073 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2074 "current_recording () -> gdb.Record.\n\
2075 Return current recording object." },
2076 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2077 "stop_recording () -> None.\n\
2078 Stop current recording." },
2080 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2081 METH_VARARGS
| METH_KEYWORDS
,
2082 "lookup_type (name [, block]) -> type\n\
2083 Return a Type corresponding to the given name." },
2084 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2085 METH_VARARGS
| METH_KEYWORDS
,
2086 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2087 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2088 a boolean indicating if name is a field of the current implied argument\n\
2089 `this' (when the current language is object-oriented)." },
2090 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2091 METH_VARARGS
| METH_KEYWORDS
,
2092 "lookup_global_symbol (name [, domain]) -> symbol\n\
2093 Return the symbol corresponding to the given name (or None)." },
2095 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2096 METH_VARARGS
| METH_KEYWORDS
,
2097 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2098 Look up the specified objfile.\n\
2099 If by_build_id is True, the objfile is looked up by using name\n\
2100 as its build id." },
2102 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2103 "Return the block containing the given pc value, or None." },
2104 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2105 "solib_name (Long) -> String.\n\
2106 Return the name of the shared library holding a given address, or None." },
2107 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2108 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2109 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2110 The first element contains any unparsed portion of the String parameter\n\
2111 (or None if the string was fully parsed). The second element contains\n\
2112 a tuple that contains all the locations that match, represented as\n\
2113 gdb.Symtab_and_line objects (or None)."},
2114 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2115 "parse_and_eval (String) -> Value.\n\
2116 Parse String as an expression, evaluate it, and return the result as a Value."
2118 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2119 "find_pc_line (pc) -> Symtab_and_line.\n\
2120 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2122 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2123 "Post an event into gdb's event loop." },
2125 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2126 "target_charset () -> string.\n\
2127 Return the name of the current target charset." },
2128 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2129 "target_wide_charset () -> string.\n\
2130 Return the name of the current target wide charset." },
2131 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2132 "rbreak (Regex) -> List.\n\
2133 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2134 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2135 "string_to_argv (String) -> Array.\n\
2136 Parse String and return an argv-like array.\n\
2137 Arguments are separate by spaces and may be quoted."
2139 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2140 "Write a string using gdb's filtered stream." },
2141 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2142 "Flush gdb's filtered stdout stream." },
2143 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2144 "selected_thread () -> gdb.InferiorThread.\n\
2145 Return the selected thread object." },
2146 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2147 "selected_inferior () -> gdb.Inferior.\n\
2148 Return the selected inferior object." },
2149 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2150 "inferiors () -> (gdb.Inferior, ...).\n\
2151 Return a tuple containing all inferiors." },
2153 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2154 "invalidate_cached_frames () -> None.\n\
2155 Invalidate any cached frame objects in gdb.\n\
2156 Intended for internal use only." },
2158 { "convenience_variable", gdbpy_convenience_variable
, METH_VARARGS
,
2159 "convenience_variable (NAME) -> value.\n\
2160 Return the value of the convenience variable $NAME,\n\
2161 or None if not set." },
2162 { "set_convenience_variable", gdbpy_set_convenience_variable
, METH_VARARGS
,
2163 "convenience_variable (NAME, VALUE) -> None.\n\
2164 Set the value of the convenience variable $NAME." },
2166 {NULL
, NULL
, 0, NULL
}
2170 struct PyModuleDef python_GdbModuleDef
=
2172 PyModuleDef_HEAD_INIT
,
2184 /* Define all the event objects. */
2185 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2186 PyTypeObject name##_event_object_type \
2187 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2189 PyVarObject_HEAD_INIT (NULL, 0) \
2190 "gdb." py_name, /* tp_name */ \
2191 sizeof (event_object), /* tp_basicsize */ \
2192 0, /* tp_itemsize */ \
2193 evpy_dealloc, /* tp_dealloc */ \
2195 0, /* tp_getattr */ \
2196 0, /* tp_setattr */ \
2197 0, /* tp_compare */ \
2199 0, /* tp_as_number */ \
2200 0, /* tp_as_sequence */ \
2201 0, /* tp_as_mapping */ \
2205 0, /* tp_getattro */ \
2206 0, /* tp_setattro */ \
2207 0, /* tp_as_buffer */ \
2208 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2210 0, /* tp_traverse */ \
2212 0, /* tp_richcompare */ \
2213 0, /* tp_weaklistoffset */ \
2215 0, /* tp_iternext */ \
2216 0, /* tp_methods */ \
2217 0, /* tp_members */ \
2218 0, /* tp_getset */ \
2219 &base, /* tp_base */ \
2221 0, /* tp_descr_get */ \
2222 0, /* tp_descr_set */ \
2223 0, /* tp_dictoffset */ \
2227 #include "py-event-types.def"
2228 #undef GDB_PY_DEFINE_EVENT_TYPE
2230 #endif /* HAVE_PYTHON */