1 /* Python frame filters
3 Copyright (C) 2013-2014 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 "exceptions.h"
25 #include "arch-utils.h"
32 #include "mi/mi-cmds.h"
33 #include "python-internal.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. In the case of the API returning a string,
48 this will be set to NULL. LANGUAGE is also a pass-through argument
49 denoting the language attributed to the Symbol. In the case of SYM
50 being NULL, this will be set to the current language. Returns
51 EXT_LANG_BT_ERROR on error with the appropriate Python exception set, and
52 EXT_LANG_BT_OK on success. */
54 static enum ext_lang_bt_status
55 extract_sym (PyObject
*obj
, char **name
, struct symbol
**sym
,
56 const struct language_defn
**language
)
58 PyObject
*result
= PyObject_CallMethod (obj
, "symbol", NULL
);
61 return EXT_LANG_BT_ERROR
;
63 /* For 'symbol' callback, the function can return a symbol or a
65 if (gdbpy_is_string (result
))
67 *name
= python_string_to_host_string (result
);
71 return EXT_LANG_BT_ERROR
;
72 /* If the API returns a string (and not a symbol), then there is
73 no symbol derived language available and the frame filter has
74 either overridden the symbol with a string, or supplied a
75 entirely synthetic symbol/value pairing. In that case, use
77 *language
= python_language
;
82 /* This type checks 'result' during the conversion so we
83 just call it unconditionally and check the return. */
84 *sym
= symbol_object_to_symbol (result
);
90 PyErr_SetString (PyExc_RuntimeError
,
91 _("Unexpected value. Expecting a "
92 "gdb.Symbol or a Python string."));
93 return EXT_LANG_BT_ERROR
;
96 /* Duplicate the symbol name, so the caller has consistency
97 in garbage collection. */
98 *name
= xstrdup (SYMBOL_PRINT_NAME (*sym
));
100 /* If a symbol is specified attempt to determine the language
101 from the symbol. If mode is not "auto", then the language
102 has been explicitly set, use that. */
103 if (language_mode
== language_mode_auto
)
104 *language
= language_def (SYMBOL_LANGUAGE (*sym
));
106 *language
= current_language
;
109 return EXT_LANG_BT_OK
;
112 /* Helper function to extract a value from an object that conforms to
113 the "Symbol Value" interface. OBJ is the Python object to extract
114 the value from. VALUE is a pass-through argument where the value
115 will be written. If the object does not have the value attribute,
116 or provides the Python None for a value, VALUE will be set to NULL
117 and this function will return as successful. Returns EXT_LANG_BT_ERROR
118 on error with the appropriate Python exception set, and EXT_LANG_BT_OK on
121 static enum ext_lang_bt_status
122 extract_value (PyObject
*obj
, struct value
**value
)
124 if (PyObject_HasAttrString (obj
, "value"))
126 PyObject
*vresult
= PyObject_CallMethod (obj
, "value", NULL
);
129 return EXT_LANG_BT_ERROR
;
131 /* The Python code has returned 'None' for a value, so we set
132 value to NULL. This flags that GDB should read the
134 if (vresult
== Py_None
)
138 return EXT_LANG_BT_OK
;
142 *value
= convert_value_from_python (vresult
);
146 return EXT_LANG_BT_ERROR
;
148 return EXT_LANG_BT_OK
;
154 return EXT_LANG_BT_OK
;
157 /* MI prints only certain values according to the type of symbol and
158 also what the user has specified. SYM is the symbol to check, and
159 MI_PRINT_TYPES is an enum specifying what the user wants emitted
160 for the MI command in question. */
162 mi_should_print (struct symbol
*sym
, enum mi_print_types type
)
166 switch (SYMBOL_CLASS (sym
))
169 case LOC_UNDEF
: /* catches errors */
170 case LOC_CONST
: /* constant */
171 case LOC_TYPEDEF
: /* local typedef */
172 case LOC_LABEL
: /* local label */
173 case LOC_BLOCK
: /* local function */
174 case LOC_CONST_BYTES
: /* loc. byte seq. */
175 case LOC_UNRESOLVED
: /* unresolved static */
176 case LOC_OPTIMIZED_OUT
: /* optimized out */
180 case LOC_ARG
: /* argument */
181 case LOC_REF_ARG
: /* reference arg */
182 case LOC_REGPARM_ADDR
: /* indirect register arg */
183 case LOC_LOCAL
: /* stack local */
184 case LOC_STATIC
: /* static */
185 case LOC_REGISTER
: /* register */
186 case LOC_COMPUTED
: /* computed location */
187 if (type
== MI_PRINT_LOCALS
)
188 print_me
= ! SYMBOL_IS_ARGUMENT (sym
);
190 print_me
= SYMBOL_IS_ARGUMENT (sym
);
195 /* Helper function which outputs a type name extracted from VAL to a
196 "type" field in the output stream OUT. OUT is the ui-out structure
197 the type name will be output too, and VAL is the value that the
198 type will be extracted from. Returns EXT_LANG_BT_ERROR on error, with
199 any GDB exceptions converted to a Python exception, or EXT_LANG_BT_OK on
202 static enum ext_lang_bt_status
203 py_print_type (struct ui_out
*out
, struct value
*val
)
205 volatile struct gdb_exception except
;
207 TRY_CATCH (except
, RETURN_MASK_ALL
)
211 struct cleanup
*cleanup
;
213 stb
= mem_fileopen ();
214 cleanup
= make_cleanup_ui_file_delete (stb
);
215 type
= check_typedef (value_type (val
));
216 type_print (value_type (val
), "", stb
, -1);
217 ui_out_field_stream (out
, "type", stb
);
218 do_cleanups (cleanup
);
220 if (except
.reason
< 0)
222 gdbpy_convert_exception (except
);
223 return EXT_LANG_BT_ERROR
;
226 return EXT_LANG_BT_OK
;
229 /* Helper function which outputs a value to an output field in a
230 stream. OUT is the ui-out structure the value will be output to,
231 VAL is the value that will be printed, OPTS contains the value
232 printing options, ARGS_TYPE is an enumerator describing the
233 argument format, and LANGUAGE is the language_defn that the value
234 will be printed with. Returns EXT_LANG_BT_ERROR on error, with any GDB
235 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
238 static enum ext_lang_bt_status
239 py_print_value (struct ui_out
*out
, struct value
*val
,
240 const struct value_print_options
*opts
,
242 enum ext_lang_frame_args args_type
,
243 const struct language_defn
*language
)
245 int should_print
= 0;
246 volatile struct gdb_exception except
;
247 int local_indent
= (4 * indent
);
249 /* Never set an indent level for common_val_print if MI. */
250 if (ui_out_is_mi_like_p (out
))
253 /* MI does not print certain values, differentiated by type,
254 depending on what ARGS_TYPE indicates. Test type against option.
255 For CLI print all values. */
256 if (args_type
== MI_PRINT_SIMPLE_VALUES
257 || args_type
== MI_PRINT_ALL_VALUES
)
259 struct type
*type
= NULL
;
261 TRY_CATCH (except
, RETURN_MASK_ALL
)
263 type
= check_typedef (value_type (val
));
265 if (except
.reason
< 0)
267 gdbpy_convert_exception (except
);
268 return EXT_LANG_BT_ERROR
;
271 if (args_type
== MI_PRINT_ALL_VALUES
)
273 else if (args_type
== MI_PRINT_SIMPLE_VALUES
274 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
275 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
276 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
279 else if (args_type
!= NO_VALUES
)
284 TRY_CATCH (except
, RETURN_MASK_ALL
)
287 struct cleanup
*cleanup
;
289 stb
= mem_fileopen ();
290 cleanup
= make_cleanup_ui_file_delete (stb
);
291 common_val_print (val
, stb
, indent
, opts
, language
);
292 ui_out_field_stream (out
, "value", stb
);
293 do_cleanups (cleanup
);
295 if (except
.reason
< 0)
297 gdbpy_convert_exception (except
);
298 return EXT_LANG_BT_ERROR
;
302 return EXT_LANG_BT_OK
;
305 /* Helper function to call a Python method and extract an iterator
306 from the result. If the function returns anything but an iterator
307 the exception is preserved and NULL is returned. FILTER is the
308 Python object to call, and FUNC is the name of the method. Returns
309 a PyObject, or NULL on error with the appropriate exception set.
310 This function can return an iterator, or NULL. */
313 get_py_iter_from_func (PyObject
*filter
, char *func
)
315 if (PyObject_HasAttrString (filter
, func
))
317 PyObject
*result
= PyObject_CallMethod (filter
, func
, NULL
);
321 if (result
== Py_None
)
327 PyObject
*iterator
= PyObject_GetIter (result
);
340 /* Helper function to output a single frame argument and value to an
341 output stream. This function will account for entry values if the
342 FV parameter is populated, the frame argument has entry values
343 associated with them, and the appropriate "set entry-value"
344 options are set. Will output in CLI or MI like format depending
345 on the type of output stream detected. OUT is the output stream,
346 SYM_NAME is the name of the symbol. If SYM_NAME is populated then
347 it must have an accompanying value in the parameter FV. FA is a
348 frame argument structure. If FA is populated, both SYM_NAME and
349 FV are ignored. OPTS contains the value printing options,
350 ARGS_TYPE is an enumerator describing the argument format,
351 PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
352 in MI output in commands where both arguments and locals are
353 printed. Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions
354 converted to a Python exception, or EXT_LANG_BT_OK on success. */
356 static enum ext_lang_bt_status
357 py_print_single_arg (struct ui_out
*out
,
358 const char *sym_name
,
359 struct frame_arg
*fa
,
361 const struct value_print_options
*opts
,
362 enum ext_lang_frame_args args_type
,
363 int print_args_field
,
364 const struct language_defn
*language
)
367 volatile struct gdb_exception except
;
368 enum ext_lang_bt_status retval
= EXT_LANG_BT_OK
;
372 if (fa
->val
== NULL
&& fa
->error
== NULL
)
373 return EXT_LANG_BT_OK
;
374 language
= language_def (SYMBOL_LANGUAGE (fa
->sym
));
380 TRY_CATCH (except
, RETURN_MASK_ALL
)
382 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
384 /* MI has varying rules for tuples, but generally if there is only
385 one element in each item in the list, do not start a tuple. The
386 exception is -stack-list-variables which emits an ARGS="1" field
387 if the value is a frame argument. This is denoted in this
388 function with PRINT_ARGS_FIELD which is flag from the caller to
389 emit the ARGS field. */
390 if (ui_out_is_mi_like_p (out
))
392 if (print_args_field
|| args_type
!= NO_VALUES
)
393 make_cleanup_ui_out_tuple_begin_end (out
, NULL
);
396 annotate_arg_begin ();
398 /* If frame argument is populated, check for entry-values and the
399 entry value options. */
404 stb
= mem_fileopen ();
405 make_cleanup_ui_file_delete (stb
);
406 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (fa
->sym
),
407 SYMBOL_LANGUAGE (fa
->sym
),
408 DMGL_PARAMS
| DMGL_ANSI
);
409 if (fa
->entry_kind
== print_entry_values_compact
)
411 fputs_filtered ("=", stb
);
413 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (fa
->sym
),
414 SYMBOL_LANGUAGE (fa
->sym
),
415 DMGL_PARAMS
| DMGL_ANSI
);
417 if (fa
->entry_kind
== print_entry_values_only
418 || fa
->entry_kind
== print_entry_values_compact
)
420 fputs_filtered ("@entry", stb
);
422 ui_out_field_stream (out
, "name", stb
);
425 /* Otherwise, just output the name. */
426 ui_out_field_string (out
, "name", sym_name
);
428 annotate_arg_name_end ();
430 if (! ui_out_is_mi_like_p (out
))
431 ui_out_text (out
, "=");
433 if (print_args_field
)
434 ui_out_field_int (out
, "arg", 1);
436 /* For MI print the type, but only for simple values. This seems
437 weird, but this is how MI choose to format the various output
439 if (args_type
== MI_PRINT_SIMPLE_VALUES
&& val
!= NULL
)
441 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
443 retval
= EXT_LANG_BT_ERROR
;
444 do_cleanups (cleanups
);
450 annotate_arg_value (value_type (val
));
452 /* If the output is to the CLI, and the user option "set print
453 frame-arguments" is set to none, just output "...". */
454 if (! ui_out_is_mi_like_p (out
) && args_type
== NO_VALUES
)
455 ui_out_field_string (out
, "value", "...");
458 /* Otherwise, print the value for both MI and the CLI, except
459 for the case of MI_PRINT_NO_VALUES. */
460 if (args_type
!= NO_VALUES
)
464 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
465 ui_out_field_fmt (out
, "value",
466 _("<error reading variable: %s>"),
469 else if (py_print_value (out
, val
, opts
, 0, args_type
, language
)
470 == EXT_LANG_BT_ERROR
)
471 retval
= EXT_LANG_BT_ERROR
;
475 do_cleanups (cleanups
);
477 if (except
.reason
< 0)
478 gdbpy_convert_exception (except
);
483 /* Helper function to loop over frame arguments provided by the
484 "frame_arguments" Python API. Elements in the iterator must
485 conform to the "Symbol Value" interface. ITER is the Python
486 iterable object, OUT is the output stream, ARGS_TYPE is an
487 enumerator describing the argument format, PRINT_ARGS_FIELD is a
488 flag which indicates if we output "ARGS=1" in MI output in commands
489 where both arguments and locals are printed, and FRAME is the
490 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
491 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
494 static enum ext_lang_bt_status
495 enumerate_args (PyObject
*iter
,
497 enum ext_lang_frame_args args_type
,
498 int print_args_field
,
499 struct frame_info
*frame
)
502 struct value_print_options opts
;
503 volatile struct gdb_exception except
;
505 get_user_print_options (&opts
);
507 if (args_type
== CLI_SCALAR_VALUES
)
509 /* True in "summary" mode, false otherwise. */
515 TRY_CATCH (except
, RETURN_MASK_ALL
)
517 annotate_frame_args ();
519 if (except
.reason
< 0)
521 gdbpy_convert_exception (except
);
525 /* Collect the first argument outside of the loop, so output of
526 commas in the argument output is correct. At the end of the
527 loop block collect another item from the iterator, and, if it is
528 not null emit a comma. */
529 item
= PyIter_Next (iter
);
530 if (item
== NULL
&& PyErr_Occurred ())
535 const struct language_defn
*language
;
539 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
541 success
= extract_sym (item
, &sym_name
, &sym
, &language
);
542 if (success
== EXT_LANG_BT_ERROR
)
548 success
= extract_value (item
, &val
);
549 if (success
== EXT_LANG_BT_ERROR
)
559 if (sym
&& ui_out_is_mi_like_p (out
)
560 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
566 /* If the object did not provide a value, read it using
567 read_frame_args and account for entry values, if any. */
570 struct frame_arg arg
, entryarg
;
572 /* If there is no value, and also no symbol, set error and
576 PyErr_SetString (PyExc_RuntimeError
,
577 _("No symbol or value provided."));
582 TRY_CATCH (except
, RETURN_MASK_ALL
)
584 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
586 if (except
.reason
< 0)
589 gdbpy_convert_exception (except
);
593 /* The object has not provided a value, so this is a frame
594 argument to be read by GDB. In this case we have to
595 account for entry-values. */
597 if (arg
.entry_kind
!= print_entry_values_only
)
599 if (py_print_single_arg (out
, NULL
, &arg
,
603 NULL
) == EXT_LANG_BT_ERROR
)
606 xfree (entryarg
.error
);
612 if (entryarg
.entry_kind
!= print_entry_values_no
)
614 if (arg
.entry_kind
!= print_entry_values_only
)
616 TRY_CATCH (except
, RETURN_MASK_ALL
)
618 ui_out_text (out
, ", ");
619 ui_out_wrap_hint (out
, " ");
621 if (except
.reason
< 0)
624 xfree (entryarg
.error
);
626 gdbpy_convert_exception (except
);
631 if (py_print_single_arg (out
, NULL
, &entryarg
, NULL
, &opts
,
632 args_type
, print_args_field
, NULL
)
633 == EXT_LANG_BT_ERROR
)
636 xfree (entryarg
.error
);
643 xfree (entryarg
.error
);
647 /* If the object has provided a value, we just print that. */
650 if (py_print_single_arg (out
, sym_name
, NULL
, val
, &opts
,
651 args_type
, print_args_field
,
652 language
) == EXT_LANG_BT_ERROR
)
662 /* Collect the next item from the iterator. If
663 this is the last item, do not print the
665 item
= PyIter_Next (iter
);
668 TRY_CATCH (except
, RETURN_MASK_ALL
)
670 ui_out_text (out
, ", ");
672 if (except
.reason
< 0)
675 gdbpy_convert_exception (except
);
679 else if (PyErr_Occurred ())
682 TRY_CATCH (except
, RETURN_MASK_ALL
)
686 if (except
.reason
< 0)
689 gdbpy_convert_exception (except
);
694 return EXT_LANG_BT_OK
;
697 return EXT_LANG_BT_ERROR
;
701 /* Helper function to loop over variables provided by the
702 "frame_locals" Python API. Elements in the iterable must conform
703 to the "Symbol Value" interface. ITER is the Python iterable
704 object, OUT is the output stream, INDENT is whether we should
705 indent the output (for CLI), ARGS_TYPE is an enumerator describing
706 the argument format, PRINT_ARGS_FIELD is flag which indicates
707 whether to output the ARGS field in the case of
708 -stack-list-variables and FRAME is the backing frame. Returns
709 EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
710 exception, or EXT_LANG_BT_OK on success. */
712 static enum ext_lang_bt_status
713 enumerate_locals (PyObject
*iter
,
716 enum ext_lang_frame_args args_type
,
717 int print_args_field
,
718 struct frame_info
*frame
)
721 struct value_print_options opts
;
723 get_user_print_options (&opts
);
726 while ((item
= PyIter_Next (iter
)))
728 const struct language_defn
*language
;
731 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
733 volatile struct gdb_exception except
;
734 int local_indent
= 8 + (8 * indent
);
735 struct cleanup
*locals_cleanups
;
737 locals_cleanups
= make_cleanup_py_decref (item
);
739 success
= extract_sym (item
, &sym_name
, &sym
, &language
);
740 if (success
== EXT_LANG_BT_ERROR
)
742 do_cleanups (locals_cleanups
);
746 make_cleanup (xfree
, sym_name
);
748 success
= extract_value (item
, &val
);
749 if (success
== EXT_LANG_BT_ERROR
)
751 do_cleanups (locals_cleanups
);
755 if (sym
!= NULL
&& ui_out_is_mi_like_p (out
)
756 && ! mi_should_print (sym
, MI_PRINT_LOCALS
))
758 do_cleanups (locals_cleanups
);
762 /* If the object did not provide a value, read it. */
765 TRY_CATCH (except
, RETURN_MASK_ALL
)
767 val
= read_var_value (sym
, frame
);
769 if (except
.reason
< 0)
771 gdbpy_convert_exception (except
);
772 do_cleanups (locals_cleanups
);
777 /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
778 each output contains only one field. The exception is
779 -stack-list-variables, which always provides a tuple. */
780 if (ui_out_is_mi_like_p (out
))
782 if (print_args_field
|| args_type
!= NO_VALUES
)
783 make_cleanup_ui_out_tuple_begin_end (out
, NULL
);
785 TRY_CATCH (except
, RETURN_MASK_ALL
)
787 if (! ui_out_is_mi_like_p (out
))
789 /* If the output is not MI we indent locals. */
790 ui_out_spaces (out
, local_indent
);
793 ui_out_field_string (out
, "name", sym_name
);
795 if (! ui_out_is_mi_like_p (out
))
796 ui_out_text (out
, " = ");
798 if (except
.reason
< 0)
800 gdbpy_convert_exception (except
);
801 do_cleanups (locals_cleanups
);
805 if (args_type
== MI_PRINT_SIMPLE_VALUES
)
807 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
809 do_cleanups (locals_cleanups
);
814 /* CLI always prints values for locals. MI uses the
815 simple/no/all system. */
816 if (! ui_out_is_mi_like_p (out
))
818 int val_indent
= (indent
+ 1) * 4;
820 if (py_print_value (out
, val
, &opts
, val_indent
, args_type
,
821 language
) == EXT_LANG_BT_ERROR
)
823 do_cleanups (locals_cleanups
);
829 if (args_type
!= NO_VALUES
)
831 if (py_print_value (out
, val
, &opts
, 0, args_type
,
832 language
) == EXT_LANG_BT_ERROR
)
834 do_cleanups (locals_cleanups
);
840 do_cleanups (locals_cleanups
);
842 TRY_CATCH (except
, RETURN_MASK_ALL
)
844 ui_out_text (out
, "\n");
846 if (except
.reason
< 0)
848 gdbpy_convert_exception (except
);
853 if (item
== NULL
&& PyErr_Occurred ())
856 return EXT_LANG_BT_OK
;
859 return EXT_LANG_BT_ERROR
;
862 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
863 error, or EXT_LANG_BT_OK on success. */
865 static enum ext_lang_bt_status
866 py_mi_print_variables (PyObject
*filter
, struct ui_out
*out
,
867 struct value_print_options
*opts
,
868 enum ext_lang_frame_args args_type
,
869 struct frame_info
*frame
)
871 struct cleanup
*old_chain
;
873 PyObject
*locals_iter
;
875 args_iter
= get_py_iter_from_func (filter
, "frame_args");
876 old_chain
= make_cleanup_py_xdecref (args_iter
);
877 if (args_iter
== NULL
)
880 locals_iter
= get_py_iter_from_func (filter
, "frame_locals");
881 if (locals_iter
== NULL
)
884 make_cleanup_py_decref (locals_iter
);
885 make_cleanup_ui_out_list_begin_end (out
, "variables");
887 if (args_iter
!= Py_None
)
888 if (enumerate_args (args_iter
, out
, args_type
, 1, frame
)
889 == EXT_LANG_BT_ERROR
)
892 if (locals_iter
!= Py_None
)
893 if (enumerate_locals (locals_iter
, out
, 1, args_type
, 1, frame
)
894 == EXT_LANG_BT_ERROR
)
897 do_cleanups (old_chain
);
898 return EXT_LANG_BT_OK
;
901 do_cleanups (old_chain
);
902 return EXT_LANG_BT_ERROR
;
905 /* Helper function for printing locals. This function largely just
906 creates the wrapping tuple, and calls enumerate_locals. Returns
907 EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
909 static enum ext_lang_bt_status
910 py_print_locals (PyObject
*filter
,
912 enum ext_lang_frame_args args_type
,
914 struct frame_info
*frame
)
916 PyObject
*locals_iter
= get_py_iter_from_func (filter
,
918 struct cleanup
*old_chain
= make_cleanup_py_xdecref (locals_iter
);
920 if (locals_iter
== NULL
)
923 make_cleanup_ui_out_list_begin_end (out
, "locals");
925 if (locals_iter
!= Py_None
)
926 if (enumerate_locals (locals_iter
, out
, indent
, args_type
,
927 0, frame
) == EXT_LANG_BT_ERROR
)
930 do_cleanups (old_chain
);
931 return EXT_LANG_BT_OK
;
934 do_cleanups (old_chain
);
935 return EXT_LANG_BT_ERROR
;
938 /* Helper function for printing frame arguments. This function
939 largely just creates the wrapping tuple, and calls enumerate_args.
940 Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
941 a Python exception, or EXT_LANG_BT_OK on success. */
943 static enum ext_lang_bt_status
944 py_print_args (PyObject
*filter
,
946 enum ext_lang_frame_args args_type
,
947 struct frame_info
*frame
)
949 PyObject
*args_iter
= get_py_iter_from_func (filter
, "frame_args");
950 struct cleanup
*old_chain
= make_cleanup_py_xdecref (args_iter
);
951 volatile struct gdb_exception except
;
953 if (args_iter
== NULL
)
956 make_cleanup_ui_out_list_begin_end (out
, "args");
958 TRY_CATCH (except
, RETURN_MASK_ALL
)
960 annotate_frame_args ();
961 if (! ui_out_is_mi_like_p (out
))
962 ui_out_text (out
, " (");
964 if (except
.reason
< 0)
966 gdbpy_convert_exception (except
);
970 if (args_iter
!= Py_None
)
971 if (enumerate_args (args_iter
, out
, args_type
, 0, frame
)
972 == EXT_LANG_BT_ERROR
)
975 TRY_CATCH (except
, RETURN_MASK_ALL
)
977 if (! ui_out_is_mi_like_p (out
))
978 ui_out_text (out
, ")");
980 if (except
.reason
< 0)
982 gdbpy_convert_exception (except
);
986 do_cleanups (old_chain
);
987 return EXT_LANG_BT_OK
;
990 do_cleanups (old_chain
);
991 return EXT_LANG_BT_ERROR
;
994 /* Print a single frame to the designated output stream, detecting
995 whether the output is MI or console, and formatting the output
996 according to the conventions of that protocol. FILTER is the
997 frame-filter associated with this frame. FLAGS is an integer
998 describing the various print options. The FLAGS variables is
999 described in "apply_frame_filter" function. ARGS_TYPE is an
1000 enumerator describing the argument format. OUT is the output
1001 stream to print, INDENT is the level of indention for this frame
1002 (in the case of elided frames), and LEVELS_PRINTED is a hash-table
1003 containing all the frames level that have already been printed.
1004 If a frame level has been printed, do not print it again (in the
1005 case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
1006 GDB exceptions converted to a Python exception, or EXT_LANG_BT_COMPLETED
1009 static enum ext_lang_bt_status
1010 py_print_frame (PyObject
*filter
, int flags
,
1011 enum ext_lang_frame_args args_type
,
1012 struct ui_out
*out
, int indent
, htab_t levels_printed
)
1015 CORE_ADDR address
= 0;
1016 struct gdbarch
*gdbarch
= NULL
;
1017 struct frame_info
*frame
= NULL
;
1018 struct cleanup
*cleanup_stack
= make_cleanup (null_cleanup
, NULL
);
1019 struct value_print_options opts
;
1020 PyObject
*py_inf_frame
, *elided
;
1021 int print_level
, print_frame_info
, print_args
, print_locals
;
1022 volatile struct gdb_exception except
;
1024 /* Extract print settings from FLAGS. */
1025 print_level
= (flags
& PRINT_LEVEL
) ? 1 : 0;
1026 print_frame_info
= (flags
& PRINT_FRAME_INFO
) ? 1 : 0;
1027 print_args
= (flags
& PRINT_ARGS
) ? 1 : 0;
1028 print_locals
= (flags
& PRINT_LOCALS
) ? 1 : 0;
1030 get_user_print_options (&opts
);
1032 /* Get the underlying frame. This is needed to determine GDB
1033 architecture, and also, in the cases of frame variables/arguments to
1034 read them if they returned filter object requires us to do so. */
1035 py_inf_frame
= PyObject_CallMethod (filter
, "inferior_frame", NULL
);
1036 if (py_inf_frame
== NULL
)
1039 frame
= frame_object_to_frame_info (py_inf_frame
);;
1041 Py_DECREF (py_inf_frame
);
1046 TRY_CATCH (except
, RETURN_MASK_ALL
)
1048 gdbarch
= get_frame_arch (frame
);
1050 if (except
.reason
< 0)
1052 gdbpy_convert_exception (except
);
1057 /* stack-list-variables. */
1058 if (print_locals
&& print_args
&& ! print_frame_info
)
1060 if (py_mi_print_variables (filter
, out
, &opts
,
1061 args_type
, frame
) == EXT_LANG_BT_ERROR
)
1065 do_cleanups (cleanup_stack
);
1066 return EXT_LANG_BT_COMPLETED
;
1070 /* -stack-list-locals does not require a
1071 wrapping frame attribute. */
1072 if (print_frame_info
|| (print_args
&& ! print_locals
))
1073 make_cleanup_ui_out_tuple_begin_end (out
, "frame");
1075 if (print_frame_info
)
1077 /* Elided frames are also printed with this function (recursively)
1078 and are printed with indention. */
1081 TRY_CATCH (except
, RETURN_MASK_ALL
)
1083 ui_out_spaces (out
, indent
*4);
1085 if (except
.reason
< 0)
1087 gdbpy_convert_exception (except
);
1092 /* The address is required for frame annotations, and also for
1093 address printing. */
1094 if (PyObject_HasAttrString (filter
, "address"))
1096 PyObject
*paddr
= PyObject_CallMethod (filter
, "address", NULL
);
1099 if (paddr
!= Py_None
)
1101 address
= PyLong_AsLong (paddr
);
1111 /* Print frame level. MI does not require the level if
1112 locals/variables only are being printed. */
1113 if ((print_frame_info
|| print_args
) && print_level
)
1115 struct frame_info
**slot
;
1117 volatile struct gdb_exception except
;
1119 slot
= (struct frame_info
**) htab_find_slot (levels_printed
,
1121 TRY_CATCH (except
, RETURN_MASK_ALL
)
1123 level
= frame_relative_level (frame
);
1125 /* Check if this frame has already been printed (there are cases
1126 where elided synthetic dummy-frames have to 'borrow' the frame
1127 architecture from the eliding frame. If that is the case, do
1128 not print 'level', but print spaces. */
1130 ui_out_field_skip (out
, "level");
1134 annotate_frame_begin (print_level
? level
: 0,
1136 ui_out_text (out
, "#");
1137 ui_out_field_fmt_int (out
, 2, ui_left
, "level",
1141 if (except
.reason
< 0)
1143 gdbpy_convert_exception (except
);
1148 if (print_frame_info
)
1150 /* Print address to the address field. If an address is not provided,
1152 if (opts
.addressprint
&& has_addr
)
1154 TRY_CATCH (except
, RETURN_MASK_ALL
)
1156 annotate_frame_address ();
1157 ui_out_field_core_addr (out
, "addr", gdbarch
, address
);
1158 annotate_frame_address_end ();
1159 ui_out_text (out
, " in ");
1161 if (except
.reason
< 0)
1163 gdbpy_convert_exception (except
);
1168 /* Print frame function name. */
1169 if (PyObject_HasAttrString (filter
, "function"))
1171 PyObject
*py_func
= PyObject_CallMethod (filter
, "function", NULL
);
1173 if (py_func
!= NULL
)
1175 const char *function
= NULL
;
1177 if (gdbpy_is_string (py_func
))
1179 char *function_to_free
= NULL
;
1181 function
= function_to_free
=
1182 python_string_to_host_string (py_func
);
1184 if (function
== NULL
)
1186 Py_DECREF (py_func
);
1189 make_cleanup (xfree
, function_to_free
);
1191 else if (PyLong_Check (py_func
))
1193 CORE_ADDR addr
= PyLong_AsUnsignedLongLong (py_func
);
1194 struct bound_minimal_symbol msymbol
;
1196 if (PyErr_Occurred ())
1199 msymbol
= lookup_minimal_symbol_by_pc (addr
);
1200 if (msymbol
.minsym
!= NULL
)
1201 function
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1203 else if (py_func
!= Py_None
)
1205 PyErr_SetString (PyExc_RuntimeError
,
1206 _("FrameDecorator.function: expecting a " \
1207 "String, integer or None."));
1208 Py_DECREF (py_func
);
1213 TRY_CATCH (except
, RETURN_MASK_ALL
)
1215 annotate_frame_function_name ();
1216 if (function
== NULL
)
1217 ui_out_field_skip (out
, "func");
1219 ui_out_field_string (out
, "func", function
);
1221 if (except
.reason
< 0)
1223 Py_DECREF (py_func
);
1224 gdbpy_convert_exception (except
);
1227 Py_DECREF (py_func
);
1235 /* Frame arguments. Check the result, and error if something went
1239 if (py_print_args (filter
, out
, args_type
, frame
) == EXT_LANG_BT_ERROR
)
1243 /* File name/source/line number information. */
1244 if (print_frame_info
)
1246 TRY_CATCH (except
, RETURN_MASK_ALL
)
1248 annotate_frame_source_begin ();
1250 if (except
.reason
< 0)
1252 gdbpy_convert_exception (except
);
1256 if (PyObject_HasAttrString (filter
, "filename"))
1258 PyObject
*py_fn
= PyObject_CallMethod (filter
, "filename",
1262 if (py_fn
!= Py_None
)
1264 char *filename
= python_string_to_host_string (py_fn
);
1266 if (filename
== NULL
)
1272 make_cleanup (xfree
, filename
);
1273 TRY_CATCH (except
, RETURN_MASK_ALL
)
1275 ui_out_wrap_hint (out
, " ");
1276 ui_out_text (out
, " at ");
1277 annotate_frame_source_file ();
1278 ui_out_field_string (out
, "file", filename
);
1279 annotate_frame_source_file_end ();
1281 if (except
.reason
< 0)
1284 gdbpy_convert_exception (except
);
1294 if (PyObject_HasAttrString (filter
, "line"))
1296 PyObject
*py_line
= PyObject_CallMethod (filter
, "line", NULL
);
1299 if (py_line
!= NULL
)
1301 if (py_line
!= Py_None
)
1303 line
= PyLong_AsLong (py_line
);
1304 TRY_CATCH (except
, RETURN_MASK_ALL
)
1306 ui_out_text (out
, ":");
1307 annotate_frame_source_line ();
1308 ui_out_field_int (out
, "line", line
);
1310 if (except
.reason
< 0)
1312 Py_DECREF (py_line
);
1313 gdbpy_convert_exception (except
);
1317 Py_DECREF (py_line
);
1324 /* For MI we need to deal with the "children" list population of
1325 elided frames, so if MI output detected do not send newline. */
1326 if (! ui_out_is_mi_like_p (out
))
1328 TRY_CATCH (except
, RETURN_MASK_ALL
)
1330 annotate_frame_end ();
1331 ui_out_text (out
, "\n");
1333 if (except
.reason
< 0)
1335 gdbpy_convert_exception (except
);
1342 if (py_print_locals (filter
, out
, args_type
, indent
,
1343 frame
) == EXT_LANG_BT_ERROR
)
1347 /* Finally recursively print elided frames, if any. */
1348 elided
= get_py_iter_from_func (filter
, "elided");
1352 make_cleanup_py_decref (elided
);
1353 if (elided
!= Py_None
)
1357 make_cleanup_ui_out_list_begin_end (out
, "children");
1359 if (! ui_out_is_mi_like_p (out
))
1362 while ((item
= PyIter_Next (elided
)))
1364 enum ext_lang_bt_status success
= py_print_frame (item
, flags
,
1369 if (success
== EXT_LANG_BT_ERROR
)
1377 if (item
== NULL
&& PyErr_Occurred ())
1382 do_cleanups (cleanup_stack
);
1383 return EXT_LANG_BT_COMPLETED
;
1386 do_cleanups (cleanup_stack
);
1387 return EXT_LANG_BT_ERROR
;
1390 /* Helper function to initiate frame filter invocation at starting
1394 bootstrap_python_frame_filters (struct frame_info
*frame
,
1395 int frame_low
, int frame_high
)
1397 struct cleanup
*cleanups
=
1398 make_cleanup (null_cleanup
, NULL
);
1399 PyObject
*module
, *sort_func
, *iterable
, *frame_obj
, *iterator
;
1400 PyObject
*py_frame_low
, *py_frame_high
;
1402 frame_obj
= frame_info_to_frame_object (frame
);
1403 if (frame_obj
== NULL
)
1405 make_cleanup_py_decref (frame_obj
);
1407 module
= PyImport_ImportModule ("gdb.frames");
1410 make_cleanup_py_decref (module
);
1412 sort_func
= PyObject_GetAttrString (module
, "execute_frame_filters");
1413 if (sort_func
== NULL
)
1415 make_cleanup_py_decref (sort_func
);
1417 py_frame_low
= PyInt_FromLong (frame_low
);
1418 if (py_frame_low
== NULL
)
1420 make_cleanup_py_decref (py_frame_low
);
1422 py_frame_high
= PyInt_FromLong (frame_high
);
1423 if (py_frame_high
== NULL
)
1425 make_cleanup_py_decref (py_frame_high
);
1427 iterable
= PyObject_CallFunctionObjArgs (sort_func
, frame_obj
,
1431 if (iterable
== NULL
)
1434 do_cleanups (cleanups
);
1436 if (iterable
!= Py_None
)
1438 iterator
= PyObject_GetIter (iterable
);
1439 Py_DECREF (iterable
);
1449 do_cleanups (cleanups
);
1453 /* This is the only publicly exported function in this file. FRAME
1454 is the source frame to start frame-filter invocation. FLAGS is an
1455 integer holding the flags for printing. The following elements of
1456 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1457 PRINT_LEVEL is a flag indicating whether to print the frame's
1458 relative level in the output. PRINT_FRAME_INFO is a flag that
1459 indicates whether this function should print the frame
1460 information, PRINT_ARGS is a flag that indicates whether to print
1461 frame arguments, and PRINT_LOCALS, likewise, with frame local
1462 variables. ARGS_TYPE is an enumerator describing the argument
1463 format, OUT is the output stream to print. FRAME_LOW is the
1464 beginning of the slice of frames to print, and FRAME_HIGH is the
1465 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1466 or EXT_LANG_BT_COMPLETED on success. */
1468 enum ext_lang_bt_status
1469 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1470 struct frame_info
*frame
, int flags
,
1471 enum ext_lang_frame_args args_type
,
1472 struct ui_out
*out
, int frame_low
, int frame_high
)
1474 struct gdbarch
*gdbarch
= NULL
;
1475 struct cleanup
*cleanups
;
1476 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1478 volatile struct gdb_exception except
;
1480 htab_t levels_printed
;
1482 if (!gdb_python_initialized
)
1483 return EXT_LANG_BT_NO_FILTERS
;
1485 TRY_CATCH (except
, RETURN_MASK_ALL
)
1487 gdbarch
= get_frame_arch (frame
);
1489 if (except
.reason
< 0)
1491 /* Let gdb try to print the stack trace. */
1492 return EXT_LANG_BT_NO_FILTERS
;
1495 cleanups
= ensure_python_env (gdbarch
, current_language
);
1497 iterable
= bootstrap_python_frame_filters (frame
, frame_low
, frame_high
);
1499 if (iterable
== NULL
)
1501 /* Normally if there is an error GDB prints the exception,
1502 abandons the backtrace and exits. The user can then call "bt
1503 no-filters", and get a default backtrace (it would be
1504 confusing to automatically start a standard backtrace halfway
1505 through a Python filtered backtrace). However in the case
1506 where GDB cannot initialize the frame filters (most likely
1507 due to incorrect auto-load paths), GDB has printed nothing.
1508 In this case it is OK to print the default backtrace after
1509 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1510 here to signify there are no filters after printing the
1511 initialization error. This return code will trigger a
1512 default backtrace. */
1514 gdbpy_print_stack ();
1515 do_cleanups (cleanups
);
1516 return EXT_LANG_BT_NO_FILTERS
;
1519 /* If iterable is None, then there are no frame filters registered.
1520 If this is the case, defer to default GDB printing routines in MI
1522 make_cleanup_py_decref (iterable
);
1523 if (iterable
== Py_None
)
1525 success
= EXT_LANG_BT_NO_FILTERS
;
1529 levels_printed
= htab_create (20,
1533 make_cleanup_htab_delete (levels_printed
);
1535 while ((item
= PyIter_Next (iterable
)))
1537 success
= py_print_frame (item
, flags
, args_type
, out
, 0,
1540 /* Do not exit on error printing a single frame. Print the
1541 error and continue with other frames. */
1542 if (success
== EXT_LANG_BT_ERROR
)
1543 gdbpy_print_stack ();
1548 if (item
== NULL
&& PyErr_Occurred ())
1552 do_cleanups (cleanups
);
1555 /* Exit and abandon backtrace on error, printing the exception that
1558 gdbpy_print_stack ();
1559 do_cleanups (cleanups
);
1560 return EXT_LANG_BT_ERROR
;