X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fpython%2Fpython.c;h=19590f49a783c75226939c004b201a09f1749244;hb=cb814510676f7f6c08b329af2f57006fa598b619;hp=344d8d2f1f8e56528a7832d71c867f0754fb35ab;hpb=9f0500621b6a4908986394eb0fac151ef097f520;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/python/python.c b/gdb/python/python.c index 344d8d2f1f..19590f49a7 100644 --- a/gdb/python/python.c +++ b/gdb/python/python.c @@ -1,6 +1,6 @@ /* General python/gdb code - Copyright (C) 2008-2015 Free Software Foundation, Inc. + Copyright (C) 2008-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -34,6 +34,8 @@ #include "extension-priv.h" #include "cli/cli-utils.h" #include +#include "location.h" +#include "ser-event.h" /* Declared constants and enum for python stack printing. */ static const char python_excp_none[] = "none"; @@ -57,8 +59,8 @@ static const char *gdbpy_should_print_stack = python_excp_message; #ifdef HAVE_PYTHON /* Forward decls, these are defined later. */ -static const struct extension_language_script_ops python_extension_script_ops; -static const struct extension_language_ops python_extension_ops; +extern const struct extension_language_script_ops python_extension_script_ops; +extern const struct extension_language_ops python_extension_ops; #endif /* The main struct describing GDB's interface to the Python @@ -103,10 +105,10 @@ const struct extension_language_defn extension_language_python = int gdb_python_initialized; -static PyMethodDef GdbMethods[]; +extern PyMethodDef python_GdbMethods[]; #ifdef IS_PY3K -static struct PyModuleDef GdbModuleDef; +extern struct PyModuleDef python_GdbModuleDef; #endif PyObject *gdb_module; @@ -144,7 +146,6 @@ static enum ext_lang_rc gdbpy_apply_type_printers const struct ext_lang_type_printers *, struct type *, char **); static void gdbpy_free_type_printers (const struct extension_language_defn *, struct ext_lang_type_printers *); -static void gdbpy_clear_quit_flag (const struct extension_language_defn *); static void gdbpy_set_quit_flag (const struct extension_language_defn *); static int gdbpy_check_quit_flag (const struct extension_language_defn *); static enum ext_lang_rc gdbpy_before_prompt_hook @@ -152,7 +153,7 @@ static enum ext_lang_rc gdbpy_before_prompt_hook /* The interface between gdb proper and loading of python scripts. */ -static const struct extension_language_script_ops python_extension_script_ops = +const struct extension_language_script_ops python_extension_script_ops = { gdbpy_source_script, gdbpy_source_objfile_script, @@ -162,7 +163,7 @@ static const struct extension_language_script_ops python_extension_script_ops = /* The interface between gdb proper and python extensions. */ -static const struct extension_language_ops python_extension_ops = +const struct extension_language_ops python_extension_ops = { gdbpy_finish_initialization, gdbpy_initialized, @@ -182,7 +183,6 @@ static const struct extension_language_ops python_extension_ops = gdbpy_breakpoint_has_cond, gdbpy_breakpoint_cond_says_stop, - gdbpy_clear_quit_flag, gdbpy_set_quit_flag, gdbpy_check_quit_flag, @@ -192,6 +192,7 @@ static const struct extension_language_ops python_extension_ops = gdbpy_free_xmethod_worker_data, gdbpy_get_matching_xmethod_workers, gdbpy_get_xmethod_arg_types, + gdbpy_get_xmethod_result_type, gdbpy_invoke_xmethod }; @@ -246,7 +247,7 @@ struct cleanup * ensure_python_env (struct gdbarch *gdbarch, const struct language_defn *language) { - struct python_env *env = xmalloc (sizeof *env); + struct python_env *env = XNEW (struct python_env); /* We should not ever enter Python unless initialized. */ if (!gdb_python_initialized) @@ -267,15 +268,6 @@ ensure_python_env (struct gdbarch *gdbarch, return make_cleanup (restore_python_env, env); } -/* Clear the quit flag. */ - -static void -gdbpy_clear_quit_flag (const struct extension_language_defn *extlang) -{ - /* This clears the flag as a side effect. */ - PyOS_InterruptOccurred (); -} - /* Set the quit flag. */ static void @@ -329,8 +321,8 @@ python_interactive_command (char *arg, int from_tty) struct cleanup *cleanup; int err; - cleanup = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + cleanup = make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; arg = skip_spaces (arg); @@ -339,7 +331,7 @@ python_interactive_command (char *arg, int from_tty) if (arg && *arg) { int len = strlen (arg); - char *script = xmalloc (len + 2); + char *script = (char *) xmalloc (len + 2); strcpy (script, arg); script[len] = '\n'; @@ -426,7 +418,7 @@ compute_python_string (struct command_line *l) for (iter = l; iter; iter = iter->next) size += strlen (iter->line) + 1; - script = xmalloc (size + 1); + script = (char *) xmalloc (size + 1); here = 0; for (iter = l; iter; iter = iter->next) { @@ -474,8 +466,8 @@ python_command (char *arg, int from_tty) cleanup = ensure_python_env (get_current_arch (), current_language); - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; arg = skip_spaces (arg); if (arg && *arg) @@ -514,7 +506,7 @@ gdbpy_parameter_value (enum var_types type, void *var) if (! str) str = ""; - return PyString_Decode (str, strlen (str), host_charset (), NULL); + return host_string_to_python_string (str); } case var_boolean: @@ -564,21 +556,27 @@ gdbpy_parameter_value (enum var_types type, void *var) PyObject * gdbpy_parameter (PyObject *self, PyObject *args) { + struct gdb_exception except = exception_none; struct cmd_list_element *alias, *prefix, *cmd; const char *arg; char *newarg; int found = -1; - volatile struct gdb_exception except; if (! PyArg_ParseTuple (args, "s", &arg)) return NULL; newarg = concat ("show ", arg, (char *) NULL); - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd); } + CATCH (ex, RETURN_MASK_ALL) + { + except = ex; + } + END_CATCH + xfree (newarg); GDB_PY_HANDLE_EXCEPTION (except); if (!found) @@ -619,7 +617,6 @@ execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw) const char *arg; PyObject *from_tty_obj = NULL, *to_string_obj = NULL; int from_tty, to_string; - volatile struct gdb_exception except; static char *keywords[] = {"command", "from_tty", "to_string", NULL }; char *result = NULL; @@ -646,14 +643,21 @@ execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw) to_string = cmp; } - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { /* Copy the argument text in case the command modifies it. */ char *copy = xstrdup (arg); struct cleanup *cleanup = make_cleanup (xfree, copy); + struct interp *interp; + + make_cleanup_restore_integer (¤t_ui->async); + current_ui->async = 0; - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + make_cleanup_restore_ui_out (¤t_uiout); + /* Use the console interpreter uiout to have the same print format + for console or MI. */ + interp = interp_lookup ("console"); + current_uiout = interp_ui_out (interp); prevent_dont_repeat (); if (to_string) @@ -666,7 +670,11 @@ execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw) do_cleanups (cleanup); } - GDB_PY_HANDLE_EXCEPTION (except); + CATCH (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH /* Do any commands attached to breakpoint we stopped at. */ bpstat_do_actions (); @@ -688,14 +696,14 @@ gdbpy_solib_name (PyObject *self, PyObject *args) { char *soname; PyObject *str_obj; - gdb_py_longest pc; + gdb_py_ulongest pc; - if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc)) + if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc)) return NULL; soname = solib_name_from_address (current_program_space, pc); if (soname) - str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL); + str_obj = host_string_to_python_string (soname); else { str_obj = Py_None; @@ -710,16 +718,16 @@ gdbpy_solib_name (PyObject *self, PyObject *args) static PyObject * gdbpy_decode_line (PyObject *self, PyObject *args) { + struct gdb_exception except = exception_none; struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to appease gcc. */ struct symtab_and_line sal; - const char *arg = NULL; - char *copy_to_free = NULL, *copy = NULL; + char *arg = NULL; struct cleanup *cleanups; PyObject *result = NULL; PyObject *return_result = NULL; PyObject *unparsed = NULL; - volatile struct gdb_exception except; + struct event_location *location = NULL; if (! PyArg_ParseTuple (args, "|s", &arg)) return NULL; @@ -727,14 +735,17 @@ gdbpy_decode_line (PyObject *self, PyObject *args) cleanups = make_cleanup (null_cleanup, NULL); sals.sals = NULL; - TRY_CATCH (except, RETURN_MASK_ALL) + + if (arg != NULL) { - if (arg) - { - copy = xstrdup (arg); - copy_to_free = copy; - sals = decode_line_1 (©, 0, 0, 0); - } + location = new_linespec_location (&arg); + make_cleanup_delete_event_location (location); + } + + TRY + { + if (location != NULL) + sals = decode_line_1 (location, 0, NULL, NULL, 0); else { set_default_source_symtab_and_line (); @@ -743,12 +754,14 @@ gdbpy_decode_line (PyObject *self, PyObject *args) sals.nelts = 1; } } - - if (sals.sals != NULL && sals.sals != &sal) + CATCH (ex, RETURN_MASK_ALL) { - make_cleanup (xfree, copy_to_free); - make_cleanup (xfree, sals.sals); + except = ex; } + END_CATCH + + if (sals.sals != NULL && sals.sals != &sal) + make_cleanup (xfree, sals.sals); if (except.reason < 0) { @@ -792,9 +805,9 @@ gdbpy_decode_line (PyObject *self, PyObject *args) goto error; } - if (copy && strlen (copy) > 0) + if (arg != NULL && strlen (arg) > 0) { - unparsed = PyString_FromString (copy); + unparsed = PyString_FromString (arg); if (unparsed == NULL) { Py_DECREF (result); @@ -824,16 +837,19 @@ gdbpy_parse_and_eval (PyObject *self, PyObject *args) { const char *expr_str; struct value *result = NULL; - volatile struct gdb_exception except; if (!PyArg_ParseTuple (args, "s", &expr_str)) return NULL; - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { result = parse_and_eval (expr_str); } - GDB_PY_HANDLE_EXCEPTION (except); + CATCH (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH return value_to_value_object (result); } @@ -845,13 +861,12 @@ static PyObject * gdbpy_find_pc_line (PyObject *self, PyObject *args) { gdb_py_ulongest pc_llu; - volatile struct gdb_exception except; PyObject *result = NULL; /* init for gcc -Wall */ if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu)) return NULL; - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { struct symtab_and_line sal; CORE_ADDR pc; @@ -860,7 +875,11 @@ gdbpy_find_pc_line (PyObject *self, PyObject *args) sal = find_pc_line (pc, 0); result = symtab_and_line_to_sal_object (sal); } - GDB_PY_HANDLE_EXCEPTION (except); + CATCH (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH return result; } @@ -900,26 +919,25 @@ static struct gdbpy_event *gdbpy_event_list; /* The final link of the event list. */ static struct gdbpy_event **gdbpy_event_list_end; -/* We use a file handler, and not an async handler, so that we can - wake up the main thread even when it is blocked in poll(). */ -static struct serial *gdbpy_event_fds[2]; +/* So that we can wake up the main thread even when it is blocked in + poll(). */ +static struct serial_event *gdbpy_serial_event; /* The file handler callback. This reads from the internal pipe, and then processes the Python event queue. This will always be run in the main gdb thread. */ static void -gdbpy_run_events (struct serial *scb, void *context) +gdbpy_run_events (int error, gdb_client_data client_data) { struct cleanup *cleanup; cleanup = ensure_python_env (get_current_arch (), current_language); - /* Flush the fd. Do this before flushing the events list, so that - any new event post afterwards is sure to re-awake the event + /* Clear the event fd. Do this before flushing the events list, so + that any new event post afterwards is sure to re-awake the event loop. */ - while (serial_readchar (gdbpy_event_fds[0], 0) >= 0) - ; + serial_event_clear (gdbpy_serial_event); while (gdbpy_event_list) { @@ -977,12 +995,7 @@ gdbpy_post_event (PyObject *self, PyObject *args) /* Wake up gdb when needed. */ if (wakeup) - { - char c = 'q'; /* Anything. */ - - if (serial_write (gdbpy_event_fds[1], &c, 1)) - return PyErr_SetFromErrno (PyExc_IOError); - } + serial_event_set (gdbpy_serial_event); Py_RETURN_NONE; } @@ -991,11 +1004,11 @@ gdbpy_post_event (PyObject *self, PyObject *args) static int gdbpy_initialize_events (void) { - if (serial_pipe (gdbpy_event_fds) == 0) - { - gdbpy_event_list_end = &gdbpy_event_list; - serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL); - } + gdbpy_event_list_end = &gdbpy_event_list; + + gdbpy_serial_event = make_serial_event (); + add_file_handler (serial_event_fd (gdbpy_serial_event), + gdbpy_run_events, NULL); return 0; } @@ -1096,13 +1109,12 @@ gdbpy_write (PyObject *self, PyObject *args, PyObject *kw) const char *arg; static char *keywords[] = {"text", "stream", NULL }; int stream_type = 0; - volatile struct gdb_exception except; if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg, &stream_type)) return NULL; - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { switch (stream_type) { @@ -1120,7 +1132,11 @@ gdbpy_write (PyObject *self, PyObject *args, PyObject *kw) fprintf_filtered (gdb_stdout, "%s", arg); } } - GDB_PY_HANDLE_EXCEPTION (except); + CATCH (except, RETURN_MASK_ALL) + { + GDB_PY_HANDLE_EXCEPTION (except); + } + END_CATCH Py_RETURN_NONE; } @@ -1158,6 +1174,14 @@ gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw) Py_RETURN_NONE; } +/* Return non-zero if print-stack is not "none". */ + +int +gdbpy_print_python_errors_p (void) +{ + return gdbpy_should_print_stack != python_excp_none; +} + /* Print a python exception trace, print just a message, or print nothing and clear the python exception, depending on gdbpy_should_print_stack. Only call this if a python exception is @@ -1165,7 +1189,6 @@ gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw) void gdbpy_print_stack (void) { - volatile struct gdb_exception except; /* Print "none", just clear exception. */ if (gdbpy_should_print_stack == python_excp_none) @@ -1179,10 +1202,14 @@ gdbpy_print_stack (void) /* PyErr_Print doesn't necessarily end output with a newline. This works because Python's stdout/stderr is fed through printf_filtered. */ - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { begin_line (); } + CATCH (except, RETURN_MASK_ALL) + { + } + END_CATCH } /* Print "message", just error print message. */ else @@ -1196,7 +1223,7 @@ gdbpy_print_stack (void) msg = gdbpy_exception_to_string (ptype, pvalue); type = gdbpy_obj_to_string (ptype); - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { if (msg == NULL) { @@ -1210,6 +1237,10 @@ gdbpy_print_stack (void) fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n", type, msg); } + CATCH (except, RETURN_MASK_ALL) + { + } + END_CATCH Py_XDECREF (ptype); Py_XDECREF (pvalue); @@ -1418,7 +1449,7 @@ gdbpy_apply_type_printers (const struct extension_language_defn *extlang, struct cleanup *cleanups; PyObject *type_obj, *type_module = NULL, *func = NULL; PyObject *result_obj = NULL; - PyObject *printers_obj = ext_printers->py_type_printers; + PyObject *printers_obj = (PyObject *) ext_printers->py_type_printers; char *result = NULL; if (printers_obj == NULL) @@ -1484,7 +1515,7 @@ gdbpy_free_type_printers (const struct extension_language_defn *extlang, struct ext_lang_type_printers *ext_printers) { struct cleanup *cleanups; - PyObject *printers = ext_printers->py_type_printers; + PyObject *printers = (PyObject *) ext_printers->py_type_printers; if (printers == NULL) return; @@ -1675,29 +1706,27 @@ message == an error message without a stack will be printed."), /foo/lib/pythonX.Y/... This must be done before calling Py_Initialize. */ progname = concat (ldirname (python_libdir), SLASH_STRING, "bin", - SLASH_STRING, "python", NULL); + SLASH_STRING, "python", (char *) NULL); #ifdef IS_PY3K - oldloc = setlocale (LC_ALL, NULL); + oldloc = xstrdup (setlocale (LC_ALL, NULL)); setlocale (LC_ALL, ""); progsize = strlen (progname); - if (progsize == (size_t) -1) - { - fprintf (stderr, "Could not convert python path to string\n"); - return; - } - progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t)); + progname_copy = (wchar_t *) PyMem_Malloc ((progsize + 1) * sizeof (wchar_t)); if (!progname_copy) { + xfree (oldloc); fprintf (stderr, "out of memory\n"); return; } count = mbstowcs (progname_copy, progname, progsize + 1); if (count == (size_t) -1) { + xfree (oldloc); fprintf (stderr, "Could not convert python path to string\n"); return; } setlocale (LC_ALL, oldloc); + xfree (oldloc); /* Note that Py_SetProgramName expects the string it is passed to remain alive for the duration of the program's execution, so @@ -1712,11 +1741,11 @@ message == an error message without a stack will be printed."), PyEval_InitThreads (); #ifdef IS_PY3K - gdb_module = PyModule_Create (&GdbModuleDef); + gdb_module = PyModule_Create (&python_GdbModuleDef); /* Add _gdb module to the list of known built-in modules. */ _PyImport_FixupBuiltin (gdb_module, "_gdb"); #else - gdb_module = Py_InitModule ("_gdb", GdbMethods); + gdb_module = Py_InitModule ("_gdb", python_GdbMethods); #endif if (gdb_module == NULL) goto fail; @@ -1790,7 +1819,8 @@ message == an error message without a stack will be printed."), || gdbpy_initialize_new_objfile_event () < 0 || gdbpy_initialize_clear_objfiles_event () < 0 || gdbpy_initialize_arch () < 0 - || gdbpy_initialize_xmethods () < 0) + || gdbpy_initialize_xmethods () < 0 + || gdbpy_initialize_unwind () < 0) goto fail; gdbpy_to_string_cst = PyString_FromString ("to_string"); @@ -1849,7 +1879,7 @@ gdbpy_finish_initialization (const struct extension_language_defn *extlang) /* Add the initial data-directory to sys.path. */ - gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL); + gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", (char *) NULL); make_cleanup (xfree, gdb_pythondir); sys_path = PySys_GetObject ("path"); @@ -1932,7 +1962,7 @@ gdbpy_initialized (const struct extension_language_defn *extlang) #ifdef HAVE_PYTHON -static PyMethodDef GdbMethods[] = +PyMethodDef python_GdbMethods[] = { { "history", gdbpy_history, METH_VARARGS, "Get a value from history" }, @@ -2044,13 +2074,13 @@ Return a tuple containing all inferiors." }, }; #ifdef IS_PY3K -static struct PyModuleDef GdbModuleDef = +struct PyModuleDef python_GdbModuleDef = { PyModuleDef_HEAD_INIT, "_gdb", NULL, -1, - GdbMethods, + python_GdbMethods, NULL, NULL, NULL,