X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fpython%2Fpy-prettyprint.c;h=fdc520d84432a8bee1cfc59901176ab10914848e;hb=2e62ab400ff96334c92e5acf0a462cb9dc0d19a7;hp=d8579fadf8f67a8315ed3bb24c5325b21e44d0e8;hpb=492d29ea1c9a8b2c7d5193908119a4e27c045687;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/python/py-prettyprint.c b/gdb/python/py-prettyprint.c index d8579fadf8..fdc520d844 100644 --- a/gdb/python/py-prettyprint.c +++ b/gdb/python/py-prettyprint.c @@ -1,6 +1,6 @@ /* Python pretty-printing - Copyright (C) 2008-2015 Free Software Foundation, Inc. + Copyright (C) 2008-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -44,29 +44,27 @@ enum string_repr_result will return None. On error, it will set the Python error and return NULL. */ -static PyObject * +static gdbpy_ref<> search_pp_list (PyObject *list, PyObject *value) { Py_ssize_t pp_list_size, list_index; - PyObject *function, *printer = NULL; pp_list_size = PyList_Size (list); for (list_index = 0; list_index < pp_list_size; list_index++) { - function = PyList_GetItem (list, list_index); + PyObject *function = PyList_GetItem (list, list_index); if (! function) return NULL; /* Skip if disabled. */ if (PyObject_HasAttr (function, gdbpy_enabled_cst)) { - PyObject *attr = PyObject_GetAttr (function, gdbpy_enabled_cst); + gdbpy_ref<> attr (PyObject_GetAttr (function, gdbpy_enabled_cst)); int cmp; - if (!attr) + if (attr == NULL) return NULL; - cmp = PyObject_IsTrue (attr); - Py_DECREF (attr); + cmp = PyObject_IsTrue (attr.get ()); if (cmp == -1) return NULL; @@ -74,16 +72,15 @@ search_pp_list (PyObject *list, PyObject *value) continue; } - printer = PyObject_CallFunctionObjArgs (function, value, NULL); - if (! printer) + gdbpy_ref<> printer (PyObject_CallFunctionObjArgs (function, value, + NULL)); + if (printer == NULL) return NULL; else if (printer != Py_None) return printer; - - Py_DECREF (printer); } - Py_RETURN_NONE; + return gdbpy_ref<>::new_reference (Py_None); } /* Subroutine of find_pretty_printer to simplify it. @@ -95,33 +92,26 @@ search_pp_list (PyObject *list, PyObject *value) static PyObject * find_pretty_printer_from_objfiles (PyObject *value) { - PyObject *pp_list; - PyObject *function; - struct objfile *obj; + for (objfile *obj : current_program_space->objfiles ()) + { + gdbpy_ref<> objf = objfile_to_objfile_object (obj); + if (objf == NULL) + { + /* Ignore the error and continue. */ + PyErr_Clear (); + continue; + } - ALL_OBJFILES (obj) - { - PyObject *objf = objfile_to_objfile_object (obj); - if (!objf) - { - /* Ignore the error and continue. */ - PyErr_Clear (); - continue; - } - - pp_list = objfpy_get_printers (objf, NULL); - function = search_pp_list (pp_list, value); - Py_XDECREF (pp_list); - - /* If there is an error in any objfile list, abort the search and exit. */ - if (! function) - return NULL; + gdbpy_ref<> pp_list (objfpy_get_printers (objf.get (), NULL)); + gdbpy_ref<> function (search_pp_list (pp_list.get (), value)); - if (function != Py_None) - return function; + /* If there is an error in any objfile list, abort the search and exit. */ + if (function == NULL) + return NULL; - Py_DECREF (function); - } + if (function != Py_None) + return function.release (); + } Py_RETURN_NONE; } @@ -132,19 +122,15 @@ find_pretty_printer_from_objfiles (PyObject *value) The result is Py_None, suitably inc-ref'd, if no pretty-printer was found. Otherwise the result is the pretty-printer function, suitably inc-ref'd. */ -static PyObject * +static gdbpy_ref<> find_pretty_printer_from_progspace (PyObject *value) { - PyObject *pp_list; - PyObject *function; - PyObject *obj = pspace_to_pspace_object (current_program_space); + gdbpy_ref<> obj = pspace_to_pspace_object (current_program_space); - if (!obj) + if (obj == NULL) return NULL; - pp_list = pspy_get_printers (obj, NULL); - function = search_pp_list (pp_list, value); - Py_XDECREF (pp_list); - return function; + gdbpy_ref<> pp_list (pspy_get_printers (obj.get (), NULL)); + return search_pp_list (pp_list.get (), value); } /* Subroutine of find_pretty_printer to simplify it. @@ -153,53 +139,41 @@ find_pretty_printer_from_progspace (PyObject *value) The result is Py_None, suitably inc-ref'd, if no pretty-printer was found. Otherwise the result is the pretty-printer function, suitably inc-ref'd. */ -static PyObject * +static gdbpy_ref<> find_pretty_printer_from_gdb (PyObject *value) { - PyObject *pp_list; - PyObject *function; - /* Fetch the global pretty printer list. */ if (gdb_python_module == NULL || ! PyObject_HasAttrString (gdb_python_module, "pretty_printers")) - Py_RETURN_NONE; - pp_list = PyObject_GetAttrString (gdb_python_module, "pretty_printers"); - if (pp_list == NULL || ! PyList_Check (pp_list)) - { - Py_XDECREF (pp_list); - Py_RETURN_NONE; - } + return gdbpy_ref<>::new_reference (Py_None); + gdbpy_ref<> pp_list (PyObject_GetAttrString (gdb_python_module, + "pretty_printers")); + if (pp_list == NULL || ! PyList_Check (pp_list.get ())) + return gdbpy_ref<>::new_reference (Py_None); - function = search_pp_list (pp_list, value); - Py_XDECREF (pp_list); - return function; + return search_pp_list (pp_list.get (), value); } /* Find the pretty-printing constructor function for VALUE. If no pretty-printer exists, return None. If one exists, return a new reference. On error, set the Python error and return NULL. */ -static PyObject * +static gdbpy_ref<> find_pretty_printer (PyObject *value) { - PyObject *function; - /* Look at the pretty-printer list for each objfile in the current program-space. */ - function = find_pretty_printer_from_objfiles (value); + gdbpy_ref<> function (find_pretty_printer_from_objfiles (value)); if (function == NULL || function != Py_None) return function; - Py_DECREF (function); /* Look at the pretty-printer list for the current program-space. */ function = find_pretty_printer_from_progspace (value); if (function == NULL || function != Py_None) return function; - Py_DECREF (function); /* Look at the pretty-printer list in the gdb module. */ - function = find_pretty_printer_from_gdb (value); - return function; + return find_pretty_printer_from_gdb (value); } /* Pretty-print a single value, via the printer object PRINTER. @@ -210,32 +184,37 @@ find_pretty_printer (PyObject *value) is returned. On error, *OUT_VALUE is set to NULL, NULL is returned, with a python exception set. */ -static PyObject * +static gdbpy_ref<> pretty_print_one_value (PyObject *printer, struct value **out_value) { - PyObject *result = NULL; + gdbpy_ref<> result; *out_value = NULL; - TRY + try { - result = PyObject_CallMethodObjArgs (printer, gdbpy_to_string_cst, NULL); - if (result) + if (!PyObject_HasAttr (printer, gdbpy_to_string_cst)) + result = gdbpy_ref<>::new_reference (Py_None); + else { - if (! gdbpy_is_string (result) && ! gdbpy_is_lazy_string (result) - && result != Py_None) + result.reset (PyObject_CallMethodObjArgs (printer, gdbpy_to_string_cst, + NULL)); + if (result != NULL) { - *out_value = convert_value_from_python (result); - if (PyErr_Occurred ()) - *out_value = NULL; - Py_DECREF (result); - result = NULL; + if (! gdbpy_is_string (result.get ()) + && ! gdbpy_is_lazy_string (result.get ()) + && result != Py_None) + { + *out_value = convert_value_from_python (result.get ()); + if (PyErr_Occurred ()) + *out_value = NULL; + result = NULL; + } } } } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { } - END_CATCH return result; } @@ -244,25 +223,24 @@ pretty_print_one_value (PyObject *printer, struct value **out_value) NULL if there is no display_hint method, or if the method did not return a string. On error, print stack trace and return NULL. On success, return an xmalloc()d string. */ -char * +gdb::unique_xmalloc_ptr gdbpy_get_display_hint (PyObject *printer) { - PyObject *hint; - char *result = NULL; + gdb::unique_xmalloc_ptr result; if (! PyObject_HasAttr (printer, gdbpy_display_hint_cst)) return NULL; - hint = PyObject_CallMethodObjArgs (printer, gdbpy_display_hint_cst, NULL); - if (hint) + gdbpy_ref<> hint (PyObject_CallMethodObjArgs (printer, gdbpy_display_hint_cst, + NULL)); + if (hint != NULL) { - if (gdbpy_is_string (hint)) + if (gdbpy_is_string (hint.get ())) { - result = python_string_to_host_string (hint); + result = python_string_to_host_string (hint.get ()); if (result == NULL) gdbpy_print_stack (); } - Py_DECREF (hint); } else gdbpy_print_stack (); @@ -277,24 +255,14 @@ print_stack_unless_memory_error (struct ui_file *stream) { if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error)) { - struct cleanup *cleanup; - PyObject *type, *value, *trace; - char *msg; - - PyErr_Fetch (&type, &value, &trace); - cleanup = make_cleanup_py_decref (type); - make_cleanup_py_decref (value); - make_cleanup_py_decref (trace); - - msg = gdbpy_exception_to_string (type, value); - make_cleanup (xfree, msg); + gdbpy_err_fetch fetched_error; + gdb::unique_xmalloc_ptr msg = fetched_error.to_string (); if (msg == NULL || *msg == '\0') fprintf_filtered (stream, _("")); else - fprintf_filtered (stream, _(""), msg); - - do_cleanups (cleanup); + fprintf_filtered (stream, _(""), + msg.get ()); } else gdbpy_print_stack (); @@ -311,51 +279,40 @@ print_string_repr (PyObject *printer, const char *hint, struct gdbarch *gdbarch) { struct value *replacement = NULL; - PyObject *py_str = NULL; enum string_repr_result result = string_repr_ok; - py_str = pretty_print_one_value (printer, &replacement); - if (py_str) + gdbpy_ref<> py_str = pretty_print_one_value (printer, &replacement); + if (py_str != NULL) { - struct cleanup *cleanup = make_cleanup_py_decref (py_str); - if (py_str == Py_None) result = string_repr_none; - else if (gdbpy_is_lazy_string (py_str)) + else if (gdbpy_is_lazy_string (py_str.get ())) { CORE_ADDR addr; long length; struct type *type; - char *encoding = NULL; + gdb::unique_xmalloc_ptr encoding; struct value_print_options local_opts = *options; - make_cleanup (free_current_contents, &encoding); - gdbpy_extract_lazy_string (py_str, &addr, &type, + gdbpy_extract_lazy_string (py_str.get (), &addr, &type, &length, &encoding); local_opts.addressprint = 0; - val_print_string (type, encoding, addr, (int) length, + val_print_string (type, encoding.get (), addr, (int) length, stream, &local_opts); } else { - PyObject *string; - - string = python_string_to_target_python_string (py_str); - if (string) + gdbpy_ref<> string + = python_string_to_target_python_string (py_str.get ()); + if (string != NULL) { char *output; long length; struct type *type; - make_cleanup_py_decref (string); -#ifdef IS_PY3K - output = PyBytes_AS_STRING (string); - length = PyBytes_GET_SIZE (string); -#else - output = PyString_AsString (string); - length = PyString_Size (string); -#endif + output = PyBytes_AS_STRING (string.get ()); + length = PyBytes_GET_SIZE (string.get ()); type = builtin_type (gdbarch)->builtin_char; if (hint && !strcmp (hint, "string")) @@ -370,8 +327,6 @@ print_string_repr (PyObject *printer, const char *hint, print_stack_unless_memory_error (stream); } } - - do_cleanups (cleanup); } else if (replacement) { @@ -389,84 +344,6 @@ print_string_repr (PyObject *printer, const char *hint, return result; } -#ifndef IS_PY3K -static void -py_restore_tstate (void *p) -{ - PyFrameObject *frame = p; - PyThreadState *tstate = PyThreadState_GET (); - - tstate->frame = frame; -} - -/* Create a dummy PyFrameObject, needed to work around - a Python-2.4 bug with generators. */ -static PyObject * -push_dummy_python_frame (void) -{ - PyObject *empty_string, *null_tuple, *globals; - PyCodeObject *code; - PyFrameObject *frame; - PyThreadState *tstate; - - empty_string = PyString_FromString (""); - if (!empty_string) - return NULL; - - null_tuple = PyTuple_New (0); - if (!null_tuple) - { - Py_DECREF (empty_string); - return NULL; - } - - code = PyCode_New (0, /* argcount */ - 0, /* nlocals */ - 0, /* stacksize */ - 0, /* flags */ - empty_string, /* code */ - null_tuple, /* consts */ - null_tuple, /* names */ - null_tuple, /* varnames */ -#if PYTHON_API_VERSION >= 1010 - null_tuple, /* freevars */ - null_tuple, /* cellvars */ -#endif - empty_string, /* filename */ - empty_string, /* name */ - 1, /* firstlineno */ - empty_string /* lnotab */ - ); - - Py_DECREF (empty_string); - Py_DECREF (null_tuple); - - if (!code) - return NULL; - - globals = PyDict_New (); - if (!globals) - { - Py_DECREF (code); - return NULL; - } - - tstate = PyThreadState_GET (); - - frame = PyFrame_New (tstate, code, globals, NULL); - - Py_DECREF (globals); - Py_DECREF (code); - - if (!frame) - return NULL; - - tstate->frame = frame; - make_cleanup (py_restore_tstate, frame->f_back); - return (PyObject *) frame; -} -#endif - /* Helper for gdbpy_apply_val_pretty_printer that formats children of the printer, if any exist. If is_py_none is true, then nothing has been printed by to_string, and format output accordingly. */ @@ -479,11 +356,6 @@ print_children (PyObject *printer, const char *hint, { int is_map, is_array, done_flag, pretty; unsigned int i; - PyObject *children, *iter; -#ifndef IS_PY3K - PyObject *frame; -#endif - struct cleanup *cleanups; if (! PyObject_HasAttr (printer, gdbpy_children_cst)) return; @@ -493,23 +365,20 @@ print_children (PyObject *printer, const char *hint, is_map = hint && ! strcmp (hint, "map"); is_array = hint && ! strcmp (hint, "array"); - children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst, - NULL); - if (! children) + gdbpy_ref<> children (PyObject_CallMethodObjArgs (printer, gdbpy_children_cst, + NULL)); + if (children == NULL) { print_stack_unless_memory_error (stream); return; } - cleanups = make_cleanup_py_decref (children); - - iter = PyObject_GetIter (children); - if (!iter) + gdbpy_ref<> iter (PyObject_GetIter (children.get ())); + if (iter == NULL) { print_stack_unless_memory_error (stream); - goto done; + return; } - make_cleanup_py_decref (iter); /* Use the prettyformat_arrays option if we are printing an array, and the pretty option otherwise. */ @@ -523,27 +392,14 @@ print_children (PyObject *printer, const char *hint, pretty = options->prettyformat_structs; } - /* Manufacture a dummy Python frame to work around Python 2.4 bug, - where it insists on having a non-NULL tstate->frame when - a generator is called. */ -#ifndef IS_PY3K - frame = push_dummy_python_frame (); - if (!frame) - { - gdbpy_print_stack (); - goto done; - } - make_cleanup_py_decref (frame); -#endif - done_flag = 0; for (i = 0; i < options->print_max; ++i) { - PyObject *py_v, *item = PyIter_Next (iter); + PyObject *py_v; const char *name; - struct cleanup *inner_cleanup; - if (! item) + gdbpy_ref<> item (PyIter_Next (iter.get ())); + if (item == NULL) { if (PyErr_Occurred ()) print_stack_unless_memory_error (stream); @@ -554,13 +410,24 @@ print_children (PyObject *printer, const char *hint, break; } - if (! PyArg_ParseTuple (item, "sO", &name, &py_v)) + if (! PyTuple_Check (item.get ()) || PyTuple_Size (item.get ()) != 2) { + PyErr_SetString (PyExc_TypeError, + _("Result of children iterator not a tuple" + " of two elements.")); + gdbpy_print_stack (); + continue; + } + if (! PyArg_ParseTuple (item.get (), "sO", &name, &py_v)) + { + /* The user won't necessarily get a stack trace here, so provide + more context. */ + if (gdbpy_print_python_errors_p ()) + fprintf_unfiltered (gdb_stderr, + _("Bad result from children iterator.\n")); gdbpy_print_stack (); - Py_DECREF (item); continue; } - inner_cleanup = make_cleanup_py_decref (item); /* Print initial "{". For other elements, there are three cases: @@ -621,28 +488,24 @@ print_children (PyObject *printer, const char *hint, CORE_ADDR addr; struct type *type; long length; - char *encoding = NULL; + gdb::unique_xmalloc_ptr encoding; struct value_print_options local_opts = *options; - make_cleanup (free_current_contents, &encoding); gdbpy_extract_lazy_string (py_v, &addr, &type, &length, &encoding); local_opts.addressprint = 0; - val_print_string (type, encoding, addr, (int) length, stream, + val_print_string (type, encoding.get (), addr, (int) length, stream, &local_opts); } else if (gdbpy_is_string (py_v)) { - char *output; + gdb::unique_xmalloc_ptr output; output = python_string_to_host_string (py_v); if (!output) gdbpy_print_stack (); else - { - fputs_filtered (output, stream); - xfree (output); - } + fputs_filtered (output.get (), stream); } else { @@ -654,13 +517,21 @@ print_children (PyObject *printer, const char *hint, error (_("Error while executing Python code.")); } else - common_val_print (value, stream, recurse + 1, options, language); + { + /* When printing the key of a map we allow one additional + level of depth. This means the key will print before the + value does. */ + struct value_print_options opt = *options; + if (is_map && i % 2 == 0 + && opt.max_depth != -1 + && opt.max_depth < INT_MAX) + ++opt.max_depth; + common_val_print (value, stream, recurse + 1, &opt, language); + } } if (is_map && i % 2 == 0) fputs_filtered ("] = ", stream); - - do_cleanups (inner_cleanup); } if (i) @@ -681,29 +552,24 @@ print_children (PyObject *printer, const char *hint, } fputs_filtered ("}", stream); } - - done: - do_cleanups (cleanups); } enum ext_lang_rc gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang, - struct type *type, const gdb_byte *valaddr, - int embedded_offset, CORE_ADDR address, + struct type *type, + LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, - const struct value *val, + struct value *val, const struct value_print_options *options, const struct language_defn *language) { struct gdbarch *gdbarch = get_type_arch (type); - PyObject *printer = NULL; - PyObject *val_obj = NULL; struct value *value; - char *hint = NULL; - struct cleanup *cleanups; - enum ext_lang_rc result = EXT_LANG_RC_NOP; enum string_repr_result print_result; + if (value_lazy (val)) + value_fetch_lazy (val); + /* No pretty-printer support for unavailable values. */ if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type))) return EXT_LANG_RC_NOP; @@ -711,64 +577,45 @@ gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang, if (!gdb_python_initialized) return EXT_LANG_RC_NOP; - cleanups = ensure_python_env (gdbarch, language); + gdbpy_enter enter_py (gdbarch, language); /* Instantiate the printer. */ - if (valaddr) - valaddr += embedded_offset; - value = value_from_contents_and_address (type, valaddr, - address + embedded_offset); - - set_value_component_location (value, val); - /* set_value_component_location resets the address, so we may - need to set it again. */ - if (VALUE_LVAL (value) != lval_internalvar - && VALUE_LVAL (value) != lval_internalvar_component - && VALUE_LVAL (value) != lval_computed) - set_value_address (value, address + embedded_offset); - - val_obj = value_to_value_object (value); - if (! val_obj) + value = value_from_component (val, type, embedded_offset); + + gdbpy_ref<> val_obj (value_to_value_object (value)); + if (val_obj == NULL) { - result = EXT_LANG_RC_ERROR; - goto done; + print_stack_unless_memory_error (stream); + return EXT_LANG_RC_ERROR; } /* Find the constructor. */ - printer = find_pretty_printer (val_obj); - Py_DECREF (val_obj); - + gdbpy_ref<> printer (find_pretty_printer (val_obj.get ())); if (printer == NULL) { - result = EXT_LANG_RC_ERROR; - goto done; + print_stack_unless_memory_error (stream); + return EXT_LANG_RC_ERROR; } - make_cleanup_py_decref (printer); if (printer == Py_None) - { - result = EXT_LANG_RC_NOP; - goto done; - } + return EXT_LANG_RC_NOP; + + if (val_print_check_max_depth (stream, recurse, options, language)) + return EXT_LANG_RC_OK; /* If we are printing a map, we want some special formatting. */ - hint = gdbpy_get_display_hint (printer); - make_cleanup (free_current_contents, &hint); + gdb::unique_xmalloc_ptr hint (gdbpy_get_display_hint (printer.get ())); /* Print the section */ - print_result = print_string_repr (printer, hint, stream, recurse, - options, language, gdbarch); + print_result = print_string_repr (printer.get (), hint.get (), stream, + recurse, options, language, gdbarch); if (print_result != string_repr_error) - print_children (printer, hint, stream, recurse, options, language, - print_result == string_repr_none); + print_children (printer.get (), hint.get (), stream, recurse, options, + language, print_result == string_repr_none); - result = EXT_LANG_RC_OK; - - done: if (PyErr_Occurred ()) print_stack_unless_memory_error (stream); - do_cleanups (cleanups); - return result; + return EXT_LANG_RC_OK; } @@ -781,15 +628,13 @@ gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang, set to the replacement value and this function returns NULL. On error, *REPLACEMENT is set to NULL and this function also returns NULL. */ -PyObject * +gdbpy_ref<> apply_varobj_pretty_printer (PyObject *printer_obj, struct value **replacement, struct ui_file *stream) { - PyObject *py_str = NULL; - *replacement = NULL; - py_str = pretty_print_one_value (printer_obj, replacement); + gdbpy_ref<> py_str = pretty_print_one_value (printer_obj, replacement); if (*replacement == NULL && py_str == NULL) print_stack_unless_memory_error (stream); @@ -801,29 +646,23 @@ apply_varobj_pretty_printer (PyObject *printer_obj, reference to the object if successful; returns NULL if not. VALUE is the value for which a printer tests to determine if it can pretty-print the value. */ -PyObject * +gdbpy_ref<> gdbpy_get_varobj_pretty_printer (struct value *value) { - PyObject *val_obj; - PyObject *pretty_printer = NULL; - - TRY + try { value = value_copy (value); } - CATCH (except, RETURN_MASK_ALL) + catch (const gdb_exception &except) { GDB_PY_HANDLE_EXCEPTION (except); } - END_CATCH - val_obj = value_to_value_object (value); - if (! val_obj) + gdbpy_ref<> val_obj (value_to_value_object (value)); + if (val_obj == NULL) return NULL; - pretty_printer = find_pretty_printer (val_obj); - Py_DECREF (val_obj); - return pretty_printer; + return find_pretty_printer (val_obj.get ()); } /* A Python function which wraps find_pretty_printer and instantiates @@ -834,7 +673,6 @@ PyObject * gdbpy_default_visualizer (PyObject *self, PyObject *args) { PyObject *val_obj; - PyObject *cons; struct value *value; if (! PyArg_ParseTuple (args, "O", &val_obj)) @@ -847,6 +685,5 @@ gdbpy_default_visualizer (PyObject *self, PyObject *args) return NULL; } - cons = find_pretty_printer (val_obj); - return cons; + return find_pretty_printer (val_obj).release (); }