1 /* General python/gdb code
3 Copyright (C) 2008-2013 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 "exceptions.h"
31 #include "event-loop.h"
33 #include "readline/tilde.h"
35 #include "cli/cli-utils.h"
39 /* Declared constants and enum for python stack printing. */
40 static const char python_excp_none[] = "none";
41 static const char python_excp_full[] = "full";
42 static const char python_excp_message[] = "message";
44 /* "set python print-stack" choices. */
45 static const char *const python_excp_enums[] =
53 /* The exception printing variable. 'full' if we want to print the
54 error message and stack, 'none' if we want to print nothing, and
55 'message' if we only want to print the error message. 'message' is
57 static const char *gdbpy_should_print_stack = python_excp_message;
61 #include "libiberty.h"
62 #include "cli/cli-decode.h"
66 #include "python-internal.h"
71 #include "gdbthread.h"
74 #include "event-top.h"
76 static PyMethodDef GdbMethods[];
79 static struct PyModuleDef GdbModuleDef;
83 PyObject *gdb_python_module;
85 /* Some string constants we may wish to use. */
86 PyObject *gdbpy_to_string_cst;
87 PyObject *gdbpy_children_cst;
88 PyObject *gdbpy_display_hint_cst;
89 PyObject *gdbpy_doc_cst;
90 PyObject *gdbpy_enabled_cst;
91 PyObject *gdbpy_value_cst;
93 /* The GdbError exception. */
94 PyObject *gdbpy_gdberror_exc;
96 /* The `gdb.error' base class. */
97 PyObject *gdbpy_gdb_error;
99 /* The `gdb.MemoryError' exception. */
100 PyObject *gdbpy_gdb_memory_error;
102 /* Architecture and language to be used in callbacks from
103 the Python interpreter. */
104 struct gdbarch *python_gdbarch;
105 const struct language_defn *python_language;
107 /* Restore global language and architecture and Python GIL state
108 when leaving the Python interpreter. */
112 PyGILState_STATE state;
113 struct gdbarch *gdbarch;
114 const struct language_defn *language;
115 PyObject *error_type, *error_value, *error_traceback;
119 restore_python_env (void *p)
121 struct python_env *env = (struct python_env *)p;
123 /* Leftover Python error is forbidden by Python Exception Handling. */
124 if (PyErr_Occurred ())
126 /* This order is similar to the one calling error afterwards. */
127 gdbpy_print_stack ();
128 warning (_("internal error: Unhandled Python exception"));
131 PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
133 PyGILState_Release (env->state);
134 python_gdbarch = env->gdbarch;
135 python_language = env->language;
139 /* Called before entering the Python interpreter to install the
140 current language and architecture to be used for Python values. */
143 ensure_python_env (struct gdbarch *gdbarch,
144 const struct language_defn *language)
146 struct python_env *env = xmalloc (sizeof *env);
148 env->state = PyGILState_Ensure ();
149 env->gdbarch = python_gdbarch;
150 env->language = python_language;
152 python_gdbarch = gdbarch;
153 python_language = language;
155 /* Save it and ensure ! PyErr_Occurred () afterwards. */
156 PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
158 return make_cleanup (restore_python_env, env);
161 /* Clear the quit flag. */
164 clear_quit_flag (void)
166 /* This clears the flag as a side effect. */
167 PyOS_InterruptOccurred ();
170 /* Set the quit flag. */
175 PyErr_SetInterrupt ();
178 /* Return true if the quit flag has been set, false otherwise. */
181 check_quit_flag (void)
183 return PyOS_InterruptOccurred ();
186 /* Evaluate a Python command like PyRun_SimpleString, but uses
187 Py_single_input which prints the result of expressions, and does
188 not automatically print the stack on errors. */
191 eval_python_command (const char *command)
195 m = PyImport_AddModule ("__main__");
199 d = PyModule_GetDict (m);
202 v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
215 /* Implementation of the gdb "python-interactive" command. */
218 python_interactive_command (char *arg, int from_tty)
220 struct cleanup *cleanup;
223 cleanup = make_cleanup_restore_integer (&interpreter_async);
224 interpreter_async = 0;
226 arg = skip_spaces (arg);
228 ensure_python_env (get_current_arch (), current_language);
232 int len = strlen (arg);
233 char *script = xmalloc (len + 2);
235 strcpy (script, arg);
237 script[len + 1] = '\0';
238 err = eval_python_command (script);
243 err = PyRun_InteractiveLoop (instream, "<stdin>");
249 gdbpy_print_stack ();
250 error (_("Error while executing Python code."));
253 do_cleanups (cleanup);
256 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
259 On Windows hosts few users would build Python themselves (this is no
260 trivial task on this platform), and thus use binaries built by
261 someone else instead. There may happen situation where the Python
262 library and GDB are using two different versions of the C runtime
263 library. Python, being built with VC, would use one version of the
264 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
265 A FILE * from one runtime does not necessarily operate correctly in
268 To work around this potential issue, we create on Windows hosts the
269 FILE object using Python routines, thus making sure that it is
270 compatible with the Python library. */
273 python_run_simple_file (FILE *file, const char *filename)
277 PyRun_SimpleFile (file, filename);
282 PyObject *python_file;
283 struct cleanup *cleanup;
285 /* Because we have a string for a filename, and are using Python to
286 open the file, we need to expand any tilde in the path first. */
287 full_path = tilde_expand (filename);
288 cleanup = make_cleanup (xfree, full_path);
289 python_file = PyFile_FromString (full_path, "r");
292 do_cleanups (cleanup);
293 gdbpy_print_stack ();
294 error (_("Error while opening file: %s"), full_path);
297 make_cleanup_py_decref (python_file);
298 PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
299 do_cleanups (cleanup);
304 /* Given a command_line, return a command string suitable for passing
305 to Python. Lines in the string are separated by newlines. The
306 return value is allocated using xmalloc and the caller is
307 responsible for freeing it. */
310 compute_python_string (struct command_line *l)
312 struct command_line *iter;
317 for (iter = l; iter; iter = iter->next)
318 size += strlen (iter->line) + 1;
320 script = xmalloc (size + 1);
322 for (iter = l; iter; iter = iter->next)
324 int len = strlen (iter->line);
326 strcpy (&script[here], iter->line);
328 script[here++] = '\n';
334 /* Take a command line structure representing a 'python' command, and
335 evaluate its body using the Python interpreter. */
338 eval_python_from_control_command (struct command_line *cmd)
342 struct cleanup *cleanup;
344 if (cmd->body_count != 1)
345 error (_("Invalid \"python\" block structure."));
347 cleanup = ensure_python_env (get_current_arch (), current_language);
349 script = compute_python_string (cmd->body_list[0]);
350 ret = PyRun_SimpleString (script);
353 error (_("Error while executing Python code."));
355 do_cleanups (cleanup);
358 /* Implementation of the gdb "python" command. */
361 python_command (char *arg, int from_tty)
363 struct cleanup *cleanup;
365 cleanup = ensure_python_env (get_current_arch (), current_language);
367 make_cleanup_restore_integer (&interpreter_async);
368 interpreter_async = 0;
370 arg = skip_spaces (arg);
373 if (PyRun_SimpleString (arg))
374 error (_("Error while executing Python code."));
378 struct command_line *l = get_command_line (python_control, "");
380 make_cleanup_free_command_lines (&l);
381 execute_control_command_untraced (l);
384 do_cleanups (cleanup);
389 /* Transform a gdb parameters's value into a Python value. May return
390 NULL (and set a Python exception) on error. Helper function for
393 gdbpy_parameter_value (enum var_types type, void *var)
398 case var_string_noescape:
399 case var_optional_filename:
403 char *str = * (char **) var;
407 return PyString_Decode (str, strlen (str), host_charset (), NULL);
418 case var_auto_boolean:
420 enum auto_boolean ab = * (enum auto_boolean *) var;
422 if (ab == AUTO_BOOLEAN_TRUE)
424 else if (ab == AUTO_BOOLEAN_FALSE)
431 if ((* (int *) var) == INT_MAX)
435 return PyLong_FromLong (* (int *) var);
439 unsigned int val = * (unsigned int *) var;
443 return PyLong_FromUnsignedLong (val);
447 return PyErr_Format (PyExc_RuntimeError,
448 _("Programmer error: unhandled type."));
451 /* A Python function which returns a gdb parameter's value as a Python
455 gdbpy_parameter (PyObject *self, PyObject *args)
457 struct cmd_list_element *alias, *prefix, *cmd;
461 volatile struct gdb_exception except;
463 if (! PyArg_ParseTuple (args, "s", &arg))
466 newarg = concat ("show ", arg, (char *) NULL);
468 TRY_CATCH (except, RETURN_MASK_ALL)
470 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
473 GDB_PY_HANDLE_EXCEPTION (except);
475 return PyErr_Format (PyExc_RuntimeError,
476 _("Could not find parameter `%s'."), arg);
479 return PyErr_Format (PyExc_RuntimeError,
480 _("`%s' is not a parameter."), arg);
481 return gdbpy_parameter_value (cmd->var_type, cmd->var);
484 /* Wrapper for target_charset. */
487 gdbpy_target_charset (PyObject *self, PyObject *args)
489 const char *cset = target_charset (python_gdbarch);
491 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
494 /* Wrapper for target_wide_charset. */
497 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
499 const char *cset = target_wide_charset (python_gdbarch);
501 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
504 /* A Python function which evaluates a string using the gdb CLI. */
507 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
510 PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
511 int from_tty, to_string;
512 volatile struct gdb_exception except;
513 static char *keywords[] = {"command", "from_tty", "to_string", NULL };
516 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
517 &PyBool_Type, &from_tty_obj,
518 &PyBool_Type, &to_string_obj))
524 int cmp = PyObject_IsTrue (from_tty_obj);
533 int cmp = PyObject_IsTrue (to_string_obj);
539 TRY_CATCH (except, RETURN_MASK_ALL)
541 /* Copy the argument text in case the command modifies it. */
542 char *copy = xstrdup (arg);
543 struct cleanup *cleanup = make_cleanup (xfree, copy);
545 make_cleanup_restore_integer (&interpreter_async);
546 interpreter_async = 0;
548 prevent_dont_repeat ();
550 result = execute_command_to_string (copy, from_tty);
554 execute_command (copy, from_tty);
557 do_cleanups (cleanup);
559 GDB_PY_HANDLE_EXCEPTION (except);
561 /* Do any commands attached to breakpoint we stopped at. */
562 bpstat_do_actions ();
566 PyObject *r = PyString_FromString (result);
573 /* Implementation of gdb.solib_name (Long) -> String.
574 Returns the name of the shared library holding a given address, or None. */
577 gdbpy_solib_name (PyObject *self, PyObject *args)
583 if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
586 soname = solib_name_from_address (current_program_space, pc);
588 str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
598 /* A Python function which is a wrapper for decode_line_1. */
601 gdbpy_decode_line (PyObject *self, PyObject *args)
603 struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
605 struct symtab_and_line sal;
606 const char *arg = NULL;
607 char *copy_to_free = NULL, *copy = NULL;
608 struct cleanup *cleanups;
609 PyObject *result = NULL;
610 PyObject *return_result = NULL;
611 PyObject *unparsed = NULL;
612 volatile struct gdb_exception except;
614 if (! PyArg_ParseTuple (args, "|s", &arg))
617 cleanups = make_cleanup (null_cleanup, NULL);
620 TRY_CATCH (except, RETURN_MASK_ALL)
624 copy = xstrdup (arg);
626 sals = decode_line_1 (©, 0, 0, 0);
630 set_default_source_symtab_and_line ();
631 sal = get_current_source_symtab_and_line ();
637 if (sals.sals != NULL && sals.sals != &sal)
639 make_cleanup (xfree, copy_to_free);
640 make_cleanup (xfree, sals.sals);
643 if (except.reason < 0)
645 do_cleanups (cleanups);
646 /* We know this will always throw. */
647 GDB_PY_HANDLE_EXCEPTION (except);
654 result = PyTuple_New (sals.nelts);
657 for (i = 0; i < sals.nelts; ++i)
661 obj = symtab_and_line_to_sal_object (sals.sals[i]);
668 PyTuple_SetItem (result, i, obj);
677 return_result = PyTuple_New (2);
684 if (copy && strlen (copy) > 0)
686 unparsed = PyString_FromString (copy);
687 if (unparsed == NULL)
690 Py_DECREF (return_result);
691 return_result = NULL;
701 PyTuple_SetItem (return_result, 0, unparsed);
702 PyTuple_SetItem (return_result, 1, result);
705 do_cleanups (cleanups);
707 return return_result;
710 /* Parse a string and evaluate it as an expression. */
712 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
714 const char *expr_str;
715 struct value *result = NULL;
716 volatile struct gdb_exception except;
718 if (!PyArg_ParseTuple (args, "s", &expr_str))
721 TRY_CATCH (except, RETURN_MASK_ALL)
723 result = parse_and_eval (expr_str);
725 GDB_PY_HANDLE_EXCEPTION (except);
727 return value_to_value_object (result);
730 /* Implementation of gdb.find_pc_line function.
731 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
734 gdbpy_find_pc_line (PyObject *self, PyObject *args)
736 gdb_py_ulongest pc_llu;
737 volatile struct gdb_exception except;
738 PyObject *result = NULL; /* init for gcc -Wall */
740 if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
743 TRY_CATCH (except, RETURN_MASK_ALL)
745 struct symtab_and_line sal;
748 pc = (CORE_ADDR) pc_llu;
749 sal = find_pc_line (pc, 0);
750 result = symtab_and_line_to_sal_object (sal);
752 GDB_PY_HANDLE_EXCEPTION (except);
757 /* Read a file as Python code.
758 FILE is the file to run. FILENAME is name of the file FILE.
759 This does not throw any errors. If an exception occurs python will print
760 the traceback and clear the error indicator. */
763 source_python_script (FILE *file, const char *filename)
765 struct cleanup *cleanup;
767 cleanup = ensure_python_env (get_current_arch (), current_language);
768 python_run_simple_file (file, filename);
769 do_cleanups (cleanup);
774 /* Posting and handling events. */
776 /* A single event. */
779 /* The Python event. This is just a callable object. */
781 /* The next event. */
782 struct gdbpy_event *next;
785 /* All pending events. */
786 static struct gdbpy_event *gdbpy_event_list;
787 /* The final link of the event list. */
788 static struct gdbpy_event **gdbpy_event_list_end;
790 /* We use a file handler, and not an async handler, so that we can
791 wake up the main thread even when it is blocked in poll(). */
792 static struct serial *gdbpy_event_fds[2];
794 /* The file handler callback. This reads from the internal pipe, and
795 then processes the Python event queue. This will always be run in
796 the main gdb thread. */
799 gdbpy_run_events (struct serial *scb, void *context)
801 struct cleanup *cleanup;
803 cleanup = ensure_python_env (get_current_arch (), current_language);
805 /* Flush the fd. Do this before flushing the events list, so that
806 any new event post afterwards is sure to re-awake the event
808 while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
811 while (gdbpy_event_list)
813 /* Dispatching the event might push a new element onto the event
814 loop, so we update here "atomically enough". */
815 struct gdbpy_event *item = gdbpy_event_list;
816 gdbpy_event_list = gdbpy_event_list->next;
817 if (gdbpy_event_list == NULL)
818 gdbpy_event_list_end = &gdbpy_event_list;
821 if (PyObject_CallObject (item->event, NULL) == NULL)
824 Py_DECREF (item->event);
828 do_cleanups (cleanup);
831 /* Submit an event to the gdb thread. */
833 gdbpy_post_event (PyObject *self, PyObject *args)
835 struct gdbpy_event *event;
839 if (!PyArg_ParseTuple (args, "O", &func))
842 if (!PyCallable_Check (func))
844 PyErr_SetString (PyExc_RuntimeError,
845 _("Posted event is not callable"));
851 /* From here until the end of the function, we have the GIL, so we
852 can operate on our global data structures without worrying. */
853 wakeup = gdbpy_event_list == NULL;
855 event = XNEW (struct gdbpy_event);
858 *gdbpy_event_list_end = event;
859 gdbpy_event_list_end = &event->next;
861 /* Wake up gdb when needed. */
864 char c = 'q'; /* Anything. */
866 if (serial_write (gdbpy_event_fds[1], &c, 1))
867 return PyErr_SetFromErrno (PyExc_IOError);
873 /* Initialize the Python event handler. */
875 gdbpy_initialize_events (void)
877 if (serial_pipe (gdbpy_event_fds) == 0)
879 gdbpy_event_list_end = &gdbpy_event_list;
880 serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
887 before_prompt_hook (const char *current_gdb_prompt)
889 struct cleanup *cleanup;
892 cleanup = ensure_python_env (get_current_arch (), current_language);
894 if (gdb_python_module
895 && PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
899 hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook");
903 make_cleanup_py_decref (hook);
905 if (PyCallable_Check (hook))
908 PyObject *current_prompt;
910 current_prompt = PyString_FromString (current_gdb_prompt);
911 if (current_prompt == NULL)
914 result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
916 Py_DECREF (current_prompt);
921 make_cleanup_py_decref (result);
923 /* Return type should be None, or a String. If it is None,
924 fall through, we will not set a prompt. If it is a
925 string, set PROMPT. Anything else, set an exception. */
926 if (result != Py_None && ! PyString_Check (result))
928 PyErr_Format (PyExc_RuntimeError,
929 _("Return from prompt_hook must " \
930 "be either a Python string, or None"));
934 if (result != Py_None)
936 prompt = python_string_to_host_string (result);
941 make_cleanup (xfree, prompt);
946 /* If a prompt has been set, PROMPT will not be NULL. If it is
947 NULL, do not set the prompt. */
951 do_cleanups (cleanup);
955 gdbpy_print_stack ();
956 do_cleanups (cleanup);
964 /* A python function to write a single string using gdb's filtered
965 output stream . The optional keyword STREAM can be used to write
966 to a particular stream. The default stream is to gdb_stdout. */
969 gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
972 static char *keywords[] = {"text", "stream", NULL };
974 volatile struct gdb_exception except;
976 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
980 TRY_CATCH (except, RETURN_MASK_ALL)
986 fprintf_filtered (gdb_stderr, "%s", arg);
991 fprintf_filtered (gdb_stdlog, "%s", arg);
995 fprintf_filtered (gdb_stdout, "%s", arg);
998 GDB_PY_HANDLE_EXCEPTION (except);
1003 /* A python function to flush a gdb stream. The optional keyword
1004 STREAM can be used to flush a particular stream. The default stream
1008 gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
1010 static char *keywords[] = {"stream", NULL };
1011 int stream_type = 0;
1013 if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
1017 switch (stream_type)
1021 gdb_flush (gdb_stderr);
1026 gdb_flush (gdb_stdlog);
1030 gdb_flush (gdb_stdout);
1036 /* Print a python exception trace, print just a message, or print
1037 nothing and clear the python exception, depending on
1038 gdbpy_should_print_stack. Only call this if a python exception is
1041 gdbpy_print_stack (void)
1043 volatile struct gdb_exception except;
1045 /* Print "none", just clear exception. */
1046 if (gdbpy_should_print_stack == python_excp_none)
1050 /* Print "full" message and backtrace. */
1051 else if (gdbpy_should_print_stack == python_excp_full)
1054 /* PyErr_Print doesn't necessarily end output with a newline.
1055 This works because Python's stdout/stderr is fed through
1057 TRY_CATCH (except, RETURN_MASK_ALL)
1062 /* Print "message", just error print message. */
1065 PyObject *ptype, *pvalue, *ptraceback;
1066 char *msg = NULL, *type = NULL;
1068 PyErr_Fetch (&ptype, &pvalue, &ptraceback);
1070 /* Fetch the error message contained within ptype, pvalue. */
1071 msg = gdbpy_exception_to_string (ptype, pvalue);
1072 type = gdbpy_obj_to_string (ptype);
1074 TRY_CATCH (except, RETURN_MASK_ALL)
1078 /* An error occurred computing the string representation of the
1080 fprintf_filtered (gdb_stderr,
1081 _("Error occurred computing Python error" \
1085 fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
1090 Py_XDECREF (pvalue);
1091 Py_XDECREF (ptraceback);
1098 /* Return the current Progspace.
1099 There always is one. */
1102 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
1106 result = pspace_to_pspace_object (current_program_space);
1112 /* Return a sequence holding all the Progspaces. */
1115 gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
1117 struct program_space *ps;
1120 list = PyList_New (0);
1126 PyObject *item = pspace_to_pspace_object (ps);
1128 if (!item || PyList_Append (list, item) == -1)
1140 /* The "current" objfile. This is set when gdb detects that a new
1141 objfile has been loaded. It is only set for the duration of a call to
1142 source_python_script_for_objfile; it is NULL at other times. */
1143 static struct objfile *gdbpy_current_objfile;
1145 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1146 as Python code. This does not throw any errors. If an exception
1147 occurs python will print the traceback and clear the error indicator. */
1150 source_python_script_for_objfile (struct objfile *objfile, FILE *file,
1151 const char *filename)
1153 struct cleanup *cleanups;
1155 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
1156 gdbpy_current_objfile = objfile;
1158 python_run_simple_file (file, filename);
1160 do_cleanups (cleanups);
1161 gdbpy_current_objfile = NULL;
1164 /* Return the current Objfile, or None if there isn't one. */
1167 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
1171 if (! gdbpy_current_objfile)
1174 result = objfile_to_objfile_object (gdbpy_current_objfile);
1180 /* Return a sequence holding all the Objfiles. */
1183 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
1185 struct objfile *objf;
1188 list = PyList_New (0);
1194 PyObject *item = objfile_to_objfile_object (objf);
1196 if (!item || PyList_Append (list, item) == -1)
1206 /* Compute the list of active type printers and return it. The result
1207 of this function can be passed to apply_type_printers, and should
1208 be freed by free_type_printers. */
1211 start_type_printers (void)
1213 struct cleanup *cleanups;
1214 PyObject *type_module, *func, *result_obj = NULL;
1216 cleanups = ensure_python_env (get_current_arch (), current_language);
1218 type_module = PyImport_ImportModule ("gdb.types");
1219 if (type_module == NULL)
1221 gdbpy_print_stack ();
1224 make_cleanup_py_decref (type_module);
1226 func = PyObject_GetAttrString (type_module, "get_type_recognizers");
1229 gdbpy_print_stack ();
1232 make_cleanup_py_decref (func);
1234 result_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
1235 if (result_obj == NULL)
1236 gdbpy_print_stack ();
1239 do_cleanups (cleanups);
1243 /* If TYPE is recognized by some type printer, return a newly
1244 allocated string holding the type's replacement name. The caller
1245 is responsible for freeing the string. Otherwise, return NULL.
1247 This function has a bit of a funny name, since it actually applies
1248 recognizers, but this seemed clearer given the start_type_printers
1249 and free_type_printers functions. */
1252 apply_type_printers (void *printers, struct type *type)
1254 struct cleanup *cleanups;
1255 PyObject *type_obj, *type_module, *func, *result_obj;
1256 PyObject *printers_obj = printers;
1257 char *result = NULL;
1259 if (printers_obj == NULL)
1262 cleanups = ensure_python_env (get_current_arch (), current_language);
1264 type_obj = type_to_type_object (type);
1265 if (type_obj == NULL)
1267 gdbpy_print_stack ();
1270 make_cleanup_py_decref (type_obj);
1272 type_module = PyImport_ImportModule ("gdb.types");
1273 if (type_module == NULL)
1275 gdbpy_print_stack ();
1278 make_cleanup_py_decref (type_module);
1280 func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
1283 gdbpy_print_stack ();
1286 make_cleanup_py_decref (func);
1288 result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
1289 type_obj, (char *) NULL);
1290 if (result_obj == NULL)
1292 gdbpy_print_stack ();
1295 make_cleanup_py_decref (result_obj);
1297 if (result_obj != Py_None)
1299 result = python_string_to_host_string (result_obj);
1301 gdbpy_print_stack ();
1305 do_cleanups (cleanups);
1309 /* Free the result of start_type_printers. */
1312 free_type_printers (void *arg)
1314 struct cleanup *cleanups;
1315 PyObject *printers = arg;
1317 if (printers == NULL)
1320 cleanups = ensure_python_env (get_current_arch (), current_language);
1321 Py_DECREF (printers);
1322 do_cleanups (cleanups);
1325 #else /* HAVE_PYTHON */
1327 /* Dummy implementation of the gdb "python-interactive" and "python"
1331 python_interactive_command (char *arg, int from_tty)
1333 arg = skip_spaces (arg);
1335 error (_("Python scripting is not supported in this copy of GDB."));
1338 struct command_line *l = get_command_line (python_control, "");
1339 struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
1341 execute_control_command_untraced (l);
1342 do_cleanups (cleanups);
1347 python_command (char *arg, int from_tty)
1349 python_interactive_command (arg, from_tty);
1353 eval_python_from_control_command (struct command_line *cmd)
1355 error (_("Python scripting is not supported in this copy of GDB."));
1359 source_python_script (FILE *file, const char *filename)
1361 throw_error (UNSUPPORTED_ERROR,
1362 _("Python scripting is not supported in this copy of GDB."));
1366 gdbpy_should_stop (struct breakpoint_object *bp_obj)
1368 internal_error (__FILE__, __LINE__,
1369 _("gdbpy_should_stop called when Python scripting is " \
1374 gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj)
1376 internal_error (__FILE__, __LINE__,
1377 _("gdbpy_breakpoint_has_py_cond called when Python " \
1378 "scripting is not supported."));
1382 start_type_printers (void)
1388 apply_type_printers (void *ignore, struct type *type)
1394 free_type_printers (void *arg)
1399 apply_frame_filter (struct frame_info *frame, int flags,
1400 enum py_frame_args args_type,
1401 struct ui_out *out, int frame_low,
1404 return PY_BT_NO_FILTERS;
1407 #endif /* HAVE_PYTHON */
1411 /* Lists for 'set python' commands. */
1413 static struct cmd_list_element *user_set_python_list;
1414 static struct cmd_list_element *user_show_python_list;
1416 /* Function for use by 'set python' prefix command. */
1419 user_set_python (char *args, int from_tty)
1421 help_list (user_set_python_list, "set python ", all_commands,
1425 /* Function for use by 'show python' prefix command. */
1428 user_show_python (char *args, int from_tty)
1430 cmd_show_list (user_show_python_list, from_tty, "");
1433 /* Initialize the Python code. */
1437 /* This is installed as a final cleanup and cleans up the
1438 interpreter. This lets Python's 'atexit' work. */
1441 finalize_python (void *ignore)
1443 /* We don't use ensure_python_env here because if we ever ran the
1444 cleanup, gdb would crash -- because the cleanup calls into the
1445 Python interpreter, which we are about to destroy. It seems
1446 clearer to make the needed calls explicitly here than to create a
1447 cleanup and then mysteriously discard it. */
1448 (void) PyGILState_Ensure ();
1449 python_gdbarch = target_gdbarch ();
1450 python_language = current_language;
1456 /* Provide a prototype to silence -Wmissing-prototypes. */
1457 extern initialize_file_ftype _initialize_python;
1460 _initialize_python (void)
1465 size_t progsize, count;
1467 wchar_t *progname_copy;
1470 add_com ("python-interactive", class_obscure,
1471 python_interactive_command,
1474 Start an interactive Python prompt.\n\
1476 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1479 Alternatively, a single-line Python command can be given as an\n\
1480 argument, and if the command is an expression, the result will be\n\
1481 printed. For example:\n\
1483 (gdb) python-interactive 2 + 3\n\
1486 #else /* HAVE_PYTHON */
1488 Start a Python interactive prompt.\n\
1490 Python scripting is not supported in this copy of GDB.\n\
1491 This command is only a placeholder.")
1492 #endif /* HAVE_PYTHON */
1494 add_com_alias ("pi", "python-interactive", class_obscure, 1);
1496 add_com ("python", class_obscure, python_command,
1499 Evaluate a Python command.\n\
1501 The command can be given as an argument, for instance:\n\
1505 If no argument is given, the following lines are read and used\n\
1506 as the Python commands. Type a line containing \"end\" to indicate\n\
1507 the end of the command.")
1508 #else /* HAVE_PYTHON */
1510 Evaluate a Python command.\n\
1512 Python scripting is not supported in this copy of GDB.\n\
1513 This command is only a placeholder.")
1514 #endif /* HAVE_PYTHON */
1516 add_com_alias ("py", "python", class_obscure, 1);
1518 /* Add set/show python print-stack. */
1519 add_prefix_cmd ("python", no_class, user_show_python,
1520 _("Prefix command for python preference settings."),
1521 &user_show_python_list, "show python ", 0,
1524 add_prefix_cmd ("python", no_class, user_set_python,
1525 _("Prefix command for python preference settings."),
1526 &user_set_python_list, "set python ", 0,
1529 add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
1530 &gdbpy_should_print_stack, _("\
1531 Set mode for Python stack dump on error."), _("\
1532 Show the mode of Python stack printing on error."), _("\
1533 none == no stack or message will be printed.\n\
1534 full == a message and a stack will be printed.\n\
1535 message == an error message without a stack will be printed."),
1537 &user_set_python_list,
1538 &user_show_python_list);
1541 #ifdef WITH_PYTHON_PATH
1542 /* Work around problem where python gets confused about where it is,
1543 and then can't find its libraries, etc.
1544 NOTE: Python assumes the following layout:
1546 /foo/lib/pythonX.Y/...
1547 This must be done before calling Py_Initialize. */
1548 progname = concat (ldirname (python_libdir), SLASH_STRING, "bin",
1549 SLASH_STRING, "python", NULL);
1551 oldloc = setlocale (LC_ALL, NULL);
1552 setlocale (LC_ALL, "");
1553 progsize = strlen (progname);
1554 if (progsize == (size_t) -1)
1556 fprintf (stderr, "Could not convert python path to string\n");
1559 progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
1562 fprintf (stderr, "out of memory\n");
1565 count = mbstowcs (progname_copy, progname, progsize + 1);
1566 if (count == (size_t) -1)
1568 fprintf (stderr, "Could not convert python path to string\n");
1571 setlocale (LC_ALL, oldloc);
1573 /* Note that Py_SetProgramName expects the string it is passed to
1574 remain alive for the duration of the program's execution, so
1575 it is not freed after this call. */
1576 Py_SetProgramName (progname_copy);
1578 Py_SetProgramName (progname);
1583 PyEval_InitThreads ();
1586 gdb_module = PyModule_Create (&GdbModuleDef);
1587 /* Add _gdb module to the list of known built-in modules. */
1588 _PyImport_FixupBuiltin (gdb_module, "_gdb");
1590 gdb_module = Py_InitModule ("_gdb", GdbMethods);
1593 /* The casts to (char*) are for python 2.4. */
1594 PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
1595 PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
1596 PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
1597 (char*) target_name);
1599 /* Add stream constants. */
1600 PyModule_AddIntConstant (gdb_module, "STDOUT", 0);
1601 PyModule_AddIntConstant (gdb_module, "STDERR", 1);
1602 PyModule_AddIntConstant (gdb_module, "STDLOG", 2);
1604 gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
1605 PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error);
1607 gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
1608 gdbpy_gdb_error, NULL);
1609 PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error);
1611 gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
1612 PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc);
1614 gdbpy_initialize_gdb_readline ();
1615 gdbpy_initialize_auto_load ();
1616 gdbpy_initialize_values ();
1617 gdbpy_initialize_frames ();
1618 gdbpy_initialize_commands ();
1619 gdbpy_initialize_symbols ();
1620 gdbpy_initialize_symtabs ();
1621 gdbpy_initialize_blocks ();
1622 gdbpy_initialize_functions ();
1623 gdbpy_initialize_parameters ();
1624 gdbpy_initialize_types ();
1625 gdbpy_initialize_pspace ();
1626 gdbpy_initialize_objfile ();
1627 gdbpy_initialize_breakpoints ();
1628 gdbpy_initialize_finishbreakpoints ();
1629 gdbpy_initialize_lazy_string ();
1630 gdbpy_initialize_thread ();
1631 gdbpy_initialize_inferior ();
1632 gdbpy_initialize_events ();
1634 gdbpy_initialize_eventregistry ();
1635 gdbpy_initialize_py_events ();
1636 gdbpy_initialize_event ();
1637 gdbpy_initialize_stop_event ();
1638 gdbpy_initialize_signal_event ();
1639 gdbpy_initialize_breakpoint_event ();
1640 gdbpy_initialize_continue_event ();
1641 gdbpy_initialize_exited_event ();
1642 gdbpy_initialize_thread_event ();
1643 gdbpy_initialize_new_objfile_event () ;
1644 gdbpy_initialize_arch ();
1646 observer_attach_before_prompt (before_prompt_hook);
1648 gdbpy_to_string_cst = PyString_FromString ("to_string");
1649 gdbpy_children_cst = PyString_FromString ("children");
1650 gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1651 gdbpy_doc_cst = PyString_FromString ("__doc__");
1652 gdbpy_enabled_cst = PyString_FromString ("enabled");
1653 gdbpy_value_cst = PyString_FromString ("value");
1655 /* Release the GIL while gdb runs. */
1656 PyThreadState_Swap (NULL);
1657 PyEval_ReleaseLock ();
1659 make_final_cleanup (finalize_python, NULL);
1660 #endif /* HAVE_PYTHON */
1665 /* Perform the remaining python initializations.
1666 These must be done after GDB is at least mostly initialized.
1667 E.g., The "info pretty-printer" command needs the "info" prefix
1668 command installed. */
1671 finish_python_initialization (void)
1674 char *gdb_pythondir;
1676 struct cleanup *cleanup;
1678 cleanup = ensure_python_env (get_current_arch (), current_language);
1680 /* Add the initial data-directory to sys.path. */
1682 gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
1683 make_cleanup (xfree, gdb_pythondir);
1685 sys_path = PySys_GetObject ("path");
1687 /* If sys.path is not defined yet, define it first. */
1688 if (!(sys_path && PyList_Check (sys_path)))
1691 PySys_SetPath (L"");
1695 sys_path = PySys_GetObject ("path");
1697 if (sys_path && PyList_Check (sys_path))
1699 PyObject *pythondir;
1702 pythondir = PyString_FromString (gdb_pythondir);
1703 if (pythondir == NULL)
1706 err = PyList_Insert (sys_path, 0, pythondir);
1710 Py_DECREF (pythondir);
1715 /* Import the gdb module to finish the initialization, and
1716 add it to __main__ for convenience. */
1717 m = PyImport_AddModule ("__main__");
1721 gdb_python_module = PyImport_ImportModule ("gdb");
1722 if (gdb_python_module == NULL)
1724 gdbpy_print_stack ();
1725 /* This is passed in one call to warning so that blank lines aren't
1726 inserted between each line of text. */
1728 "Could not load the Python gdb module from `%s'.\n"
1729 "Limited Python support is available from the _gdb module.\n"
1730 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1732 do_cleanups (cleanup);
1736 if (PyModule_AddObject (m, "gdb", gdb_python_module))
1739 /* Keep the reference to gdb_python_module since it is in a global
1742 do_cleanups (cleanup);
1746 gdbpy_print_stack ();
1747 warning (_("internal error: Unhandled Python exception"));
1748 do_cleanups (cleanup);
1751 #endif /* HAVE_PYTHON */
1757 static PyMethodDef GdbMethods[] =
1759 { "history", gdbpy_history, METH_VARARGS,
1760 "Get a value from history" },
1761 { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
1762 "Execute a gdb command" },
1763 { "parameter", gdbpy_parameter, METH_VARARGS,
1764 "Return a gdb parameter's value" },
1766 { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1767 "Return a tuple of all breakpoint objects" },
1769 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1770 "Find the default visualizer for a Value." },
1772 { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
1773 "Return the current Progspace." },
1774 { "progspaces", gdbpy_progspaces, METH_NOARGS,
1775 "Return a sequence of all progspaces." },
1777 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
1778 "Return the current Objfile being loaded, or None." },
1779 { "objfiles", gdbpy_objfiles, METH_NOARGS,
1780 "Return a sequence of all loaded objfiles." },
1782 { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
1783 "newest_frame () -> gdb.Frame.\n\
1784 Return the newest frame object." },
1785 { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
1786 "selected_frame () -> gdb.Frame.\n\
1787 Return the selected frame object." },
1788 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
1789 "stop_reason_string (Integer) -> String.\n\
1790 Return a string explaining unwind stop reason." },
1792 { "lookup_type", (PyCFunction) gdbpy_lookup_type,
1793 METH_VARARGS | METH_KEYWORDS,
1794 "lookup_type (name [, block]) -> type\n\
1795 Return a Type corresponding to the given name." },
1796 { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
1797 METH_VARARGS | METH_KEYWORDS,
1798 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1799 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1800 a boolean indicating if name is a field of the current implied argument\n\
1801 `this' (when the current language is object-oriented)." },
1802 { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
1803 METH_VARARGS | METH_KEYWORDS,
1804 "lookup_global_symbol (name [, domain]) -> symbol\n\
1805 Return the symbol corresponding to the given name (or None)." },
1806 { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
1807 "Return the block containing the given pc value, or None." },
1808 { "solib_name", gdbpy_solib_name, METH_VARARGS,
1809 "solib_name (Long) -> String.\n\
1810 Return the name of the shared library holding a given address, or None." },
1811 { "decode_line", gdbpy_decode_line, METH_VARARGS,
1812 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1813 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1814 The first element contains any unparsed portion of the String parameter\n\
1815 (or None if the string was fully parsed). The second element contains\n\
1816 a tuple that contains all the locations that match, represented as\n\
1817 gdb.Symtab_and_line objects (or None)."},
1818 { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
1819 "parse_and_eval (String) -> Value.\n\
1820 Parse String as an expression, evaluate it, and return the result as a Value."
1822 { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS,
1823 "find_pc_line (pc) -> Symtab_and_line.\n\
1824 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1826 { "post_event", gdbpy_post_event, METH_VARARGS,
1827 "Post an event into gdb's event loop." },
1829 { "target_charset", gdbpy_target_charset, METH_NOARGS,
1830 "target_charset () -> string.\n\
1831 Return the name of the current target charset." },
1832 { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
1833 "target_wide_charset () -> string.\n\
1834 Return the name of the current target wide charset." },
1836 { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
1837 "string_to_argv (String) -> Array.\n\
1838 Parse String and return an argv-like array.\n\
1839 Arguments are separate by spaces and may be quoted."
1841 { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
1842 "Write a string using gdb's filtered stream." },
1843 { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
1844 "Flush gdb's filtered stdout stream." },
1845 { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
1846 "selected_thread () -> gdb.InferiorThread.\n\
1847 Return the selected thread object." },
1848 { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
1849 "selected_inferior () -> gdb.Inferior.\n\
1850 Return the selected inferior object." },
1851 { "inferiors", gdbpy_inferiors, METH_NOARGS,
1852 "inferiors () -> (gdb.Inferior, ...).\n\
1853 Return a tuple containing all inferiors." },
1854 {NULL, NULL, 0, NULL}
1858 static struct PyModuleDef GdbModuleDef =
1860 PyModuleDef_HEAD_INIT,
1871 #endif /* HAVE_PYTHON */