X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fpython%2Fpy-framefilter.c;h=fb41e95711ed10422d8a1b25a3a184ca88156c62;hb=3804da7e07a13c14210d79de55ebfe2318421164;hp=017ea90f61909146112ca7a5497fd2bb7ff6db02;hpb=230d2906b9d1d009b22fd526181bf43e1084ed59;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/python/py-framefilter.c b/gdb/python/py-framefilter.c index 017ea90f61..fb41e95711 100644 --- a/gdb/python/py-framefilter.c +++ b/gdb/python/py-framefilter.c @@ -1,6 +1,6 @@ /* Python frame filters - Copyright (C) 2013-2019 Free Software Foundation, Inc. + Copyright (C) 2013-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -25,12 +25,15 @@ #include "python.h" #include "ui-out.h" #include "valprint.h" +#include "stack.h" +#include "source.h" #include "annotate.h" #include "hashtab.h" #include "demangle.h" #include "mi/mi-cmds.h" #include "python-internal.h" -#include "common/gdb_optional.h" +#include "gdbsupport/gdb_optional.h" +#include "cli/cli-style.h" enum mi_print_types { @@ -100,13 +103,13 @@ extract_sym (PyObject *obj, gdb::unique_xmalloc_ptr *name, /* Duplicate the symbol name, so the caller has consistency in garbage collection. */ - name->reset (xstrdup (SYMBOL_PRINT_NAME (*sym))); + name->reset (xstrdup ((*sym)->print_name ())); /* If a symbol is specified attempt to determine the language from the symbol. If mode is not "auto", then the language has been explicitly set, use that. */ if (language_mode == language_mode_auto) - *language = language_def (SYMBOL_LANGUAGE (*sym)); + *language = language_def ((*sym)->language ()); else *language = current_language; } @@ -317,7 +320,7 @@ py_print_single_arg (struct ui_out *out, { if (fa->val == NULL && fa->error == NULL) return; - language = language_def (SYMBOL_LANGUAGE (fa->sym)); + language = language_def (fa->sym->language ()); val = fa->val; } else @@ -345,15 +348,15 @@ py_print_single_arg (struct ui_out *out, { string_file stb; - fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (fa->sym), - SYMBOL_LANGUAGE (fa->sym), + fprintf_symbol_filtered (&stb, fa->sym->print_name (), + fa->sym->language (), DMGL_PARAMS | DMGL_ANSI); if (fa->entry_kind == print_entry_values_compact) { stb.puts ("="); - fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (fa->sym), - SYMBOL_LANGUAGE (fa->sym), + fprintf_symbol_filtered (&stb, fa->sym->print_name (), + fa->sym->language (), DMGL_PARAMS | DMGL_ANSI); } if (fa->entry_kind == print_entry_values_only @@ -370,7 +373,7 @@ py_print_single_arg (struct ui_out *out, out->text ("="); if (print_args_field) - out->field_int ("arg", 1); + out->field_signed ("arg", 1); /* For MI print the type, but only for simple values. This seems weird, but this is how MI choose to format the various output @@ -394,9 +397,9 @@ py_print_single_arg (struct ui_out *out, if (val == NULL) { gdb_assert (fa != NULL && fa->error != NULL); - out->field_fmt ("value", + out->field_fmt ("value", metadata_style.style (), _(""), - fa->error); + fa->error.get ()); } else py_print_value (out, val, opts, 0, args_type, language); @@ -481,10 +484,8 @@ enumerate_args (PyObject *iter, return EXT_LANG_BT_ERROR; } - read_frame_arg (sym, frame, &arg, &entryarg); - - gdb::unique_xmalloc_ptr arg_holder (arg.error); - gdb::unique_xmalloc_ptr entry_holder (entryarg.error); + read_frame_arg (user_frame_print_options, + sym, frame, &arg, &entryarg); /* The object has not provided a value, so this is a frame argument to be read by GDB. In this case we have to @@ -712,9 +713,21 @@ py_print_args (PyObject *filter, annotate_frame_args (); out->text (" ("); - if (args_iter != Py_None - && (enumerate_args (args_iter.get (), out, args_type, 0, frame) - == EXT_LANG_BT_ERROR)) + if (args_type == CLI_PRESENCE) + { + if (args_iter != Py_None) + { + gdbpy_ref<> item (PyIter_Next (args_iter.get ())); + + if (item != NULL) + out->text ("..."); + else if (PyErr_Occurred ()) + return EXT_LANG_BT_ERROR; + } + } + else if (args_iter != Py_None + && (enumerate_args (args_iter.get (), out, args_type, 0, frame) + == EXT_LANG_BT_ERROR)) return EXT_LANG_BT_ERROR; out->text (")"); @@ -747,7 +760,16 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, struct gdbarch *gdbarch = NULL; struct frame_info *frame = NULL; struct value_print_options opts; + int print_level, print_frame_info, print_args, print_locals; + /* Note that the below default in non-mi mode is the same as the + default value for the backtrace command (see the call to print_frame_info + in backtrace_command_1). + Having the same default ensures that 'bt' and 'bt no-filters' + have the same behaviour when some filters exist but do not apply + to a frame. */ + enum print_what print_what + = out->is_mi_like_p () ? LOC_AND_ADDRESS : LOCATION; gdb::unique_xmalloc_ptr function_to_free; /* Extract print settings from FLAGS. */ @@ -757,6 +779,17 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, print_locals = (flags & PRINT_LOCALS) ? 1 : 0; get_user_print_options (&opts); + if (print_frame_info) + { + gdb::optional user_frame_info_print_what; + + get_user_print_what_frame_info (&user_frame_info_print_what); + if (!out->is_mi_like_p () && user_frame_info_print_what.has_value ()) + { + /* Use the specific frame information desired by the user. */ + print_what = *user_frame_info_print_what; + } + } /* Get the underlying frame. This is needed to determine GDB architecture, and also, in the cases of frame variables/arguments to @@ -770,6 +803,8 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, if (frame == NULL) return EXT_LANG_BT_ERROR; + symtab_and_line sal = find_frame_sal (frame); + gdbarch = get_frame_arch (frame); /* stack-list-variables. */ @@ -814,9 +849,19 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, } } + /* For MI, each piece is controlled individually. */ + bool location_print = (print_frame_info + && !out->is_mi_like_p () + && (print_what == LOCATION + || print_what == SRC_AND_LOC + || print_what == LOC_AND_ADDRESS + || print_what == SHORT_LOCATION)); + /* Print frame level. MI does not require the level if locals/variables only are being printed. */ - if ((print_frame_info || print_args) && print_level) + if (print_level + && (location_print + || (out->is_mi_like_p () && (print_frame_info || print_args)))) { struct frame_info **slot; int level; @@ -838,21 +883,27 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, annotate_frame_begin (print_level ? level : 0, gdbarch, address); out->text ("#"); - out->field_fmt_int (2, ui_left, "level", - level); + out->field_fmt_signed (2, ui_left, "level", level); } } - if (print_frame_info) + if (location_print || (out->is_mi_like_p () && print_frame_info)) { /* Print address to the address field. If an address is not provided, print nothing. */ if (opts.addressprint && has_addr) { - annotate_frame_address (); - out->field_core_addr ("addr", gdbarch, address); - annotate_frame_address_end (); - out->text (" in "); + if (!sal.symtab + || frame_show_address (frame, sal) + || print_what == LOC_AND_ADDRESS) + { + annotate_frame_address (); + out->field_core_addr ("addr", gdbarch, address); + if (get_frame_pc_masked (frame)) + out->field_string ("pac", " [PAC]"); + annotate_frame_address_end (); + out->text (" in "); + } } /* Print frame function name. */ @@ -883,7 +934,7 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, msymbol = lookup_minimal_symbol_by_pc (addr); if (msymbol.minsym != NULL) - function = MSYMBOL_PRINT_NAME (msymbol.minsym); + function = msymbol.minsym->print_name (); } else if (py_func != Py_None) { @@ -897,21 +948,24 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, if (function == NULL) out->field_skip ("func"); else - out->field_string ("func", function, ui_out_style_kind::FUNCTION); + out->field_string ("func", function, function_name_style.style ()); } } /* Frame arguments. Check the result, and error if something went wrong. */ - if (print_args) + if (print_args && (location_print || out->is_mi_like_p ())) { if (py_print_args (filter, out, args_type, frame) == EXT_LANG_BT_ERROR) return EXT_LANG_BT_ERROR; } /* File name/source/line number information. */ - if (print_frame_info) + bool print_location_source + = ((location_print && print_what != SHORT_LOCATION) + || (out->is_mi_like_p () && print_frame_info)); + if (print_location_source) { annotate_frame_source_begin (); @@ -934,7 +988,7 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, out->text (" at "); annotate_frame_source_file (); out->field_string ("file", filename.get (), - ui_out_style_kind::FILE); + file_name_style.style ()); annotate_frame_source_file_end (); } } @@ -955,7 +1009,7 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, out->text (":"); annotate_frame_source_line (); - out->field_int ("line", line); + out->field_signed ("line", line); } } if (out->is_mi_like_p ()) @@ -963,12 +1017,24 @@ py_print_frame (PyObject *filter, frame_filter_flags flags, (gdbarch_bfd_arch_info (gdbarch))->printable_name); } + bool source_print + = (! out->is_mi_like_p () + && (print_what == SRC_LINE || print_what == SRC_AND_LOC)); + if (source_print) + { + if (print_location_source) + out->text ("\n"); /* Newline after the location source. */ + print_source_lines (sal.symtab, sal.line, sal.line + 1, 0); + } + /* For MI we need to deal with the "children" list population of elided frames, so if MI output detected do not send newline. */ if (! out->is_mi_like_p ()) { annotate_frame_end (); - out->text ("\n"); + /* print_source_lines has already printed a newline. */ + if (!source_print) + out->text ("\n"); } if (print_locals)