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. Returns EXT_LANG_BT_ERROR on error, with
203 any GDB exceptions converted to a Python exception, or EXT_LANG_BT_OK on
206 static enum ext_lang_bt_status
207 py_print_type (struct ui_out
*out
, struct value
*val
)
212 check_typedef (value_type (val
));
215 type_print (value_type (val
), "", &stb
, -1);
216 out
->field_stream ("type", stb
);
218 CATCH (except
, RETURN_MASK_ERROR
)
220 gdbpy_convert_exception (except
);
221 return EXT_LANG_BT_ERROR
;
225 return EXT_LANG_BT_OK
;
228 /* Helper function which outputs a value to an output field in a
229 stream. OUT is the ui-out structure the value will be output to,
230 VAL is the value that will be printed, OPTS contains the value
231 printing options, ARGS_TYPE is an enumerator describing the
232 argument format, and LANGUAGE is the language_defn that the value
233 will be printed with. Returns EXT_LANG_BT_ERROR on error, with any GDB
234 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
237 static enum ext_lang_bt_status
238 py_print_value (struct ui_out
*out
, struct value
*val
,
239 const struct value_print_options
*opts
,
241 enum ext_lang_frame_args args_type
,
242 const struct language_defn
*language
)
244 int should_print
= 0;
246 /* MI does not print certain values, differentiated by type,
247 depending on what ARGS_TYPE indicates. Test type against option.
248 For CLI print all values. */
249 if (args_type
== MI_PRINT_SIMPLE_VALUES
250 || args_type
== MI_PRINT_ALL_VALUES
)
252 struct type
*type
= NULL
;
256 type
= check_typedef (value_type (val
));
258 CATCH (except
, RETURN_MASK_ERROR
)
260 gdbpy_convert_exception (except
);
261 return EXT_LANG_BT_ERROR
;
265 if (args_type
== MI_PRINT_ALL_VALUES
)
267 else if (args_type
== MI_PRINT_SIMPLE_VALUES
268 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
269 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
270 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
273 else if (args_type
!= NO_VALUES
)
282 common_val_print (val
, &stb
, indent
, opts
, language
);
283 out
->field_stream ("value", stb
);
285 CATCH (except
, RETURN_MASK_ERROR
)
287 gdbpy_convert_exception (except
);
288 return EXT_LANG_BT_ERROR
;
293 return EXT_LANG_BT_OK
;
296 /* Helper function to call a Python method and extract an iterator
297 from the result. If the function returns anything but an iterator
298 the exception is preserved and NULL is returned. FILTER is the
299 Python object to call, and FUNC is the name of the method. Returns
300 a PyObject, or NULL on error with the appropriate exception set.
301 This function can return an iterator, or NULL. */
304 get_py_iter_from_func (PyObject
*filter
, const char *func
)
306 if (PyObject_HasAttrString (filter
, func
))
308 gdbpy_ref
<> result (PyObject_CallMethod (filter
, func
, NULL
));
312 if (result
== Py_None
)
314 return result
.release ();
318 return PyObject_GetIter (result
.get ());
328 /* Helper function to output a single frame argument and value to an
329 output stream. This function will account for entry values if the
330 FV parameter is populated, the frame argument has entry values
331 associated with them, and the appropriate "set entry-value"
332 options are set. Will output in CLI or MI like format depending
333 on the type of output stream detected. OUT is the output stream,
334 SYM_NAME is the name of the symbol. If SYM_NAME is populated then
335 it must have an accompanying value in the parameter FV. FA is a
336 frame argument structure. If FA is populated, both SYM_NAME and
337 FV are ignored. OPTS contains the value printing options,
338 ARGS_TYPE is an enumerator describing the argument format,
339 PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
340 in MI output in commands where both arguments and locals are
341 printed. Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions
342 converted to a Python exception, or EXT_LANG_BT_OK on success. */
344 static enum ext_lang_bt_status
345 py_print_single_arg (struct ui_out
*out
,
346 const char *sym_name
,
347 struct frame_arg
*fa
,
349 const struct value_print_options
*opts
,
350 enum ext_lang_frame_args args_type
,
351 int print_args_field
,
352 const struct language_defn
*language
)
355 enum ext_lang_bt_status retval
= EXT_LANG_BT_OK
;
359 if (fa
->val
== NULL
&& fa
->error
== NULL
)
360 return EXT_LANG_BT_OK
;
361 language
= language_def (SYMBOL_LANGUAGE (fa
->sym
));
369 gdb::optional
<ui_out_emit_tuple
> maybe_tuple
;
371 /* MI has varying rules for tuples, but generally if there is only
372 one element in each item in the list, do not start a tuple. The
373 exception is -stack-list-variables which emits an ARGS="1" field
374 if the value is a frame argument. This is denoted in this
375 function with PRINT_ARGS_FIELD which is flag from the caller to
376 emit the ARGS field. */
377 if (out
->is_mi_like_p ())
379 if (print_args_field
|| args_type
!= NO_VALUES
)
380 maybe_tuple
.emplace (out
, nullptr);
383 annotate_arg_begin ();
385 /* If frame argument is populated, check for entry-values and the
386 entry value options. */
391 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (fa
->sym
),
392 SYMBOL_LANGUAGE (fa
->sym
),
393 DMGL_PARAMS
| DMGL_ANSI
);
394 if (fa
->entry_kind
== print_entry_values_compact
)
398 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (fa
->sym
),
399 SYMBOL_LANGUAGE (fa
->sym
),
400 DMGL_PARAMS
| DMGL_ANSI
);
402 if (fa
->entry_kind
== print_entry_values_only
403 || fa
->entry_kind
== print_entry_values_compact
)
405 out
->field_stream ("name", stb
);
408 /* Otherwise, just output the name. */
409 out
->field_string ("name", sym_name
);
411 annotate_arg_name_end ();
413 if (! out
->is_mi_like_p ())
416 if (print_args_field
)
417 out
->field_int ("arg", 1);
419 /* For MI print the type, but only for simple values. This seems
420 weird, but this is how MI choose to format the various output
422 if (args_type
== MI_PRINT_SIMPLE_VALUES
&& val
!= NULL
)
424 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
425 retval
= EXT_LANG_BT_ERROR
;
428 if (retval
!= EXT_LANG_BT_ERROR
)
431 annotate_arg_value (value_type (val
));
433 /* If the output is to the CLI, and the user option "set print
434 frame-arguments" is set to none, just output "...". */
435 if (! out
->is_mi_like_p () && args_type
== NO_VALUES
)
436 out
->field_string ("value", "...");
439 /* Otherwise, print the value for both MI and the CLI, except
440 for the case of MI_PRINT_NO_VALUES. */
441 if (args_type
!= NO_VALUES
)
445 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
446 out
->field_fmt ("value",
447 _("<error reading variable: %s>"),
450 else if (py_print_value (out
, val
, opts
, 0, args_type
, language
)
451 == EXT_LANG_BT_ERROR
)
452 retval
= EXT_LANG_BT_ERROR
;
457 CATCH (except
, RETURN_MASK_ERROR
)
459 gdbpy_convert_exception (except
);
460 retval
= EXT_LANG_BT_ERROR
;
467 /* Helper function to loop over frame arguments provided by the
468 "frame_arguments" Python API. Elements in the iterator must
469 conform to the "Symbol Value" interface. ITER is the Python
470 iterable object, OUT is the output stream, ARGS_TYPE is an
471 enumerator describing the argument format, PRINT_ARGS_FIELD is a
472 flag which indicates if we output "ARGS=1" in MI output in commands
473 where both arguments and locals are printed, and FRAME is the
474 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
475 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
478 static enum ext_lang_bt_status
479 enumerate_args (PyObject
*iter
,
481 enum ext_lang_frame_args args_type
,
482 int print_args_field
,
483 struct frame_info
*frame
)
485 struct value_print_options opts
;
487 get_user_print_options (&opts
);
489 if (args_type
== CLI_SCALAR_VALUES
)
491 /* True in "summary" mode, false otherwise. */
499 annotate_frame_args ();
501 CATCH (except
, RETURN_MASK_ERROR
)
503 gdbpy_convert_exception (except
);
504 return EXT_LANG_BT_ERROR
;
508 /* Collect the first argument outside of the loop, so output of
509 commas in the argument output is correct. At the end of the
510 loop block collect another item from the iterator, and, if it is
511 not null emit a comma. */
512 gdbpy_ref
<> item (PyIter_Next (iter
));
513 if (item
== NULL
&& PyErr_Occurred ())
514 return EXT_LANG_BT_ERROR
;
518 const struct language_defn
*language
;
519 gdb::unique_xmalloc_ptr
<char> sym_name
;
521 struct block
*sym_block
;
523 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
525 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
527 if (success
== EXT_LANG_BT_ERROR
)
528 return EXT_LANG_BT_ERROR
;
530 success
= extract_value (item
.get (), &val
);
531 if (success
== EXT_LANG_BT_ERROR
)
532 return EXT_LANG_BT_ERROR
;
534 if (sym
&& out
->is_mi_like_p ()
535 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
538 /* If the object did not provide a value, read it using
539 read_frame_args and account for entry values, if any. */
542 struct frame_arg arg
, entryarg
;
544 /* If there is no value, and also no symbol, set error and
548 PyErr_SetString (PyExc_RuntimeError
,
549 _("No symbol or value provided."));
550 return EXT_LANG_BT_ERROR
;
555 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
557 CATCH (except
, RETURN_MASK_ERROR
)
559 gdbpy_convert_exception (except
);
560 return EXT_LANG_BT_ERROR
;
564 gdb::unique_xmalloc_ptr
<char> arg_holder (arg
.error
);
565 gdb::unique_xmalloc_ptr
<char> entry_holder (entryarg
.error
);
567 /* The object has not provided a value, so this is a frame
568 argument to be read by GDB. In this case we have to
569 account for entry-values. */
571 if (arg
.entry_kind
!= print_entry_values_only
)
573 if (py_print_single_arg (out
, NULL
, &arg
,
577 NULL
) == EXT_LANG_BT_ERROR
)
578 return EXT_LANG_BT_ERROR
;
581 if (entryarg
.entry_kind
!= print_entry_values_no
)
583 if (arg
.entry_kind
!= print_entry_values_only
)
588 out
->wrap_hint (" ");
590 CATCH (except
, RETURN_MASK_ERROR
)
592 gdbpy_convert_exception (except
);
593 return EXT_LANG_BT_ERROR
;
598 if (py_print_single_arg (out
, NULL
, &entryarg
, NULL
, &opts
,
599 args_type
, print_args_field
, NULL
)
600 == EXT_LANG_BT_ERROR
)
601 return EXT_LANG_BT_ERROR
;
606 /* If the object has provided a value, we just print that. */
609 if (py_print_single_arg (out
, sym_name
.get (), NULL
, val
, &opts
,
610 args_type
, print_args_field
,
611 language
) == EXT_LANG_BT_ERROR
)
612 return EXT_LANG_BT_ERROR
;
616 /* Collect the next item from the iterator. If
617 this is the last item, do not print the
619 item
.reset (PyIter_Next (iter
));
626 CATCH (except
, RETURN_MASK_ERROR
)
628 gdbpy_convert_exception (except
);
629 return EXT_LANG_BT_ERROR
;
633 else if (PyErr_Occurred ())
634 return EXT_LANG_BT_ERROR
;
640 CATCH (except
, RETURN_MASK_ERROR
)
642 gdbpy_convert_exception (except
);
643 return EXT_LANG_BT_ERROR
;
648 return EXT_LANG_BT_OK
;
652 /* Helper function to loop over variables provided by the
653 "frame_locals" Python API. Elements in the iterable must conform
654 to the "Symbol Value" interface. ITER is the Python iterable
655 object, OUT is the output stream, INDENT is whether we should
656 indent the output (for CLI), ARGS_TYPE is an enumerator describing
657 the argument format, PRINT_ARGS_FIELD is flag which indicates
658 whether to output the ARGS field in the case of
659 -stack-list-variables and FRAME is the backing frame. Returns
660 EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
661 exception, or EXT_LANG_BT_OK on success. */
663 static enum ext_lang_bt_status
664 enumerate_locals (PyObject
*iter
,
667 enum ext_lang_frame_args args_type
,
668 int print_args_field
,
669 struct frame_info
*frame
)
671 struct value_print_options opts
;
673 get_user_print_options (&opts
);
678 const struct language_defn
*language
;
679 gdb::unique_xmalloc_ptr
<char> sym_name
;
681 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
683 struct block
*sym_block
;
684 int local_indent
= 8 + (8 * indent
);
685 gdb::optional
<ui_out_emit_tuple
> tuple
;
687 gdbpy_ref
<> item (PyIter_Next (iter
));
691 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
693 if (success
== EXT_LANG_BT_ERROR
)
694 return EXT_LANG_BT_ERROR
;
696 success
= extract_value (item
.get (), &val
);
697 if (success
== EXT_LANG_BT_ERROR
)
698 return EXT_LANG_BT_ERROR
;
700 if (sym
!= NULL
&& out
->is_mi_like_p ()
701 && ! mi_should_print (sym
, MI_PRINT_LOCALS
))
704 /* If the object did not provide a value, read it. */
709 val
= read_var_value (sym
, sym_block
, frame
);
711 CATCH (except
, RETURN_MASK_ERROR
)
713 gdbpy_convert_exception (except
);
714 return EXT_LANG_BT_ERROR
;
719 /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
720 each output contains only one field. The exception is
721 -stack-list-variables, which always provides a tuple. */
722 if (out
->is_mi_like_p ())
724 if (print_args_field
|| args_type
!= NO_VALUES
)
725 tuple
.emplace (out
, nullptr);
729 if (! out
->is_mi_like_p ())
731 /* If the output is not MI we indent locals. */
732 out
->spaces (local_indent
);
735 out
->field_string ("name", sym_name
.get ());
737 if (! out
->is_mi_like_p ())
740 CATCH (except
, RETURN_MASK_ERROR
)
742 gdbpy_convert_exception (except
);
743 return EXT_LANG_BT_ERROR
;
747 if (args_type
== MI_PRINT_SIMPLE_VALUES
)
749 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
750 return EXT_LANG_BT_ERROR
;
753 /* CLI always prints values for locals. MI uses the
754 simple/no/all system. */
755 if (! out
->is_mi_like_p ())
757 int val_indent
= (indent
+ 1) * 4;
759 if (py_print_value (out
, val
, &opts
, val_indent
, args_type
,
760 language
) == EXT_LANG_BT_ERROR
)
761 return EXT_LANG_BT_ERROR
;
765 if (args_type
!= NO_VALUES
)
767 if (py_print_value (out
, val
, &opts
, 0, args_type
,
768 language
) == EXT_LANG_BT_ERROR
)
769 return EXT_LANG_BT_ERROR
;
777 CATCH (except
, RETURN_MASK_ERROR
)
779 gdbpy_convert_exception (except
);
780 return EXT_LANG_BT_ERROR
;
785 if (!PyErr_Occurred ())
786 return EXT_LANG_BT_OK
;
788 return EXT_LANG_BT_ERROR
;
791 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
792 error, or EXT_LANG_BT_OK on success. */
794 static enum ext_lang_bt_status
795 py_mi_print_variables (PyObject
*filter
, struct ui_out
*out
,
796 struct value_print_options
*opts
,
797 enum ext_lang_frame_args args_type
,
798 struct frame_info
*frame
)
800 gdbpy_ref
<> args_iter (get_py_iter_from_func (filter
, "frame_args"));
801 if (args_iter
== NULL
)
802 return EXT_LANG_BT_ERROR
;
804 gdbpy_ref
<> locals_iter (get_py_iter_from_func (filter
, "frame_locals"));
805 if (locals_iter
== NULL
)
806 return EXT_LANG_BT_ERROR
;
808 ui_out_emit_list
list_emitter (out
, "variables");
810 if (args_iter
!= Py_None
811 && (enumerate_args (args_iter
.get (), out
, args_type
, 1, frame
)
812 == EXT_LANG_BT_ERROR
))
813 return EXT_LANG_BT_ERROR
;
815 if (locals_iter
!= Py_None
816 && (enumerate_locals (locals_iter
.get (), out
, 1, args_type
, 1, frame
)
817 == EXT_LANG_BT_ERROR
))
818 return EXT_LANG_BT_ERROR
;
820 return EXT_LANG_BT_OK
;
823 /* Helper function for printing locals. This function largely just
824 creates the wrapping tuple, and calls enumerate_locals. Returns
825 EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
827 static enum ext_lang_bt_status
828 py_print_locals (PyObject
*filter
,
830 enum ext_lang_frame_args args_type
,
832 struct frame_info
*frame
)
834 gdbpy_ref
<> locals_iter (get_py_iter_from_func (filter
, "frame_locals"));
835 if (locals_iter
== NULL
)
836 return EXT_LANG_BT_ERROR
;
838 ui_out_emit_list
list_emitter (out
, "locals");
840 if (locals_iter
!= Py_None
841 && (enumerate_locals (locals_iter
.get (), out
, indent
, args_type
,
842 0, frame
) == EXT_LANG_BT_ERROR
))
843 return EXT_LANG_BT_ERROR
;
845 return EXT_LANG_BT_OK
;
848 /* Helper function for printing frame arguments. This function
849 largely just creates the wrapping tuple, and calls enumerate_args.
850 Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
851 a Python exception, or EXT_LANG_BT_OK on success. */
853 static enum ext_lang_bt_status
854 py_print_args (PyObject
*filter
,
856 enum ext_lang_frame_args args_type
,
857 struct frame_info
*frame
)
859 gdbpy_ref
<> args_iter (get_py_iter_from_func (filter
, "frame_args"));
860 if (args_iter
== NULL
)
861 return EXT_LANG_BT_ERROR
;
863 ui_out_emit_list
list_emitter (out
, "args");
867 annotate_frame_args ();
868 if (! out
->is_mi_like_p ())
871 CATCH (except
, RETURN_MASK_ERROR
)
873 gdbpy_convert_exception (except
);
874 return EXT_LANG_BT_ERROR
;
878 if (args_iter
!= Py_None
879 && (enumerate_args (args_iter
.get (), out
, args_type
, 0, frame
)
880 == EXT_LANG_BT_ERROR
))
881 return EXT_LANG_BT_ERROR
;
885 if (! out
->is_mi_like_p ())
888 CATCH (except
, RETURN_MASK_ERROR
)
890 gdbpy_convert_exception (except
);
891 return EXT_LANG_BT_ERROR
;
895 return EXT_LANG_BT_OK
;
898 /* Print a single frame to the designated output stream, detecting
899 whether the output is MI or console, and formatting the output
900 according to the conventions of that protocol. FILTER is the
901 frame-filter associated with this frame. FLAGS is an integer
902 describing the various print options. The FLAGS variables is
903 described in "apply_frame_filter" function. ARGS_TYPE is an
904 enumerator describing the argument format. OUT is the output
905 stream to print, INDENT is the level of indention for this frame
906 (in the case of elided frames), and LEVELS_PRINTED is a hash-table
907 containing all the frames level that have already been printed.
908 If a frame level has been printed, do not print it again (in the
909 case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
910 GDB exceptions converted to a Python exception, or EXT_LANG_BT_OK
911 on success. It can also throw an exception RETURN_QUIT. */
913 static enum ext_lang_bt_status
914 py_print_frame (PyObject
*filter
, frame_filter_flags flags
,
915 enum ext_lang_frame_args args_type
,
916 struct ui_out
*out
, int indent
, htab_t levels_printed
)
919 CORE_ADDR address
= 0;
920 struct gdbarch
*gdbarch
= NULL
;
921 struct frame_info
*frame
= NULL
;
922 struct value_print_options opts
;
923 int print_level
, print_frame_info
, print_args
, print_locals
;
924 gdb::unique_xmalloc_ptr
<char> function_to_free
;
926 /* Extract print settings from FLAGS. */
927 print_level
= (flags
& PRINT_LEVEL
) ? 1 : 0;
928 print_frame_info
= (flags
& PRINT_FRAME_INFO
) ? 1 : 0;
929 print_args
= (flags
& PRINT_ARGS
) ? 1 : 0;
930 print_locals
= (flags
& PRINT_LOCALS
) ? 1 : 0;
932 get_user_print_options (&opts
);
934 /* Get the underlying frame. This is needed to determine GDB
935 architecture, and also, in the cases of frame variables/arguments to
936 read them if they returned filter object requires us to do so. */
937 gdbpy_ref
<> py_inf_frame (PyObject_CallMethod (filter
, "inferior_frame",
939 if (py_inf_frame
== NULL
)
940 return EXT_LANG_BT_ERROR
;
942 frame
= frame_object_to_frame_info (py_inf_frame
.get ());
944 return EXT_LANG_BT_ERROR
;
948 gdbarch
= get_frame_arch (frame
);
950 CATCH (except
, RETURN_MASK_ERROR
)
952 gdbpy_convert_exception (except
);
953 return EXT_LANG_BT_ERROR
;
957 /* stack-list-variables. */
958 if (print_locals
&& print_args
&& ! print_frame_info
)
960 if (py_mi_print_variables (filter
, out
, &opts
,
961 args_type
, frame
) == EXT_LANG_BT_ERROR
)
962 return EXT_LANG_BT_ERROR
;
963 return EXT_LANG_BT_OK
;
966 gdb::optional
<ui_out_emit_tuple
> tuple
;
968 /* -stack-list-locals does not require a
969 wrapping frame attribute. */
970 if (print_frame_info
|| (print_args
&& ! print_locals
))
971 tuple
.emplace (out
, "frame");
973 if (print_frame_info
)
975 /* Elided frames are also printed with this function (recursively)
976 and are printed with indention. */
981 out
->spaces (indent
* 4);
983 CATCH (except
, RETURN_MASK_ERROR
)
985 gdbpy_convert_exception (except
);
986 return EXT_LANG_BT_ERROR
;
991 /* The address is required for frame annotations, and also for
993 if (PyObject_HasAttrString (filter
, "address"))
995 gdbpy_ref
<> paddr (PyObject_CallMethod (filter
, "address", NULL
));
998 return EXT_LANG_BT_ERROR
;
1000 if (paddr
!= Py_None
)
1002 if (get_addr_from_python (paddr
.get (), &address
) < 0)
1003 return EXT_LANG_BT_ERROR
;
1010 /* Print frame level. MI does not require the level if
1011 locals/variables only are being printed. */
1012 if ((print_frame_info
|| print_args
) && print_level
)
1014 struct frame_info
**slot
;
1017 slot
= (struct frame_info
**) htab_find_slot (levels_printed
,
1021 level
= frame_relative_level (frame
);
1023 /* Check if this frame has already been printed (there are cases
1024 where elided synthetic dummy-frames have to 'borrow' the frame
1025 architecture from the eliding frame. If that is the case, do
1026 not print 'level', but print spaces. */
1028 out
->field_skip ("level");
1032 annotate_frame_begin (print_level
? level
: 0,
1035 out
->field_fmt_int (2, ui_left
, "level",
1039 CATCH (except
, RETURN_MASK_ERROR
)
1041 gdbpy_convert_exception (except
);
1042 return EXT_LANG_BT_ERROR
;
1047 if (print_frame_info
)
1049 /* Print address to the address field. If an address is not provided,
1051 if (opts
.addressprint
&& has_addr
)
1055 annotate_frame_address ();
1056 out
->field_core_addr ("addr", gdbarch
, address
);
1057 annotate_frame_address_end ();
1060 CATCH (except
, RETURN_MASK_ERROR
)
1062 gdbpy_convert_exception (except
);
1063 return EXT_LANG_BT_ERROR
;
1068 /* Print frame function name. */
1069 if (PyObject_HasAttrString (filter
, "function"))
1071 gdbpy_ref
<> py_func (PyObject_CallMethod (filter
, "function", NULL
));
1072 const char *function
= NULL
;
1074 if (py_func
== NULL
)
1075 return EXT_LANG_BT_ERROR
;
1077 if (gdbpy_is_string (py_func
.get ()))
1079 function_to_free
= python_string_to_host_string (py_func
.get ());
1081 if (function_to_free
== NULL
)
1082 return EXT_LANG_BT_ERROR
;
1084 function
= function_to_free
.get ();
1086 else if (PyLong_Check (py_func
.get ()))
1089 struct bound_minimal_symbol msymbol
;
1091 if (get_addr_from_python (py_func
.get (), &addr
) < 0)
1092 return EXT_LANG_BT_ERROR
;
1094 msymbol
= lookup_minimal_symbol_by_pc (addr
);
1095 if (msymbol
.minsym
!= NULL
)
1096 function
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1098 else if (py_func
!= Py_None
)
1100 PyErr_SetString (PyExc_RuntimeError
,
1101 _("FrameDecorator.function: expecting a " \
1102 "String, integer or None."));
1103 return EXT_LANG_BT_ERROR
;
1108 annotate_frame_function_name ();
1109 if (function
== NULL
)
1110 out
->field_skip ("func");
1112 out
->field_string ("func", function
);
1114 CATCH (except
, RETURN_MASK_ERROR
)
1116 gdbpy_convert_exception (except
);
1117 return EXT_LANG_BT_ERROR
;
1124 /* Frame arguments. Check the result, and error if something went
1128 if (py_print_args (filter
, out
, args_type
, frame
) == EXT_LANG_BT_ERROR
)
1129 return EXT_LANG_BT_ERROR
;
1132 /* File name/source/line number information. */
1133 if (print_frame_info
)
1137 annotate_frame_source_begin ();
1139 CATCH (except
, RETURN_MASK_ERROR
)
1141 gdbpy_convert_exception (except
);
1142 return EXT_LANG_BT_ERROR
;
1146 if (PyObject_HasAttrString (filter
, "filename"))
1148 gdbpy_ref
<> py_fn (PyObject_CallMethod (filter
, "filename", NULL
));
1151 return EXT_LANG_BT_ERROR
;
1153 if (py_fn
!= Py_None
)
1155 gdb::unique_xmalloc_ptr
<char>
1156 filename (python_string_to_host_string (py_fn
.get ()));
1158 if (filename
== NULL
)
1159 return EXT_LANG_BT_ERROR
;
1163 out
->wrap_hint (" ");
1165 annotate_frame_source_file ();
1166 out
->field_string ("file", filename
.get ());
1167 annotate_frame_source_file_end ();
1169 CATCH (except
, RETURN_MASK_ERROR
)
1171 gdbpy_convert_exception (except
);
1172 return EXT_LANG_BT_ERROR
;
1178 if (PyObject_HasAttrString (filter
, "line"))
1180 gdbpy_ref
<> py_line (PyObject_CallMethod (filter
, "line", NULL
));
1183 if (py_line
== NULL
)
1184 return EXT_LANG_BT_ERROR
;
1186 if (py_line
!= Py_None
)
1188 line
= PyLong_AsLong (py_line
.get ());
1189 if (PyErr_Occurred ())
1190 return EXT_LANG_BT_ERROR
;
1195 annotate_frame_source_line ();
1196 out
->field_int ("line", line
);
1198 CATCH (except
, RETURN_MASK_ERROR
)
1200 gdbpy_convert_exception (except
);
1201 return EXT_LANG_BT_ERROR
;
1208 /* For MI we need to deal with the "children" list population of
1209 elided frames, so if MI output detected do not send newline. */
1210 if (! out
->is_mi_like_p ())
1214 annotate_frame_end ();
1217 CATCH (except
, RETURN_MASK_ERROR
)
1219 gdbpy_convert_exception (except
);
1220 return EXT_LANG_BT_ERROR
;
1227 if (py_print_locals (filter
, out
, args_type
, indent
,
1228 frame
) == EXT_LANG_BT_ERROR
)
1229 return EXT_LANG_BT_ERROR
;
1232 if ((flags
& PRINT_HIDE
) == 0)
1234 /* Finally recursively print elided frames, if any. */
1235 gdbpy_ref
<> elided (get_py_iter_from_func (filter
, "elided"));
1237 return EXT_LANG_BT_ERROR
;
1239 if (elided
!= Py_None
)
1243 ui_out_emit_list
inner_list_emiter (out
, "children");
1245 if (! out
->is_mi_like_p ())
1248 while ((item
= PyIter_Next (elided
.get ())))
1250 gdbpy_ref
<> item_ref (item
);
1252 enum ext_lang_bt_status success
1253 = py_print_frame (item
, flags
, args_type
, out
, indent
,
1256 if (success
== EXT_LANG_BT_ERROR
)
1257 return EXT_LANG_BT_ERROR
;
1259 if (item
== NULL
&& PyErr_Occurred ())
1260 return EXT_LANG_BT_ERROR
;
1264 return EXT_LANG_BT_OK
;
1267 /* Helper function to initiate frame filter invocation at starting
1271 bootstrap_python_frame_filters (struct frame_info
*frame
,
1272 int frame_low
, int frame_high
)
1274 gdbpy_ref
<> frame_obj (frame_info_to_frame_object (frame
));
1275 if (frame_obj
== NULL
)
1278 gdbpy_ref
<> module (PyImport_ImportModule ("gdb.frames"));
1282 gdbpy_ref
<> sort_func (PyObject_GetAttrString (module
.get (),
1283 "execute_frame_filters"));
1284 if (sort_func
== NULL
)
1287 gdbpy_ref
<> py_frame_low (PyInt_FromLong (frame_low
));
1288 if (py_frame_low
== NULL
)
1291 gdbpy_ref
<> py_frame_high (PyInt_FromLong (frame_high
));
1292 if (py_frame_high
== NULL
)
1295 gdbpy_ref
<> iterable (PyObject_CallFunctionObjArgs (sort_func
.get (),
1297 py_frame_low
.get (),
1298 py_frame_high
.get (),
1300 if (iterable
== NULL
)
1303 if (iterable
!= Py_None
)
1304 return PyObject_GetIter (iterable
.get ());
1306 return iterable
.release ();
1309 /* A helper function that will either print an exception or, if it is
1310 a KeyboardException, throw a quit. This can only be called when
1311 the Python exception is set. */
1314 throw_quit_or_print_exception ()
1316 if (PyErr_ExceptionMatches (PyExc_KeyboardInterrupt
))
1319 throw_quit ("Quit");
1321 gdbpy_print_stack ();
1324 /* This is the only publicly exported function in this file. FRAME
1325 is the source frame to start frame-filter invocation. FLAGS is an
1326 integer holding the flags for printing. The following elements of
1327 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1328 PRINT_LEVEL is a flag indicating whether to print the frame's
1329 relative level in the output. PRINT_FRAME_INFO is a flag that
1330 indicates whether this function should print the frame
1331 information, PRINT_ARGS is a flag that indicates whether to print
1332 frame arguments, and PRINT_LOCALS, likewise, with frame local
1333 variables. ARGS_TYPE is an enumerator describing the argument
1334 format, OUT is the output stream to print. FRAME_LOW is the
1335 beginning of the slice of frames to print, and FRAME_HIGH is the
1336 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1337 or EXT_LANG_BT_OK on success. */
1339 enum ext_lang_bt_status
1340 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1341 struct frame_info
*frame
, frame_filter_flags flags
,
1342 enum ext_lang_frame_args args_type
,
1343 struct ui_out
*out
, int frame_low
, int frame_high
)
1345 struct gdbarch
*gdbarch
= NULL
;
1346 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1348 if (!gdb_python_initialized
)
1349 return EXT_LANG_BT_NO_FILTERS
;
1353 gdbarch
= get_frame_arch (frame
);
1355 CATCH (except
, RETURN_MASK_ERROR
)
1357 /* Let gdb try to print the stack trace. */
1358 return EXT_LANG_BT_NO_FILTERS
;
1362 gdbpy_enter
enter_py (gdbarch
, current_language
);
1364 /* When we're limiting the number of frames, be careful to request
1365 one extra frame, so that we can print a message if there are more
1367 int frame_countdown
= -1;
1368 if ((flags
& PRINT_MORE_FRAMES
) != 0 && frame_low
>= 0 && frame_high
>= 0)
1371 /* This has an extra +1 because it is checked before a frame is
1373 frame_countdown
= frame_high
- frame_low
+ 1;
1376 gdbpy_ref
<> iterable (bootstrap_python_frame_filters (frame
, frame_low
,
1379 if (iterable
== NULL
)
1381 /* Normally if there is an error GDB prints the exception,
1382 abandons the backtrace and exits. The user can then call "bt
1383 no-filters", and get a default backtrace (it would be
1384 confusing to automatically start a standard backtrace halfway
1385 through a Python filtered backtrace). However in the case
1386 where GDB cannot initialize the frame filters (most likely
1387 due to incorrect auto-load paths), GDB has printed nothing.
1388 In this case it is OK to print the default backtrace after
1389 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1390 here to signify there are no filters after printing the
1391 initialization error. This return code will trigger a
1392 default backtrace. */
1394 throw_quit_or_print_exception ();
1395 return EXT_LANG_BT_NO_FILTERS
;
1398 /* If iterable is None, then there are no frame filters registered.
1399 If this is the case, defer to default GDB printing routines in MI
1401 if (iterable
== Py_None
)
1402 return EXT_LANG_BT_NO_FILTERS
;
1404 htab_up
levels_printed (htab_create (20,
1411 gdbpy_ref
<> item (PyIter_Next (iterable
.get ()));
1415 if (PyErr_Occurred ())
1417 throw_quit_or_print_exception ();
1418 return EXT_LANG_BT_ERROR
;
1423 if (frame_countdown
!= -1)
1425 gdb_assert ((flags
& PRINT_MORE_FRAMES
) != 0);
1427 if (frame_countdown
== 0)
1429 /* We've printed all the frames we were asked to
1430 print, but more frames existed. */
1431 printf_filtered (_("(More stack frames follow...)\n"));
1436 success
= py_print_frame (item
.get (), flags
, args_type
, out
, 0,
1437 levels_printed
.get ());
1439 /* Do not exit on error printing a single frame. Print the
1440 error and continue with other frames. */
1441 if (success
== EXT_LANG_BT_ERROR
)
1442 throw_quit_or_print_exception ();