1 /* General python/gdb code
3 Copyright (C) 2008-2017 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_clone_xmethod_worker_data
,
194 gdbpy_free_xmethod_worker_data
,
195 gdbpy_get_matching_xmethod_workers
,
196 gdbpy_get_xmethod_arg_types
,
197 gdbpy_get_xmethod_result_type
,
201 /* Architecture and language to be used in callbacks from
202 the Python interpreter. */
203 struct gdbarch
*python_gdbarch
;
204 const struct language_defn
*python_language
;
206 gdbpy_enter::gdbpy_enter (struct gdbarch
*gdbarch
,
207 const struct language_defn
*language
)
208 : m_gdbarch (python_gdbarch
),
209 m_language (python_language
)
211 /* We should not ever enter Python unless initialized. */
212 if (!gdb_python_initialized
)
213 error (_("Python not initialized"));
215 m_previous_active
= set_active_ext_lang (&extension_language_python
);
217 m_state
= PyGILState_Ensure ();
219 python_gdbarch
= gdbarch
;
220 python_language
= language
;
222 /* Save it and ensure ! PyErr_Occurred () afterwards. */
223 PyErr_Fetch (&m_error_type
, &m_error_value
, &m_error_traceback
);
226 gdbpy_enter::~gdbpy_enter ()
228 /* Leftover Python error is forbidden by Python Exception Handling. */
229 if (PyErr_Occurred ())
231 /* This order is similar to the one calling error afterwards. */
232 gdbpy_print_stack ();
233 warning (_("internal error: Unhandled Python exception"));
236 PyErr_Restore (m_error_type
, m_error_value
, m_error_traceback
);
238 PyGILState_Release (m_state
);
239 python_gdbarch
= m_gdbarch
;
240 python_language
= m_language
;
242 restore_active_ext_lang (m_previous_active
);
245 /* Set the quit flag. */
248 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
250 PyErr_SetInterrupt ();
253 /* Return true if the quit flag has been set, false otherwise. */
256 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
258 return PyOS_InterruptOccurred ();
261 /* Evaluate a Python command like PyRun_SimpleString, but uses
262 Py_single_input which prints the result of expressions, and does
263 not automatically print the stack on errors. */
266 eval_python_command (const char *command
)
270 m
= PyImport_AddModule ("__main__");
274 d
= PyModule_GetDict (m
);
277 gdbpy_ref
<> v (PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
));
289 /* Implementation of the gdb "python-interactive" command. */
292 python_interactive_command (const char *arg
, int from_tty
)
294 struct ui
*ui
= current_ui
;
297 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
299 arg
= skip_spaces (arg
);
301 gdbpy_enter
enter_py (get_current_arch (), current_language
);
305 int len
= strlen (arg
);
306 char *script
= (char *) xmalloc (len
+ 2);
308 strcpy (script
, arg
);
310 script
[len
+ 1] = '\0';
311 err
= eval_python_command (script
);
316 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
322 gdbpy_print_stack ();
323 error (_("Error while executing Python code."));
327 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
330 On Windows hosts few users would build Python themselves (this is no
331 trivial task on this platform), and thus use binaries built by
332 someone else instead. There may happen situation where the Python
333 library and GDB are using two different versions of the C runtime
334 library. Python, being built with VC, would use one version of the
335 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
336 A FILE * from one runtime does not necessarily operate correctly in
339 To work around this potential issue, we create on Windows hosts the
340 FILE object using Python routines, thus making sure that it is
341 compatible with the Python library. */
344 python_run_simple_file (FILE *file
, const char *filename
)
348 PyRun_SimpleFile (file
, filename
);
352 /* Because we have a string for a filename, and are using Python to
353 open the file, we need to expand any tilde in the path first. */
354 gdb::unique_xmalloc_ptr
<char> full_path (tilde_expand (filename
));
355 gdbpy_ref
<> python_file (PyFile_FromString (full_path
.get (), (char *) "r"));
356 if (python_file
== NULL
)
358 gdbpy_print_stack ();
359 error (_("Error while opening file: %s"), full_path
.get ());
362 PyRun_SimpleFile (PyFile_AsFile (python_file
.get ()), filename
);
367 /* Given a command_line, return a command string suitable for passing
368 to Python. Lines in the string are separated by newlines. */
371 compute_python_string (struct command_line
*l
)
373 struct command_line
*iter
;
376 for (iter
= l
; iter
; iter
= iter
->next
)
378 script
+= iter
->line
;
384 /* Take a command line structure representing a 'python' command, and
385 evaluate its body using the Python interpreter. */
388 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
389 struct command_line
*cmd
)
393 if (cmd
->body_count
!= 1)
394 error (_("Invalid \"python\" block structure."));
396 gdbpy_enter
enter_py (get_current_arch (), current_language
);
398 std::string script
= compute_python_string (cmd
->body_list
[0]);
399 ret
= PyRun_SimpleString (script
.c_str ());
401 error (_("Error while executing Python code."));
404 /* Implementation of the gdb "python" command. */
407 python_command (const char *arg
, int from_tty
)
409 gdbpy_enter
enter_py (get_current_arch (), current_language
);
411 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
413 arg
= skip_spaces (arg
);
416 if (PyRun_SimpleString (arg
))
417 error (_("Error while executing Python code."));
421 command_line_up l
= get_command_line (python_control
, "");
423 execute_control_command_untraced (l
.get ());
429 /* Transform a gdb parameters's value into a Python value. May return
430 NULL (and set a Python exception) on error. Helper function for
433 gdbpy_parameter_value (enum var_types type
, void *var
)
438 case var_string_noescape
:
439 case var_optional_filename
:
443 const char *str
= *(char **) var
;
447 return host_string_to_python_string (str
);
458 case var_auto_boolean
:
460 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
462 if (ab
== AUTO_BOOLEAN_TRUE
)
464 else if (ab
== AUTO_BOOLEAN_FALSE
)
471 if ((* (int *) var
) == INT_MAX
)
475 return PyLong_FromLong (* (int *) var
);
479 unsigned int val
= * (unsigned int *) var
;
483 return PyLong_FromUnsignedLong (val
);
487 return PyErr_Format (PyExc_RuntimeError
,
488 _("Programmer error: unhandled type."));
491 /* A Python function which returns a gdb parameter's value as a Python
495 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
497 struct gdb_exception except
= exception_none
;
498 struct cmd_list_element
*alias
, *prefix
, *cmd
;
503 if (! PyArg_ParseTuple (args
, "s", &arg
))
506 newarg
= concat ("show ", arg
, (char *) NULL
);
510 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
512 CATCH (ex
, RETURN_MASK_ALL
)
519 GDB_PY_HANDLE_EXCEPTION (except
);
521 return PyErr_Format (PyExc_RuntimeError
,
522 _("Could not find parameter `%s'."), arg
);
525 return PyErr_Format (PyExc_RuntimeError
,
526 _("`%s' is not a parameter."), arg
);
527 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
530 /* Wrapper for target_charset. */
533 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
535 const char *cset
= target_charset (python_gdbarch
);
537 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
540 /* Wrapper for target_wide_charset. */
543 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
545 const char *cset
= target_wide_charset (python_gdbarch
);
547 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
550 /* A Python function which evaluates a string using the gdb CLI. */
553 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
556 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
557 int from_tty
, to_string
;
558 static const char *keywords
[] = { "command", "from_tty", "to_string", NULL
};
560 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
561 &PyBool_Type
, &from_tty_obj
,
562 &PyBool_Type
, &to_string_obj
))
568 int cmp
= PyObject_IsTrue (from_tty_obj
);
577 int cmp
= PyObject_IsTrue (to_string_obj
);
583 std::string to_string_res
;
587 struct interp
*interp
;
589 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
591 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
593 /* Use the console interpreter uiout to have the same print format
594 for console or MI. */
595 interp
= interp_lookup (current_ui
, "console");
596 current_uiout
= interp_ui_out (interp
);
598 scoped_restore preventer
= prevent_dont_repeat ();
600 to_string_res
= execute_command_to_string (arg
, from_tty
);
602 execute_command (arg
, from_tty
);
604 CATCH (except
, RETURN_MASK_ALL
)
606 GDB_PY_HANDLE_EXCEPTION (except
);
610 /* Do any commands attached to breakpoint we stopped at. */
611 bpstat_do_actions ();
614 return PyString_FromString (to_string_res
.c_str ());
618 /* Implementation of gdb.solib_name (Long) -> String.
619 Returns the name of the shared library holding a given address, or None. */
622 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
628 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
631 soname
= solib_name_from_address (current_program_space
, pc
);
633 str_obj
= host_string_to_python_string (soname
);
643 /* Implementation of Python rbreak command. Take a REGEX and
644 optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
645 Python list that contains newly set breakpoints that match that
646 criteria. REGEX refers to a GDB format standard regex pattern of
647 symbols names to search; MINSYMS is an optional boolean (default
648 False) that indicates if the function should search GDB's minimal
649 symbols; THROTTLE is an optional integer (default unlimited) that
650 indicates the maximum amount of breakpoints allowable before the
651 function exits (note, if the throttle bound is passed, no
652 breakpoints will be set and a runtime error returned); SYMTABS is
653 an optional Python iterable that contains a set of gdb.Symtabs to
654 constrain the search within. */
657 gdbpy_rbreak (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
659 /* A simple type to ensure clean up of a vector of allocated strings
660 when a C interface demands a const char *array[] type
662 struct symtab_list_type
666 for (const char *elem
: vec
)
667 xfree ((void *) elem
);
669 std::vector
<const char *> vec
;
673 std::vector
<symbol_search
> symbols
;
674 unsigned long count
= 0;
675 PyObject
*symtab_list
= NULL
;
676 PyObject
*minsyms_p_obj
= NULL
;
678 unsigned int throttle
= 0;
679 static const char *keywords
[] = {"regex","minsyms", "throttle",
681 symtab_list_type symtab_paths
;
683 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!IO", keywords
,
684 ®ex
, &PyBool_Type
,
685 &minsyms_p_obj
, &throttle
,
689 /* Parse minsyms keyword. */
690 if (minsyms_p_obj
!= NULL
)
692 int cmp
= PyObject_IsTrue (minsyms_p_obj
);
698 /* The "symtabs" keyword is any Python iterable object that returns
699 a gdb.Symtab on each iteration. If specified, iterate through
700 the provided gdb.Symtabs and extract their full path. As
701 python_string_to_target_string returns a
702 gdb::unique_xmalloc_ptr<char> and a vector containing these types
703 cannot be coerced to a const char **p[] via the vector.data call,
704 release the value from the unique_xmalloc_ptr and place it in a
705 simple type symtab_list_type (which holds the vector and a
706 destructor that frees the contents of the allocated strings. */
707 if (symtab_list
!= NULL
)
709 gdbpy_ref
<> iter (PyObject_GetIter (symtab_list
));
716 gdbpy_ref
<> next (PyIter_Next (iter
.get ()));
720 if (PyErr_Occurred ())
725 gdbpy_ref
<> obj_name (PyObject_GetAttrString (next
.get (),
728 if (obj_name
== NULL
)
731 /* Is the object file still valid? */
732 if (obj_name
== Py_None
)
735 gdb::unique_xmalloc_ptr
<char> filename
=
736 python_string_to_target_string (obj_name
.get ());
738 if (filename
== NULL
)
741 /* Make sure there is a definite place to store the value of
742 filename before it is released. */
743 symtab_paths
.vec
.push_back (nullptr);
744 symtab_paths
.vec
.back () = filename
.release ();
750 const char **files
= symtab_paths
.vec
.data ();
752 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
,
753 symtab_paths
.vec
.size (), files
);
756 symbols
= search_symbols (regex
, FUNCTIONS_DOMAIN
, 0, NULL
);
758 /* Count the number of symbols (both symbols and optionally minimal
759 symbols) so we can correctly check the throttle limit. */
760 for (const symbol_search
&p
: symbols
)
762 /* Minimal symbols included? */
765 if (p
.msymbol
.minsym
!= NULL
)
769 if (p
.symbol
!= NULL
)
773 /* Check throttle bounds and exit if in excess. */
774 if (throttle
!= 0 && count
> throttle
)
776 PyErr_SetString (PyExc_RuntimeError
,
777 _("Number of breakpoints exceeds throttled maximum."));
781 gdbpy_ref
<> return_list (PyList_New (0));
783 if (return_list
== NULL
)
786 /* Construct full path names for symbols and call the Python
787 breakpoint constructor on the resulting names. Be tolerant of
788 individual breakpoint failures. */
789 for (const symbol_search
&p
: symbols
)
791 std::string symbol_name
;
793 /* Skipping minimal symbols? */
795 if (p
.msymbol
.minsym
!= NULL
)
798 if (p
.msymbol
.minsym
== NULL
)
800 struct symtab
*symtab
= symbol_symtab (p
.symbol
);
801 const char *fullname
= symtab_to_fullname (symtab
);
803 symbol_name
= fullname
;
805 symbol_name
+= SYMBOL_LINKAGE_NAME (p
.symbol
);
808 symbol_name
= MSYMBOL_LINKAGE_NAME (p
.msymbol
.minsym
);
810 gdbpy_ref
<> argList (Py_BuildValue("(s)", symbol_name
.c_str ()));
811 gdbpy_ref
<> obj (PyObject_CallObject ((PyObject
*)
812 &breakpoint_object_type
,
815 /* Tolerate individual breakpoint failures. */
817 gdbpy_print_stack ();
820 if (PyList_Append (return_list
.get (), obj
.get ()) == -1)
824 return return_list
.release ();
827 /* A Python function which is a wrapper for decode_line_1. */
830 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
832 const char *arg
= NULL
;
834 gdbpy_ref
<> unparsed
;
835 event_location_up location
;
837 if (! PyArg_ParseTuple (args
, "|s", &arg
))
841 location
= string_to_event_location_basic (&arg
, python_language
);
843 std::vector
<symtab_and_line
> decoded_sals
;
844 symtab_and_line def_sal
;
845 gdb::array_view
<symtab_and_line
> sals
;
848 if (location
!= NULL
)
850 decoded_sals
= decode_line_1 (location
.get (), 0, NULL
, NULL
, 0);
855 set_default_source_symtab_and_line ();
856 def_sal
= get_current_source_symtab_and_line ();
860 CATCH (ex
, RETURN_MASK_ALL
)
862 /* We know this will always throw. */
863 gdbpy_convert_exception (ex
);
870 result
.reset (PyTuple_New (sals
.size ()));
873 for (size_t i
= 0; i
< sals
.size (); ++i
)
875 PyObject
*obj
= symtab_and_line_to_sal_object (sals
[i
]);
879 PyTuple_SetItem (result
.get (), i
, obj
);
884 result
.reset (Py_None
);
888 gdbpy_ref
<> return_result (PyTuple_New (2));
889 if (return_result
== NULL
)
892 if (arg
!= NULL
&& strlen (arg
) > 0)
894 unparsed
.reset (PyString_FromString (arg
));
895 if (unparsed
== NULL
)
900 unparsed
.reset (Py_None
);
904 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
905 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
907 return return_result
.release ();
910 /* Parse a string and evaluate it as an expression. */
912 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
914 const char *expr_str
;
915 struct value
*result
= NULL
;
917 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
922 result
= parse_and_eval (expr_str
);
924 CATCH (except
, RETURN_MASK_ALL
)
926 GDB_PY_HANDLE_EXCEPTION (except
);
930 return value_to_value_object (result
);
933 /* Implementation of gdb.find_pc_line function.
934 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
937 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
939 gdb_py_ulongest pc_llu
;
940 PyObject
*result
= NULL
; /* init for gcc -Wall */
942 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
947 struct symtab_and_line sal
;
950 pc
= (CORE_ADDR
) pc_llu
;
951 sal
= find_pc_line (pc
, 0);
952 result
= symtab_and_line_to_sal_object (sal
);
954 CATCH (except
, RETURN_MASK_ALL
)
956 GDB_PY_HANDLE_EXCEPTION (except
);
963 /* Implementation of gdb.invalidate_cached_frames. */
966 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
968 reinit_frame_cache ();
972 /* Read a file as Python code.
973 This is the extension_language_script_ops.script_sourcer "method".
974 FILE is the file to load. FILENAME is name of the file FILE.
975 This does not throw any errors. If an exception occurs python will print
976 the traceback and clear the error indicator. */
979 gdbpy_source_script (const struct extension_language_defn
*extlang
,
980 FILE *file
, const char *filename
)
982 gdbpy_enter
enter_py (get_current_arch (), current_language
);
983 python_run_simple_file (file
, filename
);
988 /* Posting and handling events. */
990 /* A single event. */
993 /* The Python event. This is just a callable object. */
995 /* The next event. */
996 struct gdbpy_event
*next
;
999 /* All pending events. */
1000 static struct gdbpy_event
*gdbpy_event_list
;
1001 /* The final link of the event list. */
1002 static struct gdbpy_event
**gdbpy_event_list_end
;
1004 /* So that we can wake up the main thread even when it is blocked in
1006 static struct serial_event
*gdbpy_serial_event
;
1008 /* The file handler callback. This reads from the internal pipe, and
1009 then processes the Python event queue. This will always be run in
1010 the main gdb thread. */
1013 gdbpy_run_events (int error
, gdb_client_data client_data
)
1015 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1017 /* Clear the event fd. Do this before flushing the events list, so
1018 that any new event post afterwards is sure to re-awake the event
1020 serial_event_clear (gdbpy_serial_event
);
1022 while (gdbpy_event_list
)
1024 /* Dispatching the event might push a new element onto the event
1025 loop, so we update here "atomically enough". */
1026 struct gdbpy_event
*item
= gdbpy_event_list
;
1027 gdbpy_event_list
= gdbpy_event_list
->next
;
1028 if (gdbpy_event_list
== NULL
)
1029 gdbpy_event_list_end
= &gdbpy_event_list
;
1031 /* Ignore errors. */
1032 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
1033 if (call_result
== NULL
)
1036 Py_DECREF (item
->event
);
1041 /* Submit an event to the gdb thread. */
1043 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
1045 struct gdbpy_event
*event
;
1049 if (!PyArg_ParseTuple (args
, "O", &func
))
1052 if (!PyCallable_Check (func
))
1054 PyErr_SetString (PyExc_RuntimeError
,
1055 _("Posted event is not callable"));
1061 /* From here until the end of the function, we have the GIL, so we
1062 can operate on our global data structures without worrying. */
1063 wakeup
= gdbpy_event_list
== NULL
;
1065 event
= XNEW (struct gdbpy_event
);
1066 event
->event
= func
;
1068 *gdbpy_event_list_end
= event
;
1069 gdbpy_event_list_end
= &event
->next
;
1071 /* Wake up gdb when needed. */
1073 serial_event_set (gdbpy_serial_event
);
1078 /* Initialize the Python event handler. */
1080 gdbpy_initialize_events (void)
1082 gdbpy_event_list_end
= &gdbpy_event_list
;
1084 gdbpy_serial_event
= make_serial_event ();
1085 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1086 gdbpy_run_events
, NULL
);
1093 /* This is the extension_language_ops.before_prompt "method". */
1095 static enum ext_lang_rc
1096 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1097 const char *current_gdb_prompt
)
1099 if (!gdb_python_initialized
)
1100 return EXT_LANG_RC_NOP
;
1102 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1104 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
1105 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
1106 return EXT_LANG_RC_ERROR
;
1108 if (gdb_python_module
1109 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1111 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
1115 gdbpy_print_stack ();
1116 return EXT_LANG_RC_ERROR
;
1119 if (PyCallable_Check (hook
.get ()))
1121 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
1122 if (current_prompt
== NULL
)
1124 gdbpy_print_stack ();
1125 return EXT_LANG_RC_ERROR
;
1129 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1133 gdbpy_print_stack ();
1134 return EXT_LANG_RC_ERROR
;
1137 /* Return type should be None, or a String. If it is None,
1138 fall through, we will not set a prompt. If it is a
1139 string, set PROMPT. Anything else, set an exception. */
1140 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1142 PyErr_Format (PyExc_RuntimeError
,
1143 _("Return from prompt_hook must " \
1144 "be either a Python string, or None"));
1145 gdbpy_print_stack ();
1146 return EXT_LANG_RC_ERROR
;
1149 if (result
!= Py_None
)
1151 gdb::unique_xmalloc_ptr
<char>
1152 prompt (python_string_to_host_string (result
.get ()));
1156 gdbpy_print_stack ();
1157 return EXT_LANG_RC_ERROR
;
1160 set_prompt (prompt
.get ());
1161 return EXT_LANG_RC_OK
;
1166 return EXT_LANG_RC_NOP
;
1173 /* A python function to write a single string using gdb's filtered
1174 output stream . The optional keyword STREAM can be used to write
1175 to a particular stream. The default stream is to gdb_stdout. */
1178 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1181 static const char *keywords
[] = { "text", "stream", NULL
};
1182 int stream_type
= 0;
1184 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1190 switch (stream_type
)
1194 fprintf_filtered (gdb_stderr
, "%s", arg
);
1199 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1203 fprintf_filtered (gdb_stdout
, "%s", arg
);
1206 CATCH (except
, RETURN_MASK_ALL
)
1208 GDB_PY_HANDLE_EXCEPTION (except
);
1215 /* A python function to flush a gdb stream. The optional keyword
1216 STREAM can be used to flush a particular stream. The default stream
1220 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1222 static const char *keywords
[] = { "stream", NULL
};
1223 int stream_type
= 0;
1225 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1229 switch (stream_type
)
1233 gdb_flush (gdb_stderr
);
1238 gdb_flush (gdb_stdlog
);
1242 gdb_flush (gdb_stdout
);
1248 /* Return non-zero if print-stack is not "none". */
1251 gdbpy_print_python_errors_p (void)
1253 return gdbpy_should_print_stack
!= python_excp_none
;
1256 /* Print a python exception trace, print just a message, or print
1257 nothing and clear the python exception, depending on
1258 gdbpy_should_print_stack. Only call this if a python exception is
1261 gdbpy_print_stack (void)
1264 /* Print "none", just clear exception. */
1265 if (gdbpy_should_print_stack
== python_excp_none
)
1269 /* Print "full" message and backtrace. */
1270 else if (gdbpy_should_print_stack
== python_excp_full
)
1273 /* PyErr_Print doesn't necessarily end output with a newline.
1274 This works because Python's stdout/stderr is fed through
1280 CATCH (except
, RETURN_MASK_ALL
)
1285 /* Print "message", just error print message. */
1288 PyObject
*ptype
, *pvalue
, *ptraceback
;
1290 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1292 /* Fetch the error message contained within ptype, pvalue. */
1293 gdb::unique_xmalloc_ptr
<char>
1294 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1295 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1301 /* An error occurred computing the string representation of the
1303 fprintf_filtered (gdb_stderr
,
1304 _("Error occurred computing Python error" \
1308 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1309 type
.get (), msg
.get ());
1311 CATCH (except
, RETURN_MASK_ALL
)
1317 Py_XDECREF (pvalue
);
1318 Py_XDECREF (ptraceback
);
1324 /* Return the current Progspace.
1325 There always is one. */
1328 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1332 result
= pspace_to_pspace_object (current_program_space
);
1338 /* Return a sequence holding all the Progspaces. */
1341 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1343 struct program_space
*ps
;
1345 gdbpy_ref
<> list (PyList_New (0));
1351 PyObject
*item
= pspace_to_pspace_object (ps
);
1353 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1357 return list
.release ();
1362 /* The "current" objfile. This is set when gdb detects that a new
1363 objfile has been loaded. It is only set for the duration of a call to
1364 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1366 static struct objfile
*gdbpy_current_objfile
;
1368 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1369 as Python code. This does not throw any errors. If an exception
1370 occurs python will print the traceback and clear the error indicator.
1371 This is the extension_language_script_ops.objfile_script_sourcer
1375 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1376 struct objfile
*objfile
, FILE *file
,
1377 const char *filename
)
1379 if (!gdb_python_initialized
)
1382 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1383 gdbpy_current_objfile
= objfile
;
1385 python_run_simple_file (file
, filename
);
1387 gdbpy_current_objfile
= NULL
;
1390 /* Set the current objfile to OBJFILE and then execute SCRIPT
1391 as Python code. This does not throw any errors. If an exception
1392 occurs python will print the traceback and clear the error indicator.
1393 This is the extension_language_script_ops.objfile_script_executor
1397 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1398 struct objfile
*objfile
, const char *name
,
1401 if (!gdb_python_initialized
)
1404 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1405 gdbpy_current_objfile
= objfile
;
1407 PyRun_SimpleString (script
);
1409 gdbpy_current_objfile
= NULL
;
1412 /* Return the current Objfile, or None if there isn't one. */
1415 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1419 if (! gdbpy_current_objfile
)
1422 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1428 /* Return a sequence holding all the Objfiles. */
1431 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1433 struct objfile
*objf
;
1435 gdbpy_ref
<> list (PyList_New (0));
1441 PyObject
*item
= objfile_to_objfile_object (objf
);
1443 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1447 return list
.release ();
1450 /* Compute the list of active python type printers and store them in
1451 EXT_PRINTERS->py_type_printers. The product of this function is used by
1452 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1453 This is the extension_language_ops.start_type_printers "method". */
1456 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1457 struct ext_lang_type_printers
*ext_printers
)
1459 PyObject
*printers_obj
= NULL
;
1461 if (!gdb_python_initialized
)
1464 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1466 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1467 if (type_module
== NULL
)
1469 gdbpy_print_stack ();
1473 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1474 "get_type_recognizers"));
1477 gdbpy_print_stack ();
1481 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1482 if (printers_obj
== NULL
)
1483 gdbpy_print_stack ();
1485 ext_printers
->py_type_printers
= printers_obj
;
1488 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1489 a newly allocated string holding the type's replacement name, and return
1490 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1491 If there's a Python error return EXT_LANG_RC_ERROR.
1492 Otherwise, return EXT_LANG_RC_NOP.
1493 This is the extension_language_ops.apply_type_printers "method". */
1495 static enum ext_lang_rc
1496 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1497 const struct ext_lang_type_printers
*ext_printers
,
1498 struct type
*type
, char **prettied_type
)
1500 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1501 gdb::unique_xmalloc_ptr
<char> result
;
1503 if (printers_obj
== NULL
)
1504 return EXT_LANG_RC_NOP
;
1506 if (!gdb_python_initialized
)
1507 return EXT_LANG_RC_NOP
;
1509 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1511 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1512 if (type_obj
== NULL
)
1514 gdbpy_print_stack ();
1515 return EXT_LANG_RC_ERROR
;
1518 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1519 if (type_module
== NULL
)
1521 gdbpy_print_stack ();
1522 return EXT_LANG_RC_ERROR
;
1525 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1526 "apply_type_recognizers"));
1529 gdbpy_print_stack ();
1530 return EXT_LANG_RC_ERROR
;
1533 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1537 if (result_obj
== NULL
)
1539 gdbpy_print_stack ();
1540 return EXT_LANG_RC_ERROR
;
1543 if (result_obj
== Py_None
)
1544 return EXT_LANG_RC_NOP
;
1546 result
= python_string_to_host_string (result_obj
.get ());
1549 gdbpy_print_stack ();
1550 return EXT_LANG_RC_ERROR
;
1553 *prettied_type
= result
.release ();
1554 return EXT_LANG_RC_OK
;
1557 /* Free the result of start_type_printers.
1558 This is the extension_language_ops.free_type_printers "method". */
1561 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1562 struct ext_lang_type_printers
*ext_printers
)
1564 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1566 if (printers
== NULL
)
1569 if (!gdb_python_initialized
)
1572 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1573 Py_DECREF (printers
);
1576 #else /* HAVE_PYTHON */
1578 /* Dummy implementation of the gdb "python-interactive" and "python"
1582 python_interactive_command (const char *arg
, int from_tty
)
1584 arg
= skip_spaces (arg
);
1586 error (_("Python scripting is not supported in this copy of GDB."));
1589 command_line_up l
= get_command_line (python_control
, "");
1591 execute_control_command_untraced (l
.get ());
1596 python_command (const char *arg
, int from_tty
)
1598 python_interactive_command (arg
, from_tty
);
1601 #endif /* HAVE_PYTHON */
1605 /* Lists for 'set python' commands. */
1607 static struct cmd_list_element
*user_set_python_list
;
1608 static struct cmd_list_element
*user_show_python_list
;
1610 /* Function for use by 'set python' prefix command. */
1613 user_set_python (const char *args
, int from_tty
)
1615 help_list (user_set_python_list
, "set python ", all_commands
,
1619 /* Function for use by 'show python' prefix command. */
1622 user_show_python (const char *args
, int from_tty
)
1624 cmd_show_list (user_show_python_list
, from_tty
, "");
1627 /* Initialize the Python code. */
1631 /* This is installed as a final cleanup and cleans up the
1632 interpreter. This lets Python's 'atexit' work. */
1635 finalize_python (void *ignore
)
1637 struct active_ext_lang_state
*previous_active
;
1639 /* We don't use ensure_python_env here because if we ever ran the
1640 cleanup, gdb would crash -- because the cleanup calls into the
1641 Python interpreter, which we are about to destroy. It seems
1642 clearer to make the needed calls explicitly here than to create a
1643 cleanup and then mysteriously discard it. */
1645 /* This is only called as a final cleanup so we can assume the active
1646 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1647 previous_active
= set_active_ext_lang (&extension_language_python
);
1649 (void) PyGILState_Ensure ();
1650 python_gdbarch
= target_gdbarch ();
1651 python_language
= current_language
;
1655 restore_active_ext_lang (previous_active
);
1659 do_start_initialization ()
1664 size_t progsize
, count
;
1665 wchar_t *progname_copy
;
1668 #ifdef WITH_PYTHON_PATH
1669 /* Work around problem where python gets confused about where it is,
1670 and then can't find its libraries, etc.
1671 NOTE: Python assumes the following layout:
1673 /foo/lib/pythonX.Y/...
1674 This must be done before calling Py_Initialize. */
1675 progname
= concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1676 SLASH_STRING
, "python", (char *) NULL
);
1678 std::string oldloc
= setlocale (LC_ALL
, NULL
);
1679 setlocale (LC_ALL
, "");
1680 progsize
= strlen (progname
);
1681 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1684 fprintf (stderr
, "out of memory\n");
1687 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1688 if (count
== (size_t) -1)
1690 fprintf (stderr
, "Could not convert python path to string\n");
1693 setlocale (LC_ALL
, oldloc
.c_str ());
1695 /* Note that Py_SetProgramName expects the string it is passed to
1696 remain alive for the duration of the program's execution, so
1697 it is not freed after this call. */
1698 Py_SetProgramName (progname_copy
);
1700 Py_SetProgramName (progname
);
1705 PyEval_InitThreads ();
1708 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1709 /* Add _gdb module to the list of known built-in modules. */
1710 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1712 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1714 if (gdb_module
== NULL
)
1717 /* The casts to (char*) are for python 2.4. */
1718 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1719 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1720 (char*) host_name
) < 0
1721 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1722 (char*) target_name
) < 0)
1725 /* Add stream constants. */
1726 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1727 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1728 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1731 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1732 if (gdbpy_gdb_error
== NULL
1733 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1736 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1737 gdbpy_gdb_error
, NULL
);
1738 if (gdbpy_gdb_memory_error
== NULL
1739 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1740 gdbpy_gdb_memory_error
) < 0)
1743 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1744 if (gdbpy_gdberror_exc
== NULL
1745 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1746 gdbpy_gdberror_exc
) < 0)
1749 gdbpy_initialize_gdb_readline ();
1751 if (gdbpy_initialize_auto_load () < 0
1752 || gdbpy_initialize_values () < 0
1753 || gdbpy_initialize_frames () < 0
1754 || gdbpy_initialize_commands () < 0
1755 || gdbpy_initialize_instruction () < 0
1756 || gdbpy_initialize_record () < 0
1757 || gdbpy_initialize_btrace () < 0
1758 || gdbpy_initialize_symbols () < 0
1759 || gdbpy_initialize_symtabs () < 0
1760 || gdbpy_initialize_blocks () < 0
1761 || gdbpy_initialize_functions () < 0
1762 || gdbpy_initialize_parameters () < 0
1763 || gdbpy_initialize_types () < 0
1764 || gdbpy_initialize_pspace () < 0
1765 || gdbpy_initialize_objfile () < 0
1766 || gdbpy_initialize_breakpoints () < 0
1767 || gdbpy_initialize_finishbreakpoints () < 0
1768 || gdbpy_initialize_lazy_string () < 0
1769 || gdbpy_initialize_linetable () < 0
1770 || gdbpy_initialize_thread () < 0
1771 || gdbpy_initialize_inferior () < 0
1772 || gdbpy_initialize_events () < 0
1773 || gdbpy_initialize_eventregistry () < 0
1774 || gdbpy_initialize_py_events () < 0
1775 || gdbpy_initialize_event () < 0
1776 || gdbpy_initialize_arch () < 0
1777 || gdbpy_initialize_xmethods () < 0
1778 || gdbpy_initialize_unwind () < 0)
1781 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
1782 if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \
1784 #include "py-event-types.def"
1785 #undef GDB_PY_DEFINE_EVENT_TYPE
1787 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1788 if (gdbpy_to_string_cst
== NULL
)
1790 gdbpy_children_cst
= PyString_FromString ("children");
1791 if (gdbpy_children_cst
== NULL
)
1793 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1794 if (gdbpy_display_hint_cst
== NULL
)
1796 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1797 if (gdbpy_doc_cst
== NULL
)
1799 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1800 if (gdbpy_enabled_cst
== NULL
)
1802 gdbpy_value_cst
= PyString_FromString ("value");
1803 if (gdbpy_value_cst
== NULL
)
1806 /* Release the GIL while gdb runs. */
1807 PyThreadState_Swap (NULL
);
1808 PyEval_ReleaseLock ();
1810 make_final_cleanup (finalize_python
, NULL
);
1812 /* Only set this when initialization has succeeded. */
1813 gdb_python_initialized
= 1;
1817 #endif /* HAVE_PYTHON */
1820 _initialize_python (void)
1822 add_com ("python-interactive", class_obscure
,
1823 python_interactive_command
,
1826 Start an interactive Python prompt.\n\
1828 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1831 Alternatively, a single-line Python command can be given as an\n\
1832 argument, and if the command is an expression, the result will be\n\
1833 printed. For example:\n\
1835 (gdb) python-interactive 2 + 3\n\
1838 #else /* HAVE_PYTHON */
1840 Start a Python interactive prompt.\n\
1842 Python scripting is not supported in this copy of GDB.\n\
1843 This command is only a placeholder.")
1844 #endif /* HAVE_PYTHON */
1846 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1848 add_com ("python", class_obscure
, python_command
,
1851 Evaluate a Python command.\n\
1853 The command can be given as an argument, for instance:\n\
1857 If no argument is given, the following lines are read and used\n\
1858 as the Python commands. Type a line containing \"end\" to indicate\n\
1859 the end of the command.")
1860 #else /* HAVE_PYTHON */
1862 Evaluate a Python command.\n\
1864 Python scripting is not supported in this copy of GDB.\n\
1865 This command is only a placeholder.")
1866 #endif /* HAVE_PYTHON */
1868 add_com_alias ("py", "python", class_obscure
, 1);
1870 /* Add set/show python print-stack. */
1871 add_prefix_cmd ("python", no_class
, user_show_python
,
1872 _("Prefix command for python preference settings."),
1873 &user_show_python_list
, "show python ", 0,
1876 add_prefix_cmd ("python", no_class
, user_set_python
,
1877 _("Prefix command for python preference settings."),
1878 &user_set_python_list
, "set python ", 0,
1881 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1882 &gdbpy_should_print_stack
, _("\
1883 Set mode for Python stack dump on error."), _("\
1884 Show the mode of Python stack printing on error."), _("\
1885 none == no stack or message will be printed.\n\
1886 full == a message and a stack will be printed.\n\
1887 message == an error message without a stack will be printed."),
1889 &user_set_python_list
,
1890 &user_show_python_list
);
1893 if (!do_start_initialization () && PyErr_Occurred ())
1894 gdbpy_print_stack ();
1895 #endif /* HAVE_PYTHON */
1900 /* Helper function for gdbpy_finish_initialization. This does the
1901 work and then returns false if an error has occurred and must be
1902 displayed, or true on success. */
1905 do_finish_initialization (const struct extension_language_defn
*extlang
)
1910 /* Add the initial data-directory to sys.path. */
1912 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1915 sys_path
= PySys_GetObject ("path");
1917 /* If sys.path is not defined yet, define it first. */
1918 if (!(sys_path
&& PyList_Check (sys_path
)))
1921 PySys_SetPath (L
"");
1925 sys_path
= PySys_GetObject ("path");
1927 if (sys_path
&& PyList_Check (sys_path
))
1929 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1930 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1936 /* Import the gdb module to finish the initialization, and
1937 add it to __main__ for convenience. */
1938 m
= PyImport_AddModule ("__main__");
1942 /* Keep the reference to gdb_python_module since it is in a global
1944 gdb_python_module
= PyImport_ImportModule ("gdb");
1945 if (gdb_python_module
== NULL
)
1947 gdbpy_print_stack ();
1948 /* This is passed in one call to warning so that blank lines aren't
1949 inserted between each line of text. */
1951 "Could not load the Python gdb module from `%s'.\n"
1952 "Limited Python support is available from the _gdb module.\n"
1953 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1954 gdb_pythondir
.c_str ());
1955 /* We return "success" here as we've already emitted the
1960 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1963 /* Perform the remaining python initializations.
1964 These must be done after GDB is at least mostly initialized.
1965 E.g., The "info pretty-printer" command needs the "info" prefix
1967 This is the extension_language_ops.finish_initialization "method". */
1970 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1972 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1974 if (!do_finish_initialization (extlang
))
1976 gdbpy_print_stack ();
1977 warning (_("internal error: Unhandled Python exception"));
1981 /* Return non-zero if Python has successfully initialized.
1982 This is the extension_languages_ops.initialized "method". */
1985 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1987 return gdb_python_initialized
;
1990 #endif /* HAVE_PYTHON */
1996 PyMethodDef python_GdbMethods
[] =
1998 { "history", gdbpy_history
, METH_VARARGS
,
1999 "Get a value from history" },
2000 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
2001 "execute (command [, from_tty] [, to_string]) -> [String]\n\
2002 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
2003 a Python String containing the output of the command if to_string is\n\
2005 { "parameter", gdbpy_parameter
, METH_VARARGS
,
2006 "Return a gdb parameter's value" },
2008 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
2009 "Return a tuple of all breakpoint objects" },
2011 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
2012 "Find the default visualizer for a Value." },
2014 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
2015 "Return the current Progspace." },
2016 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
2017 "Return a sequence of all progspaces." },
2019 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
2020 "Return the current Objfile being loaded, or None." },
2021 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
2022 "Return a sequence of all loaded objfiles." },
2024 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2025 "newest_frame () -> gdb.Frame.\n\
2026 Return the newest frame object." },
2027 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2028 "selected_frame () -> gdb.Frame.\n\
2029 Return the selected frame object." },
2030 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2031 "stop_reason_string (Integer) -> String.\n\
2032 Return a string explaining unwind stop reason." },
2034 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
2035 "start_recording ([method] [, format]) -> gdb.Record.\n\
2036 Start recording with the given method. If no method is given, will fall back\n\
2037 to the system default method. If no format is given, will fall back to the\n\
2038 default format for the given method."},
2039 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
2040 "current_recording () -> gdb.Record.\n\
2041 Return current recording object." },
2042 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
2043 "stop_recording () -> None.\n\
2044 Stop current recording." },
2046 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2047 METH_VARARGS
| METH_KEYWORDS
,
2048 "lookup_type (name [, block]) -> type\n\
2049 Return a Type corresponding to the given name." },
2050 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2051 METH_VARARGS
| METH_KEYWORDS
,
2052 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2053 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2054 a boolean indicating if name is a field of the current implied argument\n\
2055 `this' (when the current language is object-oriented)." },
2056 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2057 METH_VARARGS
| METH_KEYWORDS
,
2058 "lookup_global_symbol (name [, domain]) -> symbol\n\
2059 Return the symbol corresponding to the given name (or None)." },
2061 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2062 METH_VARARGS
| METH_KEYWORDS
,
2063 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2064 Look up the specified objfile.\n\
2065 If by_build_id is True, the objfile is looked up by using name\n\
2066 as its build id." },
2068 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2069 "Return the block containing the given pc value, or None." },
2070 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2071 "solib_name (Long) -> String.\n\
2072 Return the name of the shared library holding a given address, or None." },
2073 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2074 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2075 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2076 The first element contains any unparsed portion of the String parameter\n\
2077 (or None if the string was fully parsed). The second element contains\n\
2078 a tuple that contains all the locations that match, represented as\n\
2079 gdb.Symtab_and_line objects (or None)."},
2080 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2081 "parse_and_eval (String) -> Value.\n\
2082 Parse String as an expression, evaluate it, and return the result as a Value."
2084 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2085 "find_pc_line (pc) -> Symtab_and_line.\n\
2086 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2088 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2089 "Post an event into gdb's event loop." },
2091 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2092 "target_charset () -> string.\n\
2093 Return the name of the current target charset." },
2094 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2095 "target_wide_charset () -> string.\n\
2096 Return the name of the current target wide charset." },
2097 { "rbreak", (PyCFunction
) gdbpy_rbreak
, METH_VARARGS
| METH_KEYWORDS
,
2098 "rbreak (Regex) -> List.\n\
2099 Return a Tuple containing gdb.Breakpoint objects that match the given Regex." },
2100 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2101 "string_to_argv (String) -> Array.\n\
2102 Parse String and return an argv-like array.\n\
2103 Arguments are separate by spaces and may be quoted."
2105 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2106 "Write a string using gdb's filtered stream." },
2107 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2108 "Flush gdb's filtered stdout stream." },
2109 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2110 "selected_thread () -> gdb.InferiorThread.\n\
2111 Return the selected thread object." },
2112 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2113 "selected_inferior () -> gdb.Inferior.\n\
2114 Return the selected inferior object." },
2115 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2116 "inferiors () -> (gdb.Inferior, ...).\n\
2117 Return a tuple containing all inferiors." },
2119 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2120 "invalidate_cached_frames () -> None.\n\
2121 Invalidate any cached frame objects in gdb.\n\
2122 Intended for internal use only." },
2124 {NULL
, NULL
, 0, NULL
}
2128 struct PyModuleDef python_GdbModuleDef
=
2130 PyModuleDef_HEAD_INIT
,
2142 /* Define all the event objects. */
2143 #define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \
2144 PyTypeObject name##_event_object_type \
2145 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \
2147 PyVarObject_HEAD_INIT (NULL, 0) \
2148 "gdb." py_name, /* tp_name */ \
2149 sizeof (event_object), /* tp_basicsize */ \
2150 0, /* tp_itemsize */ \
2151 evpy_dealloc, /* tp_dealloc */ \
2153 0, /* tp_getattr */ \
2154 0, /* tp_setattr */ \
2155 0, /* tp_compare */ \
2157 0, /* tp_as_number */ \
2158 0, /* tp_as_sequence */ \
2159 0, /* tp_as_mapping */ \
2163 0, /* tp_getattro */ \
2164 0, /* tp_setattro */ \
2165 0, /* tp_as_buffer */ \
2166 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \
2168 0, /* tp_traverse */ \
2170 0, /* tp_richcompare */ \
2171 0, /* tp_weaklistoffset */ \
2173 0, /* tp_iternext */ \
2174 0, /* tp_methods */ \
2175 0, /* tp_members */ \
2176 0, /* tp_getset */ \
2177 &base, /* tp_base */ \
2179 0, /* tp_descr_get */ \
2180 0, /* tp_descr_set */ \
2181 0, /* tp_dictoffset */ \
2185 #include "py-event-types.def"
2186 #undef GDB_PY_DEFINE_EVENT_TYPE
2188 #endif /* HAVE_PYTHON */