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 ();
373 if (print_args_field
)
374 out
->field_int ("arg", 1);
376 /* For MI print the type, but only for simple values. This seems
377 weird, but this is how MI choose to format the various output
379 if (args_type
== MI_PRINT_SIMPLE_VALUES
&& val
!= NULL
)
380 py_print_type (out
, val
);
383 annotate_arg_value (value_type (val
));
385 /* If the output is to the CLI, and the user option "set print
386 frame-arguments" is set to none, just output "...". */
387 if (! out
->is_mi_like_p () && args_type
== NO_VALUES
)
388 out
->field_string ("value", "...");
391 /* Otherwise, print the value for both MI and the CLI, except
392 for the case of MI_PRINT_NO_VALUES. */
393 if (args_type
!= NO_VALUES
)
397 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
398 out
->field_fmt ("value",
399 _("<error reading variable: %s>"),
403 py_print_value (out
, val
, opts
, 0, args_type
, language
);
408 /* Helper function to loop over frame arguments provided by the
409 "frame_arguments" Python API. Elements in the iterator must
410 conform to the "Symbol Value" interface. ITER is the Python
411 iterable object, OUT is the output stream, ARGS_TYPE is an
412 enumerator describing the argument format, PRINT_ARGS_FIELD is a
413 flag which indicates if we output "ARGS=1" in MI output in commands
414 where both arguments and locals are printed, and FRAME is the
415 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
416 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
419 static enum ext_lang_bt_status
420 enumerate_args (PyObject
*iter
,
422 enum ext_lang_frame_args args_type
,
423 int print_args_field
,
424 struct frame_info
*frame
)
426 struct value_print_options opts
;
428 get_user_print_options (&opts
);
430 if (args_type
== CLI_SCALAR_VALUES
)
432 /* True in "summary" mode, false otherwise. */
438 annotate_frame_args ();
440 /* Collect the first argument outside of the loop, so output of
441 commas in the argument output is correct. At the end of the
442 loop block collect another item from the iterator, and, if it is
443 not null emit a comma. */
444 gdbpy_ref
<> item (PyIter_Next (iter
));
445 if (item
== NULL
&& PyErr_Occurred ())
446 return EXT_LANG_BT_ERROR
;
450 const struct language_defn
*language
;
451 gdb::unique_xmalloc_ptr
<char> sym_name
;
453 struct block
*sym_block
;
455 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
457 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
459 if (success
== EXT_LANG_BT_ERROR
)
460 return EXT_LANG_BT_ERROR
;
462 success
= extract_value (item
.get (), &val
);
463 if (success
== EXT_LANG_BT_ERROR
)
464 return EXT_LANG_BT_ERROR
;
466 if (sym
&& out
->is_mi_like_p ()
467 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
470 /* If the object did not provide a value, read it using
471 read_frame_args and account for entry values, if any. */
474 struct frame_arg arg
, entryarg
;
476 /* If there is no value, and also no symbol, set error and
480 PyErr_SetString (PyExc_RuntimeError
,
481 _("No symbol or value provided."));
482 return EXT_LANG_BT_ERROR
;
485 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
487 gdb::unique_xmalloc_ptr
<char> arg_holder (arg
.error
);
488 gdb::unique_xmalloc_ptr
<char> entry_holder (entryarg
.error
);
490 /* The object has not provided a value, so this is a frame
491 argument to be read by GDB. In this case we have to
492 account for entry-values. */
494 if (arg
.entry_kind
!= print_entry_values_only
)
496 py_print_single_arg (out
, NULL
, &arg
,
503 if (entryarg
.entry_kind
!= print_entry_values_no
)
505 if (arg
.entry_kind
!= print_entry_values_only
)
508 out
->wrap_hint (" ");
511 py_print_single_arg (out
, NULL
, &entryarg
, NULL
, &opts
,
512 args_type
, print_args_field
, NULL
);
517 /* If the object has provided a value, we just print that. */
519 py_print_single_arg (out
, sym_name
.get (), NULL
, val
, &opts
,
520 args_type
, print_args_field
,
524 /* Collect the next item from the iterator. If
525 this is the last item, do not print the
527 item
.reset (PyIter_Next (iter
));
530 else if (PyErr_Occurred ())
531 return EXT_LANG_BT_ERROR
;
536 return EXT_LANG_BT_OK
;
540 /* Helper function to loop over variables provided by the
541 "frame_locals" Python API. Elements in the iterable must conform
542 to the "Symbol Value" interface. ITER is the Python iterable
543 object, OUT is the output stream, INDENT is whether we should
544 indent the output (for CLI), ARGS_TYPE is an enumerator describing
545 the argument format, PRINT_ARGS_FIELD is flag which indicates
546 whether to output the ARGS field in the case of
547 -stack-list-variables and FRAME is the backing frame. Returns
548 EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
549 exception, or EXT_LANG_BT_OK on success. */
551 static enum ext_lang_bt_status
552 enumerate_locals (PyObject
*iter
,
555 enum ext_lang_frame_args args_type
,
556 int print_args_field
,
557 struct frame_info
*frame
)
559 struct value_print_options opts
;
561 get_user_print_options (&opts
);
566 const struct language_defn
*language
;
567 gdb::unique_xmalloc_ptr
<char> sym_name
;
569 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
571 struct block
*sym_block
;
572 int local_indent
= 8 + (8 * indent
);
573 gdb::optional
<ui_out_emit_tuple
> tuple
;
575 gdbpy_ref
<> item (PyIter_Next (iter
));
579 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
581 if (success
== EXT_LANG_BT_ERROR
)
582 return EXT_LANG_BT_ERROR
;
584 success
= extract_value (item
.get (), &val
);
585 if (success
== EXT_LANG_BT_ERROR
)
586 return EXT_LANG_BT_ERROR
;
588 if (sym
!= NULL
&& out
->is_mi_like_p ()
589 && ! mi_should_print (sym
, MI_PRINT_LOCALS
))
592 /* If the object did not provide a value, read it. */
594 val
= read_var_value (sym
, sym_block
, frame
);
596 /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
597 each output contains only one field. The exception is
598 -stack-list-variables, which always provides a tuple. */
599 if (out
->is_mi_like_p ())
601 if (print_args_field
|| args_type
!= NO_VALUES
)
602 tuple
.emplace (out
, nullptr);
605 /* If the output is not MI we indent locals. */
606 out
->spaces (local_indent
);
607 out
->field_string ("name", sym_name
.get ());
610 if (args_type
== MI_PRINT_SIMPLE_VALUES
)
611 py_print_type (out
, val
);
613 /* CLI always prints values for locals. MI uses the
614 simple/no/all system. */
615 if (! out
->is_mi_like_p ())
617 int val_indent
= (indent
+ 1) * 4;
619 py_print_value (out
, val
, &opts
, val_indent
, args_type
,
624 if (args_type
!= NO_VALUES
)
625 py_print_value (out
, val
, &opts
, 0, args_type
,
632 if (!PyErr_Occurred ())
633 return EXT_LANG_BT_OK
;
635 return EXT_LANG_BT_ERROR
;
638 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
639 error, or EXT_LANG_BT_OK on success. */
641 static enum ext_lang_bt_status
642 py_mi_print_variables (PyObject
*filter
, struct ui_out
*out
,
643 struct value_print_options
*opts
,
644 enum ext_lang_frame_args args_type
,
645 struct frame_info
*frame
)
647 gdbpy_ref
<> args_iter (get_py_iter_from_func (filter
, "frame_args"));
648 if (args_iter
== NULL
)
649 return EXT_LANG_BT_ERROR
;
651 gdbpy_ref
<> locals_iter (get_py_iter_from_func (filter
, "frame_locals"));
652 if (locals_iter
== NULL
)
653 return EXT_LANG_BT_ERROR
;
655 ui_out_emit_list
list_emitter (out
, "variables");
657 if (args_iter
!= Py_None
658 && (enumerate_args (args_iter
.get (), out
, args_type
, 1, frame
)
659 == EXT_LANG_BT_ERROR
))
660 return EXT_LANG_BT_ERROR
;
662 if (locals_iter
!= Py_None
663 && (enumerate_locals (locals_iter
.get (), out
, 1, args_type
, 1, frame
)
664 == EXT_LANG_BT_ERROR
))
665 return EXT_LANG_BT_ERROR
;
667 return EXT_LANG_BT_OK
;
670 /* Helper function for printing locals. This function largely just
671 creates the wrapping tuple, and calls enumerate_locals. Returns
672 EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
674 static enum ext_lang_bt_status
675 py_print_locals (PyObject
*filter
,
677 enum ext_lang_frame_args args_type
,
679 struct frame_info
*frame
)
681 gdbpy_ref
<> locals_iter (get_py_iter_from_func (filter
, "frame_locals"));
682 if (locals_iter
== NULL
)
683 return EXT_LANG_BT_ERROR
;
685 ui_out_emit_list
list_emitter (out
, "locals");
687 if (locals_iter
!= Py_None
688 && (enumerate_locals (locals_iter
.get (), out
, indent
, args_type
,
689 0, frame
) == EXT_LANG_BT_ERROR
))
690 return EXT_LANG_BT_ERROR
;
692 return EXT_LANG_BT_OK
;
695 /* Helper function for printing frame arguments. This function
696 largely just creates the wrapping tuple, and calls enumerate_args.
697 Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
698 a Python exception, or EXT_LANG_BT_OK on success. */
700 static enum ext_lang_bt_status
701 py_print_args (PyObject
*filter
,
703 enum ext_lang_frame_args args_type
,
704 struct frame_info
*frame
)
706 gdbpy_ref
<> args_iter (get_py_iter_from_func (filter
, "frame_args"));
707 if (args_iter
== NULL
)
708 return EXT_LANG_BT_ERROR
;
710 ui_out_emit_list
list_emitter (out
, "args");
712 out
->wrap_hint (" ");
713 annotate_frame_args ();
716 if (args_iter
!= Py_None
717 && (enumerate_args (args_iter
.get (), out
, args_type
, 0, frame
)
718 == EXT_LANG_BT_ERROR
))
719 return EXT_LANG_BT_ERROR
;
723 return EXT_LANG_BT_OK
;
726 /* Print a single frame to the designated output stream, detecting
727 whether the output is MI or console, and formatting the output
728 according to the conventions of that protocol. FILTER is the
729 frame-filter associated with this frame. FLAGS is an integer
730 describing the various print options. The FLAGS variables is
731 described in "apply_frame_filter" function. ARGS_TYPE is an
732 enumerator describing the argument format. OUT is the output
733 stream to print, INDENT is the level of indention for this frame
734 (in the case of elided frames), and LEVELS_PRINTED is a hash-table
735 containing all the frames level that have already been printed.
736 If a frame level has been printed, do not print it again (in the
737 case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
738 GDB exceptions converted to a Python exception, or EXT_LANG_BT_OK
739 on success. It can also throw an exception RETURN_QUIT. */
741 static enum ext_lang_bt_status
742 py_print_frame (PyObject
*filter
, frame_filter_flags flags
,
743 enum ext_lang_frame_args args_type
,
744 struct ui_out
*out
, int indent
, htab_t levels_printed
)
747 CORE_ADDR address
= 0;
748 struct gdbarch
*gdbarch
= NULL
;
749 struct frame_info
*frame
= NULL
;
750 struct value_print_options opts
;
751 int print_level
, print_frame_info
, print_args
, print_locals
;
752 gdb::unique_xmalloc_ptr
<char> function_to_free
;
754 /* Extract print settings from FLAGS. */
755 print_level
= (flags
& PRINT_LEVEL
) ? 1 : 0;
756 print_frame_info
= (flags
& PRINT_FRAME_INFO
) ? 1 : 0;
757 print_args
= (flags
& PRINT_ARGS
) ? 1 : 0;
758 print_locals
= (flags
& PRINT_LOCALS
) ? 1 : 0;
760 get_user_print_options (&opts
);
762 /* Get the underlying frame. This is needed to determine GDB
763 architecture, and also, in the cases of frame variables/arguments to
764 read them if they returned filter object requires us to do so. */
765 gdbpy_ref
<> py_inf_frame (PyObject_CallMethod (filter
, "inferior_frame",
767 if (py_inf_frame
== NULL
)
768 return EXT_LANG_BT_ERROR
;
770 frame
= frame_object_to_frame_info (py_inf_frame
.get ());
772 return EXT_LANG_BT_ERROR
;
774 gdbarch
= get_frame_arch (frame
);
776 /* stack-list-variables. */
777 if (print_locals
&& print_args
&& ! print_frame_info
)
779 if (py_mi_print_variables (filter
, out
, &opts
,
780 args_type
, frame
) == EXT_LANG_BT_ERROR
)
781 return EXT_LANG_BT_ERROR
;
782 return EXT_LANG_BT_OK
;
785 gdb::optional
<ui_out_emit_tuple
> tuple
;
787 /* -stack-list-locals does not require a
788 wrapping frame attribute. */
789 if (print_frame_info
|| (print_args
&& ! print_locals
))
790 tuple
.emplace (out
, "frame");
792 if (print_frame_info
)
794 /* Elided frames are also printed with this function (recursively)
795 and are printed with indention. */
797 out
->spaces (indent
* 4);
799 /* The address is required for frame annotations, and also for
801 if (PyObject_HasAttrString (filter
, "address"))
803 gdbpy_ref
<> paddr (PyObject_CallMethod (filter
, "address", NULL
));
806 return EXT_LANG_BT_ERROR
;
808 if (paddr
!= Py_None
)
810 if (get_addr_from_python (paddr
.get (), &address
) < 0)
811 return EXT_LANG_BT_ERROR
;
818 /* Print frame level. MI does not require the level if
819 locals/variables only are being printed. */
820 if ((print_frame_info
|| print_args
) && print_level
)
822 struct frame_info
**slot
;
825 slot
= (struct frame_info
**) htab_find_slot (levels_printed
,
828 level
= frame_relative_level (frame
);
830 /* Check if this frame has already been printed (there are cases
831 where elided synthetic dummy-frames have to 'borrow' the frame
832 architecture from the eliding frame. If that is the case, do
833 not print 'level', but print spaces. */
835 out
->field_skip ("level");
839 annotate_frame_begin (print_level
? level
: 0,
842 out
->field_fmt_int (2, ui_left
, "level",
847 if (print_frame_info
)
849 /* Print address to the address field. If an address is not provided,
851 if (opts
.addressprint
&& has_addr
)
853 annotate_frame_address ();
854 out
->field_core_addr ("addr", gdbarch
, address
);
855 annotate_frame_address_end ();
859 /* Print frame function name. */
860 if (PyObject_HasAttrString (filter
, "function"))
862 gdbpy_ref
<> py_func (PyObject_CallMethod (filter
, "function", NULL
));
863 const char *function
= NULL
;
866 return EXT_LANG_BT_ERROR
;
868 if (gdbpy_is_string (py_func
.get ()))
870 function_to_free
= python_string_to_host_string (py_func
.get ());
872 if (function_to_free
== NULL
)
873 return EXT_LANG_BT_ERROR
;
875 function
= function_to_free
.get ();
877 else if (PyLong_Check (py_func
.get ()))
880 struct bound_minimal_symbol msymbol
;
882 if (get_addr_from_python (py_func
.get (), &addr
) < 0)
883 return EXT_LANG_BT_ERROR
;
885 msymbol
= lookup_minimal_symbol_by_pc (addr
);
886 if (msymbol
.minsym
!= NULL
)
887 function
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
889 else if (py_func
!= Py_None
)
891 PyErr_SetString (PyExc_RuntimeError
,
892 _("FrameDecorator.function: expecting a " \
893 "String, integer or None."));
894 return EXT_LANG_BT_ERROR
;
897 annotate_frame_function_name ();
898 if (function
== NULL
)
899 out
->field_skip ("func");
901 out
->field_string ("func", function
);
906 /* Frame arguments. Check the result, and error if something went
910 if (py_print_args (filter
, out
, args_type
, frame
) == EXT_LANG_BT_ERROR
)
911 return EXT_LANG_BT_ERROR
;
914 /* File name/source/line number information. */
915 if (print_frame_info
)
917 annotate_frame_source_begin ();
919 if (PyObject_HasAttrString (filter
, "filename"))
921 gdbpy_ref
<> py_fn (PyObject_CallMethod (filter
, "filename", NULL
));
924 return EXT_LANG_BT_ERROR
;
926 if (py_fn
!= Py_None
)
928 gdb::unique_xmalloc_ptr
<char>
929 filename (python_string_to_host_string (py_fn
.get ()));
931 if (filename
== NULL
)
932 return EXT_LANG_BT_ERROR
;
934 out
->wrap_hint (" ");
936 annotate_frame_source_file ();
937 out
->field_string ("file", filename
.get ());
938 annotate_frame_source_file_end ();
942 if (PyObject_HasAttrString (filter
, "line"))
944 gdbpy_ref
<> py_line (PyObject_CallMethod (filter
, "line", NULL
));
948 return EXT_LANG_BT_ERROR
;
950 if (py_line
!= Py_None
)
952 line
= PyLong_AsLong (py_line
.get ());
953 if (PyErr_Occurred ())
954 return EXT_LANG_BT_ERROR
;
957 annotate_frame_source_line ();
958 out
->field_int ("line", line
);
961 if (out
->is_mi_like_p ())
962 out
->field_string ("arch",
963 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
966 /* For MI we need to deal with the "children" list population of
967 elided frames, so if MI output detected do not send newline. */
968 if (! out
->is_mi_like_p ())
970 annotate_frame_end ();
976 if (py_print_locals (filter
, out
, args_type
, indent
,
977 frame
) == EXT_LANG_BT_ERROR
)
978 return EXT_LANG_BT_ERROR
;
981 if ((flags
& PRINT_HIDE
) == 0)
983 /* Finally recursively print elided frames, if any. */
984 gdbpy_ref
<> elided (get_py_iter_from_func (filter
, "elided"));
986 return EXT_LANG_BT_ERROR
;
988 if (elided
!= Py_None
)
992 ui_out_emit_list
inner_list_emiter (out
, "children");
996 while ((item
= PyIter_Next (elided
.get ())))
998 gdbpy_ref
<> item_ref (item
);
1000 enum ext_lang_bt_status success
1001 = py_print_frame (item
, flags
, args_type
, out
, indent
,
1004 if (success
== EXT_LANG_BT_ERROR
)
1005 return EXT_LANG_BT_ERROR
;
1007 if (item
== NULL
&& PyErr_Occurred ())
1008 return EXT_LANG_BT_ERROR
;
1012 return EXT_LANG_BT_OK
;
1015 /* Helper function to initiate frame filter invocation at starting
1019 bootstrap_python_frame_filters (struct frame_info
*frame
,
1020 int frame_low
, int frame_high
)
1022 gdbpy_ref
<> frame_obj (frame_info_to_frame_object (frame
));
1023 if (frame_obj
== NULL
)
1026 gdbpy_ref
<> module (PyImport_ImportModule ("gdb.frames"));
1030 gdbpy_ref
<> sort_func (PyObject_GetAttrString (module
.get (),
1031 "execute_frame_filters"));
1032 if (sort_func
== NULL
)
1035 gdbpy_ref
<> py_frame_low (PyInt_FromLong (frame_low
));
1036 if (py_frame_low
== NULL
)
1039 gdbpy_ref
<> py_frame_high (PyInt_FromLong (frame_high
));
1040 if (py_frame_high
== NULL
)
1043 gdbpy_ref
<> iterable (PyObject_CallFunctionObjArgs (sort_func
.get (),
1045 py_frame_low
.get (),
1046 py_frame_high
.get (),
1048 if (iterable
== NULL
)
1051 if (iterable
!= Py_None
)
1052 return PyObject_GetIter (iterable
.get ());
1054 return iterable
.release ();
1057 /* This is the only publicly exported function in this file. FRAME
1058 is the source frame to start frame-filter invocation. FLAGS is an
1059 integer holding the flags for printing. The following elements of
1060 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1061 PRINT_LEVEL is a flag indicating whether to print the frame's
1062 relative level in the output. PRINT_FRAME_INFO is a flag that
1063 indicates whether this function should print the frame
1064 information, PRINT_ARGS is a flag that indicates whether to print
1065 frame arguments, and PRINT_LOCALS, likewise, with frame local
1066 variables. ARGS_TYPE is an enumerator describing the argument
1067 format, OUT is the output stream to print. FRAME_LOW is the
1068 beginning of the slice of frames to print, and FRAME_HIGH is the
1069 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1070 or EXT_LANG_BT_OK on success. */
1072 enum ext_lang_bt_status
1073 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1074 struct frame_info
*frame
, frame_filter_flags flags
,
1075 enum ext_lang_frame_args args_type
,
1076 struct ui_out
*out
, int frame_low
, int frame_high
)
1078 struct gdbarch
*gdbarch
= NULL
;
1079 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1081 if (!gdb_python_initialized
)
1082 return EXT_LANG_BT_NO_FILTERS
;
1086 gdbarch
= get_frame_arch (frame
);
1088 CATCH (except
, RETURN_MASK_ERROR
)
1090 /* Let gdb try to print the stack trace. */
1091 return EXT_LANG_BT_NO_FILTERS
;
1095 gdbpy_enter
enter_py (gdbarch
, current_language
);
1097 /* When we're limiting the number of frames, be careful to request
1098 one extra frame, so that we can print a message if there are more
1100 int frame_countdown
= -1;
1101 if ((flags
& PRINT_MORE_FRAMES
) != 0 && frame_low
>= 0 && frame_high
>= 0)
1104 /* This has an extra +1 because it is checked before a frame is
1106 frame_countdown
= frame_high
- frame_low
+ 1;
1109 gdbpy_ref
<> iterable (bootstrap_python_frame_filters (frame
, frame_low
,
1112 if (iterable
== NULL
)
1114 /* Normally if there is an error GDB prints the exception,
1115 abandons the backtrace and exits. The user can then call "bt
1116 no-filters", and get a default backtrace (it would be
1117 confusing to automatically start a standard backtrace halfway
1118 through a Python filtered backtrace). However in the case
1119 where GDB cannot initialize the frame filters (most likely
1120 due to incorrect auto-load paths), GDB has printed nothing.
1121 In this case it is OK to print the default backtrace after
1122 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1123 here to signify there are no filters after printing the
1124 initialization error. This return code will trigger a
1125 default backtrace. */
1127 gdbpy_print_stack_or_quit ();
1128 return EXT_LANG_BT_NO_FILTERS
;
1131 /* If iterable is None, then there are no frame filters registered.
1132 If this is the case, defer to default GDB printing routines in MI
1134 if (iterable
== Py_None
)
1135 return EXT_LANG_BT_NO_FILTERS
;
1137 htab_up
levels_printed (htab_create (20,
1144 gdbpy_ref
<> item (PyIter_Next (iterable
.get ()));
1148 if (PyErr_Occurred ())
1150 gdbpy_print_stack_or_quit ();
1151 return EXT_LANG_BT_ERROR
;
1156 if (frame_countdown
!= -1)
1158 gdb_assert ((flags
& PRINT_MORE_FRAMES
) != 0);
1160 if (frame_countdown
== 0)
1162 /* We've printed all the frames we were asked to
1163 print, but more frames existed. */
1164 printf_filtered (_("(More stack frames follow...)\n"));
1171 success
= py_print_frame (item
.get (), flags
, args_type
, out
, 0,
1172 levels_printed
.get ());
1174 CATCH (except
, RETURN_MASK_ERROR
)
1176 gdbpy_convert_exception (except
);
1177 success
= EXT_LANG_BT_ERROR
;
1181 /* Do not exit on error printing a single frame. Print the
1182 error and continue with other frames. */
1183 if (success
== EXT_LANG_BT_ERROR
)
1184 gdbpy_print_stack_or_quit ();