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;
252 int local_indent
= (4 * indent
);
254 /* Never set an indent level for common_val_print if MI. */
255 if (ui_out_is_mi_like_p (out
))
258 /* MI does not print certain values, differentiated by type,
259 depending on what ARGS_TYPE indicates. Test type against option.
260 For CLI print all values. */
261 if (args_type
== MI_PRINT_SIMPLE_VALUES
262 || args_type
== MI_PRINT_ALL_VALUES
)
264 struct type
*type
= NULL
;
268 type
= check_typedef (value_type (val
));
270 CATCH (except
, RETURN_MASK_ALL
)
272 gdbpy_convert_exception (except
);
273 return EXT_LANG_BT_ERROR
;
277 if (args_type
== MI_PRINT_ALL_VALUES
)
279 else if (args_type
== MI_PRINT_SIMPLE_VALUES
280 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
281 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
282 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
285 else if (args_type
!= NO_VALUES
)
293 struct cleanup
*cleanup
;
295 stb
= mem_fileopen ();
296 cleanup
= make_cleanup_ui_file_delete (stb
);
297 common_val_print (val
, stb
, indent
, opts
, language
);
298 ui_out_field_stream (out
, "value", stb
);
299 do_cleanups (cleanup
);
301 CATCH (except
, RETURN_MASK_ALL
)
303 gdbpy_convert_exception (except
);
304 return EXT_LANG_BT_ERROR
;
309 return EXT_LANG_BT_OK
;
312 /* Helper function to call a Python method and extract an iterator
313 from the result. If the function returns anything but an iterator
314 the exception is preserved and NULL is returned. FILTER is the
315 Python object to call, and FUNC is the name of the method. Returns
316 a PyObject, or NULL on error with the appropriate exception set.
317 This function can return an iterator, or NULL. */
320 get_py_iter_from_func (PyObject
*filter
, char *func
)
322 if (PyObject_HasAttrString (filter
, func
))
324 PyObject
*result
= PyObject_CallMethod (filter
, func
, NULL
);
328 if (result
== Py_None
)
334 PyObject
*iterator
= PyObject_GetIter (result
);
347 /* Helper function to output a single frame argument and value to an
348 output stream. This function will account for entry values if the
349 FV parameter is populated, the frame argument has entry values
350 associated with them, and the appropriate "set entry-value"
351 options are set. Will output in CLI or MI like format depending
352 on the type of output stream detected. OUT is the output stream,
353 SYM_NAME is the name of the symbol. If SYM_NAME is populated then
354 it must have an accompanying value in the parameter FV. FA is a
355 frame argument structure. If FA is populated, both SYM_NAME and
356 FV are ignored. OPTS contains the value printing options,
357 ARGS_TYPE is an enumerator describing the argument format,
358 PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
359 in MI output in commands where both arguments and locals are
360 printed. Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions
361 converted to a Python exception, or EXT_LANG_BT_OK on success. */
363 static enum ext_lang_bt_status
364 py_print_single_arg (struct ui_out
*out
,
365 const char *sym_name
,
366 struct frame_arg
*fa
,
368 const struct value_print_options
*opts
,
369 enum ext_lang_frame_args args_type
,
370 int print_args_field
,
371 const struct language_defn
*language
)
374 enum ext_lang_bt_status retval
= EXT_LANG_BT_OK
;
378 if (fa
->val
== NULL
&& fa
->error
== NULL
)
379 return EXT_LANG_BT_OK
;
380 language
= language_def (SYMBOL_LANGUAGE (fa
->sym
));
388 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
390 /* MI has varying rules for tuples, but generally if there is only
391 one element in each item in the list, do not start a tuple. The
392 exception is -stack-list-variables which emits an ARGS="1" field
393 if the value is a frame argument. This is denoted in this
394 function with PRINT_ARGS_FIELD which is flag from the caller to
395 emit the ARGS field. */
396 if (ui_out_is_mi_like_p (out
))
398 if (print_args_field
|| args_type
!= NO_VALUES
)
399 make_cleanup_ui_out_tuple_begin_end (out
, NULL
);
402 annotate_arg_begin ();
404 /* If frame argument is populated, check for entry-values and the
405 entry value options. */
410 stb
= mem_fileopen ();
411 make_cleanup_ui_file_delete (stb
);
412 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (fa
->sym
),
413 SYMBOL_LANGUAGE (fa
->sym
),
414 DMGL_PARAMS
| DMGL_ANSI
);
415 if (fa
->entry_kind
== print_entry_values_compact
)
417 fputs_filtered ("=", stb
);
419 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (fa
->sym
),
420 SYMBOL_LANGUAGE (fa
->sym
),
421 DMGL_PARAMS
| DMGL_ANSI
);
423 if (fa
->entry_kind
== print_entry_values_only
424 || fa
->entry_kind
== print_entry_values_compact
)
426 fputs_filtered ("@entry", stb
);
428 ui_out_field_stream (out
, "name", stb
);
431 /* Otherwise, just output the name. */
432 ui_out_field_string (out
, "name", sym_name
);
434 annotate_arg_name_end ();
436 if (! ui_out_is_mi_like_p (out
))
437 ui_out_text (out
, "=");
439 if (print_args_field
)
440 ui_out_field_int (out
, "arg", 1);
442 /* For MI print the type, but only for simple values. This seems
443 weird, but this is how MI choose to format the various output
445 if (args_type
== MI_PRINT_SIMPLE_VALUES
&& val
!= NULL
)
447 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
449 retval
= EXT_LANG_BT_ERROR
;
450 do_cleanups (cleanups
);
454 if (retval
!= EXT_LANG_BT_ERROR
)
457 annotate_arg_value (value_type (val
));
459 /* If the output is to the CLI, and the user option "set print
460 frame-arguments" is set to none, just output "...". */
461 if (! ui_out_is_mi_like_p (out
) && args_type
== NO_VALUES
)
462 ui_out_field_string (out
, "value", "...");
465 /* Otherwise, print the value for both MI and the CLI, except
466 for the case of MI_PRINT_NO_VALUES. */
467 if (args_type
!= NO_VALUES
)
471 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
472 ui_out_field_fmt (out
, "value",
473 _("<error reading variable: %s>"),
476 else if (py_print_value (out
, val
, opts
, 0, args_type
, language
)
477 == EXT_LANG_BT_ERROR
)
478 retval
= EXT_LANG_BT_ERROR
;
482 do_cleanups (cleanups
);
485 CATCH (except
, RETURN_MASK_ERROR
)
487 gdbpy_convert_exception (except
);
494 /* Helper function to loop over frame arguments provided by the
495 "frame_arguments" Python API. Elements in the iterator must
496 conform to the "Symbol Value" interface. ITER is the Python
497 iterable object, OUT is the output stream, ARGS_TYPE is an
498 enumerator describing the argument format, PRINT_ARGS_FIELD is a
499 flag which indicates if we output "ARGS=1" in MI output in commands
500 where both arguments and locals are printed, and FRAME is the
501 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
502 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
505 static enum ext_lang_bt_status
506 enumerate_args (PyObject
*iter
,
508 enum ext_lang_frame_args args_type
,
509 int print_args_field
,
510 struct frame_info
*frame
)
513 struct value_print_options opts
;
515 get_user_print_options (&opts
);
517 if (args_type
== CLI_SCALAR_VALUES
)
519 /* True in "summary" mode, false otherwise. */
527 annotate_frame_args ();
529 CATCH (except
, RETURN_MASK_ALL
)
531 gdbpy_convert_exception (except
);
536 /* Collect the first argument outside of the loop, so output of
537 commas in the argument output is correct. At the end of the
538 loop block collect another item from the iterator, and, if it is
539 not null emit a comma. */
540 item
= PyIter_Next (iter
);
541 if (item
== NULL
&& PyErr_Occurred ())
546 const struct language_defn
*language
;
549 struct block
*sym_block
;
551 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
553 success
= extract_sym (item
, &sym_name
, &sym
, &sym_block
, &language
);
554 if (success
== EXT_LANG_BT_ERROR
)
560 success
= extract_value (item
, &val
);
561 if (success
== EXT_LANG_BT_ERROR
)
571 if (sym
&& ui_out_is_mi_like_p (out
)
572 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
578 /* If the object did not provide a value, read it using
579 read_frame_args and account for entry values, if any. */
582 struct frame_arg arg
, entryarg
;
584 /* If there is no value, and also no symbol, set error and
588 PyErr_SetString (PyExc_RuntimeError
,
589 _("No symbol or value provided."));
596 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
598 CATCH (except
, RETURN_MASK_ALL
)
601 gdbpy_convert_exception (except
);
606 /* The object has not provided a value, so this is a frame
607 argument to be read by GDB. In this case we have to
608 account for entry-values. */
610 if (arg
.entry_kind
!= print_entry_values_only
)
612 if (py_print_single_arg (out
, NULL
, &arg
,
616 NULL
) == EXT_LANG_BT_ERROR
)
619 xfree (entryarg
.error
);
625 if (entryarg
.entry_kind
!= print_entry_values_no
)
627 if (arg
.entry_kind
!= print_entry_values_only
)
631 ui_out_text (out
, ", ");
632 ui_out_wrap_hint (out
, " ");
634 CATCH (except
, RETURN_MASK_ALL
)
637 xfree (entryarg
.error
);
639 gdbpy_convert_exception (except
);
645 if (py_print_single_arg (out
, NULL
, &entryarg
, NULL
, &opts
,
646 args_type
, print_args_field
, NULL
)
647 == EXT_LANG_BT_ERROR
)
650 xfree (entryarg
.error
);
657 xfree (entryarg
.error
);
661 /* If the object has provided a value, we just print that. */
664 if (py_print_single_arg (out
, sym_name
, NULL
, val
, &opts
,
665 args_type
, print_args_field
,
666 language
) == EXT_LANG_BT_ERROR
)
676 /* Collect the next item from the iterator. If
677 this is the last item, do not print the
679 item
= PyIter_Next (iter
);
684 ui_out_text (out
, ", ");
686 CATCH (except
, RETURN_MASK_ALL
)
689 gdbpy_convert_exception (except
);
694 else if (PyErr_Occurred ())
701 CATCH (except
, RETURN_MASK_ALL
)
704 gdbpy_convert_exception (except
);
710 return EXT_LANG_BT_OK
;
713 return EXT_LANG_BT_ERROR
;
717 /* Helper function to loop over variables provided by the
718 "frame_locals" Python API. Elements in the iterable must conform
719 to the "Symbol Value" interface. ITER is the Python iterable
720 object, OUT is the output stream, INDENT is whether we should
721 indent the output (for CLI), ARGS_TYPE is an enumerator describing
722 the argument format, PRINT_ARGS_FIELD is flag which indicates
723 whether to output the ARGS field in the case of
724 -stack-list-variables and FRAME is the backing frame. Returns
725 EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
726 exception, or EXT_LANG_BT_OK on success. */
728 static enum ext_lang_bt_status
729 enumerate_locals (PyObject
*iter
,
732 enum ext_lang_frame_args args_type
,
733 int print_args_field
,
734 struct frame_info
*frame
)
737 struct value_print_options opts
;
739 get_user_print_options (&opts
);
742 while ((item
= PyIter_Next (iter
)))
744 const struct language_defn
*language
;
747 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
749 struct block
*sym_block
;
750 int local_indent
= 8 + (8 * indent
);
751 struct cleanup
*locals_cleanups
;
753 locals_cleanups
= make_cleanup_py_decref (item
);
755 success
= extract_sym (item
, &sym_name
, &sym
, &sym_block
, &language
);
756 if (success
== EXT_LANG_BT_ERROR
)
758 do_cleanups (locals_cleanups
);
762 make_cleanup (xfree
, sym_name
);
764 success
= extract_value (item
, &val
);
765 if (success
== EXT_LANG_BT_ERROR
)
767 do_cleanups (locals_cleanups
);
771 if (sym
!= NULL
&& ui_out_is_mi_like_p (out
)
772 && ! mi_should_print (sym
, MI_PRINT_LOCALS
))
774 do_cleanups (locals_cleanups
);
778 /* If the object did not provide a value, read it. */
783 val
= read_var_value (sym
, sym_block
, frame
);
785 CATCH (except
, RETURN_MASK_ERROR
)
787 gdbpy_convert_exception (except
);
788 do_cleanups (locals_cleanups
);
794 /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
795 each output contains only one field. The exception is
796 -stack-list-variables, which always provides a tuple. */
797 if (ui_out_is_mi_like_p (out
))
799 if (print_args_field
|| args_type
!= NO_VALUES
)
800 make_cleanup_ui_out_tuple_begin_end (out
, NULL
);
804 if (! ui_out_is_mi_like_p (out
))
806 /* If the output is not MI we indent locals. */
807 ui_out_spaces (out
, local_indent
);
810 ui_out_field_string (out
, "name", sym_name
);
812 if (! ui_out_is_mi_like_p (out
))
813 ui_out_text (out
, " = ");
815 CATCH (except
, RETURN_MASK_ERROR
)
817 gdbpy_convert_exception (except
);
818 do_cleanups (locals_cleanups
);
823 if (args_type
== MI_PRINT_SIMPLE_VALUES
)
825 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
827 do_cleanups (locals_cleanups
);
832 /* CLI always prints values for locals. MI uses the
833 simple/no/all system. */
834 if (! ui_out_is_mi_like_p (out
))
836 int val_indent
= (indent
+ 1) * 4;
838 if (py_print_value (out
, val
, &opts
, val_indent
, args_type
,
839 language
) == EXT_LANG_BT_ERROR
)
841 do_cleanups (locals_cleanups
);
847 if (args_type
!= NO_VALUES
)
849 if (py_print_value (out
, val
, &opts
, 0, args_type
,
850 language
) == EXT_LANG_BT_ERROR
)
852 do_cleanups (locals_cleanups
);
858 do_cleanups (locals_cleanups
);
862 ui_out_text (out
, "\n");
864 CATCH (except
, RETURN_MASK_ERROR
)
866 gdbpy_convert_exception (except
);
872 if (item
== NULL
&& PyErr_Occurred ())
875 return EXT_LANG_BT_OK
;
878 return EXT_LANG_BT_ERROR
;
881 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
882 error, or EXT_LANG_BT_OK on success. */
884 static enum ext_lang_bt_status
885 py_mi_print_variables (PyObject
*filter
, struct ui_out
*out
,
886 struct value_print_options
*opts
,
887 enum ext_lang_frame_args args_type
,
888 struct frame_info
*frame
)
890 struct cleanup
*old_chain
;
892 PyObject
*locals_iter
;
894 args_iter
= get_py_iter_from_func (filter
, "frame_args");
895 old_chain
= make_cleanup_py_xdecref (args_iter
);
896 if (args_iter
== NULL
)
899 locals_iter
= get_py_iter_from_func (filter
, "frame_locals");
900 if (locals_iter
== NULL
)
903 make_cleanup_py_decref (locals_iter
);
904 make_cleanup_ui_out_list_begin_end (out
, "variables");
906 if (args_iter
!= Py_None
)
907 if (enumerate_args (args_iter
, out
, args_type
, 1, frame
)
908 == EXT_LANG_BT_ERROR
)
911 if (locals_iter
!= Py_None
)
912 if (enumerate_locals (locals_iter
, out
, 1, args_type
, 1, frame
)
913 == EXT_LANG_BT_ERROR
)
916 do_cleanups (old_chain
);
917 return EXT_LANG_BT_OK
;
920 do_cleanups (old_chain
);
921 return EXT_LANG_BT_ERROR
;
924 /* Helper function for printing locals. This function largely just
925 creates the wrapping tuple, and calls enumerate_locals. Returns
926 EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
928 static enum ext_lang_bt_status
929 py_print_locals (PyObject
*filter
,
931 enum ext_lang_frame_args args_type
,
933 struct frame_info
*frame
)
935 PyObject
*locals_iter
= get_py_iter_from_func (filter
,
937 struct cleanup
*old_chain
= make_cleanup_py_xdecref (locals_iter
);
939 if (locals_iter
== NULL
)
942 make_cleanup_ui_out_list_begin_end (out
, "locals");
944 if (locals_iter
!= Py_None
)
945 if (enumerate_locals (locals_iter
, out
, indent
, args_type
,
946 0, frame
) == EXT_LANG_BT_ERROR
)
949 do_cleanups (old_chain
);
950 return EXT_LANG_BT_OK
;
953 do_cleanups (old_chain
);
954 return EXT_LANG_BT_ERROR
;
957 /* Helper function for printing frame arguments. This function
958 largely just creates the wrapping tuple, and calls enumerate_args.
959 Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
960 a Python exception, or EXT_LANG_BT_OK on success. */
962 static enum ext_lang_bt_status
963 py_print_args (PyObject
*filter
,
965 enum ext_lang_frame_args args_type
,
966 struct frame_info
*frame
)
968 PyObject
*args_iter
= get_py_iter_from_func (filter
, "frame_args");
969 struct cleanup
*old_chain
= make_cleanup_py_xdecref (args_iter
);
971 if (args_iter
== NULL
)
974 make_cleanup_ui_out_list_begin_end (out
, "args");
978 annotate_frame_args ();
979 if (! ui_out_is_mi_like_p (out
))
980 ui_out_text (out
, " (");
982 CATCH (except
, RETURN_MASK_ALL
)
984 gdbpy_convert_exception (except
);
989 if (args_iter
!= Py_None
)
990 if (enumerate_args (args_iter
, out
, args_type
, 0, frame
)
991 == EXT_LANG_BT_ERROR
)
996 if (! ui_out_is_mi_like_p (out
))
997 ui_out_text (out
, ")");
999 CATCH (except
, RETURN_MASK_ALL
)
1001 gdbpy_convert_exception (except
);
1006 do_cleanups (old_chain
);
1007 return EXT_LANG_BT_OK
;
1010 do_cleanups (old_chain
);
1011 return EXT_LANG_BT_ERROR
;
1014 /* Print a single frame to the designated output stream, detecting
1015 whether the output is MI or console, and formatting the output
1016 according to the conventions of that protocol. FILTER is the
1017 frame-filter associated with this frame. FLAGS is an integer
1018 describing the various print options. The FLAGS variables is
1019 described in "apply_frame_filter" function. ARGS_TYPE is an
1020 enumerator describing the argument format. OUT is the output
1021 stream to print, INDENT is the level of indention for this frame
1022 (in the case of elided frames), and LEVELS_PRINTED is a hash-table
1023 containing all the frames level that have already been printed.
1024 If a frame level has been printed, do not print it again (in the
1025 case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
1026 GDB exceptions converted to a Python exception, or EXT_LANG_BT_COMPLETED
1027 on success. It can also throw an exception RETURN_QUIT. */
1029 static enum ext_lang_bt_status
1030 py_print_frame (PyObject
*filter
, int flags
,
1031 enum ext_lang_frame_args args_type
,
1032 struct ui_out
*out
, int indent
, htab_t levels_printed
)
1035 CORE_ADDR address
= 0;
1036 struct gdbarch
*gdbarch
= NULL
;
1037 struct frame_info
*frame
= NULL
;
1038 struct cleanup
*cleanup_stack
;
1039 struct value_print_options opts
;
1040 PyObject
*py_inf_frame
;
1041 int print_level
, print_frame_info
, print_args
, print_locals
;
1043 /* Extract print settings from FLAGS. */
1044 print_level
= (flags
& PRINT_LEVEL
) ? 1 : 0;
1045 print_frame_info
= (flags
& PRINT_FRAME_INFO
) ? 1 : 0;
1046 print_args
= (flags
& PRINT_ARGS
) ? 1 : 0;
1047 print_locals
= (flags
& PRINT_LOCALS
) ? 1 : 0;
1049 get_user_print_options (&opts
);
1051 /* Get the underlying frame. This is needed to determine GDB
1052 architecture, and also, in the cases of frame variables/arguments to
1053 read them if they returned filter object requires us to do so. */
1054 py_inf_frame
= PyObject_CallMethod (filter
, "inferior_frame", NULL
);
1055 if (py_inf_frame
== NULL
)
1056 return EXT_LANG_BT_ERROR
;
1058 frame
= frame_object_to_frame_info (py_inf_frame
);;
1060 Py_DECREF (py_inf_frame
);
1063 return EXT_LANG_BT_ERROR
;
1067 gdbarch
= get_frame_arch (frame
);
1069 CATCH (except
, RETURN_MASK_ERROR
)
1071 gdbpy_convert_exception (except
);
1072 return EXT_LANG_BT_ERROR
;
1076 /* stack-list-variables. */
1077 if (print_locals
&& print_args
&& ! print_frame_info
)
1079 if (py_mi_print_variables (filter
, out
, &opts
,
1080 args_type
, frame
) == EXT_LANG_BT_ERROR
)
1081 return EXT_LANG_BT_ERROR
;
1082 return EXT_LANG_BT_COMPLETED
;
1085 cleanup_stack
= make_cleanup (null_cleanup
, NULL
);
1087 /* -stack-list-locals does not require a
1088 wrapping frame attribute. */
1089 if (print_frame_info
|| (print_args
&& ! print_locals
))
1090 make_cleanup_ui_out_tuple_begin_end (out
, "frame");
1092 if (print_frame_info
)
1094 /* Elided frames are also printed with this function (recursively)
1095 and are printed with indention. */
1100 ui_out_spaces (out
, indent
*4);
1102 CATCH (except
, RETURN_MASK_ERROR
)
1104 gdbpy_convert_exception (except
);
1105 do_cleanups (cleanup_stack
);
1106 return EXT_LANG_BT_ERROR
;
1111 /* The address is required for frame annotations, and also for
1112 address printing. */
1113 if (PyObject_HasAttrString (filter
, "address"))
1115 PyObject
*paddr
= PyObject_CallMethod (filter
, "address", NULL
);
1119 do_cleanups (cleanup_stack
);
1120 return EXT_LANG_BT_ERROR
;
1123 if (paddr
!= Py_None
)
1125 address
= PyLong_AsLong (paddr
);
1132 /* Print frame level. MI does not require the level if
1133 locals/variables only are being printed. */
1134 if ((print_frame_info
|| print_args
) && print_level
)
1136 struct frame_info
**slot
;
1139 slot
= (struct frame_info
**) htab_find_slot (levels_printed
,
1143 level
= frame_relative_level (frame
);
1145 /* Check if this frame has already been printed (there are cases
1146 where elided synthetic dummy-frames have to 'borrow' the frame
1147 architecture from the eliding frame. If that is the case, do
1148 not print 'level', but print spaces. */
1150 ui_out_field_skip (out
, "level");
1154 annotate_frame_begin (print_level
? level
: 0,
1156 ui_out_text (out
, "#");
1157 ui_out_field_fmt_int (out
, 2, ui_left
, "level",
1161 CATCH (except
, RETURN_MASK_ERROR
)
1163 gdbpy_convert_exception (except
);
1164 do_cleanups (cleanup_stack
);
1165 return EXT_LANG_BT_ERROR
;
1170 if (print_frame_info
)
1172 /* Print address to the address field. If an address is not provided,
1174 if (opts
.addressprint
&& has_addr
)
1178 annotate_frame_address ();
1179 ui_out_field_core_addr (out
, "addr", gdbarch
, address
);
1180 annotate_frame_address_end ();
1181 ui_out_text (out
, " in ");
1183 CATCH (except
, RETURN_MASK_ERROR
)
1185 gdbpy_convert_exception (except
);
1186 do_cleanups (cleanup_stack
);
1187 return EXT_LANG_BT_ERROR
;
1192 /* Print frame function name. */
1193 if (PyObject_HasAttrString (filter
, "function"))
1195 PyObject
*py_func
= PyObject_CallMethod (filter
, "function", NULL
);
1196 struct cleanup
*py_func_cleanup
;
1197 const char *function
= NULL
;
1199 if (py_func
== NULL
)
1201 do_cleanups (cleanup_stack
);
1202 return EXT_LANG_BT_ERROR
;
1204 py_func_cleanup
= make_cleanup_py_decref (py_func
);
1206 if (gdbpy_is_string (py_func
))
1208 char *function_to_free
;
1210 function
= function_to_free
=
1211 python_string_to_host_string (py_func
);
1213 if (function
== NULL
)
1215 do_cleanups (cleanup_stack
);
1216 return EXT_LANG_BT_ERROR
;
1218 make_cleanup (xfree
, function_to_free
);
1220 else if (PyLong_Check (py_func
))
1222 CORE_ADDR addr
= PyLong_AsUnsignedLongLong (py_func
);
1223 struct bound_minimal_symbol msymbol
;
1225 if (PyErr_Occurred ())
1227 do_cleanups (cleanup_stack
);
1228 return EXT_LANG_BT_ERROR
;
1231 msymbol
= lookup_minimal_symbol_by_pc (addr
);
1232 if (msymbol
.minsym
!= NULL
)
1233 function
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1235 else if (py_func
!= Py_None
)
1237 PyErr_SetString (PyExc_RuntimeError
,
1238 _("FrameDecorator.function: expecting a " \
1239 "String, integer or None."));
1240 do_cleanups (cleanup_stack
);
1241 return EXT_LANG_BT_ERROR
;
1246 annotate_frame_function_name ();
1247 if (function
== NULL
)
1248 ui_out_field_skip (out
, "func");
1250 ui_out_field_string (out
, "func", function
);
1252 CATCH (except
, RETURN_MASK_ERROR
)
1254 gdbpy_convert_exception (except
);
1255 do_cleanups (cleanup_stack
);
1256 return EXT_LANG_BT_ERROR
;
1260 do_cleanups (py_func_cleanup
);
1265 /* Frame arguments. Check the result, and error if something went
1269 if (py_print_args (filter
, out
, args_type
, frame
) == EXT_LANG_BT_ERROR
)
1271 do_cleanups (cleanup_stack
);
1272 return EXT_LANG_BT_ERROR
;
1276 /* File name/source/line number information. */
1277 if (print_frame_info
)
1281 annotate_frame_source_begin ();
1283 CATCH (except
, RETURN_MASK_ERROR
)
1285 gdbpy_convert_exception (except
);
1286 do_cleanups (cleanup_stack
);
1287 return EXT_LANG_BT_ERROR
;
1291 if (PyObject_HasAttrString (filter
, "filename"))
1293 PyObject
*py_fn
= PyObject_CallMethod (filter
, "filename", NULL
);
1294 struct cleanup
*py_fn_cleanup
;
1298 do_cleanups (cleanup_stack
);
1299 return EXT_LANG_BT_ERROR
;
1301 py_fn_cleanup
= make_cleanup_py_decref (py_fn
);
1303 if (py_fn
!= Py_None
)
1305 char *filename
= python_string_to_host_string (py_fn
);
1307 if (filename
== NULL
)
1309 do_cleanups (cleanup_stack
);
1310 return EXT_LANG_BT_ERROR
;
1313 make_cleanup (xfree
, filename
);
1316 ui_out_wrap_hint (out
, " ");
1317 ui_out_text (out
, " at ");
1318 annotate_frame_source_file ();
1319 ui_out_field_string (out
, "file", filename
);
1320 annotate_frame_source_file_end ();
1322 CATCH (except
, RETURN_MASK_ERROR
)
1324 gdbpy_convert_exception (except
);
1325 do_cleanups (cleanup_stack
);
1326 return EXT_LANG_BT_ERROR
;
1330 do_cleanups (py_fn_cleanup
);
1333 if (PyObject_HasAttrString (filter
, "line"))
1335 PyObject
*py_line
= PyObject_CallMethod (filter
, "line", NULL
);
1336 struct cleanup
*py_line_cleanup
;
1339 if (py_line
== NULL
)
1341 do_cleanups (cleanup_stack
);
1342 return EXT_LANG_BT_ERROR
;
1344 py_line_cleanup
= make_cleanup_py_decref (py_line
);
1346 if (py_line
!= Py_None
)
1348 line
= PyLong_AsLong (py_line
);
1351 ui_out_text (out
, ":");
1352 annotate_frame_source_line ();
1353 ui_out_field_int (out
, "line", line
);
1355 CATCH (except
, RETURN_MASK_ERROR
)
1357 gdbpy_convert_exception (except
);
1358 do_cleanups (cleanup_stack
);
1359 return EXT_LANG_BT_ERROR
;
1363 do_cleanups (py_line_cleanup
);
1367 /* For MI we need to deal with the "children" list population of
1368 elided frames, so if MI output detected do not send newline. */
1369 if (! ui_out_is_mi_like_p (out
))
1373 annotate_frame_end ();
1374 ui_out_text (out
, "\n");
1376 CATCH (except
, RETURN_MASK_ERROR
)
1378 gdbpy_convert_exception (except
);
1379 do_cleanups (cleanup_stack
);
1380 return EXT_LANG_BT_ERROR
;
1387 if (py_print_locals (filter
, out
, args_type
, indent
,
1388 frame
) == EXT_LANG_BT_ERROR
)
1390 do_cleanups (cleanup_stack
);
1391 return EXT_LANG_BT_ERROR
;
1397 struct cleanup
*elided_cleanup
;
1399 /* Finally recursively print elided frames, if any. */
1400 elided
= get_py_iter_from_func (filter
, "elided");
1403 do_cleanups (cleanup_stack
);
1404 return EXT_LANG_BT_ERROR
;
1406 elided_cleanup
= make_cleanup_py_decref (elided
);
1408 if (elided
!= Py_None
)
1412 make_cleanup_ui_out_list_begin_end (out
, "children");
1414 if (! ui_out_is_mi_like_p (out
))
1417 while ((item
= PyIter_Next (elided
)))
1419 struct cleanup
*item_cleanup
= make_cleanup_py_decref (item
);
1421 enum ext_lang_bt_status success
= py_print_frame (item
, flags
,
1426 do_cleanups (item_cleanup
);
1428 if (success
== EXT_LANG_BT_ERROR
)
1430 do_cleanups (cleanup_stack
);
1431 return EXT_LANG_BT_ERROR
;
1434 if (item
== NULL
&& PyErr_Occurred ())
1436 do_cleanups (cleanup_stack
);
1437 return EXT_LANG_BT_ERROR
;
1440 do_cleanups (elided_cleanup
);
1443 do_cleanups (cleanup_stack
);
1444 return EXT_LANG_BT_COMPLETED
;
1447 /* Helper function to initiate frame filter invocation at starting
1451 bootstrap_python_frame_filters (struct frame_info
*frame
,
1452 int frame_low
, int frame_high
)
1454 struct cleanup
*cleanups
=
1455 make_cleanup (null_cleanup
, NULL
);
1456 PyObject
*module
, *sort_func
, *iterable
, *frame_obj
, *iterator
;
1457 PyObject
*py_frame_low
, *py_frame_high
;
1459 frame_obj
= frame_info_to_frame_object (frame
);
1460 if (frame_obj
== NULL
)
1462 make_cleanup_py_decref (frame_obj
);
1464 module
= PyImport_ImportModule ("gdb.frames");
1467 make_cleanup_py_decref (module
);
1469 sort_func
= PyObject_GetAttrString (module
, "execute_frame_filters");
1470 if (sort_func
== NULL
)
1472 make_cleanup_py_decref (sort_func
);
1474 py_frame_low
= PyInt_FromLong (frame_low
);
1475 if (py_frame_low
== NULL
)
1477 make_cleanup_py_decref (py_frame_low
);
1479 py_frame_high
= PyInt_FromLong (frame_high
);
1480 if (py_frame_high
== NULL
)
1482 make_cleanup_py_decref (py_frame_high
);
1484 iterable
= PyObject_CallFunctionObjArgs (sort_func
, frame_obj
,
1488 if (iterable
== NULL
)
1491 do_cleanups (cleanups
);
1493 if (iterable
!= Py_None
)
1495 iterator
= PyObject_GetIter (iterable
);
1496 Py_DECREF (iterable
);
1506 do_cleanups (cleanups
);
1510 /* This is the only publicly exported function in this file. FRAME
1511 is the source frame to start frame-filter invocation. FLAGS is an
1512 integer holding the flags for printing. The following elements of
1513 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1514 PRINT_LEVEL is a flag indicating whether to print the frame's
1515 relative level in the output. PRINT_FRAME_INFO is a flag that
1516 indicates whether this function should print the frame
1517 information, PRINT_ARGS is a flag that indicates whether to print
1518 frame arguments, and PRINT_LOCALS, likewise, with frame local
1519 variables. ARGS_TYPE is an enumerator describing the argument
1520 format, OUT is the output stream to print. FRAME_LOW is the
1521 beginning of the slice of frames to print, and FRAME_HIGH is the
1522 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1523 or EXT_LANG_BT_COMPLETED on success. */
1525 enum ext_lang_bt_status
1526 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1527 struct frame_info
*frame
, int flags
,
1528 enum ext_lang_frame_args args_type
,
1529 struct ui_out
*out
, int frame_low
, int frame_high
)
1531 struct gdbarch
*gdbarch
= NULL
;
1532 struct cleanup
*cleanups
;
1533 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1536 htab_t levels_printed
;
1538 if (!gdb_python_initialized
)
1539 return EXT_LANG_BT_NO_FILTERS
;
1543 gdbarch
= get_frame_arch (frame
);
1545 CATCH (except
, RETURN_MASK_ALL
)
1547 /* Let gdb try to print the stack trace. */
1548 return EXT_LANG_BT_NO_FILTERS
;
1552 cleanups
= ensure_python_env (gdbarch
, current_language
);
1554 iterable
= bootstrap_python_frame_filters (frame
, frame_low
, frame_high
);
1556 if (iterable
== NULL
)
1558 /* Normally if there is an error GDB prints the exception,
1559 abandons the backtrace and exits. The user can then call "bt
1560 no-filters", and get a default backtrace (it would be
1561 confusing to automatically start a standard backtrace halfway
1562 through a Python filtered backtrace). However in the case
1563 where GDB cannot initialize the frame filters (most likely
1564 due to incorrect auto-load paths), GDB has printed nothing.
1565 In this case it is OK to print the default backtrace after
1566 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1567 here to signify there are no filters after printing the
1568 initialization error. This return code will trigger a
1569 default backtrace. */
1571 gdbpy_print_stack ();
1572 do_cleanups (cleanups
);
1573 return EXT_LANG_BT_NO_FILTERS
;
1576 /* If iterable is None, then there are no frame filters registered.
1577 If this is the case, defer to default GDB printing routines in MI
1579 make_cleanup_py_decref (iterable
);
1580 if (iterable
== Py_None
)
1582 success
= EXT_LANG_BT_NO_FILTERS
;
1586 levels_printed
= htab_create (20,
1590 make_cleanup_htab_delete (levels_printed
);
1592 while ((item
= PyIter_Next (iterable
)))
1594 struct cleanup
*item_cleanup
= make_cleanup_py_decref (item
);
1596 success
= py_print_frame (item
, flags
, args_type
, out
, 0,
1599 do_cleanups (item_cleanup
);
1601 /* Do not exit on error printing a single frame. Print the
1602 error and continue with other frames. */
1603 if (success
== EXT_LANG_BT_ERROR
)
1604 gdbpy_print_stack ();
1607 if (item
== NULL
&& PyErr_Occurred ())
1611 do_cleanups (cleanups
);
1614 /* Exit and abandon backtrace on error, printing the exception that
1617 gdbpy_print_stack ();
1618 do_cleanups (cleanups
);
1619 return EXT_LANG_BT_ERROR
;