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
)
216 struct cleanup
*cleanup
;
218 stb
= mem_fileopen ();
219 cleanup
= make_cleanup_ui_file_delete (stb
);
220 type
= check_typedef (value_type (val
));
221 type_print (value_type (val
), "", stb
, -1);
222 ui_out_field_stream (out
, "type", stb
);
223 do_cleanups (cleanup
);
225 CATCH (except
, RETURN_MASK_ALL
)
227 gdbpy_convert_exception (except
);
228 return EXT_LANG_BT_ERROR
;
232 return EXT_LANG_BT_OK
;
235 /* Helper function which outputs a value to an output field in a
236 stream. OUT is the ui-out structure the value will be output to,
237 VAL is the value that will be printed, OPTS contains the value
238 printing options, ARGS_TYPE is an enumerator describing the
239 argument format, and LANGUAGE is the language_defn that the value
240 will be printed with. Returns EXT_LANG_BT_ERROR on error, with any GDB
241 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
244 static enum ext_lang_bt_status
245 py_print_value (struct ui_out
*out
, struct value
*val
,
246 const struct value_print_options
*opts
,
248 enum ext_lang_frame_args args_type
,
249 const struct language_defn
*language
)
251 int should_print
= 0;
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
;
263 type
= check_typedef (value_type (val
));
265 CATCH (except
, RETURN_MASK_ALL
)
267 gdbpy_convert_exception (except
);
268 return EXT_LANG_BT_ERROR
;
272 if (args_type
== MI_PRINT_ALL_VALUES
)
274 else if (args_type
== MI_PRINT_SIMPLE_VALUES
275 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
276 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
277 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
280 else if (args_type
!= NO_VALUES
)
288 struct cleanup
*cleanup
;
290 stb
= mem_fileopen ();
291 cleanup
= make_cleanup_ui_file_delete (stb
);
292 common_val_print (val
, stb
, indent
, opts
, language
);
293 ui_out_field_stream (out
, "value", stb
);
294 do_cleanups (cleanup
);
296 CATCH (except
, RETURN_MASK_ALL
)
298 gdbpy_convert_exception (except
);
299 return EXT_LANG_BT_ERROR
;
304 return EXT_LANG_BT_OK
;
307 /* Helper function to call a Python method and extract an iterator
308 from the result. If the function returns anything but an iterator
309 the exception is preserved and NULL is returned. FILTER is the
310 Python object to call, and FUNC is the name of the method. Returns
311 a PyObject, or NULL on error with the appropriate exception set.
312 This function can return an iterator, or NULL. */
315 get_py_iter_from_func (PyObject
*filter
, char *func
)
317 if (PyObject_HasAttrString (filter
, func
))
319 PyObject
*result
= PyObject_CallMethod (filter
, func
, NULL
);
323 if (result
== Py_None
)
329 PyObject
*iterator
= PyObject_GetIter (result
);
342 /* Helper function to output a single frame argument and value to an
343 output stream. This function will account for entry values if the
344 FV parameter is populated, the frame argument has entry values
345 associated with them, and the appropriate "set entry-value"
346 options are set. Will output in CLI or MI like format depending
347 on the type of output stream detected. OUT is the output stream,
348 SYM_NAME is the name of the symbol. If SYM_NAME is populated then
349 it must have an accompanying value in the parameter FV. FA is a
350 frame argument structure. If FA is populated, both SYM_NAME and
351 FV are ignored. OPTS contains the value printing options,
352 ARGS_TYPE is an enumerator describing the argument format,
353 PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
354 in MI output in commands where both arguments and locals are
355 printed. Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions
356 converted to a Python exception, or EXT_LANG_BT_OK on success. */
358 static enum ext_lang_bt_status
359 py_print_single_arg (struct ui_out
*out
,
360 const char *sym_name
,
361 struct frame_arg
*fa
,
363 const struct value_print_options
*opts
,
364 enum ext_lang_frame_args args_type
,
365 int print_args_field
,
366 const struct language_defn
*language
)
369 enum ext_lang_bt_status retval
= EXT_LANG_BT_OK
;
373 if (fa
->val
== NULL
&& fa
->error
== NULL
)
374 return EXT_LANG_BT_OK
;
375 language
= language_def (SYMBOL_LANGUAGE (fa
->sym
));
383 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
385 /* MI has varying rules for tuples, but generally if there is only
386 one element in each item in the list, do not start a tuple. The
387 exception is -stack-list-variables which emits an ARGS="1" field
388 if the value is a frame argument. This is denoted in this
389 function with PRINT_ARGS_FIELD which is flag from the caller to
390 emit the ARGS field. */
391 if (ui_out_is_mi_like_p (out
))
393 if (print_args_field
|| args_type
!= NO_VALUES
)
394 make_cleanup_ui_out_tuple_begin_end (out
, NULL
);
397 annotate_arg_begin ();
399 /* If frame argument is populated, check for entry-values and the
400 entry value options. */
405 stb
= mem_fileopen ();
406 make_cleanup_ui_file_delete (stb
);
407 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (fa
->sym
),
408 SYMBOL_LANGUAGE (fa
->sym
),
409 DMGL_PARAMS
| DMGL_ANSI
);
410 if (fa
->entry_kind
== print_entry_values_compact
)
412 fputs_filtered ("=", stb
);
414 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (fa
->sym
),
415 SYMBOL_LANGUAGE (fa
->sym
),
416 DMGL_PARAMS
| DMGL_ANSI
);
418 if (fa
->entry_kind
== print_entry_values_only
419 || fa
->entry_kind
== print_entry_values_compact
)
421 fputs_filtered ("@entry", stb
);
423 ui_out_field_stream (out
, "name", stb
);
426 /* Otherwise, just output the name. */
427 ui_out_field_string (out
, "name", sym_name
);
429 annotate_arg_name_end ();
431 if (! ui_out_is_mi_like_p (out
))
432 ui_out_text (out
, "=");
434 if (print_args_field
)
435 ui_out_field_int (out
, "arg", 1);
437 /* For MI print the type, but only for simple values. This seems
438 weird, but this is how MI choose to format the various output
440 if (args_type
== MI_PRINT_SIMPLE_VALUES
&& val
!= NULL
)
442 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
444 retval
= EXT_LANG_BT_ERROR
;
445 do_cleanups (cleanups
);
449 if (retval
!= EXT_LANG_BT_ERROR
)
452 annotate_arg_value (value_type (val
));
454 /* If the output is to the CLI, and the user option "set print
455 frame-arguments" is set to none, just output "...". */
456 if (! ui_out_is_mi_like_p (out
) && args_type
== NO_VALUES
)
457 ui_out_field_string (out
, "value", "...");
460 /* Otherwise, print the value for both MI and the CLI, except
461 for the case of MI_PRINT_NO_VALUES. */
462 if (args_type
!= NO_VALUES
)
466 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
467 ui_out_field_fmt (out
, "value",
468 _("<error reading variable: %s>"),
471 else if (py_print_value (out
, val
, opts
, 0, args_type
, language
)
472 == EXT_LANG_BT_ERROR
)
473 retval
= EXT_LANG_BT_ERROR
;
477 do_cleanups (cleanups
);
480 CATCH (except
, RETURN_MASK_ERROR
)
482 gdbpy_convert_exception (except
);
489 /* Helper function to loop over frame arguments provided by the
490 "frame_arguments" Python API. Elements in the iterator must
491 conform to the "Symbol Value" interface. ITER is the Python
492 iterable object, OUT is the output stream, ARGS_TYPE is an
493 enumerator describing the argument format, PRINT_ARGS_FIELD is a
494 flag which indicates if we output "ARGS=1" in MI output in commands
495 where both arguments and locals are printed, and FRAME is the
496 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
497 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
500 static enum ext_lang_bt_status
501 enumerate_args (PyObject
*iter
,
503 enum ext_lang_frame_args args_type
,
504 int print_args_field
,
505 struct frame_info
*frame
)
508 struct value_print_options opts
;
510 get_user_print_options (&opts
);
512 if (args_type
== CLI_SCALAR_VALUES
)
514 /* True in "summary" mode, false otherwise. */
522 annotate_frame_args ();
524 CATCH (except
, RETURN_MASK_ALL
)
526 gdbpy_convert_exception (except
);
531 /* Collect the first argument outside of the loop, so output of
532 commas in the argument output is correct. At the end of the
533 loop block collect another item from the iterator, and, if it is
534 not null emit a comma. */
535 item
= PyIter_Next (iter
);
536 if (item
== NULL
&& PyErr_Occurred ())
541 const struct language_defn
*language
;
544 struct block
*sym_block
;
546 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
548 success
= extract_sym (item
, &sym_name
, &sym
, &sym_block
, &language
);
549 if (success
== EXT_LANG_BT_ERROR
)
555 success
= extract_value (item
, &val
);
556 if (success
== EXT_LANG_BT_ERROR
)
566 if (sym
&& ui_out_is_mi_like_p (out
)
567 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
573 /* If the object did not provide a value, read it using
574 read_frame_args and account for entry values, if any. */
577 struct frame_arg arg
, entryarg
;
579 /* If there is no value, and also no symbol, set error and
583 PyErr_SetString (PyExc_RuntimeError
,
584 _("No symbol or value provided."));
591 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
593 CATCH (except
, RETURN_MASK_ALL
)
596 gdbpy_convert_exception (except
);
601 /* The object has not provided a value, so this is a frame
602 argument to be read by GDB. In this case we have to
603 account for entry-values. */
605 if (arg
.entry_kind
!= print_entry_values_only
)
607 if (py_print_single_arg (out
, NULL
, &arg
,
611 NULL
) == EXT_LANG_BT_ERROR
)
614 xfree (entryarg
.error
);
620 if (entryarg
.entry_kind
!= print_entry_values_no
)
622 if (arg
.entry_kind
!= print_entry_values_only
)
626 ui_out_text (out
, ", ");
627 ui_out_wrap_hint (out
, " ");
629 CATCH (except
, RETURN_MASK_ALL
)
632 xfree (entryarg
.error
);
634 gdbpy_convert_exception (except
);
640 if (py_print_single_arg (out
, NULL
, &entryarg
, NULL
, &opts
,
641 args_type
, print_args_field
, NULL
)
642 == EXT_LANG_BT_ERROR
)
645 xfree (entryarg
.error
);
652 xfree (entryarg
.error
);
656 /* If the object has provided a value, we just print that. */
659 if (py_print_single_arg (out
, sym_name
, NULL
, val
, &opts
,
660 args_type
, print_args_field
,
661 language
) == EXT_LANG_BT_ERROR
)
671 /* Collect the next item from the iterator. If
672 this is the last item, do not print the
674 item
= PyIter_Next (iter
);
679 ui_out_text (out
, ", ");
681 CATCH (except
, RETURN_MASK_ALL
)
684 gdbpy_convert_exception (except
);
689 else if (PyErr_Occurred ())
696 CATCH (except
, RETURN_MASK_ALL
)
699 gdbpy_convert_exception (except
);
705 return EXT_LANG_BT_OK
;
708 return EXT_LANG_BT_ERROR
;
712 /* Helper function to loop over variables provided by the
713 "frame_locals" Python API. Elements in the iterable must conform
714 to the "Symbol Value" interface. ITER is the Python iterable
715 object, OUT is the output stream, INDENT is whether we should
716 indent the output (for CLI), ARGS_TYPE is an enumerator describing
717 the argument format, PRINT_ARGS_FIELD is flag which indicates
718 whether to output the ARGS field in the case of
719 -stack-list-variables and FRAME is the backing frame. Returns
720 EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
721 exception, or EXT_LANG_BT_OK on success. */
723 static enum ext_lang_bt_status
724 enumerate_locals (PyObject
*iter
,
727 enum ext_lang_frame_args args_type
,
728 int print_args_field
,
729 struct frame_info
*frame
)
732 struct value_print_options opts
;
734 get_user_print_options (&opts
);
737 while ((item
= PyIter_Next (iter
)))
739 const struct language_defn
*language
;
742 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
744 struct block
*sym_block
;
745 int local_indent
= 8 + (8 * indent
);
746 struct cleanup
*locals_cleanups
;
748 locals_cleanups
= make_cleanup_py_decref (item
);
750 success
= extract_sym (item
, &sym_name
, &sym
, &sym_block
, &language
);
751 if (success
== EXT_LANG_BT_ERROR
)
753 do_cleanups (locals_cleanups
);
757 make_cleanup (xfree
, sym_name
);
759 success
= extract_value (item
, &val
);
760 if (success
== EXT_LANG_BT_ERROR
)
762 do_cleanups (locals_cleanups
);
766 if (sym
!= NULL
&& ui_out_is_mi_like_p (out
)
767 && ! mi_should_print (sym
, MI_PRINT_LOCALS
))
769 do_cleanups (locals_cleanups
);
773 /* If the object did not provide a value, read it. */
778 val
= read_var_value (sym
, sym_block
, frame
);
780 CATCH (except
, RETURN_MASK_ERROR
)
782 gdbpy_convert_exception (except
);
783 do_cleanups (locals_cleanups
);
789 /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
790 each output contains only one field. The exception is
791 -stack-list-variables, which always provides a tuple. */
792 if (ui_out_is_mi_like_p (out
))
794 if (print_args_field
|| args_type
!= NO_VALUES
)
795 make_cleanup_ui_out_tuple_begin_end (out
, NULL
);
799 if (! ui_out_is_mi_like_p (out
))
801 /* If the output is not MI we indent locals. */
802 ui_out_spaces (out
, local_indent
);
805 ui_out_field_string (out
, "name", sym_name
);
807 if (! ui_out_is_mi_like_p (out
))
808 ui_out_text (out
, " = ");
810 CATCH (except
, RETURN_MASK_ERROR
)
812 gdbpy_convert_exception (except
);
813 do_cleanups (locals_cleanups
);
818 if (args_type
== MI_PRINT_SIMPLE_VALUES
)
820 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
822 do_cleanups (locals_cleanups
);
827 /* CLI always prints values for locals. MI uses the
828 simple/no/all system. */
829 if (! ui_out_is_mi_like_p (out
))
831 int val_indent
= (indent
+ 1) * 4;
833 if (py_print_value (out
, val
, &opts
, val_indent
, args_type
,
834 language
) == EXT_LANG_BT_ERROR
)
836 do_cleanups (locals_cleanups
);
842 if (args_type
!= NO_VALUES
)
844 if (py_print_value (out
, val
, &opts
, 0, args_type
,
845 language
) == EXT_LANG_BT_ERROR
)
847 do_cleanups (locals_cleanups
);
853 do_cleanups (locals_cleanups
);
857 ui_out_text (out
, "\n");
859 CATCH (except
, RETURN_MASK_ERROR
)
861 gdbpy_convert_exception (except
);
867 if (item
== NULL
&& PyErr_Occurred ())
870 return EXT_LANG_BT_OK
;
873 return EXT_LANG_BT_ERROR
;
876 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
877 error, or EXT_LANG_BT_OK on success. */
879 static enum ext_lang_bt_status
880 py_mi_print_variables (PyObject
*filter
, struct ui_out
*out
,
881 struct value_print_options
*opts
,
882 enum ext_lang_frame_args args_type
,
883 struct frame_info
*frame
)
885 struct cleanup
*old_chain
;
887 PyObject
*locals_iter
;
889 args_iter
= get_py_iter_from_func (filter
, "frame_args");
890 old_chain
= make_cleanup_py_xdecref (args_iter
);
891 if (args_iter
== NULL
)
894 locals_iter
= get_py_iter_from_func (filter
, "frame_locals");
895 if (locals_iter
== NULL
)
898 make_cleanup_py_decref (locals_iter
);
899 make_cleanup_ui_out_list_begin_end (out
, "variables");
901 if (args_iter
!= Py_None
)
902 if (enumerate_args (args_iter
, out
, args_type
, 1, frame
)
903 == EXT_LANG_BT_ERROR
)
906 if (locals_iter
!= Py_None
)
907 if (enumerate_locals (locals_iter
, out
, 1, args_type
, 1, frame
)
908 == EXT_LANG_BT_ERROR
)
911 do_cleanups (old_chain
);
912 return EXT_LANG_BT_OK
;
915 do_cleanups (old_chain
);
916 return EXT_LANG_BT_ERROR
;
919 /* Helper function for printing locals. This function largely just
920 creates the wrapping tuple, and calls enumerate_locals. Returns
921 EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
923 static enum ext_lang_bt_status
924 py_print_locals (PyObject
*filter
,
926 enum ext_lang_frame_args args_type
,
928 struct frame_info
*frame
)
930 PyObject
*locals_iter
= get_py_iter_from_func (filter
,
932 struct cleanup
*old_chain
= make_cleanup_py_xdecref (locals_iter
);
934 if (locals_iter
== NULL
)
937 make_cleanup_ui_out_list_begin_end (out
, "locals");
939 if (locals_iter
!= Py_None
)
940 if (enumerate_locals (locals_iter
, out
, indent
, args_type
,
941 0, frame
) == EXT_LANG_BT_ERROR
)
944 do_cleanups (old_chain
);
945 return EXT_LANG_BT_OK
;
948 do_cleanups (old_chain
);
949 return EXT_LANG_BT_ERROR
;
952 /* Helper function for printing frame arguments. This function
953 largely just creates the wrapping tuple, and calls enumerate_args.
954 Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
955 a Python exception, or EXT_LANG_BT_OK on success. */
957 static enum ext_lang_bt_status
958 py_print_args (PyObject
*filter
,
960 enum ext_lang_frame_args args_type
,
961 struct frame_info
*frame
)
963 PyObject
*args_iter
= get_py_iter_from_func (filter
, "frame_args");
964 struct cleanup
*old_chain
= make_cleanup_py_xdecref (args_iter
);
966 if (args_iter
== NULL
)
969 make_cleanup_ui_out_list_begin_end (out
, "args");
973 annotate_frame_args ();
974 if (! ui_out_is_mi_like_p (out
))
975 ui_out_text (out
, " (");
977 CATCH (except
, RETURN_MASK_ALL
)
979 gdbpy_convert_exception (except
);
984 if (args_iter
!= Py_None
)
985 if (enumerate_args (args_iter
, out
, args_type
, 0, frame
)
986 == EXT_LANG_BT_ERROR
)
991 if (! ui_out_is_mi_like_p (out
))
992 ui_out_text (out
, ")");
994 CATCH (except
, RETURN_MASK_ALL
)
996 gdbpy_convert_exception (except
);
1001 do_cleanups (old_chain
);
1002 return EXT_LANG_BT_OK
;
1005 do_cleanups (old_chain
);
1006 return EXT_LANG_BT_ERROR
;
1009 /* Print a single frame to the designated output stream, detecting
1010 whether the output is MI or console, and formatting the output
1011 according to the conventions of that protocol. FILTER is the
1012 frame-filter associated with this frame. FLAGS is an integer
1013 describing the various print options. The FLAGS variables is
1014 described in "apply_frame_filter" function. ARGS_TYPE is an
1015 enumerator describing the argument format. OUT is the output
1016 stream to print, INDENT is the level of indention for this frame
1017 (in the case of elided frames), and LEVELS_PRINTED is a hash-table
1018 containing all the frames level that have already been printed.
1019 If a frame level has been printed, do not print it again (in the
1020 case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
1021 GDB exceptions converted to a Python exception, or EXT_LANG_BT_COMPLETED
1022 on success. It can also throw an exception RETURN_QUIT. */
1024 static enum ext_lang_bt_status
1025 py_print_frame (PyObject
*filter
, int flags
,
1026 enum ext_lang_frame_args args_type
,
1027 struct ui_out
*out
, int indent
, htab_t levels_printed
)
1030 CORE_ADDR address
= 0;
1031 struct gdbarch
*gdbarch
= NULL
;
1032 struct frame_info
*frame
= NULL
;
1033 struct cleanup
*cleanup_stack
;
1034 struct value_print_options opts
;
1035 PyObject
*py_inf_frame
;
1036 int print_level
, print_frame_info
, print_args
, print_locals
;
1038 /* Extract print settings from FLAGS. */
1039 print_level
= (flags
& PRINT_LEVEL
) ? 1 : 0;
1040 print_frame_info
= (flags
& PRINT_FRAME_INFO
) ? 1 : 0;
1041 print_args
= (flags
& PRINT_ARGS
) ? 1 : 0;
1042 print_locals
= (flags
& PRINT_LOCALS
) ? 1 : 0;
1044 get_user_print_options (&opts
);
1046 /* Get the underlying frame. This is needed to determine GDB
1047 architecture, and also, in the cases of frame variables/arguments to
1048 read them if they returned filter object requires us to do so. */
1049 py_inf_frame
= PyObject_CallMethod (filter
, "inferior_frame", NULL
);
1050 if (py_inf_frame
== NULL
)
1051 return EXT_LANG_BT_ERROR
;
1053 frame
= frame_object_to_frame_info (py_inf_frame
);;
1055 Py_DECREF (py_inf_frame
);
1058 return EXT_LANG_BT_ERROR
;
1062 gdbarch
= get_frame_arch (frame
);
1064 CATCH (except
, RETURN_MASK_ERROR
)
1066 gdbpy_convert_exception (except
);
1067 return EXT_LANG_BT_ERROR
;
1071 /* stack-list-variables. */
1072 if (print_locals
&& print_args
&& ! print_frame_info
)
1074 if (py_mi_print_variables (filter
, out
, &opts
,
1075 args_type
, frame
) == EXT_LANG_BT_ERROR
)
1076 return EXT_LANG_BT_ERROR
;
1077 return EXT_LANG_BT_COMPLETED
;
1080 cleanup_stack
= make_cleanup (null_cleanup
, NULL
);
1082 /* -stack-list-locals does not require a
1083 wrapping frame attribute. */
1084 if (print_frame_info
|| (print_args
&& ! print_locals
))
1085 make_cleanup_ui_out_tuple_begin_end (out
, "frame");
1087 if (print_frame_info
)
1089 /* Elided frames are also printed with this function (recursively)
1090 and are printed with indention. */
1095 ui_out_spaces (out
, indent
*4);
1097 CATCH (except
, RETURN_MASK_ERROR
)
1099 gdbpy_convert_exception (except
);
1100 do_cleanups (cleanup_stack
);
1101 return EXT_LANG_BT_ERROR
;
1106 /* The address is required for frame annotations, and also for
1107 address printing. */
1108 if (PyObject_HasAttrString (filter
, "address"))
1110 PyObject
*paddr
= PyObject_CallMethod (filter
, "address", NULL
);
1114 do_cleanups (cleanup_stack
);
1115 return EXT_LANG_BT_ERROR
;
1118 if (paddr
!= Py_None
)
1120 address
= PyLong_AsLong (paddr
);
1127 /* Print frame level. MI does not require the level if
1128 locals/variables only are being printed. */
1129 if ((print_frame_info
|| print_args
) && print_level
)
1131 struct frame_info
**slot
;
1134 slot
= (struct frame_info
**) htab_find_slot (levels_printed
,
1138 level
= frame_relative_level (frame
);
1140 /* Check if this frame has already been printed (there are cases
1141 where elided synthetic dummy-frames have to 'borrow' the frame
1142 architecture from the eliding frame. If that is the case, do
1143 not print 'level', but print spaces. */
1145 ui_out_field_skip (out
, "level");
1149 annotate_frame_begin (print_level
? level
: 0,
1151 ui_out_text (out
, "#");
1152 ui_out_field_fmt_int (out
, 2, ui_left
, "level",
1156 CATCH (except
, RETURN_MASK_ERROR
)
1158 gdbpy_convert_exception (except
);
1159 do_cleanups (cleanup_stack
);
1160 return EXT_LANG_BT_ERROR
;
1165 if (print_frame_info
)
1167 /* Print address to the address field. If an address is not provided,
1169 if (opts
.addressprint
&& has_addr
)
1173 annotate_frame_address ();
1174 ui_out_field_core_addr (out
, "addr", gdbarch
, address
);
1175 annotate_frame_address_end ();
1176 ui_out_text (out
, " in ");
1178 CATCH (except
, RETURN_MASK_ERROR
)
1180 gdbpy_convert_exception (except
);
1181 do_cleanups (cleanup_stack
);
1182 return EXT_LANG_BT_ERROR
;
1187 /* Print frame function name. */
1188 if (PyObject_HasAttrString (filter
, "function"))
1190 PyObject
*py_func
= PyObject_CallMethod (filter
, "function", NULL
);
1191 struct cleanup
*py_func_cleanup
;
1192 const char *function
= NULL
;
1194 if (py_func
== NULL
)
1196 do_cleanups (cleanup_stack
);
1197 return EXT_LANG_BT_ERROR
;
1199 py_func_cleanup
= make_cleanup_py_decref (py_func
);
1201 if (gdbpy_is_string (py_func
))
1203 char *function_to_free
;
1205 function
= function_to_free
=
1206 python_string_to_host_string (py_func
);
1208 if (function
== NULL
)
1210 do_cleanups (cleanup_stack
);
1211 return EXT_LANG_BT_ERROR
;
1213 make_cleanup (xfree
, function_to_free
);
1215 else if (PyLong_Check (py_func
))
1217 CORE_ADDR addr
= PyLong_AsUnsignedLongLong (py_func
);
1218 struct bound_minimal_symbol msymbol
;
1220 if (PyErr_Occurred ())
1222 do_cleanups (cleanup_stack
);
1223 return EXT_LANG_BT_ERROR
;
1226 msymbol
= lookup_minimal_symbol_by_pc (addr
);
1227 if (msymbol
.minsym
!= NULL
)
1228 function
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1230 else if (py_func
!= Py_None
)
1232 PyErr_SetString (PyExc_RuntimeError
,
1233 _("FrameDecorator.function: expecting a " \
1234 "String, integer or None."));
1235 do_cleanups (cleanup_stack
);
1236 return EXT_LANG_BT_ERROR
;
1241 annotate_frame_function_name ();
1242 if (function
== NULL
)
1243 ui_out_field_skip (out
, "func");
1245 ui_out_field_string (out
, "func", function
);
1247 CATCH (except
, RETURN_MASK_ERROR
)
1249 gdbpy_convert_exception (except
);
1250 do_cleanups (cleanup_stack
);
1251 return EXT_LANG_BT_ERROR
;
1255 do_cleanups (py_func_cleanup
);
1260 /* Frame arguments. Check the result, and error if something went
1264 if (py_print_args (filter
, out
, args_type
, frame
) == EXT_LANG_BT_ERROR
)
1266 do_cleanups (cleanup_stack
);
1267 return EXT_LANG_BT_ERROR
;
1271 /* File name/source/line number information. */
1272 if (print_frame_info
)
1276 annotate_frame_source_begin ();
1278 CATCH (except
, RETURN_MASK_ERROR
)
1280 gdbpy_convert_exception (except
);
1281 do_cleanups (cleanup_stack
);
1282 return EXT_LANG_BT_ERROR
;
1286 if (PyObject_HasAttrString (filter
, "filename"))
1288 PyObject
*py_fn
= PyObject_CallMethod (filter
, "filename", NULL
);
1289 struct cleanup
*py_fn_cleanup
;
1293 do_cleanups (cleanup_stack
);
1294 return EXT_LANG_BT_ERROR
;
1296 py_fn_cleanup
= make_cleanup_py_decref (py_fn
);
1298 if (py_fn
!= Py_None
)
1300 char *filename
= python_string_to_host_string (py_fn
);
1302 if (filename
== NULL
)
1304 do_cleanups (cleanup_stack
);
1305 return EXT_LANG_BT_ERROR
;
1308 make_cleanup (xfree
, filename
);
1311 ui_out_wrap_hint (out
, " ");
1312 ui_out_text (out
, " at ");
1313 annotate_frame_source_file ();
1314 ui_out_field_string (out
, "file", filename
);
1315 annotate_frame_source_file_end ();
1317 CATCH (except
, RETURN_MASK_ERROR
)
1319 gdbpy_convert_exception (except
);
1320 do_cleanups (cleanup_stack
);
1321 return EXT_LANG_BT_ERROR
;
1325 do_cleanups (py_fn_cleanup
);
1328 if (PyObject_HasAttrString (filter
, "line"))
1330 PyObject
*py_line
= PyObject_CallMethod (filter
, "line", NULL
);
1331 struct cleanup
*py_line_cleanup
;
1334 if (py_line
== NULL
)
1336 do_cleanups (cleanup_stack
);
1337 return EXT_LANG_BT_ERROR
;
1339 py_line_cleanup
= make_cleanup_py_decref (py_line
);
1341 if (py_line
!= Py_None
)
1343 line
= PyLong_AsLong (py_line
);
1346 ui_out_text (out
, ":");
1347 annotate_frame_source_line ();
1348 ui_out_field_int (out
, "line", line
);
1350 CATCH (except
, RETURN_MASK_ERROR
)
1352 gdbpy_convert_exception (except
);
1353 do_cleanups (cleanup_stack
);
1354 return EXT_LANG_BT_ERROR
;
1358 do_cleanups (py_line_cleanup
);
1362 /* For MI we need to deal with the "children" list population of
1363 elided frames, so if MI output detected do not send newline. */
1364 if (! ui_out_is_mi_like_p (out
))
1368 annotate_frame_end ();
1369 ui_out_text (out
, "\n");
1371 CATCH (except
, RETURN_MASK_ERROR
)
1373 gdbpy_convert_exception (except
);
1374 do_cleanups (cleanup_stack
);
1375 return EXT_LANG_BT_ERROR
;
1382 if (py_print_locals (filter
, out
, args_type
, indent
,
1383 frame
) == EXT_LANG_BT_ERROR
)
1385 do_cleanups (cleanup_stack
);
1386 return EXT_LANG_BT_ERROR
;
1392 struct cleanup
*elided_cleanup
;
1394 /* Finally recursively print elided frames, if any. */
1395 elided
= get_py_iter_from_func (filter
, "elided");
1398 do_cleanups (cleanup_stack
);
1399 return EXT_LANG_BT_ERROR
;
1401 elided_cleanup
= make_cleanup_py_decref (elided
);
1403 if (elided
!= Py_None
)
1407 make_cleanup_ui_out_list_begin_end (out
, "children");
1409 if (! ui_out_is_mi_like_p (out
))
1412 while ((item
= PyIter_Next (elided
)))
1414 struct cleanup
*item_cleanup
= make_cleanup_py_decref (item
);
1416 enum ext_lang_bt_status success
= py_print_frame (item
, flags
,
1421 do_cleanups (item_cleanup
);
1423 if (success
== EXT_LANG_BT_ERROR
)
1425 do_cleanups (cleanup_stack
);
1426 return EXT_LANG_BT_ERROR
;
1429 if (item
== NULL
&& PyErr_Occurred ())
1431 do_cleanups (cleanup_stack
);
1432 return EXT_LANG_BT_ERROR
;
1435 do_cleanups (elided_cleanup
);
1438 do_cleanups (cleanup_stack
);
1439 return EXT_LANG_BT_COMPLETED
;
1442 /* Helper function to initiate frame filter invocation at starting
1446 bootstrap_python_frame_filters (struct frame_info
*frame
,
1447 int frame_low
, int frame_high
)
1449 struct cleanup
*cleanups
=
1450 make_cleanup (null_cleanup
, NULL
);
1451 PyObject
*module
, *sort_func
, *iterable
, *frame_obj
, *iterator
;
1452 PyObject
*py_frame_low
, *py_frame_high
;
1454 frame_obj
= frame_info_to_frame_object (frame
);
1455 if (frame_obj
== NULL
)
1457 make_cleanup_py_decref (frame_obj
);
1459 module
= PyImport_ImportModule ("gdb.frames");
1462 make_cleanup_py_decref (module
);
1464 sort_func
= PyObject_GetAttrString (module
, "execute_frame_filters");
1465 if (sort_func
== NULL
)
1467 make_cleanup_py_decref (sort_func
);
1469 py_frame_low
= PyInt_FromLong (frame_low
);
1470 if (py_frame_low
== NULL
)
1472 make_cleanup_py_decref (py_frame_low
);
1474 py_frame_high
= PyInt_FromLong (frame_high
);
1475 if (py_frame_high
== NULL
)
1477 make_cleanup_py_decref (py_frame_high
);
1479 iterable
= PyObject_CallFunctionObjArgs (sort_func
, frame_obj
,
1483 if (iterable
== NULL
)
1486 do_cleanups (cleanups
);
1488 if (iterable
!= Py_None
)
1490 iterator
= PyObject_GetIter (iterable
);
1491 Py_DECREF (iterable
);
1501 do_cleanups (cleanups
);
1505 /* This is the only publicly exported function in this file. FRAME
1506 is the source frame to start frame-filter invocation. FLAGS is an
1507 integer holding the flags for printing. The following elements of
1508 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1509 PRINT_LEVEL is a flag indicating whether to print the frame's
1510 relative level in the output. PRINT_FRAME_INFO is a flag that
1511 indicates whether this function should print the frame
1512 information, PRINT_ARGS is a flag that indicates whether to print
1513 frame arguments, and PRINT_LOCALS, likewise, with frame local
1514 variables. ARGS_TYPE is an enumerator describing the argument
1515 format, OUT is the output stream to print. FRAME_LOW is the
1516 beginning of the slice of frames to print, and FRAME_HIGH is the
1517 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1518 or EXT_LANG_BT_COMPLETED on success. */
1520 enum ext_lang_bt_status
1521 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1522 struct frame_info
*frame
, int flags
,
1523 enum ext_lang_frame_args args_type
,
1524 struct ui_out
*out
, int frame_low
, int frame_high
)
1526 struct gdbarch
*gdbarch
= NULL
;
1527 struct cleanup
*cleanups
;
1528 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1531 htab_t levels_printed
;
1533 if (!gdb_python_initialized
)
1534 return EXT_LANG_BT_NO_FILTERS
;
1538 gdbarch
= get_frame_arch (frame
);
1540 CATCH (except
, RETURN_MASK_ALL
)
1542 /* Let gdb try to print the stack trace. */
1543 return EXT_LANG_BT_NO_FILTERS
;
1547 cleanups
= ensure_python_env (gdbarch
, current_language
);
1549 iterable
= bootstrap_python_frame_filters (frame
, frame_low
, frame_high
);
1551 if (iterable
== NULL
)
1553 /* Normally if there is an error GDB prints the exception,
1554 abandons the backtrace and exits. The user can then call "bt
1555 no-filters", and get a default backtrace (it would be
1556 confusing to automatically start a standard backtrace halfway
1557 through a Python filtered backtrace). However in the case
1558 where GDB cannot initialize the frame filters (most likely
1559 due to incorrect auto-load paths), GDB has printed nothing.
1560 In this case it is OK to print the default backtrace after
1561 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1562 here to signify there are no filters after printing the
1563 initialization error. This return code will trigger a
1564 default backtrace. */
1566 gdbpy_print_stack ();
1567 do_cleanups (cleanups
);
1568 return EXT_LANG_BT_NO_FILTERS
;
1571 /* If iterable is None, then there are no frame filters registered.
1572 If this is the case, defer to default GDB printing routines in MI
1574 make_cleanup_py_decref (iterable
);
1575 if (iterable
== Py_None
)
1577 success
= EXT_LANG_BT_NO_FILTERS
;
1581 levels_printed
= htab_create (20,
1585 make_cleanup_htab_delete (levels_printed
);
1587 while ((item
= PyIter_Next (iterable
)))
1589 struct cleanup
*item_cleanup
= make_cleanup_py_decref (item
);
1591 success
= py_print_frame (item
, flags
, args_type
, out
, 0,
1594 do_cleanups (item_cleanup
);
1596 /* Do not exit on error printing a single frame. Print the
1597 error and continue with other frames. */
1598 if (success
== EXT_LANG_BT_ERROR
)
1599 gdbpy_print_stack ();
1602 if (item
== NULL
&& PyErr_Occurred ())
1606 do_cleanups (cleanups
);
1609 /* Exit and abandon backtrace on error, printing the exception that
1612 gdbpy_print_stack ();
1613 do_cleanups (cleanups
);
1614 return EXT_LANG_BT_ERROR
;