1 /* Python frame filters
3 Copyright (C) 2013-2019 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"
33 #include "common/gdb_optional.h"
41 /* Helper function to extract a symbol, a name and a language
42 definition from a Python object that conforms to the "Symbol Value"
43 interface. OBJ is the Python object to extract the values from.
44 NAME is a pass-through argument where the name of the symbol will
45 be written. NAME is allocated in this function, but the caller is
46 responsible for clean up. SYM is a pass-through argument where the
47 symbol will be written and SYM_BLOCK is a pass-through argument to
48 write the block where the symbol lies in. In the case of the API
49 returning a string, this will be set to NULL. LANGUAGE is also a
50 pass-through argument denoting the language attributed to the
51 Symbol. In the case of SYM being NULL, this will be set to the
52 current language. Returns EXT_LANG_BT_ERROR on error with the
53 appropriate Python exception set, and EXT_LANG_BT_OK on success. */
55 static enum ext_lang_bt_status
56 extract_sym (PyObject
*obj
, gdb::unique_xmalloc_ptr
<char> *name
,
57 struct symbol
**sym
, const struct block
**sym_block
,
58 const struct language_defn
**language
)
60 gdbpy_ref
<> result (PyObject_CallMethod (obj
, "symbol", NULL
));
63 return EXT_LANG_BT_ERROR
;
65 /* For 'symbol' callback, the function can return a symbol or a
67 if (gdbpy_is_string (result
.get ()))
69 *name
= python_string_to_host_string (result
.get ());
72 return EXT_LANG_BT_ERROR
;
73 /* If the API returns a string (and not a symbol), then there is
74 no symbol derived language available and the frame filter has
75 either overridden the symbol with a string, or supplied a
76 entirely synthetic symbol/value pairing. In that case, use
78 *language
= python_language
;
84 /* This type checks 'result' during the conversion so we
85 just call it unconditionally and check the return. */
86 *sym
= symbol_object_to_symbol (result
.get ());
87 /* TODO: currently, we have no way to recover the block in which SYMBOL
88 was found, so we have no block to return. Trying to evaluate SYMBOL
89 will yield an incorrect value when it's located in a FRAME and
90 evaluated from another frame (as permitted in nested functions). */
95 PyErr_SetString (PyExc_RuntimeError
,
96 _("Unexpected value. Expecting a "
97 "gdb.Symbol or a Python string."));
98 return EXT_LANG_BT_ERROR
;
101 /* Duplicate the symbol name, so the caller has consistency
102 in garbage collection. */
103 name
->reset (xstrdup (SYMBOL_PRINT_NAME (*sym
)));
105 /* If a symbol is specified attempt to determine the language
106 from the symbol. If mode is not "auto", then the language
107 has been explicitly set, use that. */
108 if (language_mode
== language_mode_auto
)
109 *language
= language_def (SYMBOL_LANGUAGE (*sym
));
111 *language
= current_language
;
114 return EXT_LANG_BT_OK
;
117 /* Helper function to extract a value from an object that conforms to
118 the "Symbol Value" interface. OBJ is the Python object to extract
119 the value from. VALUE is a pass-through argument where the value
120 will be written. If the object does not have the value attribute,
121 or provides the Python None for a value, VALUE will be set to NULL
122 and this function will return as successful. Returns EXT_LANG_BT_ERROR
123 on error with the appropriate Python exception set, and EXT_LANG_BT_OK on
126 static enum ext_lang_bt_status
127 extract_value (PyObject
*obj
, struct value
**value
)
129 if (PyObject_HasAttrString (obj
, "value"))
131 gdbpy_ref
<> vresult (PyObject_CallMethod (obj
, "value", NULL
));
134 return EXT_LANG_BT_ERROR
;
136 /* The Python code has returned 'None' for a value, so we set
137 value to NULL. This flags that GDB should read the
139 if (vresult
== Py_None
)
142 return EXT_LANG_BT_OK
;
146 *value
= convert_value_from_python (vresult
.get ());
149 return EXT_LANG_BT_ERROR
;
151 return EXT_LANG_BT_OK
;
157 return EXT_LANG_BT_OK
;
160 /* MI prints only certain values according to the type of symbol and
161 also what the user has specified. SYM is the symbol to check, and
162 MI_PRINT_TYPES is an enum specifying what the user wants emitted
163 for the MI command in question. */
165 mi_should_print (struct symbol
*sym
, enum mi_print_types type
)
169 switch (SYMBOL_CLASS (sym
))
172 case LOC_UNDEF
: /* catches errors */
173 case LOC_CONST
: /* constant */
174 case LOC_TYPEDEF
: /* local typedef */
175 case LOC_LABEL
: /* local label */
176 case LOC_BLOCK
: /* local function */
177 case LOC_CONST_BYTES
: /* loc. byte seq. */
178 case LOC_UNRESOLVED
: /* unresolved static */
179 case LOC_OPTIMIZED_OUT
: /* optimized out */
183 case LOC_ARG
: /* argument */
184 case LOC_REF_ARG
: /* reference arg */
185 case LOC_REGPARM_ADDR
: /* indirect register arg */
186 case LOC_LOCAL
: /* stack local */
187 case LOC_STATIC
: /* static */
188 case LOC_REGISTER
: /* register */
189 case LOC_COMPUTED
: /* computed location */
190 if (type
== MI_PRINT_LOCALS
)
191 print_me
= ! SYMBOL_IS_ARGUMENT (sym
);
193 print_me
= SYMBOL_IS_ARGUMENT (sym
);
198 /* Helper function which outputs a type name extracted from VAL to a
199 "type" field in the output stream OUT. OUT is the ui-out structure
200 the type name will be output too, and VAL is the value that the
201 type will be extracted from. */
204 py_print_type (struct ui_out
*out
, struct value
*val
)
206 check_typedef (value_type (val
));
209 type_print (value_type (val
), "", &stb
, -1);
210 out
->field_stream ("type", stb
);
213 /* Helper function which outputs a value to an output field in a
214 stream. OUT is the ui-out structure the value will be output to,
215 VAL is the value that will be printed, OPTS contains the value
216 printing options, ARGS_TYPE is an enumerator describing the
217 argument format, and LANGUAGE is the language_defn that the value
218 will be printed with. */
221 py_print_value (struct ui_out
*out
, struct value
*val
,
222 const struct value_print_options
*opts
,
224 enum ext_lang_frame_args args_type
,
225 const struct language_defn
*language
)
227 int should_print
= 0;
229 /* MI does not print certain values, differentiated by type,
230 depending on what ARGS_TYPE indicates. Test type against option.
231 For CLI print all values. */
232 if (args_type
== MI_PRINT_SIMPLE_VALUES
233 || args_type
== MI_PRINT_ALL_VALUES
)
235 struct type
*type
= check_typedef (value_type (val
));
237 if (args_type
== MI_PRINT_ALL_VALUES
)
239 else if (args_type
== MI_PRINT_SIMPLE_VALUES
240 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
241 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
242 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
245 else if (args_type
!= NO_VALUES
)
252 common_val_print (val
, &stb
, indent
, opts
, language
);
253 out
->field_stream ("value", stb
);
257 /* Helper function to call a Python method and extract an iterator
258 from the result. If the function returns anything but an iterator
259 the exception is preserved and NULL is returned. FILTER is the
260 Python object to call, and FUNC is the name of the method. Returns
261 a PyObject, or NULL on error with the appropriate exception set.
262 This function can return an iterator, or NULL. */
265 get_py_iter_from_func (PyObject
*filter
, const char *func
)
267 if (PyObject_HasAttrString (filter
, func
))
269 gdbpy_ref
<> result (PyObject_CallMethod (filter
, func
, NULL
));
273 if (result
== Py_None
)
275 return result
.release ();
279 return PyObject_GetIter (result
.get ());
289 /* Helper function to output a single frame argument and value to an
290 output stream. This function will account for entry values if the
291 FV parameter is populated, the frame argument has entry values
292 associated with them, and the appropriate "set entry-value"
293 options are set. Will output in CLI or MI like format depending
294 on the type of output stream detected. OUT is the output stream,
295 SYM_NAME is the name of the symbol. If SYM_NAME is populated then
296 it must have an accompanying value in the parameter FV. FA is a
297 frame argument structure. If FA is populated, both SYM_NAME and
298 FV are ignored. OPTS contains the value printing options,
299 ARGS_TYPE is an enumerator describing the argument format,
300 PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
301 in MI output in commands where both arguments and locals are
305 py_print_single_arg (struct ui_out
*out
,
306 const char *sym_name
,
307 struct frame_arg
*fa
,
309 const struct value_print_options
*opts
,
310 enum ext_lang_frame_args args_type
,
311 int print_args_field
,
312 const struct language_defn
*language
)
318 if (fa
->val
== NULL
&& fa
->error
== NULL
)
320 language
= language_def (SYMBOL_LANGUAGE (fa
->sym
));
326 gdb::optional
<ui_out_emit_tuple
> maybe_tuple
;
328 /* MI has varying rules for tuples, but generally if there is only
329 one element in each item in the list, do not start a tuple. The
330 exception is -stack-list-variables which emits an ARGS="1" field
331 if the value is a frame argument. This is denoted in this
332 function with PRINT_ARGS_FIELD which is flag from the caller to
333 emit the ARGS field. */
334 if (out
->is_mi_like_p ())
336 if (print_args_field
|| args_type
!= NO_VALUES
)
337 maybe_tuple
.emplace (out
, nullptr);
340 annotate_arg_begin ();
342 /* If frame argument is populated, check for entry-values and the
343 entry value options. */
348 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (fa
->sym
),
349 SYMBOL_LANGUAGE (fa
->sym
),
350 DMGL_PARAMS
| DMGL_ANSI
);
351 if (fa
->entry_kind
== print_entry_values_compact
)
355 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (fa
->sym
),
356 SYMBOL_LANGUAGE (fa
->sym
),
357 DMGL_PARAMS
| DMGL_ANSI
);
359 if (fa
->entry_kind
== print_entry_values_only
360 || fa
->entry_kind
== print_entry_values_compact
)
362 out
->field_stream ("name", stb
);
365 /* Otherwise, just output the name. */
366 out
->field_string ("name", sym_name
);
368 annotate_arg_name_end ();
372 if (print_args_field
)
373 out
->field_int ("arg", 1);
375 /* For MI print the type, but only for simple values. This seems
376 weird, but this is how MI choose to format the various output
378 if (args_type
== MI_PRINT_SIMPLE_VALUES
&& val
!= NULL
)
379 py_print_type (out
, val
);
382 annotate_arg_value (value_type (val
));
384 /* If the output is to the CLI, and the user option "set print
385 frame-arguments" is set to none, just output "...". */
386 if (! out
->is_mi_like_p () && args_type
== NO_VALUES
)
387 out
->field_string ("value", "...");
390 /* Otherwise, print the value for both MI and the CLI, except
391 for the case of MI_PRINT_NO_VALUES. */
392 if (args_type
!= NO_VALUES
)
396 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
397 out
->field_fmt ("value",
398 _("<error reading variable: %s>"),
402 py_print_value (out
, val
, opts
, 0, args_type
, language
);
407 /* Helper function to loop over frame arguments provided by the
408 "frame_arguments" Python API. Elements in the iterator must
409 conform to the "Symbol Value" interface. ITER is the Python
410 iterable object, OUT is the output stream, ARGS_TYPE is an
411 enumerator describing the argument format, PRINT_ARGS_FIELD is a
412 flag which indicates if we output "ARGS=1" in MI output in commands
413 where both arguments and locals are printed, and FRAME is the
414 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
415 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
418 static enum ext_lang_bt_status
419 enumerate_args (PyObject
*iter
,
421 enum ext_lang_frame_args args_type
,
422 int print_args_field
,
423 struct frame_info
*frame
)
425 struct value_print_options opts
;
427 get_user_print_options (&opts
);
429 if (args_type
== CLI_SCALAR_VALUES
)
431 /* True in "summary" mode, false otherwise. */
437 annotate_frame_args ();
439 /* Collect the first argument outside of the loop, so output of
440 commas in the argument output is correct. At the end of the
441 loop block collect another item from the iterator, and, if it is
442 not null emit a comma. */
443 gdbpy_ref
<> item (PyIter_Next (iter
));
444 if (item
== NULL
&& PyErr_Occurred ())
445 return EXT_LANG_BT_ERROR
;
449 const struct language_defn
*language
;
450 gdb::unique_xmalloc_ptr
<char> sym_name
;
452 const struct block
*sym_block
;
454 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
456 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
458 if (success
== EXT_LANG_BT_ERROR
)
459 return EXT_LANG_BT_ERROR
;
461 success
= extract_value (item
.get (), &val
);
462 if (success
== EXT_LANG_BT_ERROR
)
463 return EXT_LANG_BT_ERROR
;
465 if (sym
&& out
->is_mi_like_p ()
466 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
469 /* If the object did not provide a value, read it using
470 read_frame_args and account for entry values, if any. */
473 struct frame_arg arg
, entryarg
;
475 /* If there is no value, and also no symbol, set error and
479 PyErr_SetString (PyExc_RuntimeError
,
480 _("No symbol or value provided."));
481 return EXT_LANG_BT_ERROR
;
484 read_frame_arg (user_frame_print_options
,
485 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 const 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
, ui_out_style_kind::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 ui_out_style_kind::FILE);
939 annotate_frame_source_file_end ();
943 if (PyObject_HasAttrString (filter
, "line"))
945 gdbpy_ref
<> py_line (PyObject_CallMethod (filter
, "line", NULL
));
949 return EXT_LANG_BT_ERROR
;
951 if (py_line
!= Py_None
)
953 line
= PyLong_AsLong (py_line
.get ());
954 if (PyErr_Occurred ())
955 return EXT_LANG_BT_ERROR
;
958 annotate_frame_source_line ();
959 out
->field_int ("line", line
);
962 if (out
->is_mi_like_p ())
963 out
->field_string ("arch",
964 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
967 /* For MI we need to deal with the "children" list population of
968 elided frames, so if MI output detected do not send newline. */
969 if (! out
->is_mi_like_p ())
971 annotate_frame_end ();
977 if (py_print_locals (filter
, out
, args_type
, indent
,
978 frame
) == EXT_LANG_BT_ERROR
)
979 return EXT_LANG_BT_ERROR
;
982 if ((flags
& PRINT_HIDE
) == 0)
984 /* Finally recursively print elided frames, if any. */
985 gdbpy_ref
<> elided (get_py_iter_from_func (filter
, "elided"));
987 return EXT_LANG_BT_ERROR
;
989 if (elided
!= Py_None
)
993 ui_out_emit_list
inner_list_emiter (out
, "children");
997 while ((item
= PyIter_Next (elided
.get ())))
999 gdbpy_ref
<> item_ref (item
);
1001 enum ext_lang_bt_status success
1002 = py_print_frame (item
, flags
, args_type
, out
, indent
,
1005 if (success
== EXT_LANG_BT_ERROR
)
1006 return EXT_LANG_BT_ERROR
;
1008 if (item
== NULL
&& PyErr_Occurred ())
1009 return EXT_LANG_BT_ERROR
;
1013 return EXT_LANG_BT_OK
;
1016 /* Helper function to initiate frame filter invocation at starting
1020 bootstrap_python_frame_filters (struct frame_info
*frame
,
1021 int frame_low
, int frame_high
)
1023 gdbpy_ref
<> frame_obj (frame_info_to_frame_object (frame
));
1024 if (frame_obj
== NULL
)
1027 gdbpy_ref
<> module (PyImport_ImportModule ("gdb.frames"));
1031 gdbpy_ref
<> sort_func (PyObject_GetAttrString (module
.get (),
1032 "execute_frame_filters"));
1033 if (sort_func
== NULL
)
1036 gdbpy_ref
<> py_frame_low (PyInt_FromLong (frame_low
));
1037 if (py_frame_low
== NULL
)
1040 gdbpy_ref
<> py_frame_high (PyInt_FromLong (frame_high
));
1041 if (py_frame_high
== NULL
)
1044 gdbpy_ref
<> iterable (PyObject_CallFunctionObjArgs (sort_func
.get (),
1046 py_frame_low
.get (),
1047 py_frame_high
.get (),
1049 if (iterable
== NULL
)
1052 if (iterable
!= Py_None
)
1053 return PyObject_GetIter (iterable
.get ());
1055 return iterable
.release ();
1058 /* This is the only publicly exported function in this file. FRAME
1059 is the source frame to start frame-filter invocation. FLAGS is an
1060 integer holding the flags for printing. The following elements of
1061 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1062 PRINT_LEVEL is a flag indicating whether to print the frame's
1063 relative level in the output. PRINT_FRAME_INFO is a flag that
1064 indicates whether this function should print the frame
1065 information, PRINT_ARGS is a flag that indicates whether to print
1066 frame arguments, and PRINT_LOCALS, likewise, with frame local
1067 variables. ARGS_TYPE is an enumerator describing the argument
1068 format, OUT is the output stream to print. FRAME_LOW is the
1069 beginning of the slice of frames to print, and FRAME_HIGH is the
1070 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1071 or EXT_LANG_BT_OK on success. */
1073 enum ext_lang_bt_status
1074 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1075 struct frame_info
*frame
, frame_filter_flags flags
,
1076 enum ext_lang_frame_args args_type
,
1077 struct ui_out
*out
, int frame_low
, int frame_high
)
1079 struct gdbarch
*gdbarch
= NULL
;
1080 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1082 if (!gdb_python_initialized
)
1083 return EXT_LANG_BT_NO_FILTERS
;
1087 gdbarch
= get_frame_arch (frame
);
1089 catch (const gdb_exception_error
&except
)
1091 /* Let gdb try to print the stack trace. */
1092 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 (const gdb_exception_error
&except
)
1176 gdbpy_convert_exception (except
);
1177 success
= EXT_LANG_BT_ERROR
;
1180 /* Do not exit on error printing a single frame. Print the
1181 error and continue with other frames. */
1182 if (success
== EXT_LANG_BT_ERROR
)
1183 gdbpy_print_stack_or_quit ();