X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fpython%2Fpython.c;h=03ea5d5286cfb047158fa0eafa5109295d8c9653;hb=95a6b0a106fac6ea35670421534d461a3663c0ba;hp=40c4ec97943f7d5b33208d667ec749cdaa677290;hpb=b939114242762636cfdcf9a45949cb54cdaacc8c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/python/python.c b/gdb/python/python.c index 40c4ec9794..03ea5d5286 100644 --- a/gdb/python/python.c +++ b/gdb/python/python.c @@ -1,6 +1,6 @@ /* General python/gdb code - Copyright (C) 2008-2014 Free Software Foundation, Inc. + Copyright (C) 2008-2017 Free Software Foundation, Inc. This file is part of GDB. @@ -27,7 +27,6 @@ #include "objfiles.h" #include "value.h" #include "language.h" -#include "exceptions.h" #include "event-loop.h" #include "serial.h" #include "readline/tilde.h" @@ -35,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"; @@ -58,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 @@ -98,16 +99,18 @@ const struct extension_language_defn extension_language_python = #include "gdbthread.h" #include "interps.h" #include "event-top.h" +#include "py-ref.h" +#include "py-event.h" /* True if Python has been successfully initialized, false otherwise. */ 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; @@ -132,6 +135,7 @@ PyObject *gdbpy_gdb_memory_error; static script_sourcer_func gdbpy_source_script; static objfile_script_sourcer_func gdbpy_source_objfile_script; +static objfile_script_executor_func gdbpy_execute_objfile_script; static void gdbpy_finish_initialization (const struct extension_language_defn *); static int gdbpy_initialized (const struct extension_language_defn *); @@ -144,7 +148,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,16 +155,17 @@ 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, + gdbpy_execute_objfile_script, gdbpy_auto_load_enabled }; /* 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, @@ -181,7 +185,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, @@ -191,6 +194,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 }; @@ -199,80 +203,43 @@ static const struct extension_language_ops python_extension_ops = struct gdbarch *python_gdbarch; const struct language_defn *python_language; -/* Restore global language and architecture and Python GIL state - when leaving the Python interpreter. */ - -struct python_env -{ - struct active_ext_lang_state *previous_active; - PyGILState_STATE state; - struct gdbarch *gdbarch; - const struct language_defn *language; - PyObject *error_type, *error_value, *error_traceback; -}; - -static void -restore_python_env (void *p) +gdbpy_enter::gdbpy_enter (struct gdbarch *gdbarch, + const struct language_defn *language) +: m_gdbarch (python_gdbarch), + m_language (python_language) { - struct python_env *env = (struct python_env *)p; - - /* Leftover Python error is forbidden by Python Exception Handling. */ - if (PyErr_Occurred ()) - { - /* This order is similar to the one calling error afterwards. */ - gdbpy_print_stack (); - warning (_("internal error: Unhandled Python exception")); - } - - PyErr_Restore (env->error_type, env->error_value, env->error_traceback); - - PyGILState_Release (env->state); - python_gdbarch = env->gdbarch; - python_language = env->language; - - restore_active_ext_lang (env->previous_active); - - xfree (env); -} - -/* Called before entering the Python interpreter to install the - current language and architecture to be used for Python values. - Also set the active extension language for GDB so that SIGINT's - are directed our way, and if necessary install the right SIGINT - handler. */ - -struct cleanup * -ensure_python_env (struct gdbarch *gdbarch, - const struct language_defn *language) -{ - struct python_env *env = xmalloc (sizeof *env); - /* We should not ever enter Python unless initialized. */ if (!gdb_python_initialized) error (_("Python not initialized")); - env->previous_active = set_active_ext_lang (&extension_language_python); + m_previous_active = set_active_ext_lang (&extension_language_python); - env->state = PyGILState_Ensure (); - env->gdbarch = python_gdbarch; - env->language = python_language; + m_state = PyGILState_Ensure (); python_gdbarch = gdbarch; python_language = language; /* Save it and ensure ! PyErr_Occurred () afterwards. */ - PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback); - - return make_cleanup (restore_python_env, env); + PyErr_Fetch (&m_error_type, &m_error_value, &m_error_traceback); } -/* Clear the quit flag. */ - -static void -gdbpy_clear_quit_flag (const struct extension_language_defn *extlang) +gdbpy_enter::~gdbpy_enter () { - /* This clears the flag as a side effect. */ - PyOS_InterruptOccurred (); + /* Leftover Python error is forbidden by Python Exception Handling. */ + if (PyErr_Occurred ()) + { + /* This order is similar to the one calling error afterwards. */ + gdbpy_print_stack (); + warning (_("internal error: Unhandled Python exception")); + } + + PyErr_Restore (m_error_type, m_error_value, m_error_traceback); + + PyGILState_Release (m_state); + python_gdbarch = m_gdbarch; + python_language = m_language; + + restore_active_ext_lang (m_previous_active); } /* Set the quit flag. */ @@ -298,7 +265,7 @@ gdbpy_check_quit_flag (const struct extension_language_defn *extlang) static int eval_python_command (const char *command) { - PyObject *m, *d, *v; + PyObject *m, *d; m = PyImport_AddModule ("__main__"); if (m == NULL) @@ -307,11 +274,10 @@ eval_python_command (const char *command) d = PyModule_GetDict (m); if (d == NULL) return -1; - v = PyRun_StringFlags (command, Py_single_input, d, d, NULL); + gdbpy_ref<> v (PyRun_StringFlags (command, Py_single_input, d, d, NULL)); if (v == NULL) return -1; - Py_DECREF (v); #ifndef IS_PY3K if (Py_FlushLine ()) PyErr_Clear (); @@ -323,22 +289,21 @@ eval_python_command (const char *command) /* Implementation of the gdb "python-interactive" command. */ static void -python_interactive_command (char *arg, int from_tty) +python_interactive_command (const char *arg, int from_tty) { - struct cleanup *cleanup; + struct ui *ui = current_ui; int err; - cleanup = make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0); arg = skip_spaces (arg); - ensure_python_env (get_current_arch (), current_language); + gdbpy_enter enter_py (get_current_arch (), current_language); if (arg && *arg) { int len = strlen (arg); - char *script = xmalloc (len + 2); + char *script = (char *) xmalloc (len + 2); strcpy (script, arg); script[len] = '\n'; @@ -348,7 +313,7 @@ python_interactive_command (char *arg, int from_tty) } else { - err = PyRun_InteractiveLoop (instream, ""); + err = PyRun_InteractiveLoop (ui->instream, ""); dont_repeat (); } @@ -357,8 +322,6 @@ python_interactive_command (char *arg, int from_tty) gdbpy_print_stack (); error (_("Error while executing Python code.")); } - - do_cleanups (cleanup); } /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run @@ -386,56 +349,35 @@ python_run_simple_file (FILE *file, const char *filename) #else /* _WIN32 */ - char *full_path; - PyObject *python_file; - struct cleanup *cleanup; - /* Because we have a string for a filename, and are using Python to open the file, we need to expand any tilde in the path first. */ - full_path = tilde_expand (filename); - cleanup = make_cleanup (xfree, full_path); - python_file = PyFile_FromString (full_path, "r"); - if (! python_file) + gdb::unique_xmalloc_ptr full_path (tilde_expand (filename)); + gdbpy_ref<> python_file (PyFile_FromString (full_path.get (), (char *) "r")); + if (python_file == NULL) { - do_cleanups (cleanup); gdbpy_print_stack (); - error (_("Error while opening file: %s"), full_path); + error (_("Error while opening file: %s"), full_path.get ()); } - make_cleanup_py_decref (python_file); - PyRun_SimpleFile (PyFile_AsFile (python_file), filename); - do_cleanups (cleanup); + PyRun_SimpleFile (PyFile_AsFile (python_file.get ()), filename); #endif /* _WIN32 */ } /* Given a command_line, return a command string suitable for passing - to Python. Lines in the string are separated by newlines. The - return value is allocated using xmalloc and the caller is - responsible for freeing it. */ + to Python. Lines in the string are separated by newlines. */ -static char * +static std::string compute_python_string (struct command_line *l) { struct command_line *iter; - char *script = NULL; - int size = 0; - int here; - - for (iter = l; iter; iter = iter->next) - size += strlen (iter->line) + 1; + std::string script; - script = xmalloc (size + 1); - here = 0; for (iter = l; iter; iter = iter->next) { - int len = strlen (iter->line); - - strcpy (&script[here], iter->line); - here += len; - script[here++] = '\n'; + script += iter->line; + script += '\n'; } - script[here] = '\0'; return script; } @@ -447,34 +389,26 @@ gdbpy_eval_from_control_command (const struct extension_language_defn *extlang, struct command_line *cmd) { int ret; - char *script; - struct cleanup *cleanup; if (cmd->body_count != 1) error (_("Invalid \"python\" block structure.")); - cleanup = ensure_python_env (get_current_arch (), current_language); + gdbpy_enter enter_py (get_current_arch (), current_language); - script = compute_python_string (cmd->body_list[0]); - ret = PyRun_SimpleString (script); - xfree (script); + std::string script = compute_python_string (cmd->body_list[0]); + ret = PyRun_SimpleString (script.c_str ()); if (ret) error (_("Error while executing Python code.")); - - do_cleanups (cleanup); } /* Implementation of the gdb "python" command. */ static void -python_command (char *arg, int from_tty) +python_command (const char *arg, int from_tty) { - struct cleanup *cleanup; - - cleanup = ensure_python_env (get_current_arch (), current_language); + gdbpy_enter enter_py (get_current_arch (), current_language); - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0); arg = skip_spaces (arg); if (arg && *arg) @@ -484,13 +418,10 @@ python_command (char *arg, int from_tty) } else { - struct command_line *l = get_command_line (python_control, ""); + command_line_up l = get_command_line (python_control, ""); - make_cleanup_free_command_lines (&l); - execute_control_command_untraced (l); + execute_control_command_untraced (l.get ()); } - - do_cleanups (cleanup); } @@ -509,11 +440,11 @@ gdbpy_parameter_value (enum var_types type, void *var) case var_filename: case var_enum: { - char *str = * (char **) var; + const char *str = *(char **) var; if (! str) str = ""; - return PyString_Decode (str, strlen (str), host_charset (), NULL); + return host_string_to_python_string (str); } case var_boolean: @@ -560,24 +491,30 @@ gdbpy_parameter_value (enum var_types type, void *var) /* A Python function which returns a gdb parameter's value as a Python value. */ -PyObject * +static 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) @@ -618,13 +555,11 @@ 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; + static const char *keywords[] = { "command", "from_tty", "to_string", NULL }; - if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg, - &PyBool_Type, &from_tty_obj, - &PyBool_Type, &to_string_obj)) + if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg, + &PyBool_Type, &from_tty_obj, + &PyBool_Type, &to_string_obj)) return NULL; from_tty = 0; @@ -645,37 +580,38 @@ execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw) to_string = cmp; } - TRY_CATCH (except, RETURN_MASK_ALL) + std::string to_string_res; + + 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; + + scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0); - make_cleanup_restore_integer (&interpreter_async); - interpreter_async = 0; + scoped_restore save_uiout = make_scoped_restore (¤t_uiout); - prevent_dont_repeat (); + /* Use the console interpreter uiout to have the same print format + for console or MI. */ + interp = interp_lookup (current_ui, "console"); + current_uiout = interp_ui_out (interp); + + scoped_restore preventer = prevent_dont_repeat (); if (to_string) - result = execute_command_to_string (copy, from_tty); + to_string_res = execute_command_to_string (arg, from_tty); else - { - result = NULL; - execute_command (copy, from_tty); - } - - do_cleanups (cleanup); + execute_command (arg, from_tty); } - 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 (); - if (result) - { - PyObject *r = PyString_FromString (result); - xfree (result); - return r; - } + if (to_string) + return PyString_FromString (to_string_res.c_str ()); Py_RETURN_NONE; } @@ -687,14 +623,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; @@ -709,112 +645,82 @@ gdbpy_solib_name (PyObject *self, PyObject *args) static PyObject * gdbpy_decode_line (PyObject *self, PyObject *args) { - 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; - struct cleanup *cleanups; - PyObject *result = NULL; - PyObject *return_result = NULL; - PyObject *unparsed = NULL; - volatile struct gdb_exception except; + gdbpy_ref<> result; + gdbpy_ref<> unparsed; + event_location_up location; if (! PyArg_ParseTuple (args, "|s", &arg)) return NULL; - cleanups = make_cleanup (null_cleanup, NULL); + if (arg != NULL) + location = string_to_event_location_basic (&arg, python_language); - sals.sals = NULL; - TRY_CATCH (except, RETURN_MASK_ALL) + std::vector decoded_sals; + symtab_and_line def_sal; + gdb::array_view sals; + TRY { - if (arg) + if (location != NULL) { - copy = xstrdup (arg); - copy_to_free = copy; - sals = decode_line_1 (©, 0, 0, 0); + decoded_sals = decode_line_1 (location.get (), 0, NULL, NULL, 0); + sals = decoded_sals; } else { set_default_source_symtab_and_line (); - sal = get_current_source_symtab_and_line (); - sals.sals = &sal; - sals.nelts = 1; + def_sal = get_current_source_symtab_and_line (); + sals = def_sal; } } - - if (sals.sals != NULL && sals.sals != &sal) + CATCH (ex, RETURN_MASK_ALL) { - make_cleanup (xfree, copy_to_free); - make_cleanup (xfree, sals.sals); - } - - if (except.reason < 0) - { - do_cleanups (cleanups); /* We know this will always throw. */ - gdbpy_convert_exception (except); + gdbpy_convert_exception (ex); return NULL; } + END_CATCH - if (sals.nelts) + if (!sals.empty ()) { - int i; - - result = PyTuple_New (sals.nelts); - if (! result) - goto error; - for (i = 0; i < sals.nelts; ++i) + result.reset (PyTuple_New (sals.size ())); + if (result == NULL) + return NULL; + for (size_t i = 0; i < sals.size (); ++i) { - PyObject *obj; - - obj = symtab_and_line_to_sal_object (sals.sals[i]); - if (! obj) - { - Py_DECREF (result); - goto error; - } + PyObject *obj = symtab_and_line_to_sal_object (sals[i]); + if (obj == NULL) + return NULL; - PyTuple_SetItem (result, i, obj); + PyTuple_SetItem (result.get (), i, obj); } } else { - result = Py_None; + result.reset (Py_None); Py_INCREF (Py_None); } - return_result = PyTuple_New (2); - if (! return_result) - { - Py_DECREF (result); - goto error; - } + gdbpy_ref<> return_result (PyTuple_New (2)); + if (return_result == NULL) + return NULL; - if (copy && strlen (copy) > 0) + if (arg != NULL && strlen (arg) > 0) { - unparsed = PyString_FromString (copy); + unparsed.reset (PyString_FromString (arg)); if (unparsed == NULL) - { - Py_DECREF (result); - Py_DECREF (return_result); - return_result = NULL; - goto error; - } + return NULL; } else { - unparsed = Py_None; + unparsed.reset (Py_None); Py_INCREF (Py_None); } - PyTuple_SetItem (return_result, 0, unparsed); - PyTuple_SetItem (return_result, 1, result); - - error: - do_cleanups (cleanups); + PyTuple_SetItem (return_result.get (), 0, unparsed.release ()); + PyTuple_SetItem (return_result.get (), 1, result.release ()); - return return_result; + return return_result.release (); } /* Parse a string and evaluate it as an expression. */ @@ -823,16 +729,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); } @@ -844,13 +753,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; @@ -859,11 +767,24 @@ 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; } +/* Implementation of gdb.invalidate_cached_frames. */ + +static PyObject * +gdbpy_invalidate_cached_frames (PyObject *self, PyObject *args) +{ + reinit_frame_cache (); + Py_RETURN_NONE; +} + /* Read a file as Python code. This is the extension_language_script_ops.script_sourcer "method". FILE is the file to load. FILENAME is name of the file FILE. @@ -874,11 +795,8 @@ static void gdbpy_source_script (const struct extension_language_defn *extlang, FILE *file, const char *filename) { - struct cleanup *cleanup; - - cleanup = ensure_python_env (get_current_arch (), current_language); + gdbpy_enter enter_py (get_current_arch (), current_language); python_run_simple_file (file, filename); - do_cleanups (cleanup); } @@ -899,31 +817,26 @@ 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); + gdbpy_enter enter_py (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) { - PyObject *call_result; - /* Dispatching the event might push a new element onto the event loop, so we update here "atomically enough". */ struct gdbpy_event *item = gdbpy_event_list; @@ -932,16 +845,13 @@ gdbpy_run_events (struct serial *scb, void *context) gdbpy_event_list_end = &gdbpy_event_list; /* Ignore errors. */ - call_result = PyObject_CallObject (item->event, NULL); + gdbpy_ref<> call_result (PyObject_CallObject (item->event, NULL)); if (call_result == NULL) PyErr_Clear (); - Py_XDECREF (call_result); Py_DECREF (item->event); xfree (item); } - - do_cleanups (cleanup); } /* Submit an event to the gdb thread. */ @@ -976,12 +886,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; } @@ -990,11 +895,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; } @@ -1007,78 +912,74 @@ static enum ext_lang_rc gdbpy_before_prompt_hook (const struct extension_language_defn *extlang, const char *current_gdb_prompt) { - struct cleanup *cleanup; - char *prompt = NULL; - if (!gdb_python_initialized) return EXT_LANG_RC_NOP; - cleanup = ensure_python_env (get_current_arch (), current_language); + gdbpy_enter enter_py (get_current_arch (), current_language); + + if (!evregpy_no_listeners_p (gdb_py_events.before_prompt) + && evpy_emit_event (NULL, gdb_py_events.before_prompt) < 0) + return EXT_LANG_RC_ERROR; if (gdb_python_module && PyObject_HasAttrString (gdb_python_module, "prompt_hook")) { - PyObject *hook; - - hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook"); + gdbpy_ref<> hook (PyObject_GetAttrString (gdb_python_module, + "prompt_hook")); if (hook == NULL) - goto fail; - - make_cleanup_py_decref (hook); - - if (PyCallable_Check (hook)) { - PyObject *result; - PyObject *current_prompt; + gdbpy_print_stack (); + return EXT_LANG_RC_ERROR; + } - current_prompt = PyString_FromString (current_gdb_prompt); + if (PyCallable_Check (hook.get ())) + { + gdbpy_ref<> current_prompt (PyString_FromString (current_gdb_prompt)); if (current_prompt == NULL) - goto fail; - - result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL); - - Py_DECREF (current_prompt); + { + gdbpy_print_stack (); + return EXT_LANG_RC_ERROR; + } + gdbpy_ref<> result + (PyObject_CallFunctionObjArgs (hook.get (), current_prompt.get (), + NULL)); if (result == NULL) - goto fail; - - make_cleanup_py_decref (result); + { + gdbpy_print_stack (); + return EXT_LANG_RC_ERROR; + } /* Return type should be None, or a String. If it is None, fall through, we will not set a prompt. If it is a string, set PROMPT. Anything else, set an exception. */ - if (result != Py_None && ! PyString_Check (result)) + if (result != Py_None && ! PyString_Check (result.get ())) { PyErr_Format (PyExc_RuntimeError, _("Return from prompt_hook must " \ "be either a Python string, or None")); - goto fail; + gdbpy_print_stack (); + return EXT_LANG_RC_ERROR; } if (result != Py_None) { - prompt = python_string_to_host_string (result); + gdb::unique_xmalloc_ptr + prompt (python_string_to_host_string (result.get ())); if (prompt == NULL) - goto fail; - else - make_cleanup (xfree, prompt); + { + gdbpy_print_stack (); + return EXT_LANG_RC_ERROR; + } + + set_prompt (prompt.get ()); + return EXT_LANG_RC_OK; } } } - /* If a prompt has been set, PROMPT will not be NULL. If it is - NULL, do not set the prompt. */ - if (prompt != NULL) - set_prompt (prompt); - - do_cleanups (cleanup); - return prompt != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_NOP; - - fail: - gdbpy_print_stack (); - do_cleanups (cleanup); - return EXT_LANG_RC_ERROR; + return EXT_LANG_RC_NOP; } @@ -1093,15 +994,14 @@ static PyObject * gdbpy_write (PyObject *self, PyObject *args, PyObject *kw) { const char *arg; - static char *keywords[] = {"text", "stream", NULL }; + static const 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)) + if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg, + &stream_type)) return NULL; - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { switch (stream_type) { @@ -1119,7 +1019,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; } @@ -1131,11 +1035,11 @@ gdbpy_write (PyObject *self, PyObject *args, PyObject *kw) static PyObject * gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw) { - static char *keywords[] = {"stream", NULL }; + static const char *keywords[] = { "stream", NULL }; int stream_type = 0; - if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords, - &stream_type)) + if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords, + &stream_type)) return NULL; switch (stream_type) @@ -1157,6 +1061,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 @@ -1164,7 +1076,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) @@ -1178,24 +1089,28 @@ 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 { PyObject *ptype, *pvalue, *ptraceback; - char *msg = NULL, *type = NULL; PyErr_Fetch (&ptype, &pvalue, &ptraceback); /* Fetch the error message contained within ptype, pvalue. */ - msg = gdbpy_exception_to_string (ptype, pvalue); - type = gdbpy_obj_to_string (ptype); + gdb::unique_xmalloc_ptr + msg (gdbpy_exception_to_string (ptype, pvalue)); + gdb::unique_xmalloc_ptr type (gdbpy_obj_to_string (ptype)); - TRY_CATCH (except, RETURN_MASK_ALL) + TRY { if (msg == NULL) { @@ -1207,13 +1122,16 @@ gdbpy_print_stack (void) } else fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n", - type, msg); + type.get (), msg.get ()); + } + CATCH (except, RETURN_MASK_ALL) + { } + END_CATCH Py_XDECREF (ptype); Py_XDECREF (pvalue); Py_XDECREF (ptraceback); - xfree (msg); } } @@ -1239,31 +1157,28 @@ static PyObject * gdbpy_progspaces (PyObject *unused1, PyObject *unused2) { struct program_space *ps; - PyObject *list; - list = PyList_New (0); - if (!list) + gdbpy_ref<> list (PyList_New (0)); + if (list == NULL) return NULL; ALL_PSPACES (ps) { PyObject *item = pspace_to_pspace_object (ps); - if (!item || PyList_Append (list, item) == -1) - { - Py_DECREF (list); - return NULL; - } + if (!item || PyList_Append (list.get (), item) == -1) + return NULL; } - return list; + return list.release (); } /* The "current" objfile. This is set when gdb detects that a new objfile has been loaded. It is only set for the duration of a call to - gdbpy_source_objfile_script; it is NULL at other times. */ + gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL + at other times. */ static struct objfile *gdbpy_current_objfile; /* Set the current objfile to OBJFILE and then read FILE named FILENAME @@ -1277,17 +1192,36 @@ gdbpy_source_objfile_script (const struct extension_language_defn *extlang, struct objfile *objfile, FILE *file, const char *filename) { - struct cleanup *cleanups; - if (!gdb_python_initialized) return; - cleanups = ensure_python_env (get_objfile_arch (objfile), current_language); + gdbpy_enter enter_py (get_objfile_arch (objfile), current_language); gdbpy_current_objfile = objfile; python_run_simple_file (file, filename); - do_cleanups (cleanups); + gdbpy_current_objfile = NULL; +} + +/* Set the current objfile to OBJFILE and then execute SCRIPT + as Python code. This does not throw any errors. If an exception + occurs python will print the traceback and clear the error indicator. + This is the extension_language_script_ops.objfile_script_executor + "method". */ + +static void +gdbpy_execute_objfile_script (const struct extension_language_defn *extlang, + struct objfile *objfile, const char *name, + const char *script) +{ + if (!gdb_python_initialized) + return; + + gdbpy_enter enter_py (get_objfile_arch (objfile), current_language); + gdbpy_current_objfile = objfile; + + PyRun_SimpleString (script); + gdbpy_current_objfile = NULL; } @@ -1313,24 +1247,20 @@ static PyObject * gdbpy_objfiles (PyObject *unused1, PyObject *unused2) { struct objfile *objf; - PyObject *list; - list = PyList_New (0); - if (!list) + gdbpy_ref<> list (PyList_New (0)); + if (list == NULL) return NULL; ALL_OBJFILES (objf) { PyObject *item = objfile_to_objfile_object (objf); - if (!item || PyList_Append (list, item) == -1) - { - Py_DECREF (list); - return NULL; - } + if (!item || PyList_Append (list.get (), item) == -1) + return NULL; } - return list; + return list.release (); } /* Compute the list of active python type printers and store them in @@ -1342,38 +1272,33 @@ static void gdbpy_start_type_printers (const struct extension_language_defn *extlang, struct ext_lang_type_printers *ext_printers) { - struct cleanup *cleanups; - PyObject *type_module, *func = NULL, *printers_obj = NULL; + PyObject *printers_obj = NULL; if (!gdb_python_initialized) return; - cleanups = ensure_python_env (get_current_arch (), current_language); + gdbpy_enter enter_py (get_current_arch (), current_language); - type_module = PyImport_ImportModule ("gdb.types"); + gdbpy_ref<> type_module (PyImport_ImportModule ("gdb.types")); if (type_module == NULL) { gdbpy_print_stack (); - goto done; + return; } - func = PyObject_GetAttrString (type_module, "get_type_recognizers"); + gdbpy_ref<> func (PyObject_GetAttrString (type_module.get (), + "get_type_recognizers")); if (func == NULL) { gdbpy_print_stack (); - goto done; + return; } - printers_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL); + printers_obj = PyObject_CallFunctionObjArgs (func.get (), (char *) NULL); if (printers_obj == NULL) gdbpy_print_stack (); else ext_printers->py_type_printers = printers_obj; - - done: - Py_XDECREF (type_module); - Py_XDECREF (func); - do_cleanups (cleanups); } /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE @@ -1388,11 +1313,8 @@ gdbpy_apply_type_printers (const struct extension_language_defn *extlang, const struct ext_lang_type_printers *ext_printers, struct type *type, char **prettied_type) { - struct cleanup *cleanups; - PyObject *type_obj, *type_module = NULL, *func = NULL; - PyObject *result_obj = NULL; - PyObject *printers_obj = ext_printers->py_type_printers; - char *result = NULL; + PyObject *printers_obj = (PyObject *) ext_printers->py_type_printers; + gdb::unique_xmalloc_ptr result; if (printers_obj == NULL) return EXT_LANG_RC_NOP; @@ -1400,53 +1322,52 @@ gdbpy_apply_type_printers (const struct extension_language_defn *extlang, if (!gdb_python_initialized) return EXT_LANG_RC_NOP; - cleanups = ensure_python_env (get_current_arch (), current_language); + gdbpy_enter enter_py (get_current_arch (), current_language); - type_obj = type_to_type_object (type); + gdbpy_ref<> type_obj (type_to_type_object (type)); if (type_obj == NULL) { gdbpy_print_stack (); - goto done; + return EXT_LANG_RC_ERROR; } - type_module = PyImport_ImportModule ("gdb.types"); + gdbpy_ref<> type_module (PyImport_ImportModule ("gdb.types")); if (type_module == NULL) { gdbpy_print_stack (); - goto done; + return EXT_LANG_RC_ERROR; } - func = PyObject_GetAttrString (type_module, "apply_type_recognizers"); + gdbpy_ref<> func (PyObject_GetAttrString (type_module.get (), + "apply_type_recognizers")); if (func == NULL) { gdbpy_print_stack (); - goto done; + return EXT_LANG_RC_ERROR; } - result_obj = PyObject_CallFunctionObjArgs (func, printers_obj, - type_obj, (char *) NULL); + gdbpy_ref<> result_obj (PyObject_CallFunctionObjArgs (func.get (), + printers_obj, + type_obj.get (), + (char *) NULL)); if (result_obj == NULL) { gdbpy_print_stack (); - goto done; + return EXT_LANG_RC_ERROR; } - if (result_obj != Py_None) + if (result_obj == Py_None) + return EXT_LANG_RC_NOP; + + result = python_string_to_host_string (result_obj.get ()); + if (result == NULL) { - result = python_string_to_host_string (result_obj); - if (result == NULL) - gdbpy_print_stack (); + gdbpy_print_stack (); + return EXT_LANG_RC_ERROR; } - done: - Py_XDECREF (type_obj); - Py_XDECREF (type_module); - Py_XDECREF (func); - Py_XDECREF (result_obj); - do_cleanups (cleanups); - if (result != NULL) - *prettied_type = result; - return result != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_ERROR; + *prettied_type = result.release (); + return EXT_LANG_RC_OK; } /* Free the result of start_type_printers. @@ -1456,8 +1377,7 @@ static void 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; @@ -1465,9 +1385,8 @@ gdbpy_free_type_printers (const struct extension_language_defn *extlang, if (!gdb_python_initialized) return; - cleanups = ensure_python_env (get_current_arch (), current_language); + gdbpy_enter enter_py (get_current_arch (), current_language); Py_DECREF (printers); - do_cleanups (cleanups); } #else /* HAVE_PYTHON */ @@ -1476,23 +1395,21 @@ gdbpy_free_type_printers (const struct extension_language_defn *extlang, command. */ static void -python_interactive_command (char *arg, int from_tty) +python_interactive_command (const char *arg, int from_tty) { arg = skip_spaces (arg); if (arg && *arg) error (_("Python scripting is not supported in this copy of GDB.")); else { - struct command_line *l = get_command_line (python_control, ""); - struct cleanup *cleanups = make_cleanup_free_command_lines (&l); + command_line_up l = get_command_line (python_control, ""); - execute_control_command_untraced (l); - do_cleanups (cleanups); + execute_control_command_untraced (l.get ()); } } static void -python_command (char *arg, int from_tty) +python_command (const char *arg, int from_tty) { python_interactive_command (arg, from_tty); } @@ -1509,7 +1426,7 @@ static struct cmd_list_element *user_show_python_list; /* Function for use by 'set python' prefix command. */ static void -user_set_python (char *args, int from_tty) +user_set_python (const char *args, int from_tty) { help_list (user_set_python_list, "set python ", all_commands, gdb_stdout); @@ -1518,7 +1435,7 @@ user_set_python (char *args, int from_tty) /* Function for use by 'show python' prefix command. */ static void -user_show_python (char *args, int from_tty) +user_show_python (const char *args, int from_tty) { cmd_show_list (user_show_python_list, from_tty, ""); } @@ -1553,93 +1470,17 @@ finalize_python (void *ignore) restore_active_ext_lang (previous_active); } -#endif - -/* Provide a prototype to silence -Wmissing-prototypes. */ -extern initialize_file_ftype _initialize_python; -void -_initialize_python (void) +static bool +do_start_initialization () { char *progname; #ifdef IS_PY3K int i; size_t progsize, count; - char *oldloc; wchar_t *progname_copy; #endif - add_com ("python-interactive", class_obscure, - python_interactive_command, -#ifdef HAVE_PYTHON - _("\ -Start an interactive Python prompt.\n\ -\n\ -To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\ -prompt).\n\ -\n\ -Alternatively, a single-line Python command can be given as an\n\ -argument, and if the command is an expression, the result will be\n\ -printed. For example:\n\ -\n\ - (gdb) python-interactive 2 + 3\n\ - 5\n\ -") -#else /* HAVE_PYTHON */ - _("\ -Start a Python interactive prompt.\n\ -\n\ -Python scripting is not supported in this copy of GDB.\n\ -This command is only a placeholder.") -#endif /* HAVE_PYTHON */ - ); - add_com_alias ("pi", "python-interactive", class_obscure, 1); - - add_com ("python", class_obscure, python_command, -#ifdef HAVE_PYTHON - _("\ -Evaluate a Python command.\n\ -\n\ -The command can be given as an argument, for instance:\n\ -\n\ - python print 23\n\ -\n\ -If no argument is given, the following lines are read and used\n\ -as the Python commands. Type a line containing \"end\" to indicate\n\ -the end of the command.") -#else /* HAVE_PYTHON */ - _("\ -Evaluate a Python command.\n\ -\n\ -Python scripting is not supported in this copy of GDB.\n\ -This command is only a placeholder.") -#endif /* HAVE_PYTHON */ - ); - add_com_alias ("py", "python", class_obscure, 1); - - /* Add set/show python print-stack. */ - add_prefix_cmd ("python", no_class, user_show_python, - _("Prefix command for python preference settings."), - &user_show_python_list, "show python ", 0, - &showlist); - - add_prefix_cmd ("python", no_class, user_set_python, - _("Prefix command for python preference settings."), - &user_set_python_list, "set python ", 0, - &setlist); - - add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums, - &gdbpy_should_print_stack, _("\ -Set mode for Python stack dump on error."), _("\ -Show the mode of Python stack printing on error."), _("\ -none == no stack or message will be printed.\n\ -full == a message and a stack will be printed.\n\ -message == an error message without a stack will be printed."), - NULL, NULL, - &user_set_python_list, - &user_show_python_list); - -#ifdef HAVE_PYTHON #ifdef WITH_PYTHON_PATH /* Work around problem where python gets confused about where it is, and then can't find its libraries, etc. @@ -1647,30 +1488,25 @@ message == an error message without a stack will be printed."), /foo/bin/python /foo/lib/pythonX.Y/... This must be done before calling Py_Initialize. */ - progname = concat (ldirname (python_libdir), SLASH_STRING, "bin", - SLASH_STRING, "python", NULL); + progname = concat (ldirname (python_libdir).c_str (), SLASH_STRING, "bin", + SLASH_STRING, "python", (char *) NULL); #ifdef IS_PY3K - oldloc = setlocale (LC_ALL, NULL); + std::string oldloc = 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) { fprintf (stderr, "out of memory\n"); - return; + return false; } count = mbstowcs (progname_copy, progname, progsize + 1); if (count == (size_t) -1) { fprintf (stderr, "Could not convert python path to string\n"); - return; + return false; } - setlocale (LC_ALL, oldloc); + setlocale (LC_ALL, oldloc.c_str ()); /* Note that Py_SetProgramName expects the string it is passed to remain alive for the duration of the program's execution, so @@ -1685,14 +1521,14 @@ 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; + return false; /* The casts to (char*) are for python 2.4. */ if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0 @@ -1700,31 +1536,31 @@ message == an error message without a stack will be printed."), (char*) host_name) < 0 || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name) < 0) - goto fail; + return false; /* Add stream constants. */ if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0 || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0 || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0) - goto fail; + return false; gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL); if (gdbpy_gdb_error == NULL || gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0) - goto fail; + return false; gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError", gdbpy_gdb_error, NULL); if (gdbpy_gdb_memory_error == NULL || gdb_pymodule_addobject (gdb_module, "MemoryError", gdbpy_gdb_memory_error) < 0) - goto fail; + return false; gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL); if (gdbpy_gdberror_exc == NULL || gdb_pymodule_addobject (gdb_module, "GdbError", gdbpy_gdberror_exc) < 0) - goto fail; + return false; gdbpy_initialize_gdb_readline (); @@ -1732,6 +1568,9 @@ message == an error message without a stack will be printed."), || gdbpy_initialize_values () < 0 || gdbpy_initialize_frames () < 0 || gdbpy_initialize_commands () < 0 + || gdbpy_initialize_instruction () < 0 + || gdbpy_initialize_record () < 0 + || gdbpy_initialize_btrace () < 0 || gdbpy_initialize_symbols () < 0 || gdbpy_initialize_symtabs () < 0 || gdbpy_initialize_blocks () < 0 @@ -1750,35 +1589,35 @@ message == an error message without a stack will be printed."), || gdbpy_initialize_eventregistry () < 0 || gdbpy_initialize_py_events () < 0 || gdbpy_initialize_event () < 0 - || gdbpy_initialize_stop_event () < 0 - || gdbpy_initialize_signal_event () < 0 - || gdbpy_initialize_breakpoint_event () < 0 - || gdbpy_initialize_continue_event () < 0 - || gdbpy_initialize_exited_event () < 0 - || gdbpy_initialize_thread_event () < 0 - || gdbpy_initialize_new_objfile_event () < 0 || gdbpy_initialize_arch () < 0 - || gdbpy_initialize_xmethods () < 0) - goto fail; + || gdbpy_initialize_xmethods () < 0 + || gdbpy_initialize_unwind () < 0) + return false; + +#define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \ + if (gdbpy_initialize_event_generic (&name##_event_object_type, py_name) < 0) \ + return false; +#include "py-event-types.def" +#undef GDB_PY_DEFINE_EVENT_TYPE gdbpy_to_string_cst = PyString_FromString ("to_string"); if (gdbpy_to_string_cst == NULL) - goto fail; + return false; gdbpy_children_cst = PyString_FromString ("children"); if (gdbpy_children_cst == NULL) - goto fail; + return false; gdbpy_display_hint_cst = PyString_FromString ("display_hint"); if (gdbpy_display_hint_cst == NULL) - goto fail; + return false; gdbpy_doc_cst = PyString_FromString ("__doc__"); if (gdbpy_doc_cst == NULL) - goto fail; + return false; gdbpy_enabled_cst = PyString_FromString ("enabled"); if (gdbpy_enabled_cst == NULL) - goto fail; + return false; gdbpy_value_cst = PyString_FromString ("value"); if (gdbpy_value_cst == NULL) - goto fail; + return false; /* Release the GIL while gdb runs. */ PyThreadState_Swap (NULL); @@ -1786,39 +1625,108 @@ message == an error message without a stack will be printed."), make_final_cleanup (finalize_python, NULL); + /* Only set this when initialization has succeeded. */ gdb_python_initialized = 1; - return; + return true; +} - fail: - gdbpy_print_stack (); - /* Do not set 'gdb_python_initialized'. */ - return; +#endif /* HAVE_PYTHON */ +void +_initialize_python (void) +{ + add_com ("python-interactive", class_obscure, + python_interactive_command, +#ifdef HAVE_PYTHON + _("\ +Start an interactive Python prompt.\n\ +\n\ +To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\ +prompt).\n\ +\n\ +Alternatively, a single-line Python command can be given as an\n\ +argument, and if the command is an expression, the result will be\n\ +printed. For example:\n\ +\n\ + (gdb) python-interactive 2 + 3\n\ + 5\n\ +") +#else /* HAVE_PYTHON */ + _("\ +Start a Python interactive prompt.\n\ +\n\ +Python scripting is not supported in this copy of GDB.\n\ +This command is only a placeholder.") +#endif /* HAVE_PYTHON */ + ); + add_com_alias ("pi", "python-interactive", class_obscure, 1); + + add_com ("python", class_obscure, python_command, +#ifdef HAVE_PYTHON + _("\ +Evaluate a Python command.\n\ +\n\ +The command can be given as an argument, for instance:\n\ +\n\ + python print 23\n\ +\n\ +If no argument is given, the following lines are read and used\n\ +as the Python commands. Type a line containing \"end\" to indicate\n\ +the end of the command.") +#else /* HAVE_PYTHON */ + _("\ +Evaluate a Python command.\n\ +\n\ +Python scripting is not supported in this copy of GDB.\n\ +This command is only a placeholder.") +#endif /* HAVE_PYTHON */ + ); + add_com_alias ("py", "python", class_obscure, 1); + + /* Add set/show python print-stack. */ + add_prefix_cmd ("python", no_class, user_show_python, + _("Prefix command for python preference settings."), + &user_show_python_list, "show python ", 0, + &showlist); + + add_prefix_cmd ("python", no_class, user_set_python, + _("Prefix command for python preference settings."), + &user_set_python_list, "set python ", 0, + &setlist); + + add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums, + &gdbpy_should_print_stack, _("\ +Set mode for Python stack dump on error."), _("\ +Show the mode of Python stack printing on error."), _("\ +none == no stack or message will be printed.\n\ +full == a message and a stack will be printed.\n\ +message == an error message without a stack will be printed."), + NULL, NULL, + &user_set_python_list, + &user_show_python_list); + +#ifdef HAVE_PYTHON + if (!do_start_initialization () && PyErr_Occurred ()) + gdbpy_print_stack (); #endif /* HAVE_PYTHON */ } #ifdef HAVE_PYTHON -/* Perform the remaining python initializations. - These must be done after GDB is at least mostly initialized. - E.g., The "info pretty-printer" command needs the "info" prefix - command installed. - This is the extension_language_ops.finish_initialization "method". */ +/* Helper function for gdbpy_finish_initialization. This does the + work and then returns false if an error has occurred and must be + displayed, or true on success. */ -static void -gdbpy_finish_initialization (const struct extension_language_defn *extlang) +static bool +do_finish_initialization (const struct extension_language_defn *extlang) { PyObject *m; - char *gdb_pythondir; PyObject *sys_path; - struct cleanup *cleanup; - - cleanup = ensure_python_env (get_current_arch (), current_language); /* Add the initial data-directory to sys.path. */ - gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL); - make_cleanup (xfree, gdb_pythondir); + std::string gdb_pythondir = (std::string (gdb_datadir) + SLASH_STRING + + "python"); sys_path = PySys_GetObject ("path"); @@ -1834,27 +1742,21 @@ gdbpy_finish_initialization (const struct extension_language_defn *extlang) } if (sys_path && PyList_Check (sys_path)) { - PyObject *pythondir; - int err; - - pythondir = PyString_FromString (gdb_pythondir); - if (pythondir == NULL) - goto fail; - - err = PyList_Insert (sys_path, 0, pythondir); - Py_DECREF (pythondir); - if (err) - goto fail; + gdbpy_ref<> pythondir (PyString_FromString (gdb_pythondir.c_str ())); + if (pythondir == NULL || PyList_Insert (sys_path, 0, pythondir.get ())) + return false; } else - goto fail; + return false; /* Import the gdb module to finish the initialization, and add it to __main__ for convenience. */ m = PyImport_AddModule ("__main__"); if (m == NULL) - goto fail; + return false; + /* Keep the reference to gdb_python_module since it is in a global + variable. */ gdb_python_module = PyImport_ImportModule ("gdb"); if (gdb_python_module == NULL) { @@ -1865,24 +1767,31 @@ gdbpy_finish_initialization (const struct extension_language_defn *extlang) "Could not load the Python gdb module from `%s'.\n" "Limited Python support is available from the _gdb module.\n" "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"), - gdb_pythondir); - do_cleanups (cleanup); - return; + gdb_pythondir.c_str ()); + /* We return "success" here as we've already emitted the + warning. */ + return true; } - if (gdb_pymodule_addobject (m, "gdb", gdb_python_module) < 0) - goto fail; + return gdb_pymodule_addobject (m, "gdb", gdb_python_module) >= 0; +} - /* Keep the reference to gdb_python_module since it is in a global - variable. */ +/* Perform the remaining python initializations. + These must be done after GDB is at least mostly initialized. + E.g., The "info pretty-printer" command needs the "info" prefix + command installed. + This is the extension_language_ops.finish_initialization "method". */ - do_cleanups (cleanup); - return; +static void +gdbpy_finish_initialization (const struct extension_language_defn *extlang) +{ + gdbpy_enter enter_py (get_current_arch (), current_language); - fail: - gdbpy_print_stack (); - warning (_("internal error: Unhandled Python exception")); - do_cleanups (cleanup); + if (!do_finish_initialization (extlang)) + { + gdbpy_print_stack (); + warning (_("internal error: Unhandled Python exception")); + } } /* Return non-zero if Python has successfully initialized. @@ -1900,7 +1809,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" }, @@ -1938,6 +1847,18 @@ Return the selected frame object." }, "stop_reason_string (Integer) -> String.\n\ Return a string explaining unwind stop reason." }, + { "start_recording", gdbpy_start_recording, METH_VARARGS, + "start_recording ([method] [, format]) -> gdb.Record.\n\ +Start recording with the given method. If no method is given, will fall back\n\ +to the system default method. If no format is given, will fall back to the\n\ +default format for the given method."}, + { "current_recording", gdbpy_current_recording, METH_NOARGS, + "current_recording () -> gdb.Record.\n\ +Return current recording object." }, + { "stop_recording", gdbpy_stop_recording, METH_NOARGS, + "stop_recording () -> None.\n\ +Stop current recording." }, + { "lookup_type", (PyCFunction) gdbpy_lookup_type, METH_VARARGS | METH_KEYWORDS, "lookup_type (name [, block]) -> type\n\ @@ -1952,6 +1873,14 @@ a boolean indicating if name is a field of the current implied argument\n\ METH_VARARGS | METH_KEYWORDS, "lookup_global_symbol (name [, domain]) -> symbol\n\ Return the symbol corresponding to the given name (or None)." }, + + { "lookup_objfile", (PyCFunction) gdbpy_lookup_objfile, + METH_VARARGS | METH_KEYWORDS, + "lookup_objfile (name, [by_build_id]) -> objfile\n\ +Look up the specified objfile.\n\ +If by_build_id is True, the objfile is looked up by using name\n\ +as its build id." }, + { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS, "Return the block containing the given pc value, or None." }, { "solib_name", gdbpy_solib_name, METH_VARARGS, @@ -2000,21 +1929,74 @@ Return the selected inferior object." }, { "inferiors", gdbpy_inferiors, METH_NOARGS, "inferiors () -> (gdb.Inferior, ...).\n\ Return a tuple containing all inferiors." }, + + { "invalidate_cached_frames", gdbpy_invalidate_cached_frames, METH_NOARGS, + "invalidate_cached_frames () -> None.\n\ +Invalidate any cached frame objects in gdb.\n\ +Intended for internal use only." }, + {NULL, NULL, 0, NULL} }; #ifdef IS_PY3K -static struct PyModuleDef GdbModuleDef = +struct PyModuleDef python_GdbModuleDef = { PyModuleDef_HEAD_INIT, "_gdb", NULL, -1, - GdbMethods, + python_GdbMethods, NULL, NULL, NULL, NULL }; #endif + +/* Define all the event objects. */ +#define GDB_PY_DEFINE_EVENT_TYPE(name, py_name, doc, base) \ + PyTypeObject name##_event_object_type \ + CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object") \ + = { \ + PyVarObject_HEAD_INIT (NULL, 0) \ + "gdb." py_name, /* tp_name */ \ + sizeof (event_object), /* tp_basicsize */ \ + 0, /* tp_itemsize */ \ + evpy_dealloc, /* tp_dealloc */ \ + 0, /* tp_print */ \ + 0, /* tp_getattr */ \ + 0, /* tp_setattr */ \ + 0, /* tp_compare */ \ + 0, /* tp_repr */ \ + 0, /* tp_as_number */ \ + 0, /* tp_as_sequence */ \ + 0, /* tp_as_mapping */ \ + 0, /* tp_hash */ \ + 0, /* tp_call */ \ + 0, /* tp_str */ \ + 0, /* tp_getattro */ \ + 0, /* tp_setattro */ \ + 0, /* tp_as_buffer */ \ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ \ + doc, /* tp_doc */ \ + 0, /* tp_traverse */ \ + 0, /* tp_clear */ \ + 0, /* tp_richcompare */ \ + 0, /* tp_weaklistoffset */ \ + 0, /* tp_iter */ \ + 0, /* tp_iternext */ \ + 0, /* tp_methods */ \ + 0, /* tp_members */ \ + 0, /* tp_getset */ \ + &base, /* tp_base */ \ + 0, /* tp_dict */ \ + 0, /* tp_descr_get */ \ + 0, /* tp_descr_set */ \ + 0, /* tp_dictoffset */ \ + 0, /* tp_init */ \ + 0 /* tp_alloc */ \ + }; +#include "py-event-types.def" +#undef GDB_PY_DEFINE_EVENT_TYPE + #endif /* HAVE_PYTHON */