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 /* True if Python has been successfully initialized, false
79 int gdb_python_initialized;
81 static PyMethodDef GdbMethods[];
84 static struct PyModuleDef GdbModuleDef;
88 PyObject *gdb_python_module;
90 /* Some string constants we may wish to use. */
91 PyObject *gdbpy_to_string_cst;
92 PyObject *gdbpy_children_cst;
93 PyObject *gdbpy_display_hint_cst;
94 PyObject *gdbpy_doc_cst;
95 PyObject *gdbpy_enabled_cst;
96 PyObject *gdbpy_value_cst;
98 /* The GdbError exception. */
99 PyObject *gdbpy_gdberror_exc;
101 /* The `gdb.error' base class. */
102 PyObject *gdbpy_gdb_error;
104 /* The `gdb.MemoryError' exception. */
105 PyObject *gdbpy_gdb_memory_error;
107 /* Architecture and language to be used in callbacks from
108 the Python interpreter. */
109 struct gdbarch *python_gdbarch;
110 const struct language_defn *python_language;
112 /* Restore global language and architecture and Python GIL state
113 when leaving the Python interpreter. */
117 PyGILState_STATE state;
118 struct gdbarch *gdbarch;
119 const struct language_defn *language;
120 PyObject *error_type, *error_value, *error_traceback;
124 restore_python_env (void *p)
126 struct python_env *env = (struct python_env *)p;
128 /* Leftover Python error is forbidden by Python Exception Handling. */
129 if (PyErr_Occurred ())
131 /* This order is similar to the one calling error afterwards. */
132 gdbpy_print_stack ();
133 warning (_("internal error: Unhandled Python exception"));
136 PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
138 PyGILState_Release (env->state);
139 python_gdbarch = env->gdbarch;
140 python_language = env->language;
144 /* Called before entering the Python interpreter to install the
145 current language and architecture to be used for Python values. */
148 ensure_python_env (struct gdbarch *gdbarch,
149 const struct language_defn *language)
151 struct python_env *env = xmalloc (sizeof *env);
153 env->state = PyGILState_Ensure ();
154 env->gdbarch = python_gdbarch;
155 env->language = python_language;
157 python_gdbarch = gdbarch;
158 python_language = language;
160 /* Save it and ensure ! PyErr_Occurred () afterwards. */
161 PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
163 return make_cleanup (restore_python_env, env);
166 /* Clear the quit flag. */
169 clear_quit_flag (void)
171 /* This clears the flag as a side effect. */
172 PyOS_InterruptOccurred ();
175 /* Set the quit flag. */
180 PyErr_SetInterrupt ();
183 /* Return true if the quit flag has been set, false otherwise. */
186 check_quit_flag (void)
188 return PyOS_InterruptOccurred ();
191 /* Evaluate a Python command like PyRun_SimpleString, but uses
192 Py_single_input which prints the result of expressions, and does
193 not automatically print the stack on errors. */
196 eval_python_command (const char *command)
200 m = PyImport_AddModule ("__main__");
204 d = PyModule_GetDict (m);
207 v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
220 /* Implementation of the gdb "python-interactive" command. */
223 python_interactive_command (char *arg, int from_tty)
225 struct cleanup *cleanup;
228 cleanup = make_cleanup_restore_integer (&interpreter_async);
229 interpreter_async = 0;
231 arg = skip_spaces (arg);
233 ensure_python_env (get_current_arch (), current_language);
237 int len = strlen (arg);
238 char *script = xmalloc (len + 2);
240 strcpy (script, arg);
242 script[len + 1] = '\0';
243 err = eval_python_command (script);
248 err = PyRun_InteractiveLoop (instream, "<stdin>");
254 gdbpy_print_stack ();
255 error (_("Error while executing Python code."));
258 do_cleanups (cleanup);
261 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
264 On Windows hosts few users would build Python themselves (this is no
265 trivial task on this platform), and thus use binaries built by
266 someone else instead. There may happen situation where the Python
267 library and GDB are using two different versions of the C runtime
268 library. Python, being built with VC, would use one version of the
269 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
270 A FILE * from one runtime does not necessarily operate correctly in
273 To work around this potential issue, we create on Windows hosts the
274 FILE object using Python routines, thus making sure that it is
275 compatible with the Python library. */
278 python_run_simple_file (FILE *file, const char *filename)
282 PyRun_SimpleFile (file, filename);
287 PyObject *python_file;
288 struct cleanup *cleanup;
290 /* Because we have a string for a filename, and are using Python to
291 open the file, we need to expand any tilde in the path first. */
292 full_path = tilde_expand (filename);
293 cleanup = make_cleanup (xfree, full_path);
294 python_file = PyFile_FromString (full_path, "r");
297 do_cleanups (cleanup);
298 gdbpy_print_stack ();
299 error (_("Error while opening file: %s"), full_path);
302 make_cleanup_py_decref (python_file);
303 PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
304 do_cleanups (cleanup);
309 /* Given a command_line, return a command string suitable for passing
310 to Python. Lines in the string are separated by newlines. The
311 return value is allocated using xmalloc and the caller is
312 responsible for freeing it. */
315 compute_python_string (struct command_line *l)
317 struct command_line *iter;
322 for (iter = l; iter; iter = iter->next)
323 size += strlen (iter->line) + 1;
325 script = xmalloc (size + 1);
327 for (iter = l; iter; iter = iter->next)
329 int len = strlen (iter->line);
331 strcpy (&script[here], iter->line);
333 script[here++] = '\n';
339 /* Take a command line structure representing a 'python' command, and
340 evaluate its body using the Python interpreter. */
343 eval_python_from_control_command (struct command_line *cmd)
347 struct cleanup *cleanup;
349 if (cmd->body_count != 1)
350 error (_("Invalid \"python\" block structure."));
352 cleanup = ensure_python_env (get_current_arch (), current_language);
354 script = compute_python_string (cmd->body_list[0]);
355 ret = PyRun_SimpleString (script);
358 error (_("Error while executing Python code."));
360 do_cleanups (cleanup);
363 /* Implementation of the gdb "python" command. */
366 python_command (char *arg, int from_tty)
368 struct cleanup *cleanup;
370 cleanup = ensure_python_env (get_current_arch (), current_language);
372 make_cleanup_restore_integer (&interpreter_async);
373 interpreter_async = 0;
375 arg = skip_spaces (arg);
378 if (PyRun_SimpleString (arg))
379 error (_("Error while executing Python code."));
383 struct command_line *l = get_command_line (python_control, "");
385 make_cleanup_free_command_lines (&l);
386 execute_control_command_untraced (l);
389 do_cleanups (cleanup);
394 /* Transform a gdb parameters's value into a Python value. May return
395 NULL (and set a Python exception) on error. Helper function for
398 gdbpy_parameter_value (enum var_types type, void *var)
403 case var_string_noescape:
404 case var_optional_filename:
408 char *str = * (char **) var;
412 return PyString_Decode (str, strlen (str), host_charset (), NULL);
423 case var_auto_boolean:
425 enum auto_boolean ab = * (enum auto_boolean *) var;
427 if (ab == AUTO_BOOLEAN_TRUE)
429 else if (ab == AUTO_BOOLEAN_FALSE)
436 if ((* (int *) var) == INT_MAX)
440 return PyLong_FromLong (* (int *) var);
444 unsigned int val = * (unsigned int *) var;
448 return PyLong_FromUnsignedLong (val);
452 return PyErr_Format (PyExc_RuntimeError,
453 _("Programmer error: unhandled type."));
456 /* A Python function which returns a gdb parameter's value as a Python
460 gdbpy_parameter (PyObject *self, PyObject *args)
462 struct cmd_list_element *alias, *prefix, *cmd;
466 volatile struct gdb_exception except;
468 if (! PyArg_ParseTuple (args, "s", &arg))
471 newarg = concat ("show ", arg, (char *) NULL);
473 TRY_CATCH (except, RETURN_MASK_ALL)
475 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
478 GDB_PY_HANDLE_EXCEPTION (except);
480 return PyErr_Format (PyExc_RuntimeError,
481 _("Could not find parameter `%s'."), arg);
484 return PyErr_Format (PyExc_RuntimeError,
485 _("`%s' is not a parameter."), arg);
486 return gdbpy_parameter_value (cmd->var_type, cmd->var);
489 /* Wrapper for target_charset. */
492 gdbpy_target_charset (PyObject *self, PyObject *args)
494 const char *cset = target_charset (python_gdbarch);
496 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
499 /* Wrapper for target_wide_charset. */
502 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
504 const char *cset = target_wide_charset (python_gdbarch);
506 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
509 /* A Python function which evaluates a string using the gdb CLI. */
512 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
515 PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
516 int from_tty, to_string;
517 volatile struct gdb_exception except;
518 static char *keywords[] = {"command", "from_tty", "to_string", NULL };
521 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
522 &PyBool_Type, &from_tty_obj,
523 &PyBool_Type, &to_string_obj))
529 int cmp = PyObject_IsTrue (from_tty_obj);
538 int cmp = PyObject_IsTrue (to_string_obj);
544 TRY_CATCH (except, RETURN_MASK_ALL)
546 /* Copy the argument text in case the command modifies it. */
547 char *copy = xstrdup (arg);
548 struct cleanup *cleanup = make_cleanup (xfree, copy);
550 make_cleanup_restore_integer (&interpreter_async);
551 interpreter_async = 0;
553 prevent_dont_repeat ();
555 result = execute_command_to_string (copy, from_tty);
559 execute_command (copy, from_tty);
562 do_cleanups (cleanup);
564 GDB_PY_HANDLE_EXCEPTION (except);
566 /* Do any commands attached to breakpoint we stopped at. */
567 bpstat_do_actions ();
571 PyObject *r = PyString_FromString (result);
578 /* Implementation of gdb.solib_name (Long) -> String.
579 Returns the name of the shared library holding a given address, or None. */
582 gdbpy_solib_name (PyObject *self, PyObject *args)
588 if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
591 soname = solib_name_from_address (current_program_space, pc);
593 str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
603 /* A Python function which is a wrapper for decode_line_1. */
606 gdbpy_decode_line (PyObject *self, PyObject *args)
608 struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
610 struct symtab_and_line sal;
611 const char *arg = NULL;
612 char *copy_to_free = NULL, *copy = NULL;
613 struct cleanup *cleanups;
614 PyObject *result = NULL;
615 PyObject *return_result = NULL;
616 PyObject *unparsed = NULL;
617 volatile struct gdb_exception except;
619 if (! PyArg_ParseTuple (args, "|s", &arg))
622 cleanups = make_cleanup (null_cleanup, NULL);
625 TRY_CATCH (except, RETURN_MASK_ALL)
629 copy = xstrdup (arg);
631 sals = decode_line_1 (©, 0, 0, 0);
635 set_default_source_symtab_and_line ();
636 sal = get_current_source_symtab_and_line ();
642 if (sals.sals != NULL && sals.sals != &sal)
644 make_cleanup (xfree, copy_to_free);
645 make_cleanup (xfree, sals.sals);
648 if (except.reason < 0)
650 do_cleanups (cleanups);
651 /* We know this will always throw. */
652 GDB_PY_HANDLE_EXCEPTION (except);
659 result = PyTuple_New (sals.nelts);
662 for (i = 0; i < sals.nelts; ++i)
666 obj = symtab_and_line_to_sal_object (sals.sals[i]);
673 PyTuple_SetItem (result, i, obj);
682 return_result = PyTuple_New (2);
689 if (copy && strlen (copy) > 0)
691 unparsed = PyString_FromString (copy);
692 if (unparsed == NULL)
695 Py_DECREF (return_result);
696 return_result = NULL;
706 PyTuple_SetItem (return_result, 0, unparsed);
707 PyTuple_SetItem (return_result, 1, result);
710 do_cleanups (cleanups);
712 return return_result;
715 /* Parse a string and evaluate it as an expression. */
717 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
719 const char *expr_str;
720 struct value *result = NULL;
721 volatile struct gdb_exception except;
723 if (!PyArg_ParseTuple (args, "s", &expr_str))
726 TRY_CATCH (except, RETURN_MASK_ALL)
728 result = parse_and_eval (expr_str);
730 GDB_PY_HANDLE_EXCEPTION (except);
732 return value_to_value_object (result);
735 /* Implementation of gdb.find_pc_line function.
736 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
739 gdbpy_find_pc_line (PyObject *self, PyObject *args)
741 gdb_py_ulongest pc_llu;
742 volatile struct gdb_exception except;
743 PyObject *result = NULL; /* init for gcc -Wall */
745 if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
748 TRY_CATCH (except, RETURN_MASK_ALL)
750 struct symtab_and_line sal;
753 pc = (CORE_ADDR) pc_llu;
754 sal = find_pc_line (pc, 0);
755 result = symtab_and_line_to_sal_object (sal);
757 GDB_PY_HANDLE_EXCEPTION (except);
762 /* Read a file as Python code.
763 FILE is the file to run. FILENAME is name of the file FILE.
764 This does not throw any errors. If an exception occurs python will print
765 the traceback and clear the error indicator. */
768 source_python_script (FILE *file, const char *filename)
770 struct cleanup *cleanup;
772 cleanup = ensure_python_env (get_current_arch (), current_language);
773 python_run_simple_file (file, filename);
774 do_cleanups (cleanup);
779 /* Posting and handling events. */
781 /* A single event. */
784 /* The Python event. This is just a callable object. */
786 /* The next event. */
787 struct gdbpy_event *next;
790 /* All pending events. */
791 static struct gdbpy_event *gdbpy_event_list;
792 /* The final link of the event list. */
793 static struct gdbpy_event **gdbpy_event_list_end;
795 /* We use a file handler, and not an async handler, so that we can
796 wake up the main thread even when it is blocked in poll(). */
797 static struct serial *gdbpy_event_fds[2];
799 /* The file handler callback. This reads from the internal pipe, and
800 then processes the Python event queue. This will always be run in
801 the main gdb thread. */
804 gdbpy_run_events (struct serial *scb, void *context)
806 struct cleanup *cleanup;
808 cleanup = ensure_python_env (get_current_arch (), current_language);
810 /* Flush the fd. Do this before flushing the events list, so that
811 any new event post afterwards is sure to re-awake the event
813 while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
816 while (gdbpy_event_list)
818 /* Dispatching the event might push a new element onto the event
819 loop, so we update here "atomically enough". */
820 struct gdbpy_event *item = gdbpy_event_list;
821 gdbpy_event_list = gdbpy_event_list->next;
822 if (gdbpy_event_list == NULL)
823 gdbpy_event_list_end = &gdbpy_event_list;
826 if (PyObject_CallObject (item->event, NULL) == NULL)
829 Py_DECREF (item->event);
833 do_cleanups (cleanup);
836 /* Submit an event to the gdb thread. */
838 gdbpy_post_event (PyObject *self, PyObject *args)
840 struct gdbpy_event *event;
844 if (!PyArg_ParseTuple (args, "O", &func))
847 if (!PyCallable_Check (func))
849 PyErr_SetString (PyExc_RuntimeError,
850 _("Posted event is not callable"));
856 /* From here until the end of the function, we have the GIL, so we
857 can operate on our global data structures without worrying. */
858 wakeup = gdbpy_event_list == NULL;
860 event = XNEW (struct gdbpy_event);
863 *gdbpy_event_list_end = event;
864 gdbpy_event_list_end = &event->next;
866 /* Wake up gdb when needed. */
869 char c = 'q'; /* Anything. */
871 if (serial_write (gdbpy_event_fds[1], &c, 1))
872 return PyErr_SetFromErrno (PyExc_IOError);
878 /* Initialize the Python event handler. */
880 gdbpy_initialize_events (void)
882 if (serial_pipe (gdbpy_event_fds) == 0)
884 gdbpy_event_list_end = &gdbpy_event_list;
885 serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
894 before_prompt_hook (const char *current_gdb_prompt)
896 struct cleanup *cleanup;
899 cleanup = ensure_python_env (get_current_arch (), current_language);
901 if (gdb_python_module
902 && PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
906 hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook");
910 make_cleanup_py_decref (hook);
912 if (PyCallable_Check (hook))
915 PyObject *current_prompt;
917 current_prompt = PyString_FromString (current_gdb_prompt);
918 if (current_prompt == NULL)
921 result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
923 Py_DECREF (current_prompt);
928 make_cleanup_py_decref (result);
930 /* Return type should be None, or a String. If it is None,
931 fall through, we will not set a prompt. If it is a
932 string, set PROMPT. Anything else, set an exception. */
933 if (result != Py_None && ! PyString_Check (result))
935 PyErr_Format (PyExc_RuntimeError,
936 _("Return from prompt_hook must " \
937 "be either a Python string, or None"));
941 if (result != Py_None)
943 prompt = python_string_to_host_string (result);
948 make_cleanup (xfree, prompt);
953 /* If a prompt has been set, PROMPT will not be NULL. If it is
954 NULL, do not set the prompt. */
958 do_cleanups (cleanup);
962 gdbpy_print_stack ();
963 do_cleanups (cleanup);
971 /* A python function to write a single string using gdb's filtered
972 output stream . The optional keyword STREAM can be used to write
973 to a particular stream. The default stream is to gdb_stdout. */
976 gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
979 static char *keywords[] = {"text", "stream", NULL };
981 volatile struct gdb_exception except;
983 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
987 TRY_CATCH (except, RETURN_MASK_ALL)
993 fprintf_filtered (gdb_stderr, "%s", arg);
998 fprintf_filtered (gdb_stdlog, "%s", arg);
1002 fprintf_filtered (gdb_stdout, "%s", arg);
1005 GDB_PY_HANDLE_EXCEPTION (except);
1010 /* A python function to flush a gdb stream. The optional keyword
1011 STREAM can be used to flush a particular stream. The default stream
1015 gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
1017 static char *keywords[] = {"stream", NULL };
1018 int stream_type = 0;
1020 if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
1024 switch (stream_type)
1028 gdb_flush (gdb_stderr);
1033 gdb_flush (gdb_stdlog);
1037 gdb_flush (gdb_stdout);
1043 /* Print a python exception trace, print just a message, or print
1044 nothing and clear the python exception, depending on
1045 gdbpy_should_print_stack. Only call this if a python exception is
1048 gdbpy_print_stack (void)
1050 volatile struct gdb_exception except;
1052 /* Print "none", just clear exception. */
1053 if (gdbpy_should_print_stack == python_excp_none)
1057 /* Print "full" message and backtrace. */
1058 else if (gdbpy_should_print_stack == python_excp_full)
1061 /* PyErr_Print doesn't necessarily end output with a newline.
1062 This works because Python's stdout/stderr is fed through
1064 TRY_CATCH (except, RETURN_MASK_ALL)
1069 /* Print "message", just error print message. */
1072 PyObject *ptype, *pvalue, *ptraceback;
1073 char *msg = NULL, *type = NULL;
1075 PyErr_Fetch (&ptype, &pvalue, &ptraceback);
1077 /* Fetch the error message contained within ptype, pvalue. */
1078 msg = gdbpy_exception_to_string (ptype, pvalue);
1079 type = gdbpy_obj_to_string (ptype);
1081 TRY_CATCH (except, RETURN_MASK_ALL)
1085 /* An error occurred computing the string representation of the
1087 fprintf_filtered (gdb_stderr,
1088 _("Error occurred computing Python error" \
1092 fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
1097 Py_XDECREF (pvalue);
1098 Py_XDECREF (ptraceback);
1105 /* Return the current Progspace.
1106 There always is one. */
1109 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
1113 result = pspace_to_pspace_object (current_program_space);
1119 /* Return a sequence holding all the Progspaces. */
1122 gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
1124 struct program_space *ps;
1127 list = PyList_New (0);
1133 PyObject *item = pspace_to_pspace_object (ps);
1135 if (!item || PyList_Append (list, item) == -1)
1147 /* The "current" objfile. This is set when gdb detects that a new
1148 objfile has been loaded. It is only set for the duration of a call to
1149 source_python_script_for_objfile; it is NULL at other times. */
1150 static struct objfile *gdbpy_current_objfile;
1152 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1153 as Python code. This does not throw any errors. If an exception
1154 occurs python will print the traceback and clear the error indicator. */
1157 source_python_script_for_objfile (struct objfile *objfile, FILE *file,
1158 const char *filename)
1160 struct cleanup *cleanups;
1162 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
1163 gdbpy_current_objfile = objfile;
1165 python_run_simple_file (file, filename);
1167 do_cleanups (cleanups);
1168 gdbpy_current_objfile = NULL;
1171 /* Return the current Objfile, or None if there isn't one. */
1174 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
1178 if (! gdbpy_current_objfile)
1181 result = objfile_to_objfile_object (gdbpy_current_objfile);
1187 /* Return a sequence holding all the Objfiles. */
1190 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
1192 struct objfile *objf;
1195 list = PyList_New (0);
1201 PyObject *item = objfile_to_objfile_object (objf);
1203 if (!item || PyList_Append (list, item) == -1)
1213 /* Compute the list of active type printers and return it. The result
1214 of this function can be passed to apply_type_printers, and should
1215 be freed by free_type_printers. */
1218 start_type_printers (void)
1220 struct cleanup *cleanups;
1221 PyObject *type_module, *func, *result_obj = NULL;
1223 cleanups = ensure_python_env (get_current_arch (), current_language);
1225 type_module = PyImport_ImportModule ("gdb.types");
1226 if (type_module == NULL)
1228 gdbpy_print_stack ();
1231 make_cleanup_py_decref (type_module);
1233 func = PyObject_GetAttrString (type_module, "get_type_recognizers");
1236 gdbpy_print_stack ();
1239 make_cleanup_py_decref (func);
1241 result_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
1242 if (result_obj == NULL)
1243 gdbpy_print_stack ();
1246 do_cleanups (cleanups);
1250 /* If TYPE is recognized by some type printer, return a newly
1251 allocated string holding the type's replacement name. The caller
1252 is responsible for freeing the string. Otherwise, return NULL.
1254 This function has a bit of a funny name, since it actually applies
1255 recognizers, but this seemed clearer given the start_type_printers
1256 and free_type_printers functions. */
1259 apply_type_printers (void *printers, struct type *type)
1261 struct cleanup *cleanups;
1262 PyObject *type_obj, *type_module, *func, *result_obj;
1263 PyObject *printers_obj = printers;
1264 char *result = NULL;
1266 if (printers_obj == NULL)
1269 cleanups = ensure_python_env (get_current_arch (), current_language);
1271 type_obj = type_to_type_object (type);
1272 if (type_obj == NULL)
1274 gdbpy_print_stack ();
1277 make_cleanup_py_decref (type_obj);
1279 type_module = PyImport_ImportModule ("gdb.types");
1280 if (type_module == NULL)
1282 gdbpy_print_stack ();
1285 make_cleanup_py_decref (type_module);
1287 func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
1290 gdbpy_print_stack ();
1293 make_cleanup_py_decref (func);
1295 result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
1296 type_obj, (char *) NULL);
1297 if (result_obj == NULL)
1299 gdbpy_print_stack ();
1302 make_cleanup_py_decref (result_obj);
1304 if (result_obj != Py_None)
1306 result = python_string_to_host_string (result_obj);
1308 gdbpy_print_stack ();
1312 do_cleanups (cleanups);
1316 /* Free the result of start_type_printers. */
1319 free_type_printers (void *arg)
1321 struct cleanup *cleanups;
1322 PyObject *printers = arg;
1324 if (printers == NULL)
1327 cleanups = ensure_python_env (get_current_arch (), current_language);
1328 Py_DECREF (printers);
1329 do_cleanups (cleanups);
1332 #else /* HAVE_PYTHON */
1334 /* Dummy implementation of the gdb "python-interactive" and "python"
1338 python_interactive_command (char *arg, int from_tty)
1340 arg = skip_spaces (arg);
1342 error (_("Python scripting is not supported in this copy of GDB."));
1345 struct command_line *l = get_command_line (python_control, "");
1346 struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
1348 execute_control_command_untraced (l);
1349 do_cleanups (cleanups);
1354 python_command (char *arg, int from_tty)
1356 python_interactive_command (arg, from_tty);
1360 eval_python_from_control_command (struct command_line *cmd)
1362 error (_("Python scripting is not supported in this copy of GDB."));
1366 source_python_script (FILE *file, const char *filename)
1368 throw_error (UNSUPPORTED_ERROR,
1369 _("Python scripting is not supported in this copy of GDB."));
1373 gdbpy_should_stop (struct breakpoint_object *bp_obj)
1375 internal_error (__FILE__, __LINE__,
1376 _("gdbpy_should_stop called when Python scripting is " \
1381 gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj)
1383 internal_error (__FILE__, __LINE__,
1384 _("gdbpy_breakpoint_has_py_cond called when Python " \
1385 "scripting is not supported."));
1389 start_type_printers (void)
1395 apply_type_printers (void *ignore, struct type *type)
1401 free_type_printers (void *arg)
1406 apply_frame_filter (struct frame_info *frame, int flags,
1407 enum py_frame_args args_type,
1408 struct ui_out *out, int frame_low,
1411 return PY_BT_NO_FILTERS;
1414 #endif /* HAVE_PYTHON */
1418 /* Lists for 'set python' commands. */
1420 static struct cmd_list_element *user_set_python_list;
1421 static struct cmd_list_element *user_show_python_list;
1423 /* Function for use by 'set python' prefix command. */
1426 user_set_python (char *args, int from_tty)
1428 help_list (user_set_python_list, "set python ", all_commands,
1432 /* Function for use by 'show python' prefix command. */
1435 user_show_python (char *args, int from_tty)
1437 cmd_show_list (user_show_python_list, from_tty, "");
1440 /* Initialize the Python code. */
1444 /* This is installed as a final cleanup and cleans up the
1445 interpreter. This lets Python's 'atexit' work. */
1448 finalize_python (void *ignore)
1450 /* We don't use ensure_python_env here because if we ever ran the
1451 cleanup, gdb would crash -- because the cleanup calls into the
1452 Python interpreter, which we are about to destroy. It seems
1453 clearer to make the needed calls explicitly here than to create a
1454 cleanup and then mysteriously discard it. */
1455 (void) PyGILState_Ensure ();
1456 python_gdbarch = target_gdbarch ();
1457 python_language = current_language;
1463 /* Provide a prototype to silence -Wmissing-prototypes. */
1464 extern initialize_file_ftype _initialize_python;
1467 _initialize_python (void)
1472 size_t progsize, count;
1474 wchar_t *progname_copy;
1477 add_com ("python-interactive", class_obscure,
1478 python_interactive_command,
1481 Start an interactive Python prompt.\n\
1483 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1486 Alternatively, a single-line Python command can be given as an\n\
1487 argument, and if the command is an expression, the result will be\n\
1488 printed. For example:\n\
1490 (gdb) python-interactive 2 + 3\n\
1493 #else /* HAVE_PYTHON */
1495 Start a Python interactive prompt.\n\
1497 Python scripting is not supported in this copy of GDB.\n\
1498 This command is only a placeholder.")
1499 #endif /* HAVE_PYTHON */
1501 add_com_alias ("pi", "python-interactive", class_obscure, 1);
1503 add_com ("python", class_obscure, python_command,
1506 Evaluate a Python command.\n\
1508 The command can be given as an argument, for instance:\n\
1512 If no argument is given, the following lines are read and used\n\
1513 as the Python commands. Type a line containing \"end\" to indicate\n\
1514 the end of the command.")
1515 #else /* HAVE_PYTHON */
1517 Evaluate a Python command.\n\
1519 Python scripting is not supported in this copy of GDB.\n\
1520 This command is only a placeholder.")
1521 #endif /* HAVE_PYTHON */
1523 add_com_alias ("py", "python", class_obscure, 1);
1525 /* Add set/show python print-stack. */
1526 add_prefix_cmd ("python", no_class, user_show_python,
1527 _("Prefix command for python preference settings."),
1528 &user_show_python_list, "show python ", 0,
1531 add_prefix_cmd ("python", no_class, user_set_python,
1532 _("Prefix command for python preference settings."),
1533 &user_set_python_list, "set python ", 0,
1536 add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
1537 &gdbpy_should_print_stack, _("\
1538 Set mode for Python stack dump on error."), _("\
1539 Show the mode of Python stack printing on error."), _("\
1540 none == no stack or message will be printed.\n\
1541 full == a message and a stack will be printed.\n\
1542 message == an error message without a stack will be printed."),
1544 &user_set_python_list,
1545 &user_show_python_list);
1548 #ifdef WITH_PYTHON_PATH
1549 /* Work around problem where python gets confused about where it is,
1550 and then can't find its libraries, etc.
1551 NOTE: Python assumes the following layout:
1553 /foo/lib/pythonX.Y/...
1554 This must be done before calling Py_Initialize. */
1555 progname = concat (ldirname (python_libdir), SLASH_STRING, "bin",
1556 SLASH_STRING, "python", NULL);
1558 oldloc = setlocale (LC_ALL, NULL);
1559 setlocale (LC_ALL, "");
1560 progsize = strlen (progname);
1561 if (progsize == (size_t) -1)
1563 fprintf (stderr, "Could not convert python path to string\n");
1566 progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
1569 fprintf (stderr, "out of memory\n");
1572 count = mbstowcs (progname_copy, progname, progsize + 1);
1573 if (count == (size_t) -1)
1575 fprintf (stderr, "Could not convert python path to string\n");
1578 setlocale (LC_ALL, oldloc);
1580 /* Note that Py_SetProgramName expects the string it is passed to
1581 remain alive for the duration of the program's execution, so
1582 it is not freed after this call. */
1583 Py_SetProgramName (progname_copy);
1585 Py_SetProgramName (progname);
1590 PyEval_InitThreads ();
1593 gdb_module = PyModule_Create (&GdbModuleDef);
1594 /* Add _gdb module to the list of known built-in modules. */
1595 _PyImport_FixupBuiltin (gdb_module, "_gdb");
1597 gdb_module = Py_InitModule ("_gdb", GdbMethods);
1599 if (gdb_module == NULL)
1602 /* The casts to (char*) are for python 2.4. */
1603 if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0
1604 || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG",
1605 (char*) host_name) < 0
1606 || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
1607 (char*) target_name) < 0)
1610 /* Add stream constants. */
1611 if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
1612 || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
1613 || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
1616 gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
1617 if (gdbpy_gdb_error == NULL
1618 || PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error) < 0)
1621 gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
1622 gdbpy_gdb_error, NULL);
1623 if (gdbpy_gdb_memory_error == NULL
1624 || PyModule_AddObject (gdb_module, "MemoryError",
1625 gdbpy_gdb_memory_error) < 0)
1628 gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
1629 if (gdbpy_gdberror_exc == NULL
1630 || PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc) < 0)
1633 gdbpy_initialize_gdb_readline ();
1635 if (gdbpy_initialize_auto_load () < 0
1636 || gdbpy_initialize_values () < 0
1637 || gdbpy_initialize_frames () < 0
1638 || gdbpy_initialize_commands () < 0
1639 || gdbpy_initialize_symbols () < 0
1640 || gdbpy_initialize_symtabs () < 0
1641 || gdbpy_initialize_blocks () < 0
1642 || gdbpy_initialize_functions () < 0
1643 || gdbpy_initialize_parameters () < 0
1644 || gdbpy_initialize_types () < 0
1645 || gdbpy_initialize_pspace () < 0
1646 || gdbpy_initialize_objfile () < 0
1647 || gdbpy_initialize_breakpoints () < 0
1648 || gdbpy_initialize_finishbreakpoints () < 0
1649 || gdbpy_initialize_lazy_string () < 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_exited_event () < 0
1661 || gdbpy_initialize_thread_event () < 0
1662 || gdbpy_initialize_new_objfile_event () < 0
1663 || gdbpy_initialize_arch () < 0)
1666 observer_attach_before_prompt (before_prompt_hook);
1668 gdbpy_to_string_cst = PyString_FromString ("to_string");
1669 if (gdbpy_to_string_cst == NULL)
1671 gdbpy_children_cst = PyString_FromString ("children");
1672 if (gdbpy_children_cst == NULL)
1674 gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1675 if (gdbpy_display_hint_cst == NULL)
1677 gdbpy_doc_cst = PyString_FromString ("__doc__");
1678 if (gdbpy_doc_cst == NULL)
1680 gdbpy_enabled_cst = PyString_FromString ("enabled");
1681 if (gdbpy_enabled_cst == NULL)
1683 gdbpy_value_cst = PyString_FromString ("value");
1684 if (gdbpy_value_cst == NULL)
1687 /* Release the GIL while gdb runs. */
1688 PyThreadState_Swap (NULL);
1689 PyEval_ReleaseLock ();
1691 make_final_cleanup (finalize_python, NULL);
1693 gdb_python_initialized = 1;
1697 gdbpy_print_stack ();
1698 /* Do not set 'gdb_python_initialized'. */
1701 #endif /* HAVE_PYTHON */
1706 /* Perform the remaining python initializations.
1707 These must be done after GDB is at least mostly initialized.
1708 E.g., The "info pretty-printer" command needs the "info" prefix
1709 command installed. */
1712 finish_python_initialization (void)
1715 char *gdb_pythondir;
1717 struct cleanup *cleanup;
1719 cleanup = ensure_python_env (get_current_arch (), current_language);
1721 /* Add the initial data-directory to sys.path. */
1723 gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
1724 make_cleanup (xfree, gdb_pythondir);
1726 sys_path = PySys_GetObject ("path");
1728 /* If sys.path is not defined yet, define it first. */
1729 if (!(sys_path && PyList_Check (sys_path)))
1732 PySys_SetPath (L"");
1736 sys_path = PySys_GetObject ("path");
1738 if (sys_path && PyList_Check (sys_path))
1740 PyObject *pythondir;
1743 pythondir = PyString_FromString (gdb_pythondir);
1744 if (pythondir == NULL)
1747 err = PyList_Insert (sys_path, 0, pythondir);
1751 Py_DECREF (pythondir);
1756 /* Import the gdb module to finish the initialization, and
1757 add it to __main__ for convenience. */
1758 m = PyImport_AddModule ("__main__");
1762 gdb_python_module = PyImport_ImportModule ("gdb");
1763 if (gdb_python_module == NULL)
1765 gdbpy_print_stack ();
1766 /* This is passed in one call to warning so that blank lines aren't
1767 inserted between each line of text. */
1769 "Could not load the Python gdb module from `%s'.\n"
1770 "Limited Python support is available from the _gdb module.\n"
1771 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1773 do_cleanups (cleanup);
1777 if (PyModule_AddObject (m, "gdb", gdb_python_module))
1780 /* Keep the reference to gdb_python_module since it is in a global
1783 do_cleanups (cleanup);
1787 gdbpy_print_stack ();
1788 warning (_("internal error: Unhandled Python exception"));
1789 do_cleanups (cleanup);
1792 #endif /* HAVE_PYTHON */
1798 static PyMethodDef GdbMethods[] =
1800 { "history", gdbpy_history, METH_VARARGS,
1801 "Get a value from history" },
1802 { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
1803 "Execute a gdb command" },
1804 { "parameter", gdbpy_parameter, METH_VARARGS,
1805 "Return a gdb parameter's value" },
1807 { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1808 "Return a tuple of all breakpoint objects" },
1810 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1811 "Find the default visualizer for a Value." },
1813 { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
1814 "Return the current Progspace." },
1815 { "progspaces", gdbpy_progspaces, METH_NOARGS,
1816 "Return a sequence of all progspaces." },
1818 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
1819 "Return the current Objfile being loaded, or None." },
1820 { "objfiles", gdbpy_objfiles, METH_NOARGS,
1821 "Return a sequence of all loaded objfiles." },
1823 { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
1824 "newest_frame () -> gdb.Frame.\n\
1825 Return the newest frame object." },
1826 { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
1827 "selected_frame () -> gdb.Frame.\n\
1828 Return the selected frame object." },
1829 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
1830 "stop_reason_string (Integer) -> String.\n\
1831 Return a string explaining unwind stop reason." },
1833 { "lookup_type", (PyCFunction) gdbpy_lookup_type,
1834 METH_VARARGS | METH_KEYWORDS,
1835 "lookup_type (name [, block]) -> type\n\
1836 Return a Type corresponding to the given name." },
1837 { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
1838 METH_VARARGS | METH_KEYWORDS,
1839 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1840 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1841 a boolean indicating if name is a field of the current implied argument\n\
1842 `this' (when the current language is object-oriented)." },
1843 { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
1844 METH_VARARGS | METH_KEYWORDS,
1845 "lookup_global_symbol (name [, domain]) -> symbol\n\
1846 Return the symbol corresponding to the given name (or None)." },
1847 { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
1848 "Return the block containing the given pc value, or None." },
1849 { "solib_name", gdbpy_solib_name, METH_VARARGS,
1850 "solib_name (Long) -> String.\n\
1851 Return the name of the shared library holding a given address, or None." },
1852 { "decode_line", gdbpy_decode_line, METH_VARARGS,
1853 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1854 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1855 The first element contains any unparsed portion of the String parameter\n\
1856 (or None if the string was fully parsed). The second element contains\n\
1857 a tuple that contains all the locations that match, represented as\n\
1858 gdb.Symtab_and_line objects (or None)."},
1859 { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
1860 "parse_and_eval (String) -> Value.\n\
1861 Parse String as an expression, evaluate it, and return the result as a Value."
1863 { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS,
1864 "find_pc_line (pc) -> Symtab_and_line.\n\
1865 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1867 { "post_event", gdbpy_post_event, METH_VARARGS,
1868 "Post an event into gdb's event loop." },
1870 { "target_charset", gdbpy_target_charset, METH_NOARGS,
1871 "target_charset () -> string.\n\
1872 Return the name of the current target charset." },
1873 { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
1874 "target_wide_charset () -> string.\n\
1875 Return the name of the current target wide charset." },
1877 { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
1878 "string_to_argv (String) -> Array.\n\
1879 Parse String and return an argv-like array.\n\
1880 Arguments are separate by spaces and may be quoted."
1882 { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
1883 "Write a string using gdb's filtered stream." },
1884 { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
1885 "Flush gdb's filtered stdout stream." },
1886 { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
1887 "selected_thread () -> gdb.InferiorThread.\n\
1888 Return the selected thread object." },
1889 { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
1890 "selected_inferior () -> gdb.Inferior.\n\
1891 Return the selected inferior object." },
1892 { "inferiors", gdbpy_inferiors, METH_NOARGS,
1893 "inferiors () -> (gdb.Inferior, ...).\n\
1894 Return a tuple containing all inferiors." },
1895 {NULL, NULL, 0, NULL}
1899 static struct PyModuleDef GdbModuleDef =
1901 PyModuleDef_HEAD_INIT,
1912 #endif /* HAVE_PYTHON */