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 (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 (), "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. The
369 return value is allocated using xmalloc and the caller is
370 responsible for freeing it. */
373 compute_python_string (struct command_line
*l
)
375 struct command_line
*iter
;
380 for (iter
= l
; iter
; iter
= iter
->next
)
381 size
+= strlen (iter
->line
) + 1;
383 script
= (char *) xmalloc (size
+ 1);
385 for (iter
= l
; iter
; iter
= iter
->next
)
387 int len
= strlen (iter
->line
);
389 strcpy (&script
[here
], iter
->line
);
391 script
[here
++] = '\n';
397 /* Take a command line structure representing a 'python' command, and
398 evaluate its body using the Python interpreter. */
401 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
402 struct command_line
*cmd
)
407 if (cmd
->body_count
!= 1)
408 error (_("Invalid \"python\" block structure."));
410 gdbpy_enter
enter_py (get_current_arch (), current_language
);
412 script
= compute_python_string (cmd
->body_list
[0]);
413 ret
= PyRun_SimpleString (script
);
416 error (_("Error while executing Python code."));
419 /* Implementation of the gdb "python" command. */
422 python_command (char *arg
, int from_tty
)
424 gdbpy_enter
enter_py (get_current_arch (), current_language
);
426 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
428 arg
= skip_spaces (arg
);
431 if (PyRun_SimpleString (arg
))
432 error (_("Error while executing Python code."));
436 struct command_line
*l
= get_command_line (python_control
, "");
437 struct cleanup
*cleanup
= make_cleanup_free_command_lines (&l
);
439 execute_control_command_untraced (l
);
440 do_cleanups (cleanup
);
446 /* Transform a gdb parameters's value into a Python value. May return
447 NULL (and set a Python exception) on error. Helper function for
450 gdbpy_parameter_value (enum var_types type
, void *var
)
455 case var_string_noescape
:
456 case var_optional_filename
:
460 char *str
= * (char **) var
;
464 return host_string_to_python_string (str
);
475 case var_auto_boolean
:
477 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
479 if (ab
== AUTO_BOOLEAN_TRUE
)
481 else if (ab
== AUTO_BOOLEAN_FALSE
)
488 if ((* (int *) var
) == INT_MAX
)
492 return PyLong_FromLong (* (int *) var
);
496 unsigned int val
= * (unsigned int *) var
;
500 return PyLong_FromUnsignedLong (val
);
504 return PyErr_Format (PyExc_RuntimeError
,
505 _("Programmer error: unhandled type."));
508 /* A Python function which returns a gdb parameter's value as a Python
512 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
514 struct gdb_exception except
= exception_none
;
515 struct cmd_list_element
*alias
, *prefix
, *cmd
;
520 if (! PyArg_ParseTuple (args
, "s", &arg
))
523 newarg
= concat ("show ", arg
, (char *) NULL
);
527 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
529 CATCH (ex
, RETURN_MASK_ALL
)
536 GDB_PY_HANDLE_EXCEPTION (except
);
538 return PyErr_Format (PyExc_RuntimeError
,
539 _("Could not find parameter `%s'."), arg
);
542 return PyErr_Format (PyExc_RuntimeError
,
543 _("`%s' is not a parameter."), arg
);
544 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
547 /* Wrapper for target_charset. */
550 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
552 const char *cset
= target_charset (python_gdbarch
);
554 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
557 /* Wrapper for target_wide_charset. */
560 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
562 const char *cset
= target_wide_charset (python_gdbarch
);
564 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
567 /* A Python function which evaluates a string using the gdb CLI. */
570 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
573 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
574 int from_tty
, to_string
;
575 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
577 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
578 &PyBool_Type
, &from_tty_obj
,
579 &PyBool_Type
, &to_string_obj
))
585 int cmp
= PyObject_IsTrue (from_tty_obj
);
594 int cmp
= PyObject_IsTrue (to_string_obj
);
600 std::string to_string_res
;
604 /* Copy the argument text in case the command modifies it. */
605 std::string
copy (arg
);
606 struct interp
*interp
;
608 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
610 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
612 /* Use the console interpreter uiout to have the same print format
613 for console or MI. */
614 interp
= interp_lookup (current_ui
, "console");
615 current_uiout
= interp_ui_out (interp
);
617 scoped_restore preventer
= prevent_dont_repeat ();
619 to_string_res
= execute_command_to_string (©
[0], from_tty
);
621 execute_command (©
[0], from_tty
);
623 CATCH (except
, RETURN_MASK_ALL
)
625 GDB_PY_HANDLE_EXCEPTION (except
);
629 /* Do any commands attached to breakpoint we stopped at. */
630 bpstat_do_actions ();
633 return PyString_FromString (to_string_res
.c_str ());
637 /* Implementation of gdb.solib_name (Long) -> String.
638 Returns the name of the shared library holding a given address, or None. */
641 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
647 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
650 soname
= solib_name_from_address (current_program_space
, pc
);
652 str_obj
= host_string_to_python_string (soname
);
662 /* A Python function which is a wrapper for decode_line_1. */
665 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
667 struct gdb_exception except
= exception_none
;
668 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
670 struct symtab_and_line sal
;
672 struct cleanup
*cleanups
;
674 gdbpy_ref
<> unparsed
;
675 struct event_location
*location
= NULL
;
677 if (! PyArg_ParseTuple (args
, "|s", &arg
))
680 cleanups
= make_cleanup (null_cleanup
, NULL
);
686 location
= string_to_event_location_basic (&arg
, python_language
);
687 make_cleanup_delete_event_location (location
);
692 if (location
!= NULL
)
693 sals
= decode_line_1 (location
, 0, NULL
, NULL
, 0);
696 set_default_source_symtab_and_line ();
697 sal
= get_current_source_symtab_and_line ();
702 CATCH (ex
, RETURN_MASK_ALL
)
708 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
709 make_cleanup (xfree
, sals
.sals
);
711 if (except
.reason
< 0)
713 do_cleanups (cleanups
);
714 /* We know this will always throw. */
715 gdbpy_convert_exception (except
);
723 result
.reset (PyTuple_New (sals
.nelts
));
726 do_cleanups (cleanups
);
729 for (i
= 0; i
< sals
.nelts
; ++i
)
733 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
736 do_cleanups (cleanups
);
740 PyTuple_SetItem (result
.get (), i
, obj
);
745 result
.reset (Py_None
);
749 gdbpy_ref
<> return_result (PyTuple_New (2));
750 if (return_result
== NULL
)
752 do_cleanups (cleanups
);
756 if (arg
!= NULL
&& strlen (arg
) > 0)
758 unparsed
.reset (PyString_FromString (arg
));
759 if (unparsed
== NULL
)
761 do_cleanups (cleanups
);
767 unparsed
.reset (Py_None
);
771 PyTuple_SetItem (return_result
.get (), 0, unparsed
.release ());
772 PyTuple_SetItem (return_result
.get (), 1, result
.release ());
774 do_cleanups (cleanups
);
776 return return_result
.release ();
779 /* Parse a string and evaluate it as an expression. */
781 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
783 const char *expr_str
;
784 struct value
*result
= NULL
;
786 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
791 result
= parse_and_eval (expr_str
);
793 CATCH (except
, RETURN_MASK_ALL
)
795 GDB_PY_HANDLE_EXCEPTION (except
);
799 return value_to_value_object (result
);
802 /* Implementation of gdb.find_pc_line function.
803 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
806 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
808 gdb_py_ulongest pc_llu
;
809 PyObject
*result
= NULL
; /* init for gcc -Wall */
811 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
816 struct symtab_and_line sal
;
819 pc
= (CORE_ADDR
) pc_llu
;
820 sal
= find_pc_line (pc
, 0);
821 result
= symtab_and_line_to_sal_object (sal
);
823 CATCH (except
, RETURN_MASK_ALL
)
825 GDB_PY_HANDLE_EXCEPTION (except
);
832 /* Implementation of gdb.invalidate_cached_frames. */
835 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
837 reinit_frame_cache ();
841 /* Read a file as Python code.
842 This is the extension_language_script_ops.script_sourcer "method".
843 FILE is the file to load. FILENAME is name of the file FILE.
844 This does not throw any errors. If an exception occurs python will print
845 the traceback and clear the error indicator. */
848 gdbpy_source_script (const struct extension_language_defn
*extlang
,
849 FILE *file
, const char *filename
)
851 gdbpy_enter
enter_py (get_current_arch (), current_language
);
852 python_run_simple_file (file
, filename
);
857 /* Posting and handling events. */
859 /* A single event. */
862 /* The Python event. This is just a callable object. */
864 /* The next event. */
865 struct gdbpy_event
*next
;
868 /* All pending events. */
869 static struct gdbpy_event
*gdbpy_event_list
;
870 /* The final link of the event list. */
871 static struct gdbpy_event
**gdbpy_event_list_end
;
873 /* So that we can wake up the main thread even when it is blocked in
875 static struct serial_event
*gdbpy_serial_event
;
877 /* The file handler callback. This reads from the internal pipe, and
878 then processes the Python event queue. This will always be run in
879 the main gdb thread. */
882 gdbpy_run_events (int error
, gdb_client_data client_data
)
884 gdbpy_enter
enter_py (get_current_arch (), current_language
);
886 /* Clear the event fd. Do this before flushing the events list, so
887 that any new event post afterwards is sure to re-awake the event
889 serial_event_clear (gdbpy_serial_event
);
891 while (gdbpy_event_list
)
893 /* Dispatching the event might push a new element onto the event
894 loop, so we update here "atomically enough". */
895 struct gdbpy_event
*item
= gdbpy_event_list
;
896 gdbpy_event_list
= gdbpy_event_list
->next
;
897 if (gdbpy_event_list
== NULL
)
898 gdbpy_event_list_end
= &gdbpy_event_list
;
901 gdbpy_ref
<> call_result (PyObject_CallObject (item
->event
, NULL
));
902 if (call_result
== NULL
)
905 Py_DECREF (item
->event
);
910 /* Submit an event to the gdb thread. */
912 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
914 struct gdbpy_event
*event
;
918 if (!PyArg_ParseTuple (args
, "O", &func
))
921 if (!PyCallable_Check (func
))
923 PyErr_SetString (PyExc_RuntimeError
,
924 _("Posted event is not callable"));
930 /* From here until the end of the function, we have the GIL, so we
931 can operate on our global data structures without worrying. */
932 wakeup
= gdbpy_event_list
== NULL
;
934 event
= XNEW (struct gdbpy_event
);
937 *gdbpy_event_list_end
= event
;
938 gdbpy_event_list_end
= &event
->next
;
940 /* Wake up gdb when needed. */
942 serial_event_set (gdbpy_serial_event
);
947 /* Initialize the Python event handler. */
949 gdbpy_initialize_events (void)
951 gdbpy_event_list_end
= &gdbpy_event_list
;
953 gdbpy_serial_event
= make_serial_event ();
954 add_file_handler (serial_event_fd (gdbpy_serial_event
),
955 gdbpy_run_events
, NULL
);
962 /* This is the extension_language_ops.before_prompt "method". */
964 static enum ext_lang_rc
965 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
966 const char *current_gdb_prompt
)
968 if (!gdb_python_initialized
)
969 return EXT_LANG_RC_NOP
;
971 gdbpy_enter
enter_py (get_current_arch (), current_language
);
973 if (!evregpy_no_listeners_p (gdb_py_events
.before_prompt
)
974 && evpy_emit_event (NULL
, gdb_py_events
.before_prompt
) < 0)
975 return EXT_LANG_RC_ERROR
;
977 if (gdb_python_module
978 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
980 gdbpy_ref
<> hook (PyObject_GetAttrString (gdb_python_module
,
984 gdbpy_print_stack ();
985 return EXT_LANG_RC_ERROR
;
988 if (PyCallable_Check (hook
.get ()))
990 gdbpy_ref
<> current_prompt (PyString_FromString (current_gdb_prompt
));
991 if (current_prompt
== NULL
)
993 gdbpy_print_stack ();
994 return EXT_LANG_RC_ERROR
;
998 (PyObject_CallFunctionObjArgs (hook
.get (), current_prompt
.get (),
1002 gdbpy_print_stack ();
1003 return EXT_LANG_RC_ERROR
;
1006 /* Return type should be None, or a String. If it is None,
1007 fall through, we will not set a prompt. If it is a
1008 string, set PROMPT. Anything else, set an exception. */
1009 if (result
!= Py_None
&& ! PyString_Check (result
.get ()))
1011 PyErr_Format (PyExc_RuntimeError
,
1012 _("Return from prompt_hook must " \
1013 "be either a Python string, or None"));
1014 gdbpy_print_stack ();
1015 return EXT_LANG_RC_ERROR
;
1018 if (result
!= Py_None
)
1020 gdb::unique_xmalloc_ptr
<char>
1021 prompt (python_string_to_host_string (result
.get ()));
1025 gdbpy_print_stack ();
1026 return EXT_LANG_RC_ERROR
;
1029 set_prompt (prompt
.get ());
1030 return EXT_LANG_RC_OK
;
1035 return EXT_LANG_RC_NOP
;
1042 /* A python function to write a single string using gdb's filtered
1043 output stream . The optional keyword STREAM can be used to write
1044 to a particular stream. The default stream is to gdb_stdout. */
1047 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1050 static char *keywords
[] = {"text", "stream", NULL
};
1051 int stream_type
= 0;
1053 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1059 switch (stream_type
)
1063 fprintf_filtered (gdb_stderr
, "%s", arg
);
1068 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1072 fprintf_filtered (gdb_stdout
, "%s", arg
);
1075 CATCH (except
, RETURN_MASK_ALL
)
1077 GDB_PY_HANDLE_EXCEPTION (except
);
1084 /* A python function to flush a gdb stream. The optional keyword
1085 STREAM can be used to flush a particular stream. The default stream
1089 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1091 static char *keywords
[] = {"stream", NULL
};
1092 int stream_type
= 0;
1094 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1098 switch (stream_type
)
1102 gdb_flush (gdb_stderr
);
1107 gdb_flush (gdb_stdlog
);
1111 gdb_flush (gdb_stdout
);
1117 /* Return non-zero if print-stack is not "none". */
1120 gdbpy_print_python_errors_p (void)
1122 return gdbpy_should_print_stack
!= python_excp_none
;
1125 /* Print a python exception trace, print just a message, or print
1126 nothing and clear the python exception, depending on
1127 gdbpy_should_print_stack. Only call this if a python exception is
1130 gdbpy_print_stack (void)
1133 /* Print "none", just clear exception. */
1134 if (gdbpy_should_print_stack
== python_excp_none
)
1138 /* Print "full" message and backtrace. */
1139 else if (gdbpy_should_print_stack
== python_excp_full
)
1142 /* PyErr_Print doesn't necessarily end output with a newline.
1143 This works because Python's stdout/stderr is fed through
1149 CATCH (except
, RETURN_MASK_ALL
)
1154 /* Print "message", just error print message. */
1157 PyObject
*ptype
, *pvalue
, *ptraceback
;
1159 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1161 /* Fetch the error message contained within ptype, pvalue. */
1162 gdb::unique_xmalloc_ptr
<char>
1163 msg (gdbpy_exception_to_string (ptype
, pvalue
));
1164 gdb::unique_xmalloc_ptr
<char> type (gdbpy_obj_to_string (ptype
));
1170 /* An error occurred computing the string representation of the
1172 fprintf_filtered (gdb_stderr
,
1173 _("Error occurred computing Python error" \
1177 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1178 type
.get (), msg
.get ());
1180 CATCH (except
, RETURN_MASK_ALL
)
1186 Py_XDECREF (pvalue
);
1187 Py_XDECREF (ptraceback
);
1193 /* Return the current Progspace.
1194 There always is one. */
1197 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1201 result
= pspace_to_pspace_object (current_program_space
);
1207 /* Return a sequence holding all the Progspaces. */
1210 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1212 struct program_space
*ps
;
1214 gdbpy_ref
<> list (PyList_New (0));
1220 PyObject
*item
= pspace_to_pspace_object (ps
);
1222 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1226 return list
.release ();
1231 /* The "current" objfile. This is set when gdb detects that a new
1232 objfile has been loaded. It is only set for the duration of a call to
1233 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1235 static struct objfile
*gdbpy_current_objfile
;
1237 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1238 as Python code. This does not throw any errors. If an exception
1239 occurs python will print the traceback and clear the error indicator.
1240 This is the extension_language_script_ops.objfile_script_sourcer
1244 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1245 struct objfile
*objfile
, FILE *file
,
1246 const char *filename
)
1248 if (!gdb_python_initialized
)
1251 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1252 gdbpy_current_objfile
= objfile
;
1254 python_run_simple_file (file
, filename
);
1256 gdbpy_current_objfile
= NULL
;
1259 /* Set the current objfile to OBJFILE and then execute SCRIPT
1260 as Python code. This does not throw any errors. If an exception
1261 occurs python will print the traceback and clear the error indicator.
1262 This is the extension_language_script_ops.objfile_script_executor
1266 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1267 struct objfile
*objfile
, const char *name
,
1270 if (!gdb_python_initialized
)
1273 gdbpy_enter
enter_py (get_objfile_arch (objfile
), current_language
);
1274 gdbpy_current_objfile
= objfile
;
1276 PyRun_SimpleString (script
);
1278 gdbpy_current_objfile
= NULL
;
1281 /* Return the current Objfile, or None if there isn't one. */
1284 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1288 if (! gdbpy_current_objfile
)
1291 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1297 /* Return a sequence holding all the Objfiles. */
1300 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1302 struct objfile
*objf
;
1304 gdbpy_ref
<> list (PyList_New (0));
1310 PyObject
*item
= objfile_to_objfile_object (objf
);
1312 if (!item
|| PyList_Append (list
.get (), item
) == -1)
1316 return list
.release ();
1319 /* Compute the list of active python type printers and store them in
1320 EXT_PRINTERS->py_type_printers. The product of this function is used by
1321 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1322 This is the extension_language_ops.start_type_printers "method". */
1325 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1326 struct ext_lang_type_printers
*ext_printers
)
1328 PyObject
*printers_obj
= NULL
;
1330 if (!gdb_python_initialized
)
1333 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1335 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1336 if (type_module
== NULL
)
1338 gdbpy_print_stack ();
1342 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1343 "get_type_recognizers"));
1346 gdbpy_print_stack ();
1350 printers_obj
= PyObject_CallFunctionObjArgs (func
.get (), (char *) NULL
);
1351 if (printers_obj
== NULL
)
1352 gdbpy_print_stack ();
1354 ext_printers
->py_type_printers
= printers_obj
;
1357 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1358 a newly allocated string holding the type's replacement name, and return
1359 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1360 If there's a Python error return EXT_LANG_RC_ERROR.
1361 Otherwise, return EXT_LANG_RC_NOP.
1362 This is the extension_language_ops.apply_type_printers "method". */
1364 static enum ext_lang_rc
1365 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1366 const struct ext_lang_type_printers
*ext_printers
,
1367 struct type
*type
, char **prettied_type
)
1369 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1370 gdb::unique_xmalloc_ptr
<char> result
;
1372 if (printers_obj
== NULL
)
1373 return EXT_LANG_RC_NOP
;
1375 if (!gdb_python_initialized
)
1376 return EXT_LANG_RC_NOP
;
1378 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1380 gdbpy_ref
<> type_obj (type_to_type_object (type
));
1381 if (type_obj
== NULL
)
1383 gdbpy_print_stack ();
1384 return EXT_LANG_RC_ERROR
;
1387 gdbpy_ref
<> type_module (PyImport_ImportModule ("gdb.types"));
1388 if (type_module
== NULL
)
1390 gdbpy_print_stack ();
1391 return EXT_LANG_RC_ERROR
;
1394 gdbpy_ref
<> func (PyObject_GetAttrString (type_module
.get (),
1395 "apply_type_recognizers"));
1398 gdbpy_print_stack ();
1399 return EXT_LANG_RC_ERROR
;
1402 gdbpy_ref
<> result_obj (PyObject_CallFunctionObjArgs (func
.get (),
1406 if (result_obj
== NULL
)
1408 gdbpy_print_stack ();
1409 return EXT_LANG_RC_ERROR
;
1412 if (result_obj
== Py_None
)
1413 return EXT_LANG_RC_NOP
;
1415 result
= python_string_to_host_string (result_obj
.get ());
1418 gdbpy_print_stack ();
1419 return EXT_LANG_RC_ERROR
;
1422 *prettied_type
= result
.release ();
1423 return EXT_LANG_RC_OK
;
1426 /* Free the result of start_type_printers.
1427 This is the extension_language_ops.free_type_printers "method". */
1430 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1431 struct ext_lang_type_printers
*ext_printers
)
1433 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1435 if (printers
== NULL
)
1438 if (!gdb_python_initialized
)
1441 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1442 Py_DECREF (printers
);
1445 #else /* HAVE_PYTHON */
1447 /* Dummy implementation of the gdb "python-interactive" and "python"
1451 python_interactive_command (char *arg
, int from_tty
)
1453 arg
= skip_spaces (arg
);
1455 error (_("Python scripting is not supported in this copy of GDB."));
1458 struct command_line
*l
= get_command_line (python_control
, "");
1459 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1461 execute_control_command_untraced (l
);
1462 do_cleanups (cleanups
);
1467 python_command (char *arg
, int from_tty
)
1469 python_interactive_command (arg
, from_tty
);
1472 #endif /* HAVE_PYTHON */
1476 /* Lists for 'set python' commands. */
1478 static struct cmd_list_element
*user_set_python_list
;
1479 static struct cmd_list_element
*user_show_python_list
;
1481 /* Function for use by 'set python' prefix command. */
1484 user_set_python (char *args
, int from_tty
)
1486 help_list (user_set_python_list
, "set python ", all_commands
,
1490 /* Function for use by 'show python' prefix command. */
1493 user_show_python (char *args
, int from_tty
)
1495 cmd_show_list (user_show_python_list
, from_tty
, "");
1498 /* Initialize the Python code. */
1502 /* This is installed as a final cleanup and cleans up the
1503 interpreter. This lets Python's 'atexit' work. */
1506 finalize_python (void *ignore
)
1508 struct active_ext_lang_state
*previous_active
;
1510 /* We don't use ensure_python_env here because if we ever ran the
1511 cleanup, gdb would crash -- because the cleanup calls into the
1512 Python interpreter, which we are about to destroy. It seems
1513 clearer to make the needed calls explicitly here than to create a
1514 cleanup and then mysteriously discard it. */
1516 /* This is only called as a final cleanup so we can assume the active
1517 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1518 previous_active
= set_active_ext_lang (&extension_language_python
);
1520 (void) PyGILState_Ensure ();
1521 python_gdbarch
= target_gdbarch ();
1522 python_language
= current_language
;
1526 restore_active_ext_lang (previous_active
);
1530 /* Provide a prototype to silence -Wmissing-prototypes. */
1531 extern initialize_file_ftype _initialize_python
;
1536 do_start_initialization ()
1541 size_t progsize
, count
;
1543 wchar_t *progname_copy
;
1546 #ifdef WITH_PYTHON_PATH
1547 /* Work around problem where python gets confused about where it is,
1548 and then can't find its libraries, etc.
1549 NOTE: Python assumes the following layout:
1551 /foo/lib/pythonX.Y/...
1552 This must be done before calling Py_Initialize. */
1553 progname
= concat (ldirname (python_libdir
).c_str (), SLASH_STRING
, "bin",
1554 SLASH_STRING
, "python", (char *) NULL
);
1556 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1557 setlocale (LC_ALL
, "");
1558 progsize
= strlen (progname
);
1559 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1563 fprintf (stderr
, "out of memory\n");
1566 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1567 if (count
== (size_t) -1)
1570 fprintf (stderr
, "Could not convert python path to string\n");
1573 setlocale (LC_ALL
, oldloc
);
1576 /* Note that Py_SetProgramName expects the string it is passed to
1577 remain alive for the duration of the program's execution, so
1578 it is not freed after this call. */
1579 Py_SetProgramName (progname_copy
);
1581 Py_SetProgramName (progname
);
1586 PyEval_InitThreads ();
1589 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1590 /* Add _gdb module to the list of known built-in modules. */
1591 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1593 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1595 if (gdb_module
== NULL
)
1598 /* The casts to (char*) are for python 2.4. */
1599 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1600 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1601 (char*) host_name
) < 0
1602 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1603 (char*) target_name
) < 0)
1606 /* Add stream constants. */
1607 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1608 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1609 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1612 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1613 if (gdbpy_gdb_error
== NULL
1614 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1617 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1618 gdbpy_gdb_error
, NULL
);
1619 if (gdbpy_gdb_memory_error
== NULL
1620 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1621 gdbpy_gdb_memory_error
) < 0)
1624 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1625 if (gdbpy_gdberror_exc
== NULL
1626 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1627 gdbpy_gdberror_exc
) < 0)
1630 gdbpy_initialize_gdb_readline ();
1632 if (gdbpy_initialize_auto_load () < 0
1633 || gdbpy_initialize_values () < 0
1634 || gdbpy_initialize_frames () < 0
1635 || gdbpy_initialize_commands () < 0
1636 || gdbpy_initialize_record () < 0
1637 || gdbpy_initialize_btrace () < 0
1638 || gdbpy_initialize_symbols () < 0
1639 || gdbpy_initialize_symtabs () < 0
1640 || gdbpy_initialize_blocks () < 0
1641 || gdbpy_initialize_functions () < 0
1642 || gdbpy_initialize_parameters () < 0
1643 || gdbpy_initialize_types () < 0
1644 || gdbpy_initialize_pspace () < 0
1645 || gdbpy_initialize_objfile () < 0
1646 || gdbpy_initialize_breakpoints () < 0
1647 || gdbpy_initialize_finishbreakpoints () < 0
1648 || gdbpy_initialize_lazy_string () < 0
1649 || gdbpy_initialize_linetable () < 0
1650 || gdbpy_initialize_thread () < 0
1651 || gdbpy_initialize_inferior () < 0
1652 || gdbpy_initialize_events () < 0
1653 || gdbpy_initialize_eventregistry () < 0
1654 || gdbpy_initialize_py_events () < 0
1655 || gdbpy_initialize_event () < 0
1656 || gdbpy_initialize_stop_event () < 0
1657 || gdbpy_initialize_signal_event () < 0
1658 || gdbpy_initialize_breakpoint_event () < 0
1659 || gdbpy_initialize_continue_event () < 0
1660 || gdbpy_initialize_inferior_call_pre_event () < 0
1661 || gdbpy_initialize_inferior_call_post_event () < 0
1662 || gdbpy_initialize_register_changed_event () < 0
1663 || gdbpy_initialize_memory_changed_event () < 0
1664 || gdbpy_initialize_exited_event () < 0
1665 || gdbpy_initialize_thread_event () < 0
1666 || gdbpy_initialize_new_objfile_event () < 0
1667 || gdbpy_initialize_clear_objfiles_event () < 0
1668 || gdbpy_initialize_arch () < 0
1669 || gdbpy_initialize_xmethods () < 0
1670 || gdbpy_initialize_unwind () < 0)
1673 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1674 if (gdbpy_to_string_cst
== NULL
)
1676 gdbpy_children_cst
= PyString_FromString ("children");
1677 if (gdbpy_children_cst
== NULL
)
1679 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1680 if (gdbpy_display_hint_cst
== NULL
)
1682 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1683 if (gdbpy_doc_cst
== NULL
)
1685 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1686 if (gdbpy_enabled_cst
== NULL
)
1688 gdbpy_value_cst
= PyString_FromString ("value");
1689 if (gdbpy_value_cst
== NULL
)
1692 /* Release the GIL while gdb runs. */
1693 PyThreadState_Swap (NULL
);
1694 PyEval_ReleaseLock ();
1696 make_final_cleanup (finalize_python
, NULL
);
1698 /* Only set this when initialization has succeeded. */
1699 gdb_python_initialized
= 1;
1703 #endif /* HAVE_PYTHON */
1706 _initialize_python (void)
1708 add_com ("python-interactive", class_obscure
,
1709 python_interactive_command
,
1712 Start an interactive Python prompt.\n\
1714 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1717 Alternatively, a single-line Python command can be given as an\n\
1718 argument, and if the command is an expression, the result will be\n\
1719 printed. For example:\n\
1721 (gdb) python-interactive 2 + 3\n\
1724 #else /* HAVE_PYTHON */
1726 Start a Python interactive prompt.\n\
1728 Python scripting is not supported in this copy of GDB.\n\
1729 This command is only a placeholder.")
1730 #endif /* HAVE_PYTHON */
1732 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1734 add_com ("python", class_obscure
, python_command
,
1737 Evaluate a Python command.\n\
1739 The command can be given as an argument, for instance:\n\
1743 If no argument is given, the following lines are read and used\n\
1744 as the Python commands. Type a line containing \"end\" to indicate\n\
1745 the end of the command.")
1746 #else /* HAVE_PYTHON */
1748 Evaluate a Python command.\n\
1750 Python scripting is not supported in this copy of GDB.\n\
1751 This command is only a placeholder.")
1752 #endif /* HAVE_PYTHON */
1754 add_com_alias ("py", "python", class_obscure
, 1);
1756 /* Add set/show python print-stack. */
1757 add_prefix_cmd ("python", no_class
, user_show_python
,
1758 _("Prefix command for python preference settings."),
1759 &user_show_python_list
, "show python ", 0,
1762 add_prefix_cmd ("python", no_class
, user_set_python
,
1763 _("Prefix command for python preference settings."),
1764 &user_set_python_list
, "set python ", 0,
1767 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1768 &gdbpy_should_print_stack
, _("\
1769 Set mode for Python stack dump on error."), _("\
1770 Show the mode of Python stack printing on error."), _("\
1771 none == no stack or message will be printed.\n\
1772 full == a message and a stack will be printed.\n\
1773 message == an error message without a stack will be printed."),
1775 &user_set_python_list
,
1776 &user_show_python_list
);
1779 if (!do_start_initialization () && PyErr_Occurred ())
1780 gdbpy_print_stack ();
1781 #endif /* HAVE_PYTHON */
1786 /* Helper function for gdbpy_finish_initialization. This does the
1787 work and then returns false if an error has occurred and must be
1788 displayed, or true on success. */
1791 do_finish_initialization (const struct extension_language_defn
*extlang
)
1796 /* Add the initial data-directory to sys.path. */
1798 std::string gdb_pythondir
= (std::string (gdb_datadir
) + SLASH_STRING
1801 sys_path
= PySys_GetObject ("path");
1803 /* If sys.path is not defined yet, define it first. */
1804 if (!(sys_path
&& PyList_Check (sys_path
)))
1807 PySys_SetPath (L
"");
1811 sys_path
= PySys_GetObject ("path");
1813 if (sys_path
&& PyList_Check (sys_path
))
1815 gdbpy_ref
<> pythondir (PyString_FromString (gdb_pythondir
.c_str ()));
1816 if (pythondir
== NULL
|| PyList_Insert (sys_path
, 0, pythondir
.get ()))
1822 /* Import the gdb module to finish the initialization, and
1823 add it to __main__ for convenience. */
1824 m
= PyImport_AddModule ("__main__");
1828 /* Keep the reference to gdb_python_module since it is in a global
1830 gdb_python_module
= PyImport_ImportModule ("gdb");
1831 if (gdb_python_module
== NULL
)
1833 gdbpy_print_stack ();
1834 /* This is passed in one call to warning so that blank lines aren't
1835 inserted between each line of text. */
1837 "Could not load the Python gdb module from `%s'.\n"
1838 "Limited Python support is available from the _gdb module.\n"
1839 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1840 gdb_pythondir
.c_str ());
1841 /* We return "success" here as we've already emitted the
1846 return gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) >= 0;
1849 /* Perform the remaining python initializations.
1850 These must be done after GDB is at least mostly initialized.
1851 E.g., The "info pretty-printer" command needs the "info" prefix
1853 This is the extension_language_ops.finish_initialization "method". */
1856 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1858 gdbpy_enter
enter_py (get_current_arch (), current_language
);
1860 if (!do_finish_initialization (extlang
))
1862 gdbpy_print_stack ();
1863 warning (_("internal error: Unhandled Python exception"));
1867 /* Return non-zero if Python has successfully initialized.
1868 This is the extension_languages_ops.initialized "method". */
1871 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1873 return gdb_python_initialized
;
1876 #endif /* HAVE_PYTHON */
1882 PyMethodDef python_GdbMethods
[] =
1884 { "history", gdbpy_history
, METH_VARARGS
,
1885 "Get a value from history" },
1886 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1887 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1888 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1889 a Python String containing the output of the command if to_string is\n\
1891 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1892 "Return a gdb parameter's value" },
1894 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1895 "Return a tuple of all breakpoint objects" },
1897 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1898 "Find the default visualizer for a Value." },
1900 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1901 "Return the current Progspace." },
1902 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1903 "Return a sequence of all progspaces." },
1905 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1906 "Return the current Objfile being loaded, or None." },
1907 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1908 "Return a sequence of all loaded objfiles." },
1910 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1911 "newest_frame () -> gdb.Frame.\n\
1912 Return the newest frame object." },
1913 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1914 "selected_frame () -> gdb.Frame.\n\
1915 Return the selected frame object." },
1916 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1917 "stop_reason_string (Integer) -> String.\n\
1918 Return a string explaining unwind stop reason." },
1920 { "start_recording", gdbpy_start_recording
, METH_VARARGS
,
1921 "start_recording ([method] [, format]) -> gdb.Record.\n\
1922 Start recording with the given method. If no method is given, will fall back\n\
1923 to the system default method. If no format is given, will fall back to the\n\
1924 default format for the given method."},
1925 { "current_recording", gdbpy_current_recording
, METH_NOARGS
,
1926 "current_recording () -> gdb.Record.\n\
1927 Return current recording object." },
1928 { "stop_recording", gdbpy_stop_recording
, METH_NOARGS
,
1929 "stop_recording () -> None.\n\
1930 Stop current recording." },
1932 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1933 METH_VARARGS
| METH_KEYWORDS
,
1934 "lookup_type (name [, block]) -> type\n\
1935 Return a Type corresponding to the given name." },
1936 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1937 METH_VARARGS
| METH_KEYWORDS
,
1938 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1939 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1940 a boolean indicating if name is a field of the current implied argument\n\
1941 `this' (when the current language is object-oriented)." },
1942 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1943 METH_VARARGS
| METH_KEYWORDS
,
1944 "lookup_global_symbol (name [, domain]) -> symbol\n\
1945 Return the symbol corresponding to the given name (or None)." },
1947 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
1948 METH_VARARGS
| METH_KEYWORDS
,
1949 "lookup_objfile (name, [by_build_id]) -> objfile\n\
1950 Look up the specified objfile.\n\
1951 If by_build_id is True, the objfile is looked up by using name\n\
1952 as its build id." },
1954 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1955 "Return the block containing the given pc value, or None." },
1956 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1957 "solib_name (Long) -> String.\n\
1958 Return the name of the shared library holding a given address, or None." },
1959 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1960 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1961 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1962 The first element contains any unparsed portion of the String parameter\n\
1963 (or None if the string was fully parsed). The second element contains\n\
1964 a tuple that contains all the locations that match, represented as\n\
1965 gdb.Symtab_and_line objects (or None)."},
1966 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1967 "parse_and_eval (String) -> Value.\n\
1968 Parse String as an expression, evaluate it, and return the result as a Value."
1970 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
1971 "find_pc_line (pc) -> Symtab_and_line.\n\
1972 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1974 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1975 "Post an event into gdb's event loop." },
1977 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
1978 "target_charset () -> string.\n\
1979 Return the name of the current target charset." },
1980 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
1981 "target_wide_charset () -> string.\n\
1982 Return the name of the current target wide charset." },
1984 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
1985 "string_to_argv (String) -> Array.\n\
1986 Parse String and return an argv-like array.\n\
1987 Arguments are separate by spaces and may be quoted."
1989 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
1990 "Write a string using gdb's filtered stream." },
1991 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
1992 "Flush gdb's filtered stdout stream." },
1993 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
1994 "selected_thread () -> gdb.InferiorThread.\n\
1995 Return the selected thread object." },
1996 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
1997 "selected_inferior () -> gdb.Inferior.\n\
1998 Return the selected inferior object." },
1999 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2000 "inferiors () -> (gdb.Inferior, ...).\n\
2001 Return a tuple containing all inferiors." },
2003 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2004 "invalidate_cached_frames () -> None.\n\
2005 Invalidate any cached frame objects in gdb.\n\
2006 Intended for internal use only." },
2008 {NULL
, NULL
, 0, NULL
}
2012 struct PyModuleDef python_GdbModuleDef
=
2014 PyModuleDef_HEAD_INIT
,
2025 #endif /* HAVE_PYTHON */