1 /* Python frame filters
3 Copyright (C) 2013-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "arch-utils.h"
31 #include "mi/mi-cmds.h"
32 #include "python-internal.h"
34 #include "common/gdb_optional.h"
42 /* Helper function to extract a symbol, a name and a language
43 definition from a Python object that conforms to the "Symbol Value"
44 interface. OBJ is the Python object to extract the values from.
45 NAME is a pass-through argument where the name of the symbol will
46 be written. NAME is allocated in this function, but the caller is
47 responsible for clean up. SYM is a pass-through argument where the
48 symbol will be written and SYM_BLOCK is a pass-through argument to
49 write the block where the symbol lies in. In the case of the API
50 returning a string, this will be set to NULL. LANGUAGE is also a
51 pass-through argument denoting the language attributed to the
52 Symbol. In the case of SYM being NULL, this will be set to the
53 current language. Returns EXT_LANG_BT_ERROR on error with the
54 appropriate Python exception set, and EXT_LANG_BT_OK on success. */
56 static enum ext_lang_bt_status
57 extract_sym (PyObject
*obj
, gdb::unique_xmalloc_ptr
<char> *name
,
58 struct symbol
**sym
, struct block
**sym_block
,
59 const struct language_defn
**language
)
61 gdbpy_ref
<> result (PyObject_CallMethod (obj
, "symbol", NULL
));
64 return EXT_LANG_BT_ERROR
;
66 /* For 'symbol' callback, the function can return a symbol or a
68 if (gdbpy_is_string (result
.get ()))
70 *name
= python_string_to_host_string (result
.get ());
73 return EXT_LANG_BT_ERROR
;
74 /* If the API returns a string (and not a symbol), then there is
75 no symbol derived language available and the frame filter has
76 either overridden the symbol with a string, or supplied a
77 entirely synthetic symbol/value pairing. In that case, use
79 *language
= python_language
;
85 /* This type checks 'result' during the conversion so we
86 just call it unconditionally and check the return. */
87 *sym
= symbol_object_to_symbol (result
.get ());
88 /* TODO: currently, we have no way to recover the block in which SYMBOL
89 was found, so we have no block to return. Trying to evaluate SYMBOL
90 will yield an incorrect value when it's located in a FRAME and
91 evaluated from another frame (as permitted in nested functions). */
96 PyErr_SetString (PyExc_RuntimeError
,
97 _("Unexpected value. Expecting a "
98 "gdb.Symbol or a Python string."));
99 return EXT_LANG_BT_ERROR
;
102 /* Duplicate the symbol name, so the caller has consistency
103 in garbage collection. */
104 name
->reset (xstrdup (SYMBOL_PRINT_NAME (*sym
)));
106 /* If a symbol is specified attempt to determine the language
107 from the symbol. If mode is not "auto", then the language
108 has been explicitly set, use that. */
109 if (language_mode
== language_mode_auto
)
110 *language
= language_def (SYMBOL_LANGUAGE (*sym
));
112 *language
= current_language
;
115 return EXT_LANG_BT_OK
;
118 /* Helper function to extract a value from an object that conforms to
119 the "Symbol Value" interface. OBJ is the Python object to extract
120 the value from. VALUE is a pass-through argument where the value
121 will be written. If the object does not have the value attribute,
122 or provides the Python None for a value, VALUE will be set to NULL
123 and this function will return as successful. Returns EXT_LANG_BT_ERROR
124 on error with the appropriate Python exception set, and EXT_LANG_BT_OK on
127 static enum ext_lang_bt_status
128 extract_value (PyObject
*obj
, struct value
**value
)
130 if (PyObject_HasAttrString (obj
, "value"))
132 gdbpy_ref
<> vresult (PyObject_CallMethod (obj
, "value", NULL
));
135 return EXT_LANG_BT_ERROR
;
137 /* The Python code has returned 'None' for a value, so we set
138 value to NULL. This flags that GDB should read the
140 if (vresult
== Py_None
)
143 return EXT_LANG_BT_OK
;
147 *value
= convert_value_from_python (vresult
.get ());
150 return EXT_LANG_BT_ERROR
;
152 return EXT_LANG_BT_OK
;
158 return EXT_LANG_BT_OK
;
161 /* MI prints only certain values according to the type of symbol and
162 also what the user has specified. SYM is the symbol to check, and
163 MI_PRINT_TYPES is an enum specifying what the user wants emitted
164 for the MI command in question. */
166 mi_should_print (struct symbol
*sym
, enum mi_print_types type
)
170 switch (SYMBOL_CLASS (sym
))
173 case LOC_UNDEF
: /* catches errors */
174 case LOC_CONST
: /* constant */
175 case LOC_TYPEDEF
: /* local typedef */
176 case LOC_LABEL
: /* local label */
177 case LOC_BLOCK
: /* local function */
178 case LOC_CONST_BYTES
: /* loc. byte seq. */
179 case LOC_UNRESOLVED
: /* unresolved static */
180 case LOC_OPTIMIZED_OUT
: /* optimized out */
184 case LOC_ARG
: /* argument */
185 case LOC_REF_ARG
: /* reference arg */
186 case LOC_REGPARM_ADDR
: /* indirect register arg */
187 case LOC_LOCAL
: /* stack local */
188 case LOC_STATIC
: /* static */
189 case LOC_REGISTER
: /* register */
190 case LOC_COMPUTED
: /* computed location */
191 if (type
== MI_PRINT_LOCALS
)
192 print_me
= ! SYMBOL_IS_ARGUMENT (sym
);
194 print_me
= SYMBOL_IS_ARGUMENT (sym
);
199 /* Helper function which outputs a type name extracted from VAL to a
200 "type" field in the output stream OUT. OUT is the ui-out structure
201 the type name will be output too, and VAL is the value that the
202 type will be extracted from. */
205 py_print_type (struct ui_out
*out
, struct value
*val
)
207 check_typedef (value_type (val
));
210 type_print (value_type (val
), "", &stb
, -1);
211 out
->field_stream ("type", stb
);
214 /* Helper function which outputs a value to an output field in a
215 stream. OUT is the ui-out structure the value will be output to,
216 VAL is the value that will be printed, OPTS contains the value
217 printing options, ARGS_TYPE is an enumerator describing the
218 argument format, and LANGUAGE is the language_defn that the value
219 will be printed with. */
222 py_print_value (struct ui_out
*out
, struct value
*val
,
223 const struct value_print_options
*opts
,
225 enum ext_lang_frame_args args_type
,
226 const struct language_defn
*language
)
228 int should_print
= 0;
230 /* MI does not print certain values, differentiated by type,
231 depending on what ARGS_TYPE indicates. Test type against option.
232 For CLI print all values. */
233 if (args_type
== MI_PRINT_SIMPLE_VALUES
234 || args_type
== MI_PRINT_ALL_VALUES
)
236 struct type
*type
= check_typedef (value_type (val
));
238 if (args_type
== MI_PRINT_ALL_VALUES
)
240 else if (args_type
== MI_PRINT_SIMPLE_VALUES
241 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
242 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
243 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
246 else if (args_type
!= NO_VALUES
)
253 common_val_print (val
, &stb
, indent
, opts
, language
);
254 out
->field_stream ("value", stb
);
258 /* Helper function to call a Python method and extract an iterator
259 from the result. If the function returns anything but an iterator
260 the exception is preserved and NULL is returned. FILTER is the
261 Python object to call, and FUNC is the name of the method. Returns
262 a PyObject, or NULL on error with the appropriate exception set.
263 This function can return an iterator, or NULL. */
266 get_py_iter_from_func (PyObject
*filter
, const char *func
)
268 if (PyObject_HasAttrString (filter
, func
))
270 gdbpy_ref
<> result (PyObject_CallMethod (filter
, func
, NULL
));
274 if (result
== Py_None
)
276 return result
.release ();
280 return PyObject_GetIter (result
.get ());
290 /* Helper function to output a single frame argument and value to an
291 output stream. This function will account for entry values if the
292 FV parameter is populated, the frame argument has entry values
293 associated with them, and the appropriate "set entry-value"
294 options are set. Will output in CLI or MI like format depending
295 on the type of output stream detected. OUT is the output stream,
296 SYM_NAME is the name of the symbol. If SYM_NAME is populated then
297 it must have an accompanying value in the parameter FV. FA is a
298 frame argument structure. If FA is populated, both SYM_NAME and
299 FV are ignored. OPTS contains the value printing options,
300 ARGS_TYPE is an enumerator describing the argument format,
301 PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
302 in MI output in commands where both arguments and locals are
306 py_print_single_arg (struct ui_out
*out
,
307 const char *sym_name
,
308 struct frame_arg
*fa
,
310 const struct value_print_options
*opts
,
311 enum ext_lang_frame_args args_type
,
312 int print_args_field
,
313 const struct language_defn
*language
)
319 if (fa
->val
== NULL
&& fa
->error
== NULL
)
321 language
= language_def (SYMBOL_LANGUAGE (fa
->sym
));
327 gdb::optional
<ui_out_emit_tuple
> maybe_tuple
;
329 /* MI has varying rules for tuples, but generally if there is only
330 one element in each item in the list, do not start a tuple. The
331 exception is -stack-list-variables which emits an ARGS="1" field
332 if the value is a frame argument. This is denoted in this
333 function with PRINT_ARGS_FIELD which is flag from the caller to
334 emit the ARGS field. */
335 if (out
->is_mi_like_p ())
337 if (print_args_field
|| args_type
!= NO_VALUES
)
338 maybe_tuple
.emplace (out
, nullptr);
341 annotate_arg_begin ();
343 /* If frame argument is populated, check for entry-values and the
344 entry value options. */
349 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (fa
->sym
),
350 SYMBOL_LANGUAGE (fa
->sym
),
351 DMGL_PARAMS
| DMGL_ANSI
);
352 if (fa
->entry_kind
== print_entry_values_compact
)
356 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (fa
->sym
),
357 SYMBOL_LANGUAGE (fa
->sym
),
358 DMGL_PARAMS
| DMGL_ANSI
);
360 if (fa
->entry_kind
== print_entry_values_only
361 || fa
->entry_kind
== print_entry_values_compact
)
363 out
->field_stream ("name", stb
);
366 /* Otherwise, just output the name. */
367 out
->field_string ("name", sym_name
);
369 annotate_arg_name_end ();
371 if (! out
->is_mi_like_p ())
374 if (print_args_field
)
375 out
->field_int ("arg", 1);
377 /* For MI print the type, but only for simple values. This seems
378 weird, but this is how MI choose to format the various output
380 if (args_type
== MI_PRINT_SIMPLE_VALUES
&& val
!= NULL
)
381 py_print_type (out
, val
);
384 annotate_arg_value (value_type (val
));
386 /* If the output is to the CLI, and the user option "set print
387 frame-arguments" is set to none, just output "...". */
388 if (! out
->is_mi_like_p () && args_type
== NO_VALUES
)
389 out
->field_string ("value", "...");
392 /* Otherwise, print the value for both MI and the CLI, except
393 for the case of MI_PRINT_NO_VALUES. */
394 if (args_type
!= NO_VALUES
)
398 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
399 out
->field_fmt ("value",
400 _("<error reading variable: %s>"),
404 py_print_value (out
, val
, opts
, 0, args_type
, language
);
409 /* Helper function to loop over frame arguments provided by the
410 "frame_arguments" Python API. Elements in the iterator must
411 conform to the "Symbol Value" interface. ITER is the Python
412 iterable object, OUT is the output stream, ARGS_TYPE is an
413 enumerator describing the argument format, PRINT_ARGS_FIELD is a
414 flag which indicates if we output "ARGS=1" in MI output in commands
415 where both arguments and locals are printed, and FRAME is the
416 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
417 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
420 static enum ext_lang_bt_status
421 enumerate_args (PyObject
*iter
,
423 enum ext_lang_frame_args args_type
,
424 int print_args_field
,
425 struct frame_info
*frame
)
427 struct value_print_options opts
;
429 get_user_print_options (&opts
);
431 if (args_type
== CLI_SCALAR_VALUES
)
433 /* True in "summary" mode, false otherwise. */
439 annotate_frame_args ();
441 /* Collect the first argument outside of the loop, so output of
442 commas in the argument output is correct. At the end of the
443 loop block collect another item from the iterator, and, if it is
444 not null emit a comma. */
445 gdbpy_ref
<> item (PyIter_Next (iter
));
446 if (item
== NULL
&& PyErr_Occurred ())
447 return EXT_LANG_BT_ERROR
;
451 const struct language_defn
*language
;
452 gdb::unique_xmalloc_ptr
<char> sym_name
;
454 struct block
*sym_block
;
456 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
458 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
460 if (success
== EXT_LANG_BT_ERROR
)
461 return EXT_LANG_BT_ERROR
;
463 success
= extract_value (item
.get (), &val
);
464 if (success
== EXT_LANG_BT_ERROR
)
465 return EXT_LANG_BT_ERROR
;
467 if (sym
&& out
->is_mi_like_p ()
468 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
471 /* If the object did not provide a value, read it using
472 read_frame_args and account for entry values, if any. */
475 struct frame_arg arg
, entryarg
;
477 /* If there is no value, and also no symbol, set error and
481 PyErr_SetString (PyExc_RuntimeError
,
482 _("No symbol or value provided."));
483 return EXT_LANG_BT_ERROR
;
486 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
488 gdb::unique_xmalloc_ptr
<char> arg_holder (arg
.error
);
489 gdb::unique_xmalloc_ptr
<char> entry_holder (entryarg
.error
);
491 /* The object has not provided a value, so this is a frame
492 argument to be read by GDB. In this case we have to
493 account for entry-values. */
495 if (arg
.entry_kind
!= print_entry_values_only
)
497 py_print_single_arg (out
, NULL
, &arg
,
504 if (entryarg
.entry_kind
!= print_entry_values_no
)
506 if (arg
.entry_kind
!= print_entry_values_only
)
509 out
->wrap_hint (" ");
512 py_print_single_arg (out
, NULL
, &entryarg
, NULL
, &opts
,
513 args_type
, print_args_field
, NULL
);
518 /* If the object has provided a value, we just print that. */
520 py_print_single_arg (out
, sym_name
.get (), NULL
, val
, &opts
,
521 args_type
, print_args_field
,
525 /* Collect the next item from the iterator. If
526 this is the last item, do not print the
528 item
.reset (PyIter_Next (iter
));
531 else if (PyErr_Occurred ())
532 return EXT_LANG_BT_ERROR
;
537 return EXT_LANG_BT_OK
;
541 /* Helper function to loop over variables provided by the
542 "frame_locals" Python API. Elements in the iterable must conform
543 to the "Symbol Value" interface. ITER is the Python iterable
544 object, OUT is the output stream, INDENT is whether we should
545 indent the output (for CLI), ARGS_TYPE is an enumerator describing
546 the argument format, PRINT_ARGS_FIELD is flag which indicates
547 whether to output the ARGS field in the case of
548 -stack-list-variables and FRAME is the backing frame. Returns
549 EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
550 exception, or EXT_LANG_BT_OK on success. */
552 static enum ext_lang_bt_status
553 enumerate_locals (PyObject
*iter
,
556 enum ext_lang_frame_args args_type
,
557 int print_args_field
,
558 struct frame_info
*frame
)
560 struct value_print_options opts
;
562 get_user_print_options (&opts
);
567 const struct language_defn
*language
;
568 gdb::unique_xmalloc_ptr
<char> sym_name
;
570 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
572 struct block
*sym_block
;
573 int local_indent
= 8 + (8 * indent
);
574 gdb::optional
<ui_out_emit_tuple
> tuple
;
576 gdbpy_ref
<> item (PyIter_Next (iter
));
580 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
582 if (success
== EXT_LANG_BT_ERROR
)
583 return EXT_LANG_BT_ERROR
;
585 success
= extract_value (item
.get (), &val
);
586 if (success
== EXT_LANG_BT_ERROR
)
587 return EXT_LANG_BT_ERROR
;
589 if (sym
!= NULL
&& out
->is_mi_like_p ()
590 && ! mi_should_print (sym
, MI_PRINT_LOCALS
))
593 /* If the object did not provide a value, read it. */
595 val
= read_var_value (sym
, sym_block
, frame
);
597 /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
598 each output contains only one field. The exception is
599 -stack-list-variables, which always provides a tuple. */
600 if (out
->is_mi_like_p ())
602 if (print_args_field
|| args_type
!= NO_VALUES
)
603 tuple
.emplace (out
, nullptr);
605 if (! out
->is_mi_like_p ())
607 /* If the output is not MI we indent locals. */
608 out
->spaces (local_indent
);
611 out
->field_string ("name", sym_name
.get ());
613 if (! out
->is_mi_like_p ())
616 if (args_type
== MI_PRINT_SIMPLE_VALUES
)
617 py_print_type (out
, val
);
619 /* CLI always prints values for locals. MI uses the
620 simple/no/all system. */
621 if (! out
->is_mi_like_p ())
623 int val_indent
= (indent
+ 1) * 4;
625 py_print_value (out
, val
, &opts
, val_indent
, args_type
,
630 if (args_type
!= NO_VALUES
)
631 py_print_value (out
, val
, &opts
, 0, args_type
,
638 if (!PyErr_Occurred ())
639 return EXT_LANG_BT_OK
;
641 return EXT_LANG_BT_ERROR
;
644 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
645 error, or EXT_LANG_BT_OK on success. */
647 static enum ext_lang_bt_status
648 py_mi_print_variables (PyObject
*filter
, struct ui_out
*out
,
649 struct value_print_options
*opts
,
650 enum ext_lang_frame_args args_type
,
651 struct frame_info
*frame
)
653 gdbpy_ref
<> args_iter (get_py_iter_from_func (filter
, "frame_args"));
654 if (args_iter
== NULL
)
655 return EXT_LANG_BT_ERROR
;
657 gdbpy_ref
<> locals_iter (get_py_iter_from_func (filter
, "frame_locals"));
658 if (locals_iter
== NULL
)
659 return EXT_LANG_BT_ERROR
;
661 ui_out_emit_list
list_emitter (out
, "variables");
663 if (args_iter
!= Py_None
664 && (enumerate_args (args_iter
.get (), out
, args_type
, 1, frame
)
665 == EXT_LANG_BT_ERROR
))
666 return EXT_LANG_BT_ERROR
;
668 if (locals_iter
!= Py_None
669 && (enumerate_locals (locals_iter
.get (), out
, 1, args_type
, 1, frame
)
670 == EXT_LANG_BT_ERROR
))
671 return EXT_LANG_BT_ERROR
;
673 return EXT_LANG_BT_OK
;
676 /* Helper function for printing locals. This function largely just
677 creates the wrapping tuple, and calls enumerate_locals. Returns
678 EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
680 static enum ext_lang_bt_status
681 py_print_locals (PyObject
*filter
,
683 enum ext_lang_frame_args args_type
,
685 struct frame_info
*frame
)
687 gdbpy_ref
<> locals_iter (get_py_iter_from_func (filter
, "frame_locals"));
688 if (locals_iter
== NULL
)
689 return EXT_LANG_BT_ERROR
;
691 ui_out_emit_list
list_emitter (out
, "locals");
693 if (locals_iter
!= Py_None
694 && (enumerate_locals (locals_iter
.get (), out
, indent
, args_type
,
695 0, frame
) == EXT_LANG_BT_ERROR
))
696 return EXT_LANG_BT_ERROR
;
698 return EXT_LANG_BT_OK
;
701 /* Helper function for printing frame arguments. This function
702 largely just creates the wrapping tuple, and calls enumerate_args.
703 Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
704 a Python exception, or EXT_LANG_BT_OK on success. */
706 static enum ext_lang_bt_status
707 py_print_args (PyObject
*filter
,
709 enum ext_lang_frame_args args_type
,
710 struct frame_info
*frame
)
712 gdbpy_ref
<> args_iter (get_py_iter_from_func (filter
, "frame_args"));
713 if (args_iter
== NULL
)
714 return EXT_LANG_BT_ERROR
;
716 ui_out_emit_list
list_emitter (out
, "args");
718 out
->wrap_hint (" ");
719 annotate_frame_args ();
720 if (! out
->is_mi_like_p ())
723 if (args_iter
!= Py_None
724 && (enumerate_args (args_iter
.get (), out
, args_type
, 0, frame
)
725 == EXT_LANG_BT_ERROR
))
726 return EXT_LANG_BT_ERROR
;
728 if (! out
->is_mi_like_p ())
731 return EXT_LANG_BT_OK
;
734 /* Print a single frame to the designated output stream, detecting
735 whether the output is MI or console, and formatting the output
736 according to the conventions of that protocol. FILTER is the
737 frame-filter associated with this frame. FLAGS is an integer
738 describing the various print options. The FLAGS variables is
739 described in "apply_frame_filter" function. ARGS_TYPE is an
740 enumerator describing the argument format. OUT is the output
741 stream to print, INDENT is the level of indention for this frame
742 (in the case of elided frames), and LEVELS_PRINTED is a hash-table
743 containing all the frames level that have already been printed.
744 If a frame level has been printed, do not print it again (in the
745 case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
746 GDB exceptions converted to a Python exception, or EXT_LANG_BT_OK
747 on success. It can also throw an exception RETURN_QUIT. */
749 static enum ext_lang_bt_status
750 py_print_frame (PyObject
*filter
, frame_filter_flags flags
,
751 enum ext_lang_frame_args args_type
,
752 struct ui_out
*out
, int indent
, htab_t levels_printed
)
755 CORE_ADDR address
= 0;
756 struct gdbarch
*gdbarch
= NULL
;
757 struct frame_info
*frame
= NULL
;
758 struct value_print_options opts
;
759 int print_level
, print_frame_info
, print_args
, print_locals
;
760 gdb::unique_xmalloc_ptr
<char> function_to_free
;
762 /* Extract print settings from FLAGS. */
763 print_level
= (flags
& PRINT_LEVEL
) ? 1 : 0;
764 print_frame_info
= (flags
& PRINT_FRAME_INFO
) ? 1 : 0;
765 print_args
= (flags
& PRINT_ARGS
) ? 1 : 0;
766 print_locals
= (flags
& PRINT_LOCALS
) ? 1 : 0;
768 get_user_print_options (&opts
);
770 /* Get the underlying frame. This is needed to determine GDB
771 architecture, and also, in the cases of frame variables/arguments to
772 read them if they returned filter object requires us to do so. */
773 gdbpy_ref
<> py_inf_frame (PyObject_CallMethod (filter
, "inferior_frame",
775 if (py_inf_frame
== NULL
)
776 return EXT_LANG_BT_ERROR
;
778 frame
= frame_object_to_frame_info (py_inf_frame
.get ());
780 return EXT_LANG_BT_ERROR
;
782 gdbarch
= get_frame_arch (frame
);
784 /* stack-list-variables. */
785 if (print_locals
&& print_args
&& ! print_frame_info
)
787 if (py_mi_print_variables (filter
, out
, &opts
,
788 args_type
, frame
) == EXT_LANG_BT_ERROR
)
789 return EXT_LANG_BT_ERROR
;
790 return EXT_LANG_BT_OK
;
793 gdb::optional
<ui_out_emit_tuple
> tuple
;
795 /* -stack-list-locals does not require a
796 wrapping frame attribute. */
797 if (print_frame_info
|| (print_args
&& ! print_locals
))
798 tuple
.emplace (out
, "frame");
800 if (print_frame_info
)
802 /* Elided frames are also printed with this function (recursively)
803 and are printed with indention. */
805 out
->spaces (indent
* 4);
807 /* The address is required for frame annotations, and also for
809 if (PyObject_HasAttrString (filter
, "address"))
811 gdbpy_ref
<> paddr (PyObject_CallMethod (filter
, "address", NULL
));
814 return EXT_LANG_BT_ERROR
;
816 if (paddr
!= Py_None
)
818 if (get_addr_from_python (paddr
.get (), &address
) < 0)
819 return EXT_LANG_BT_ERROR
;
826 /* Print frame level. MI does not require the level if
827 locals/variables only are being printed. */
828 if ((print_frame_info
|| print_args
) && print_level
)
830 struct frame_info
**slot
;
833 slot
= (struct frame_info
**) htab_find_slot (levels_printed
,
836 level
= frame_relative_level (frame
);
838 /* Check if this frame has already been printed (there are cases
839 where elided synthetic dummy-frames have to 'borrow' the frame
840 architecture from the eliding frame. If that is the case, do
841 not print 'level', but print spaces. */
843 out
->field_skip ("level");
847 annotate_frame_begin (print_level
? level
: 0,
850 out
->field_fmt_int (2, ui_left
, "level",
855 if (print_frame_info
)
857 /* Print address to the address field. If an address is not provided,
859 if (opts
.addressprint
&& has_addr
)
861 annotate_frame_address ();
862 out
->field_core_addr ("addr", gdbarch
, address
);
863 annotate_frame_address_end ();
867 /* Print frame function name. */
868 if (PyObject_HasAttrString (filter
, "function"))
870 gdbpy_ref
<> py_func (PyObject_CallMethod (filter
, "function", NULL
));
871 const char *function
= NULL
;
874 return EXT_LANG_BT_ERROR
;
876 if (gdbpy_is_string (py_func
.get ()))
878 function_to_free
= python_string_to_host_string (py_func
.get ());
880 if (function_to_free
== NULL
)
881 return EXT_LANG_BT_ERROR
;
883 function
= function_to_free
.get ();
885 else if (PyLong_Check (py_func
.get ()))
888 struct bound_minimal_symbol msymbol
;
890 if (get_addr_from_python (py_func
.get (), &addr
) < 0)
891 return EXT_LANG_BT_ERROR
;
893 msymbol
= lookup_minimal_symbol_by_pc (addr
);
894 if (msymbol
.minsym
!= NULL
)
895 function
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
897 else if (py_func
!= Py_None
)
899 PyErr_SetString (PyExc_RuntimeError
,
900 _("FrameDecorator.function: expecting a " \
901 "String, integer or None."));
902 return EXT_LANG_BT_ERROR
;
905 annotate_frame_function_name ();
906 if (function
== NULL
)
907 out
->field_skip ("func");
909 out
->field_string ("func", function
);
914 /* Frame arguments. Check the result, and error if something went
918 if (py_print_args (filter
, out
, args_type
, frame
) == EXT_LANG_BT_ERROR
)
919 return EXT_LANG_BT_ERROR
;
922 /* File name/source/line number information. */
923 if (print_frame_info
)
925 annotate_frame_source_begin ();
927 if (PyObject_HasAttrString (filter
, "filename"))
929 gdbpy_ref
<> py_fn (PyObject_CallMethod (filter
, "filename", NULL
));
932 return EXT_LANG_BT_ERROR
;
934 if (py_fn
!= Py_None
)
936 gdb::unique_xmalloc_ptr
<char>
937 filename (python_string_to_host_string (py_fn
.get ()));
939 if (filename
== NULL
)
940 return EXT_LANG_BT_ERROR
;
942 out
->wrap_hint (" ");
944 annotate_frame_source_file ();
945 out
->field_string ("file", filename
.get ());
946 annotate_frame_source_file_end ();
950 if (PyObject_HasAttrString (filter
, "line"))
952 gdbpy_ref
<> py_line (PyObject_CallMethod (filter
, "line", NULL
));
956 return EXT_LANG_BT_ERROR
;
958 if (py_line
!= Py_None
)
960 line
= PyLong_AsLong (py_line
.get ());
961 if (PyErr_Occurred ())
962 return EXT_LANG_BT_ERROR
;
965 annotate_frame_source_line ();
966 out
->field_int ("line", line
);
971 /* For MI we need to deal with the "children" list population of
972 elided frames, so if MI output detected do not send newline. */
973 if (! out
->is_mi_like_p ())
975 annotate_frame_end ();
981 if (py_print_locals (filter
, out
, args_type
, indent
,
982 frame
) == EXT_LANG_BT_ERROR
)
983 return EXT_LANG_BT_ERROR
;
986 if ((flags
& PRINT_HIDE
) == 0)
988 /* Finally recursively print elided frames, if any. */
989 gdbpy_ref
<> elided (get_py_iter_from_func (filter
, "elided"));
991 return EXT_LANG_BT_ERROR
;
993 if (elided
!= Py_None
)
997 ui_out_emit_list
inner_list_emiter (out
, "children");
999 if (! out
->is_mi_like_p ())
1002 while ((item
= PyIter_Next (elided
.get ())))
1004 gdbpy_ref
<> item_ref (item
);
1006 enum ext_lang_bt_status success
1007 = py_print_frame (item
, flags
, args_type
, out
, indent
,
1010 if (success
== EXT_LANG_BT_ERROR
)
1011 return EXT_LANG_BT_ERROR
;
1013 if (item
== NULL
&& PyErr_Occurred ())
1014 return EXT_LANG_BT_ERROR
;
1018 return EXT_LANG_BT_OK
;
1021 /* Helper function to initiate frame filter invocation at starting
1025 bootstrap_python_frame_filters (struct frame_info
*frame
,
1026 int frame_low
, int frame_high
)
1028 gdbpy_ref
<> frame_obj (frame_info_to_frame_object (frame
));
1029 if (frame_obj
== NULL
)
1032 gdbpy_ref
<> module (PyImport_ImportModule ("gdb.frames"));
1036 gdbpy_ref
<> sort_func (PyObject_GetAttrString (module
.get (),
1037 "execute_frame_filters"));
1038 if (sort_func
== NULL
)
1041 gdbpy_ref
<> py_frame_low (PyInt_FromLong (frame_low
));
1042 if (py_frame_low
== NULL
)
1045 gdbpy_ref
<> py_frame_high (PyInt_FromLong (frame_high
));
1046 if (py_frame_high
== NULL
)
1049 gdbpy_ref
<> iterable (PyObject_CallFunctionObjArgs (sort_func
.get (),
1051 py_frame_low
.get (),
1052 py_frame_high
.get (),
1054 if (iterable
== NULL
)
1057 if (iterable
!= Py_None
)
1058 return PyObject_GetIter (iterable
.get ());
1060 return iterable
.release ();
1063 /* A helper function that will either print an exception or, if it is
1064 a KeyboardException, throw a quit. This can only be called when
1065 the Python exception is set. */
1068 throw_quit_or_print_exception ()
1070 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1073 throw_quit ("Quit");
1075 gdbpy_print_stack ();
1078 /* This is the only publicly exported function in this file. FRAME
1079 is the source frame to start frame-filter invocation. FLAGS is an
1080 integer holding the flags for printing. The following elements of
1081 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1082 PRINT_LEVEL is a flag indicating whether to print the frame's
1083 relative level in the output. PRINT_FRAME_INFO is a flag that
1084 indicates whether this function should print the frame
1085 information, PRINT_ARGS is a flag that indicates whether to print
1086 frame arguments, and PRINT_LOCALS, likewise, with frame local
1087 variables. ARGS_TYPE is an enumerator describing the argument
1088 format, OUT is the output stream to print. FRAME_LOW is the
1089 beginning of the slice of frames to print, and FRAME_HIGH is the
1090 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1091 or EXT_LANG_BT_OK on success. */
1093 enum ext_lang_bt_status
1094 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1095 struct frame_info
*frame
, frame_filter_flags flags
,
1096 enum ext_lang_frame_args args_type
,
1097 struct ui_out
*out
, int frame_low
, int frame_high
)
1099 struct gdbarch
*gdbarch
= NULL
;
1100 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1102 if (!gdb_python_initialized
)
1103 return EXT_LANG_BT_NO_FILTERS
;
1107 gdbarch
= get_frame_arch (frame
);
1109 CATCH (except
, RETURN_MASK_ERROR
)
1111 /* Let gdb try to print the stack trace. */
1112 return EXT_LANG_BT_NO_FILTERS
;
1116 gdbpy_enter
enter_py (gdbarch
, current_language
);
1118 /* When we're limiting the number of frames, be careful to request
1119 one extra frame, so that we can print a message if there are more
1121 int frame_countdown
= -1;
1122 if ((flags
& PRINT_MORE_FRAMES
) != 0 && frame_low
>= 0 && frame_high
>= 0)
1125 /* This has an extra +1 because it is checked before a frame is
1127 frame_countdown
= frame_high
- frame_low
+ 1;
1130 gdbpy_ref
<> iterable (bootstrap_python_frame_filters (frame
, frame_low
,
1133 if (iterable
== NULL
)
1135 /* Normally if there is an error GDB prints the exception,
1136 abandons the backtrace and exits. The user can then call "bt
1137 no-filters", and get a default backtrace (it would be
1138 confusing to automatically start a standard backtrace halfway
1139 through a Python filtered backtrace). However in the case
1140 where GDB cannot initialize the frame filters (most likely
1141 due to incorrect auto-load paths), GDB has printed nothing.
1142 In this case it is OK to print the default backtrace after
1143 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1144 here to signify there are no filters after printing the
1145 initialization error. This return code will trigger a
1146 default backtrace. */
1148 throw_quit_or_print_exception ();
1149 return EXT_LANG_BT_NO_FILTERS
;
1152 /* If iterable is None, then there are no frame filters registered.
1153 If this is the case, defer to default GDB printing routines in MI
1155 if (iterable
== Py_None
)
1156 return EXT_LANG_BT_NO_FILTERS
;
1158 htab_up
levels_printed (htab_create (20,
1165 gdbpy_ref
<> item (PyIter_Next (iterable
.get ()));
1169 if (PyErr_Occurred ())
1171 throw_quit_or_print_exception ();
1172 return EXT_LANG_BT_ERROR
;
1177 if (frame_countdown
!= -1)
1179 gdb_assert ((flags
& PRINT_MORE_FRAMES
) != 0);
1181 if (frame_countdown
== 0)
1183 /* We've printed all the frames we were asked to
1184 print, but more frames existed. */
1185 printf_filtered (_("(More stack frames follow...)\n"));
1192 success
= py_print_frame (item
.get (), flags
, args_type
, out
, 0,
1193 levels_printed
.get ());
1195 CATCH (except
, RETURN_MASK_ERROR
)
1197 gdbpy_convert_exception (except
);
1198 success
= EXT_LANG_BT_ERROR
;
1202 /* Do not exit on error printing a single frame. Print the
1203 error and continue with other frames. */
1204 if (success
== EXT_LANG_BT_ERROR
)
1205 throw_quit_or_print_exception ();