1 /* Python frame filters
3 Copyright (C) 2013-2016 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"
40 /* Helper function to extract a symbol, a name and a language
41 definition from a Python object that conforms to the "Symbol Value"
42 interface. OBJ is the Python object to extract the values from.
43 NAME is a pass-through argument where the name of the symbol will
44 be written. NAME is allocated in this function, but the caller is
45 responsible for clean up. SYM is a pass-through argument where the
46 symbol will be written and SYM_BLOCK is a pass-through argument to
47 write the block where the symbol lies in. In the case of the API
48 returning a string, this will be set to NULL. LANGUAGE is also a
49 pass-through argument denoting the language attributed to the
50 Symbol. In the case of SYM being NULL, this will be set to the
51 current language. Returns EXT_LANG_BT_ERROR on error with the
52 appropriate Python exception set, and EXT_LANG_BT_OK on success. */
54 static enum ext_lang_bt_status
55 extract_sym (PyObject
*obj
, char **name
, struct symbol
**sym
,
56 struct block
**sym_block
, 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
;
83 /* This type checks 'result' during the conversion so we
84 just call it unconditionally and check the return. */
85 *sym
= symbol_object_to_symbol (result
);
86 /* TODO: currently, we have no way to recover the block in which SYMBOL
87 was found, so we have no block to return. Trying to evaluate SYMBOL
88 will yield an incorrect value when it's located in a FRAME and
89 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
= 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 PyObject
*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
)
144 return EXT_LANG_BT_OK
;
148 *value
= convert_value_from_python (vresult
);
152 return EXT_LANG_BT_ERROR
;
154 return EXT_LANG_BT_OK
;
160 return EXT_LANG_BT_OK
;
163 /* MI prints only certain values according to the type of symbol and
164 also what the user has specified. SYM is the symbol to check, and
165 MI_PRINT_TYPES is an enum specifying what the user wants emitted
166 for the MI command in question. */
168 mi_should_print (struct symbol
*sym
, enum mi_print_types type
)
172 switch (SYMBOL_CLASS (sym
))
175 case LOC_UNDEF
: /* catches errors */
176 case LOC_CONST
: /* constant */
177 case LOC_TYPEDEF
: /* local typedef */
178 case LOC_LABEL
: /* local label */
179 case LOC_BLOCK
: /* local function */
180 case LOC_CONST_BYTES
: /* loc. byte seq. */
181 case LOC_UNRESOLVED
: /* unresolved static */
182 case LOC_OPTIMIZED_OUT
: /* optimized out */
186 case LOC_ARG
: /* argument */
187 case LOC_REF_ARG
: /* reference arg */
188 case LOC_REGPARM_ADDR
: /* indirect register arg */
189 case LOC_LOCAL
: /* stack local */
190 case LOC_STATIC
: /* static */
191 case LOC_REGISTER
: /* register */
192 case LOC_COMPUTED
: /* computed location */
193 if (type
== MI_PRINT_LOCALS
)
194 print_me
= ! SYMBOL_IS_ARGUMENT (sym
);
196 print_me
= SYMBOL_IS_ARGUMENT (sym
);
201 /* Helper function which outputs a type name extracted from VAL to a
202 "type" field in the output stream OUT. OUT is the ui-out structure
203 the type name will be output too, and VAL is the value that the
204 type will be extracted from. Returns EXT_LANG_BT_ERROR on error, with
205 any GDB exceptions converted to a Python exception, or EXT_LANG_BT_OK on
208 static enum ext_lang_bt_status
209 py_print_type (struct ui_out
*out
, struct value
*val
)
215 struct cleanup
*cleanup
;
217 stb
= mem_fileopen ();
218 cleanup
= make_cleanup_ui_file_delete (stb
);
219 check_typedef (value_type (val
));
220 type_print (value_type (val
), "", stb
, -1);
221 ui_out_field_stream (out
, "type", stb
);
222 do_cleanups (cleanup
);
224 CATCH (except
, RETURN_MASK_ALL
)
226 gdbpy_convert_exception (except
);
227 return EXT_LANG_BT_ERROR
;
231 return EXT_LANG_BT_OK
;
234 /* Helper function which outputs a value to an output field in a
235 stream. OUT is the ui-out structure the value will be output to,
236 VAL is the value that will be printed, OPTS contains the value
237 printing options, ARGS_TYPE is an enumerator describing the
238 argument format, and LANGUAGE is the language_defn that the value
239 will be printed with. Returns EXT_LANG_BT_ERROR on error, with any GDB
240 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
243 static enum ext_lang_bt_status
244 py_print_value (struct ui_out
*out
, struct value
*val
,
245 const struct value_print_options
*opts
,
247 enum ext_lang_frame_args args_type
,
248 const struct language_defn
*language
)
250 int should_print
= 0;
252 /* MI does not print certain values, differentiated by type,
253 depending on what ARGS_TYPE indicates. Test type against option.
254 For CLI print all values. */
255 if (args_type
== MI_PRINT_SIMPLE_VALUES
256 || args_type
== MI_PRINT_ALL_VALUES
)
258 struct type
*type
= NULL
;
262 type
= check_typedef (value_type (val
));
264 CATCH (except
, RETURN_MASK_ALL
)
266 gdbpy_convert_exception (except
);
267 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
)
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 CATCH (except
, RETURN_MASK_ALL
)
297 gdbpy_convert_exception (except
);
298 return EXT_LANG_BT_ERROR
;
303 return EXT_LANG_BT_OK
;
306 /* Helper function to call a Python method and extract an iterator
307 from the result. If the function returns anything but an iterator
308 the exception is preserved and NULL is returned. FILTER is the
309 Python object to call, and FUNC is the name of the method. Returns
310 a PyObject, or NULL on error with the appropriate exception set.
311 This function can return an iterator, or NULL. */
314 get_py_iter_from_func (PyObject
*filter
, char *func
)
316 if (PyObject_HasAttrString (filter
, func
))
318 PyObject
*result
= PyObject_CallMethod (filter
, func
, NULL
);
322 if (result
== Py_None
)
328 PyObject
*iterator
= PyObject_GetIter (result
);
341 /* Helper function to output a single frame argument and value to an
342 output stream. This function will account for entry values if the
343 FV parameter is populated, the frame argument has entry values
344 associated with them, and the appropriate "set entry-value"
345 options are set. Will output in CLI or MI like format depending
346 on the type of output stream detected. OUT is the output stream,
347 SYM_NAME is the name of the symbol. If SYM_NAME is populated then
348 it must have an accompanying value in the parameter FV. FA is a
349 frame argument structure. If FA is populated, both SYM_NAME and
350 FV are ignored. OPTS contains the value printing options,
351 ARGS_TYPE is an enumerator describing the argument format,
352 PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
353 in MI output in commands where both arguments and locals are
354 printed. Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions
355 converted to a Python exception, or EXT_LANG_BT_OK on success. */
357 static enum ext_lang_bt_status
358 py_print_single_arg (struct ui_out
*out
,
359 const char *sym_name
,
360 struct frame_arg
*fa
,
362 const struct value_print_options
*opts
,
363 enum ext_lang_frame_args args_type
,
364 int print_args_field
,
365 const struct language_defn
*language
)
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
));
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
);
448 if (retval
!= EXT_LANG_BT_ERROR
)
451 annotate_arg_value (value_type (val
));
453 /* If the output is to the CLI, and the user option "set print
454 frame-arguments" is set to none, just output "...". */
455 if (! ui_out_is_mi_like_p (out
) && args_type
== NO_VALUES
)
456 ui_out_field_string (out
, "value", "...");
459 /* Otherwise, print the value for both MI and the CLI, except
460 for the case of MI_PRINT_NO_VALUES. */
461 if (args_type
!= NO_VALUES
)
465 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
466 ui_out_field_fmt (out
, "value",
467 _("<error reading variable: %s>"),
470 else if (py_print_value (out
, val
, opts
, 0, args_type
, language
)
471 == EXT_LANG_BT_ERROR
)
472 retval
= EXT_LANG_BT_ERROR
;
476 do_cleanups (cleanups
);
479 CATCH (except
, RETURN_MASK_ERROR
)
481 gdbpy_convert_exception (except
);
488 /* Helper function to loop over frame arguments provided by the
489 "frame_arguments" Python API. Elements in the iterator must
490 conform to the "Symbol Value" interface. ITER is the Python
491 iterable object, OUT is the output stream, ARGS_TYPE is an
492 enumerator describing the argument format, PRINT_ARGS_FIELD is a
493 flag which indicates if we output "ARGS=1" in MI output in commands
494 where both arguments and locals are printed, and FRAME is the
495 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
496 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
499 static enum ext_lang_bt_status
500 enumerate_args (PyObject
*iter
,
502 enum ext_lang_frame_args args_type
,
503 int print_args_field
,
504 struct frame_info
*frame
)
507 struct value_print_options opts
;
509 get_user_print_options (&opts
);
511 if (args_type
== CLI_SCALAR_VALUES
)
513 /* True in "summary" mode, false otherwise. */
521 annotate_frame_args ();
523 CATCH (except
, RETURN_MASK_ALL
)
525 gdbpy_convert_exception (except
);
530 /* Collect the first argument outside of the loop, so output of
531 commas in the argument output is correct. At the end of the
532 loop block collect another item from the iterator, and, if it is
533 not null emit a comma. */
534 item
= PyIter_Next (iter
);
535 if (item
== NULL
&& PyErr_Occurred ())
540 const struct language_defn
*language
;
543 struct block
*sym_block
;
545 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
547 success
= extract_sym (item
, &sym_name
, &sym
, &sym_block
, &language
);
548 if (success
== EXT_LANG_BT_ERROR
)
554 success
= extract_value (item
, &val
);
555 if (success
== EXT_LANG_BT_ERROR
)
565 if (sym
&& ui_out_is_mi_like_p (out
)
566 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
572 /* If the object did not provide a value, read it using
573 read_frame_args and account for entry values, if any. */
576 struct frame_arg arg
, entryarg
;
578 /* If there is no value, and also no symbol, set error and
582 PyErr_SetString (PyExc_RuntimeError
,
583 _("No symbol or value provided."));
590 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
592 CATCH (except
, RETURN_MASK_ALL
)
595 gdbpy_convert_exception (except
);
600 /* The object has not provided a value, so this is a frame
601 argument to be read by GDB. In this case we have to
602 account for entry-values. */
604 if (arg
.entry_kind
!= print_entry_values_only
)
606 if (py_print_single_arg (out
, NULL
, &arg
,
610 NULL
) == EXT_LANG_BT_ERROR
)
613 xfree (entryarg
.error
);
619 if (entryarg
.entry_kind
!= print_entry_values_no
)
621 if (arg
.entry_kind
!= print_entry_values_only
)
625 ui_out_text (out
, ", ");
626 ui_out_wrap_hint (out
, " ");
628 CATCH (except
, RETURN_MASK_ALL
)
631 xfree (entryarg
.error
);
633 gdbpy_convert_exception (except
);
639 if (py_print_single_arg (out
, NULL
, &entryarg
, NULL
, &opts
,
640 args_type
, print_args_field
, NULL
)
641 == EXT_LANG_BT_ERROR
)
644 xfree (entryarg
.error
);
651 xfree (entryarg
.error
);
655 /* If the object has provided a value, we just print that. */
658 if (py_print_single_arg (out
, sym_name
, NULL
, val
, &opts
,
659 args_type
, print_args_field
,
660 language
) == EXT_LANG_BT_ERROR
)
670 /* Collect the next item from the iterator. If
671 this is the last item, do not print the
673 item
= PyIter_Next (iter
);
678 ui_out_text (out
, ", ");
680 CATCH (except
, RETURN_MASK_ALL
)
683 gdbpy_convert_exception (except
);
688 else if (PyErr_Occurred ())
695 CATCH (except
, RETURN_MASK_ALL
)
698 gdbpy_convert_exception (except
);
704 return EXT_LANG_BT_OK
;
707 return EXT_LANG_BT_ERROR
;
711 /* Helper function to loop over variables provided by the
712 "frame_locals" Python API. Elements in the iterable must conform
713 to the "Symbol Value" interface. ITER is the Python iterable
714 object, OUT is the output stream, INDENT is whether we should
715 indent the output (for CLI), ARGS_TYPE is an enumerator describing
716 the argument format, PRINT_ARGS_FIELD is flag which indicates
717 whether to output the ARGS field in the case of
718 -stack-list-variables and FRAME is the backing frame. Returns
719 EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
720 exception, or EXT_LANG_BT_OK on success. */
722 static enum ext_lang_bt_status
723 enumerate_locals (PyObject
*iter
,
726 enum ext_lang_frame_args args_type
,
727 int print_args_field
,
728 struct frame_info
*frame
)
731 struct value_print_options opts
;
733 get_user_print_options (&opts
);
736 while ((item
= PyIter_Next (iter
)))
738 const struct language_defn
*language
;
741 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
743 struct block
*sym_block
;
744 int local_indent
= 8 + (8 * indent
);
745 struct cleanup
*locals_cleanups
;
747 locals_cleanups
= make_cleanup_py_decref (item
);
749 success
= extract_sym (item
, &sym_name
, &sym
, &sym_block
, &language
);
750 if (success
== EXT_LANG_BT_ERROR
)
752 do_cleanups (locals_cleanups
);
756 make_cleanup (xfree
, sym_name
);
758 success
= extract_value (item
, &val
);
759 if (success
== EXT_LANG_BT_ERROR
)
761 do_cleanups (locals_cleanups
);
765 if (sym
!= NULL
&& ui_out_is_mi_like_p (out
)
766 && ! mi_should_print (sym
, MI_PRINT_LOCALS
))
768 do_cleanups (locals_cleanups
);
772 /* If the object did not provide a value, read it. */
777 val
= read_var_value (sym
, sym_block
, frame
);
779 CATCH (except
, RETURN_MASK_ERROR
)
781 gdbpy_convert_exception (except
);
782 do_cleanups (locals_cleanups
);
788 /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
789 each output contains only one field. The exception is
790 -stack-list-variables, which always provides a tuple. */
791 if (ui_out_is_mi_like_p (out
))
793 if (print_args_field
|| args_type
!= NO_VALUES
)
794 make_cleanup_ui_out_tuple_begin_end (out
, NULL
);
798 if (! ui_out_is_mi_like_p (out
))
800 /* If the output is not MI we indent locals. */
801 ui_out_spaces (out
, local_indent
);
804 ui_out_field_string (out
, "name", sym_name
);
806 if (! ui_out_is_mi_like_p (out
))
807 ui_out_text (out
, " = ");
809 CATCH (except
, RETURN_MASK_ERROR
)
811 gdbpy_convert_exception (except
);
812 do_cleanups (locals_cleanups
);
817 if (args_type
== MI_PRINT_SIMPLE_VALUES
)
819 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
821 do_cleanups (locals_cleanups
);
826 /* CLI always prints values for locals. MI uses the
827 simple/no/all system. */
828 if (! ui_out_is_mi_like_p (out
))
830 int val_indent
= (indent
+ 1) * 4;
832 if (py_print_value (out
, val
, &opts
, val_indent
, args_type
,
833 language
) == EXT_LANG_BT_ERROR
)
835 do_cleanups (locals_cleanups
);
841 if (args_type
!= NO_VALUES
)
843 if (py_print_value (out
, val
, &opts
, 0, args_type
,
844 language
) == EXT_LANG_BT_ERROR
)
846 do_cleanups (locals_cleanups
);
852 do_cleanups (locals_cleanups
);
856 ui_out_text (out
, "\n");
858 CATCH (except
, RETURN_MASK_ERROR
)
860 gdbpy_convert_exception (except
);
866 if (item
== NULL
&& PyErr_Occurred ())
869 return EXT_LANG_BT_OK
;
872 return EXT_LANG_BT_ERROR
;
875 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
876 error, or EXT_LANG_BT_OK on success. */
878 static enum ext_lang_bt_status
879 py_mi_print_variables (PyObject
*filter
, struct ui_out
*out
,
880 struct value_print_options
*opts
,
881 enum ext_lang_frame_args args_type
,
882 struct frame_info
*frame
)
884 struct cleanup
*old_chain
;
886 PyObject
*locals_iter
;
888 args_iter
= get_py_iter_from_func (filter
, "frame_args");
889 old_chain
= make_cleanup_py_xdecref (args_iter
);
890 if (args_iter
== NULL
)
893 locals_iter
= get_py_iter_from_func (filter
, "frame_locals");
894 if (locals_iter
== NULL
)
897 make_cleanup_py_decref (locals_iter
);
898 make_cleanup_ui_out_list_begin_end (out
, "variables");
900 if (args_iter
!= Py_None
)
901 if (enumerate_args (args_iter
, out
, args_type
, 1, frame
)
902 == EXT_LANG_BT_ERROR
)
905 if (locals_iter
!= Py_None
)
906 if (enumerate_locals (locals_iter
, out
, 1, args_type
, 1, frame
)
907 == EXT_LANG_BT_ERROR
)
910 do_cleanups (old_chain
);
911 return EXT_LANG_BT_OK
;
914 do_cleanups (old_chain
);
915 return EXT_LANG_BT_ERROR
;
918 /* Helper function for printing locals. This function largely just
919 creates the wrapping tuple, and calls enumerate_locals. Returns
920 EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
922 static enum ext_lang_bt_status
923 py_print_locals (PyObject
*filter
,
925 enum ext_lang_frame_args args_type
,
927 struct frame_info
*frame
)
929 PyObject
*locals_iter
= get_py_iter_from_func (filter
,
931 struct cleanup
*old_chain
= make_cleanup_py_xdecref (locals_iter
);
933 if (locals_iter
== NULL
)
936 make_cleanup_ui_out_list_begin_end (out
, "locals");
938 if (locals_iter
!= Py_None
)
939 if (enumerate_locals (locals_iter
, out
, indent
, args_type
,
940 0, frame
) == EXT_LANG_BT_ERROR
)
943 do_cleanups (old_chain
);
944 return EXT_LANG_BT_OK
;
947 do_cleanups (old_chain
);
948 return EXT_LANG_BT_ERROR
;
951 /* Helper function for printing frame arguments. This function
952 largely just creates the wrapping tuple, and calls enumerate_args.
953 Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
954 a Python exception, or EXT_LANG_BT_OK on success. */
956 static enum ext_lang_bt_status
957 py_print_args (PyObject
*filter
,
959 enum ext_lang_frame_args args_type
,
960 struct frame_info
*frame
)
962 PyObject
*args_iter
= get_py_iter_from_func (filter
, "frame_args");
963 struct cleanup
*old_chain
= make_cleanup_py_xdecref (args_iter
);
965 if (args_iter
== NULL
)
968 make_cleanup_ui_out_list_begin_end (out
, "args");
972 annotate_frame_args ();
973 if (! ui_out_is_mi_like_p (out
))
974 ui_out_text (out
, " (");
976 CATCH (except
, RETURN_MASK_ALL
)
978 gdbpy_convert_exception (except
);
983 if (args_iter
!= Py_None
)
984 if (enumerate_args (args_iter
, out
, args_type
, 0, frame
)
985 == EXT_LANG_BT_ERROR
)
990 if (! ui_out_is_mi_like_p (out
))
991 ui_out_text (out
, ")");
993 CATCH (except
, RETURN_MASK_ALL
)
995 gdbpy_convert_exception (except
);
1000 do_cleanups (old_chain
);
1001 return EXT_LANG_BT_OK
;
1004 do_cleanups (old_chain
);
1005 return EXT_LANG_BT_ERROR
;
1008 /* Print a single frame to the designated output stream, detecting
1009 whether the output is MI or console, and formatting the output
1010 according to the conventions of that protocol. FILTER is the
1011 frame-filter associated with this frame. FLAGS is an integer
1012 describing the various print options. The FLAGS variables is
1013 described in "apply_frame_filter" function. ARGS_TYPE is an
1014 enumerator describing the argument format. OUT is the output
1015 stream to print, INDENT is the level of indention for this frame
1016 (in the case of elided frames), and LEVELS_PRINTED is a hash-table
1017 containing all the frames level that have already been printed.
1018 If a frame level has been printed, do not print it again (in the
1019 case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
1020 GDB exceptions converted to a Python exception, or EXT_LANG_BT_COMPLETED
1021 on success. It can also throw an exception RETURN_QUIT. */
1023 static enum ext_lang_bt_status
1024 py_print_frame (PyObject
*filter
, int flags
,
1025 enum ext_lang_frame_args args_type
,
1026 struct ui_out
*out
, int indent
, htab_t levels_printed
)
1029 CORE_ADDR address
= 0;
1030 struct gdbarch
*gdbarch
= NULL
;
1031 struct frame_info
*frame
= NULL
;
1032 struct cleanup
*cleanup_stack
;
1033 struct value_print_options opts
;
1034 PyObject
*py_inf_frame
;
1035 int print_level
, print_frame_info
, print_args
, print_locals
;
1037 /* Extract print settings from FLAGS. */
1038 print_level
= (flags
& PRINT_LEVEL
) ? 1 : 0;
1039 print_frame_info
= (flags
& PRINT_FRAME_INFO
) ? 1 : 0;
1040 print_args
= (flags
& PRINT_ARGS
) ? 1 : 0;
1041 print_locals
= (flags
& PRINT_LOCALS
) ? 1 : 0;
1043 get_user_print_options (&opts
);
1045 /* Get the underlying frame. This is needed to determine GDB
1046 architecture, and also, in the cases of frame variables/arguments to
1047 read them if they returned filter object requires us to do so. */
1048 py_inf_frame
= PyObject_CallMethod (filter
, "inferior_frame", NULL
);
1049 if (py_inf_frame
== NULL
)
1050 return EXT_LANG_BT_ERROR
;
1052 frame
= frame_object_to_frame_info (py_inf_frame
);;
1054 Py_DECREF (py_inf_frame
);
1057 return EXT_LANG_BT_ERROR
;
1061 gdbarch
= get_frame_arch (frame
);
1063 CATCH (except
, RETURN_MASK_ERROR
)
1065 gdbpy_convert_exception (except
);
1066 return EXT_LANG_BT_ERROR
;
1070 /* stack-list-variables. */
1071 if (print_locals
&& print_args
&& ! print_frame_info
)
1073 if (py_mi_print_variables (filter
, out
, &opts
,
1074 args_type
, frame
) == EXT_LANG_BT_ERROR
)
1075 return EXT_LANG_BT_ERROR
;
1076 return EXT_LANG_BT_COMPLETED
;
1079 cleanup_stack
= make_cleanup (null_cleanup
, NULL
);
1081 /* -stack-list-locals does not require a
1082 wrapping frame attribute. */
1083 if (print_frame_info
|| (print_args
&& ! print_locals
))
1084 make_cleanup_ui_out_tuple_begin_end (out
, "frame");
1086 if (print_frame_info
)
1088 /* Elided frames are also printed with this function (recursively)
1089 and are printed with indention. */
1094 ui_out_spaces (out
, indent
*4);
1096 CATCH (except
, RETURN_MASK_ERROR
)
1098 gdbpy_convert_exception (except
);
1099 do_cleanups (cleanup_stack
);
1100 return EXT_LANG_BT_ERROR
;
1105 /* The address is required for frame annotations, and also for
1106 address printing. */
1107 if (PyObject_HasAttrString (filter
, "address"))
1109 PyObject
*paddr
= PyObject_CallMethod (filter
, "address", NULL
);
1113 do_cleanups (cleanup_stack
);
1114 return EXT_LANG_BT_ERROR
;
1117 if (paddr
!= Py_None
)
1119 address
= PyLong_AsLong (paddr
);
1126 /* Print frame level. MI does not require the level if
1127 locals/variables only are being printed. */
1128 if ((print_frame_info
|| print_args
) && print_level
)
1130 struct frame_info
**slot
;
1133 slot
= (struct frame_info
**) htab_find_slot (levels_printed
,
1137 level
= frame_relative_level (frame
);
1139 /* Check if this frame has already been printed (there are cases
1140 where elided synthetic dummy-frames have to 'borrow' the frame
1141 architecture from the eliding frame. If that is the case, do
1142 not print 'level', but print spaces. */
1144 ui_out_field_skip (out
, "level");
1148 annotate_frame_begin (print_level
? level
: 0,
1150 ui_out_text (out
, "#");
1151 ui_out_field_fmt_int (out
, 2, ui_left
, "level",
1155 CATCH (except
, RETURN_MASK_ERROR
)
1157 gdbpy_convert_exception (except
);
1158 do_cleanups (cleanup_stack
);
1159 return EXT_LANG_BT_ERROR
;
1164 if (print_frame_info
)
1166 /* Print address to the address field. If an address is not provided,
1168 if (opts
.addressprint
&& has_addr
)
1172 annotate_frame_address ();
1173 ui_out_field_core_addr (out
, "addr", gdbarch
, address
);
1174 annotate_frame_address_end ();
1175 ui_out_text (out
, " in ");
1177 CATCH (except
, RETURN_MASK_ERROR
)
1179 gdbpy_convert_exception (except
);
1180 do_cleanups (cleanup_stack
);
1181 return EXT_LANG_BT_ERROR
;
1186 /* Print frame function name. */
1187 if (PyObject_HasAttrString (filter
, "function"))
1189 PyObject
*py_func
= PyObject_CallMethod (filter
, "function", NULL
);
1190 struct cleanup
*py_func_cleanup
;
1191 const char *function
= NULL
;
1193 if (py_func
== NULL
)
1195 do_cleanups (cleanup_stack
);
1196 return EXT_LANG_BT_ERROR
;
1198 py_func_cleanup
= make_cleanup_py_decref (py_func
);
1200 if (gdbpy_is_string (py_func
))
1202 char *function_to_free
;
1204 function
= function_to_free
=
1205 python_string_to_host_string (py_func
);
1207 if (function
== NULL
)
1209 do_cleanups (cleanup_stack
);
1210 return EXT_LANG_BT_ERROR
;
1212 make_cleanup (xfree
, function_to_free
);
1214 else if (PyLong_Check (py_func
))
1216 CORE_ADDR addr
= PyLong_AsUnsignedLongLong (py_func
);
1217 struct bound_minimal_symbol msymbol
;
1219 if (PyErr_Occurred ())
1221 do_cleanups (cleanup_stack
);
1222 return EXT_LANG_BT_ERROR
;
1225 msymbol
= lookup_minimal_symbol_by_pc (addr
);
1226 if (msymbol
.minsym
!= NULL
)
1227 function
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1229 else if (py_func
!= Py_None
)
1231 PyErr_SetString (PyExc_RuntimeError
,
1232 _("FrameDecorator.function: expecting a " \
1233 "String, integer or None."));
1234 do_cleanups (cleanup_stack
);
1235 return EXT_LANG_BT_ERROR
;
1240 annotate_frame_function_name ();
1241 if (function
== NULL
)
1242 ui_out_field_skip (out
, "func");
1244 ui_out_field_string (out
, "func", function
);
1246 CATCH (except
, RETURN_MASK_ERROR
)
1248 gdbpy_convert_exception (except
);
1249 do_cleanups (cleanup_stack
);
1250 return EXT_LANG_BT_ERROR
;
1254 do_cleanups (py_func_cleanup
);
1259 /* Frame arguments. Check the result, and error if something went
1263 if (py_print_args (filter
, out
, args_type
, frame
) == EXT_LANG_BT_ERROR
)
1265 do_cleanups (cleanup_stack
);
1266 return EXT_LANG_BT_ERROR
;
1270 /* File name/source/line number information. */
1271 if (print_frame_info
)
1275 annotate_frame_source_begin ();
1277 CATCH (except
, RETURN_MASK_ERROR
)
1279 gdbpy_convert_exception (except
);
1280 do_cleanups (cleanup_stack
);
1281 return EXT_LANG_BT_ERROR
;
1285 if (PyObject_HasAttrString (filter
, "filename"))
1287 PyObject
*py_fn
= PyObject_CallMethod (filter
, "filename", NULL
);
1288 struct cleanup
*py_fn_cleanup
;
1292 do_cleanups (cleanup_stack
);
1293 return EXT_LANG_BT_ERROR
;
1295 py_fn_cleanup
= make_cleanup_py_decref (py_fn
);
1297 if (py_fn
!= Py_None
)
1299 char *filename
= python_string_to_host_string (py_fn
);
1301 if (filename
== NULL
)
1303 do_cleanups (cleanup_stack
);
1304 return EXT_LANG_BT_ERROR
;
1307 make_cleanup (xfree
, filename
);
1310 ui_out_wrap_hint (out
, " ");
1311 ui_out_text (out
, " at ");
1312 annotate_frame_source_file ();
1313 ui_out_field_string (out
, "file", filename
);
1314 annotate_frame_source_file_end ();
1316 CATCH (except
, RETURN_MASK_ERROR
)
1318 gdbpy_convert_exception (except
);
1319 do_cleanups (cleanup_stack
);
1320 return EXT_LANG_BT_ERROR
;
1324 do_cleanups (py_fn_cleanup
);
1327 if (PyObject_HasAttrString (filter
, "line"))
1329 PyObject
*py_line
= PyObject_CallMethod (filter
, "line", NULL
);
1330 struct cleanup
*py_line_cleanup
;
1333 if (py_line
== NULL
)
1335 do_cleanups (cleanup_stack
);
1336 return EXT_LANG_BT_ERROR
;
1338 py_line_cleanup
= make_cleanup_py_decref (py_line
);
1340 if (py_line
!= Py_None
)
1342 line
= PyLong_AsLong (py_line
);
1345 ui_out_text (out
, ":");
1346 annotate_frame_source_line ();
1347 ui_out_field_int (out
, "line", line
);
1349 CATCH (except
, RETURN_MASK_ERROR
)
1351 gdbpy_convert_exception (except
);
1352 do_cleanups (cleanup_stack
);
1353 return EXT_LANG_BT_ERROR
;
1357 do_cleanups (py_line_cleanup
);
1361 /* For MI we need to deal with the "children" list population of
1362 elided frames, so if MI output detected do not send newline. */
1363 if (! ui_out_is_mi_like_p (out
))
1367 annotate_frame_end ();
1368 ui_out_text (out
, "\n");
1370 CATCH (except
, RETURN_MASK_ERROR
)
1372 gdbpy_convert_exception (except
);
1373 do_cleanups (cleanup_stack
);
1374 return EXT_LANG_BT_ERROR
;
1381 if (py_print_locals (filter
, out
, args_type
, indent
,
1382 frame
) == EXT_LANG_BT_ERROR
)
1384 do_cleanups (cleanup_stack
);
1385 return EXT_LANG_BT_ERROR
;
1391 struct cleanup
*elided_cleanup
;
1393 /* Finally recursively print elided frames, if any. */
1394 elided
= get_py_iter_from_func (filter
, "elided");
1397 do_cleanups (cleanup_stack
);
1398 return EXT_LANG_BT_ERROR
;
1400 elided_cleanup
= make_cleanup_py_decref (elided
);
1402 if (elided
!= Py_None
)
1406 make_cleanup_ui_out_list_begin_end (out
, "children");
1408 if (! ui_out_is_mi_like_p (out
))
1411 while ((item
= PyIter_Next (elided
)))
1413 struct cleanup
*item_cleanup
= make_cleanup_py_decref (item
);
1415 enum ext_lang_bt_status success
= py_print_frame (item
, flags
,
1420 do_cleanups (item_cleanup
);
1422 if (success
== EXT_LANG_BT_ERROR
)
1424 do_cleanups (cleanup_stack
);
1425 return EXT_LANG_BT_ERROR
;
1428 if (item
== NULL
&& PyErr_Occurred ())
1430 do_cleanups (cleanup_stack
);
1431 return EXT_LANG_BT_ERROR
;
1434 do_cleanups (elided_cleanup
);
1437 do_cleanups (cleanup_stack
);
1438 return EXT_LANG_BT_COMPLETED
;
1441 /* Helper function to initiate frame filter invocation at starting
1445 bootstrap_python_frame_filters (struct frame_info
*frame
,
1446 int frame_low
, int frame_high
)
1448 struct cleanup
*cleanups
=
1449 make_cleanup (null_cleanup
, NULL
);
1450 PyObject
*module
, *sort_func
, *iterable
, *frame_obj
, *iterator
;
1451 PyObject
*py_frame_low
, *py_frame_high
;
1453 frame_obj
= frame_info_to_frame_object (frame
);
1454 if (frame_obj
== NULL
)
1456 make_cleanup_py_decref (frame_obj
);
1458 module
= PyImport_ImportModule ("gdb.frames");
1461 make_cleanup_py_decref (module
);
1463 sort_func
= PyObject_GetAttrString (module
, "execute_frame_filters");
1464 if (sort_func
== NULL
)
1466 make_cleanup_py_decref (sort_func
);
1468 py_frame_low
= PyInt_FromLong (frame_low
);
1469 if (py_frame_low
== NULL
)
1471 make_cleanup_py_decref (py_frame_low
);
1473 py_frame_high
= PyInt_FromLong (frame_high
);
1474 if (py_frame_high
== NULL
)
1476 make_cleanup_py_decref (py_frame_high
);
1478 iterable
= PyObject_CallFunctionObjArgs (sort_func
, frame_obj
,
1482 if (iterable
== NULL
)
1485 do_cleanups (cleanups
);
1487 if (iterable
!= Py_None
)
1489 iterator
= PyObject_GetIter (iterable
);
1490 Py_DECREF (iterable
);
1500 do_cleanups (cleanups
);
1504 /* This is the only publicly exported function in this file. FRAME
1505 is the source frame to start frame-filter invocation. FLAGS is an
1506 integer holding the flags for printing. The following elements of
1507 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1508 PRINT_LEVEL is a flag indicating whether to print the frame's
1509 relative level in the output. PRINT_FRAME_INFO is a flag that
1510 indicates whether this function should print the frame
1511 information, PRINT_ARGS is a flag that indicates whether to print
1512 frame arguments, and PRINT_LOCALS, likewise, with frame local
1513 variables. ARGS_TYPE is an enumerator describing the argument
1514 format, OUT is the output stream to print. FRAME_LOW is the
1515 beginning of the slice of frames to print, and FRAME_HIGH is the
1516 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1517 or EXT_LANG_BT_COMPLETED on success. */
1519 enum ext_lang_bt_status
1520 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1521 struct frame_info
*frame
, int flags
,
1522 enum ext_lang_frame_args args_type
,
1523 struct ui_out
*out
, int frame_low
, int frame_high
)
1525 struct gdbarch
*gdbarch
= NULL
;
1526 struct cleanup
*cleanups
;
1527 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1530 htab_t levels_printed
;
1532 if (!gdb_python_initialized
)
1533 return EXT_LANG_BT_NO_FILTERS
;
1537 gdbarch
= get_frame_arch (frame
);
1539 CATCH (except
, RETURN_MASK_ALL
)
1541 /* Let gdb try to print the stack trace. */
1542 return EXT_LANG_BT_NO_FILTERS
;
1546 cleanups
= ensure_python_env (gdbarch
, current_language
);
1548 iterable
= bootstrap_python_frame_filters (frame
, frame_low
, frame_high
);
1550 if (iterable
== NULL
)
1552 /* Normally if there is an error GDB prints the exception,
1553 abandons the backtrace and exits. The user can then call "bt
1554 no-filters", and get a default backtrace (it would be
1555 confusing to automatically start a standard backtrace halfway
1556 through a Python filtered backtrace). However in the case
1557 where GDB cannot initialize the frame filters (most likely
1558 due to incorrect auto-load paths), GDB has printed nothing.
1559 In this case it is OK to print the default backtrace after
1560 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1561 here to signify there are no filters after printing the
1562 initialization error. This return code will trigger a
1563 default backtrace. */
1565 gdbpy_print_stack ();
1566 do_cleanups (cleanups
);
1567 return EXT_LANG_BT_NO_FILTERS
;
1570 /* If iterable is None, then there are no frame filters registered.
1571 If this is the case, defer to default GDB printing routines in MI
1573 make_cleanup_py_decref (iterable
);
1574 if (iterable
== Py_None
)
1576 success
= EXT_LANG_BT_NO_FILTERS
;
1580 levels_printed
= htab_create (20,
1584 make_cleanup_htab_delete (levels_printed
);
1586 while ((item
= PyIter_Next (iterable
)))
1588 struct cleanup
*item_cleanup
= make_cleanup_py_decref (item
);
1590 success
= py_print_frame (item
, flags
, args_type
, out
, 0,
1593 do_cleanups (item_cleanup
);
1595 /* Do not exit on error printing a single frame. Print the
1596 error and continue with other frames. */
1597 if (success
== EXT_LANG_BT_ERROR
)
1598 gdbpy_print_stack ();
1601 if (item
== NULL
&& PyErr_Occurred ())
1605 do_cleanups (cleanups
);
1608 /* Exit and abandon backtrace on error, printing the exception that
1611 gdbpy_print_stack ();
1612 do_cleanups (cleanups
);
1613 return EXT_LANG_BT_ERROR
;