1 /* Python frame filters
3 Copyright (C) 2013-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "arch-utils.h"
31 #include "mi/mi-cmds.h"
32 #include "python-internal.h"
34 #include "common/gdb_optional.h"
42 /* Helper function to extract a symbol, a name and a language
43 definition from a Python object that conforms to the "Symbol Value"
44 interface. OBJ is the Python object to extract the values from.
45 NAME is a pass-through argument where the name of the symbol will
46 be written. NAME is allocated in this function, but the caller is
47 responsible for clean up. SYM is a pass-through argument where the
48 symbol will be written and SYM_BLOCK is a pass-through argument to
49 write the block where the symbol lies in. In the case of the API
50 returning a string, this will be set to NULL. LANGUAGE is also a
51 pass-through argument denoting the language attributed to the
52 Symbol. In the case of SYM being NULL, this will be set to the
53 current language. Returns EXT_LANG_BT_ERROR on error with the
54 appropriate Python exception set, and EXT_LANG_BT_OK on success. */
56 static enum ext_lang_bt_status
57 extract_sym (PyObject
*obj
, gdb::unique_xmalloc_ptr
<char> *name
,
58 struct symbol
**sym
, struct block
**sym_block
,
59 const struct language_defn
**language
)
61 gdbpy_ref
result (PyObject_CallMethod (obj
, "symbol", NULL
));
64 return EXT_LANG_BT_ERROR
;
66 /* For 'symbol' callback, the function can return a symbol or a
68 if (gdbpy_is_string (result
.get ()))
70 *name
= python_string_to_host_string (result
.get ());
73 return EXT_LANG_BT_ERROR
;
74 /* If the API returns a string (and not a symbol), then there is
75 no symbol derived language available and the frame filter has
76 either overridden the symbol with a string, or supplied a
77 entirely synthetic symbol/value pairing. In that case, use
79 *language
= python_language
;
85 /* This type checks 'result' during the conversion so we
86 just call it unconditionally and check the return. */
87 *sym
= symbol_object_to_symbol (result
.get ());
88 /* TODO: currently, we have no way to recover the block in which SYMBOL
89 was found, so we have no block to return. Trying to evaluate SYMBOL
90 will yield an incorrect value when it's located in a FRAME and
91 evaluated from another frame (as permitted in nested functions). */
96 PyErr_SetString (PyExc_RuntimeError
,
97 _("Unexpected value. Expecting a "
98 "gdb.Symbol or a Python string."));
99 return EXT_LANG_BT_ERROR
;
102 /* Duplicate the symbol name, so the caller has consistency
103 in garbage collection. */
104 name
->reset (xstrdup (SYMBOL_PRINT_NAME (*sym
)));
106 /* If a symbol is specified attempt to determine the language
107 from the symbol. If mode is not "auto", then the language
108 has been explicitly set, use that. */
109 if (language_mode
== language_mode_auto
)
110 *language
= language_def (SYMBOL_LANGUAGE (*sym
));
112 *language
= current_language
;
115 return EXT_LANG_BT_OK
;
118 /* Helper function to extract a value from an object that conforms to
119 the "Symbol Value" interface. OBJ is the Python object to extract
120 the value from. VALUE is a pass-through argument where the value
121 will be written. If the object does not have the value attribute,
122 or provides the Python None for a value, VALUE will be set to NULL
123 and this function will return as successful. Returns EXT_LANG_BT_ERROR
124 on error with the appropriate Python exception set, and EXT_LANG_BT_OK on
127 static enum ext_lang_bt_status
128 extract_value (PyObject
*obj
, struct value
**value
)
130 if (PyObject_HasAttrString (obj
, "value"))
132 gdbpy_ref
vresult (PyObject_CallMethod (obj
, "value", NULL
));
135 return EXT_LANG_BT_ERROR
;
137 /* The Python code has returned 'None' for a value, so we set
138 value to NULL. This flags that GDB should read the
140 if (vresult
== Py_None
)
143 return EXT_LANG_BT_OK
;
147 *value
= convert_value_from_python (vresult
.get ());
150 return EXT_LANG_BT_ERROR
;
152 return EXT_LANG_BT_OK
;
158 return EXT_LANG_BT_OK
;
161 /* MI prints only certain values according to the type of symbol and
162 also what the user has specified. SYM is the symbol to check, and
163 MI_PRINT_TYPES is an enum specifying what the user wants emitted
164 for the MI command in question. */
166 mi_should_print (struct symbol
*sym
, enum mi_print_types type
)
170 switch (SYMBOL_CLASS (sym
))
173 case LOC_UNDEF
: /* catches errors */
174 case LOC_CONST
: /* constant */
175 case LOC_TYPEDEF
: /* local typedef */
176 case LOC_LABEL
: /* local label */
177 case LOC_BLOCK
: /* local function */
178 case LOC_CONST_BYTES
: /* loc. byte seq. */
179 case LOC_UNRESOLVED
: /* unresolved static */
180 case LOC_OPTIMIZED_OUT
: /* optimized out */
184 case LOC_ARG
: /* argument */
185 case LOC_REF_ARG
: /* reference arg */
186 case LOC_REGPARM_ADDR
: /* indirect register arg */
187 case LOC_LOCAL
: /* stack local */
188 case LOC_STATIC
: /* static */
189 case LOC_REGISTER
: /* register */
190 case LOC_COMPUTED
: /* computed location */
191 if (type
== MI_PRINT_LOCALS
)
192 print_me
= ! SYMBOL_IS_ARGUMENT (sym
);
194 print_me
= SYMBOL_IS_ARGUMENT (sym
);
199 /* Helper function which outputs a type name extracted from VAL to a
200 "type" field in the output stream OUT. OUT is the ui-out structure
201 the type name will be output too, and VAL is the value that the
202 type will be extracted from. Returns EXT_LANG_BT_ERROR on error, with
203 any GDB exceptions converted to a Python exception, or EXT_LANG_BT_OK on
206 static enum ext_lang_bt_status
207 py_print_type (struct ui_out
*out
, struct value
*val
)
212 check_typedef (value_type (val
));
215 type_print (value_type (val
), "", &stb
, -1);
216 out
->field_stream ("type", stb
);
218 CATCH (except
, RETURN_MASK_ALL
)
220 gdbpy_convert_exception (except
);
221 return EXT_LANG_BT_ERROR
;
225 return EXT_LANG_BT_OK
;
228 /* Helper function which outputs a value to an output field in a
229 stream. OUT is the ui-out structure the value will be output to,
230 VAL is the value that will be printed, OPTS contains the value
231 printing options, ARGS_TYPE is an enumerator describing the
232 argument format, and LANGUAGE is the language_defn that the value
233 will be printed with. Returns EXT_LANG_BT_ERROR on error, with any GDB
234 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
237 static enum ext_lang_bt_status
238 py_print_value (struct ui_out
*out
, struct value
*val
,
239 const struct value_print_options
*opts
,
241 enum ext_lang_frame_args args_type
,
242 const struct language_defn
*language
)
244 int should_print
= 0;
246 /* MI does not print certain values, differentiated by type,
247 depending on what ARGS_TYPE indicates. Test type against option.
248 For CLI print all values. */
249 if (args_type
== MI_PRINT_SIMPLE_VALUES
250 || args_type
== MI_PRINT_ALL_VALUES
)
252 struct type
*type
= NULL
;
256 type
= check_typedef (value_type (val
));
258 CATCH (except
, RETURN_MASK_ALL
)
260 gdbpy_convert_exception (except
);
261 return EXT_LANG_BT_ERROR
;
265 if (args_type
== MI_PRINT_ALL_VALUES
)
267 else if (args_type
== MI_PRINT_SIMPLE_VALUES
268 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
269 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
270 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
273 else if (args_type
!= NO_VALUES
)
282 common_val_print (val
, &stb
, indent
, opts
, language
);
283 out
->field_stream ("value", stb
);
285 CATCH (except
, RETURN_MASK_ALL
)
287 gdbpy_convert_exception (except
);
288 return EXT_LANG_BT_ERROR
;
293 return EXT_LANG_BT_OK
;
296 /* Helper function to call a Python method and extract an iterator
297 from the result. If the function returns anything but an iterator
298 the exception is preserved and NULL is returned. FILTER is the
299 Python object to call, and FUNC is the name of the method. Returns
300 a PyObject, or NULL on error with the appropriate exception set.
301 This function can return an iterator, or NULL. */
304 get_py_iter_from_func (PyObject
*filter
, char *func
)
306 if (PyObject_HasAttrString (filter
, func
))
308 gdbpy_ref
result (PyObject_CallMethod (filter
, func
, NULL
));
312 if (result
== Py_None
)
314 return result
.release ();
318 return PyObject_GetIter (result
.get ());
328 /* Helper function to output a single frame argument and value to an
329 output stream. This function will account for entry values if the
330 FV parameter is populated, the frame argument has entry values
331 associated with them, and the appropriate "set entry-value"
332 options are set. Will output in CLI or MI like format depending
333 on the type of output stream detected. OUT is the output stream,
334 SYM_NAME is the name of the symbol. If SYM_NAME is populated then
335 it must have an accompanying value in the parameter FV. FA is a
336 frame argument structure. If FA is populated, both SYM_NAME and
337 FV are ignored. OPTS contains the value printing options,
338 ARGS_TYPE is an enumerator describing the argument format,
339 PRINT_ARGS_FIELD is a flag which indicates if we output "ARGS=1"
340 in MI output in commands where both arguments and locals are
341 printed. Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions
342 converted to a Python exception, or EXT_LANG_BT_OK on success. */
344 static enum ext_lang_bt_status
345 py_print_single_arg (struct ui_out
*out
,
346 const char *sym_name
,
347 struct frame_arg
*fa
,
349 const struct value_print_options
*opts
,
350 enum ext_lang_frame_args args_type
,
351 int print_args_field
,
352 const struct language_defn
*language
)
355 enum ext_lang_bt_status retval
= EXT_LANG_BT_OK
;
359 if (fa
->val
== NULL
&& fa
->error
== NULL
)
360 return EXT_LANG_BT_OK
;
361 language
= language_def (SYMBOL_LANGUAGE (fa
->sym
));
369 gdb::optional
<ui_out_emit_tuple
> maybe_tuple
;
371 /* MI has varying rules for tuples, but generally if there is only
372 one element in each item in the list, do not start a tuple. The
373 exception is -stack-list-variables which emits an ARGS="1" field
374 if the value is a frame argument. This is denoted in this
375 function with PRINT_ARGS_FIELD which is flag from the caller to
376 emit the ARGS field. */
377 if (out
->is_mi_like_p ())
379 if (print_args_field
|| args_type
!= NO_VALUES
)
380 maybe_tuple
.emplace (out
, nullptr);
383 annotate_arg_begin ();
385 /* If frame argument is populated, check for entry-values and the
386 entry value options. */
391 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (fa
->sym
),
392 SYMBOL_LANGUAGE (fa
->sym
),
393 DMGL_PARAMS
| DMGL_ANSI
);
394 if (fa
->entry_kind
== print_entry_values_compact
)
398 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (fa
->sym
),
399 SYMBOL_LANGUAGE (fa
->sym
),
400 DMGL_PARAMS
| DMGL_ANSI
);
402 if (fa
->entry_kind
== print_entry_values_only
403 || fa
->entry_kind
== print_entry_values_compact
)
405 out
->field_stream ("name", stb
);
408 /* Otherwise, just output the name. */
409 out
->field_string ("name", sym_name
);
411 annotate_arg_name_end ();
413 if (! out
->is_mi_like_p ())
416 if (print_args_field
)
417 out
->field_int ("arg", 1);
419 /* For MI print the type, but only for simple values. This seems
420 weird, but this is how MI choose to format the various output
422 if (args_type
== MI_PRINT_SIMPLE_VALUES
&& val
!= NULL
)
424 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
425 retval
= EXT_LANG_BT_ERROR
;
428 if (retval
!= EXT_LANG_BT_ERROR
)
431 annotate_arg_value (value_type (val
));
433 /* If the output is to the CLI, and the user option "set print
434 frame-arguments" is set to none, just output "...". */
435 if (! out
->is_mi_like_p () && args_type
== NO_VALUES
)
436 out
->field_string ("value", "...");
439 /* Otherwise, print the value for both MI and the CLI, except
440 for the case of MI_PRINT_NO_VALUES. */
441 if (args_type
!= NO_VALUES
)
445 gdb_assert (fa
!= NULL
&& fa
->error
!= NULL
);
446 out
->field_fmt ("value",
447 _("<error reading variable: %s>"),
450 else if (py_print_value (out
, val
, opts
, 0, args_type
, language
)
451 == EXT_LANG_BT_ERROR
)
452 retval
= EXT_LANG_BT_ERROR
;
457 CATCH (except
, RETURN_MASK_ERROR
)
459 gdbpy_convert_exception (except
);
466 /* Helper function to loop over frame arguments provided by the
467 "frame_arguments" Python API. Elements in the iterator must
468 conform to the "Symbol Value" interface. ITER is the Python
469 iterable object, OUT is the output stream, ARGS_TYPE is an
470 enumerator describing the argument format, PRINT_ARGS_FIELD is a
471 flag which indicates if we output "ARGS=1" in MI output in commands
472 where both arguments and locals are printed, and FRAME is the
473 backing frame. Returns EXT_LANG_BT_ERROR on error, with any GDB
474 exceptions converted to a Python exception, or EXT_LANG_BT_OK on
477 static enum ext_lang_bt_status
478 enumerate_args (PyObject
*iter
,
480 enum ext_lang_frame_args args_type
,
481 int print_args_field
,
482 struct frame_info
*frame
)
484 struct value_print_options opts
;
486 get_user_print_options (&opts
);
488 if (args_type
== CLI_SCALAR_VALUES
)
490 /* True in "summary" mode, false otherwise. */
498 annotate_frame_args ();
500 CATCH (except
, RETURN_MASK_ALL
)
502 gdbpy_convert_exception (except
);
503 return EXT_LANG_BT_ERROR
;
507 /* Collect the first argument outside of the loop, so output of
508 commas in the argument output is correct. At the end of the
509 loop block collect another item from the iterator, and, if it is
510 not null emit a comma. */
511 gdbpy_ref
item (PyIter_Next (iter
));
512 if (item
== NULL
&& PyErr_Occurred ())
513 return EXT_LANG_BT_ERROR
;
517 const struct language_defn
*language
;
518 gdb::unique_xmalloc_ptr
<char> sym_name
;
520 struct block
*sym_block
;
522 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
524 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
526 if (success
== EXT_LANG_BT_ERROR
)
527 return EXT_LANG_BT_ERROR
;
529 success
= extract_value (item
.get (), &val
);
530 if (success
== EXT_LANG_BT_ERROR
)
531 return EXT_LANG_BT_ERROR
;
533 if (sym
&& out
->is_mi_like_p ()
534 && ! mi_should_print (sym
, MI_PRINT_ARGS
))
537 /* If the object did not provide a value, read it using
538 read_frame_args and account for entry values, if any. */
541 struct frame_arg arg
, entryarg
;
543 /* If there is no value, and also no symbol, set error and
547 PyErr_SetString (PyExc_RuntimeError
,
548 _("No symbol or value provided."));
549 return EXT_LANG_BT_ERROR
;
554 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
556 CATCH (except
, RETURN_MASK_ALL
)
558 gdbpy_convert_exception (except
);
559 return EXT_LANG_BT_ERROR
;
563 /* The object has not provided a value, so this is a frame
564 argument to be read by GDB. In this case we have to
565 account for entry-values. */
567 if (arg
.entry_kind
!= print_entry_values_only
)
569 if (py_print_single_arg (out
, NULL
, &arg
,
573 NULL
) == EXT_LANG_BT_ERROR
)
576 xfree (entryarg
.error
);
577 return EXT_LANG_BT_ERROR
;
581 if (entryarg
.entry_kind
!= print_entry_values_no
)
583 if (arg
.entry_kind
!= print_entry_values_only
)
588 out
->wrap_hint (" ");
590 CATCH (except
, RETURN_MASK_ALL
)
593 xfree (entryarg
.error
);
594 gdbpy_convert_exception (except
);
595 return EXT_LANG_BT_ERROR
;
600 if (py_print_single_arg (out
, NULL
, &entryarg
, NULL
, &opts
,
601 args_type
, print_args_field
, NULL
)
602 == EXT_LANG_BT_ERROR
)
605 xfree (entryarg
.error
);
606 return EXT_LANG_BT_ERROR
;
611 xfree (entryarg
.error
);
615 /* If the object has provided a value, we just print that. */
618 if (py_print_single_arg (out
, sym_name
.get (), NULL
, val
, &opts
,
619 args_type
, print_args_field
,
620 language
) == EXT_LANG_BT_ERROR
)
621 return EXT_LANG_BT_ERROR
;
625 /* Collect the next item from the iterator. If
626 this is the last item, do not print the
628 item
.reset (PyIter_Next (iter
));
635 CATCH (except
, RETURN_MASK_ALL
)
637 gdbpy_convert_exception (except
);
638 return EXT_LANG_BT_ERROR
;
642 else if (PyErr_Occurred ())
643 return EXT_LANG_BT_ERROR
;
649 CATCH (except
, RETURN_MASK_ALL
)
651 gdbpy_convert_exception (except
);
652 return EXT_LANG_BT_ERROR
;
657 return EXT_LANG_BT_OK
;
661 /* Helper function to loop over variables provided by the
662 "frame_locals" Python API. Elements in the iterable must conform
663 to the "Symbol Value" interface. ITER is the Python iterable
664 object, OUT is the output stream, INDENT is whether we should
665 indent the output (for CLI), ARGS_TYPE is an enumerator describing
666 the argument format, PRINT_ARGS_FIELD is flag which indicates
667 whether to output the ARGS field in the case of
668 -stack-list-variables and FRAME is the backing frame. Returns
669 EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to a Python
670 exception, or EXT_LANG_BT_OK on success. */
672 static enum ext_lang_bt_status
673 enumerate_locals (PyObject
*iter
,
676 enum ext_lang_frame_args args_type
,
677 int print_args_field
,
678 struct frame_info
*frame
)
680 struct value_print_options opts
;
682 get_user_print_options (&opts
);
687 const struct language_defn
*language
;
688 gdb::unique_xmalloc_ptr
<char> sym_name
;
690 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
692 struct block
*sym_block
;
693 int local_indent
= 8 + (8 * indent
);
694 gdb::optional
<ui_out_emit_tuple
> tuple
;
696 gdbpy_ref
item (PyIter_Next (iter
));
700 success
= extract_sym (item
.get (), &sym_name
, &sym
, &sym_block
,
702 if (success
== EXT_LANG_BT_ERROR
)
703 return EXT_LANG_BT_ERROR
;
705 success
= extract_value (item
.get (), &val
);
706 if (success
== EXT_LANG_BT_ERROR
)
707 return EXT_LANG_BT_ERROR
;
709 if (sym
!= NULL
&& out
->is_mi_like_p ()
710 && ! mi_should_print (sym
, MI_PRINT_LOCALS
))
713 /* If the object did not provide a value, read it. */
718 val
= read_var_value (sym
, sym_block
, frame
);
720 CATCH (except
, RETURN_MASK_ERROR
)
722 gdbpy_convert_exception (except
);
723 return EXT_LANG_BT_ERROR
;
728 /* With PRINT_NO_VALUES, MI does not emit a tuple normally as
729 each output contains only one field. The exception is
730 -stack-list-variables, which always provides a tuple. */
731 if (out
->is_mi_like_p ())
733 if (print_args_field
|| args_type
!= NO_VALUES
)
734 tuple
.emplace (out
, nullptr);
738 if (! out
->is_mi_like_p ())
740 /* If the output is not MI we indent locals. */
741 out
->spaces (local_indent
);
744 out
->field_string ("name", sym_name
.get ());
746 if (! out
->is_mi_like_p ())
749 CATCH (except
, RETURN_MASK_ERROR
)
751 gdbpy_convert_exception (except
);
752 return EXT_LANG_BT_ERROR
;
756 if (args_type
== MI_PRINT_SIMPLE_VALUES
)
758 if (py_print_type (out
, val
) == EXT_LANG_BT_ERROR
)
759 return EXT_LANG_BT_ERROR
;
762 /* CLI always prints values for locals. MI uses the
763 simple/no/all system. */
764 if (! out
->is_mi_like_p ())
766 int val_indent
= (indent
+ 1) * 4;
768 if (py_print_value (out
, val
, &opts
, val_indent
, args_type
,
769 language
) == EXT_LANG_BT_ERROR
)
770 return EXT_LANG_BT_ERROR
;
774 if (args_type
!= NO_VALUES
)
776 if (py_print_value (out
, val
, &opts
, 0, args_type
,
777 language
) == EXT_LANG_BT_ERROR
)
778 return EXT_LANG_BT_ERROR
;
786 CATCH (except
, RETURN_MASK_ERROR
)
788 gdbpy_convert_exception (except
);
789 return EXT_LANG_BT_ERROR
;
794 if (!PyErr_Occurred ())
795 return EXT_LANG_BT_OK
;
797 return EXT_LANG_BT_ERROR
;
800 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
801 error, or EXT_LANG_BT_OK on success. */
803 static enum ext_lang_bt_status
804 py_mi_print_variables (PyObject
*filter
, struct ui_out
*out
,
805 struct value_print_options
*opts
,
806 enum ext_lang_frame_args args_type
,
807 struct frame_info
*frame
)
809 gdbpy_ref
args_iter (get_py_iter_from_func (filter
, "frame_args"));
810 if (args_iter
== NULL
)
811 return EXT_LANG_BT_ERROR
;
813 gdbpy_ref
locals_iter (get_py_iter_from_func (filter
, "frame_locals"));
814 if (locals_iter
== NULL
)
815 return EXT_LANG_BT_ERROR
;
817 ui_out_emit_list
list_emitter (out
, "variables");
819 if (args_iter
!= Py_None
820 && (enumerate_args (args_iter
.get (), out
, args_type
, 1, frame
)
821 == EXT_LANG_BT_ERROR
))
822 return EXT_LANG_BT_ERROR
;
824 if (locals_iter
!= Py_None
825 && (enumerate_locals (locals_iter
.get (), out
, 1, args_type
, 1, frame
)
826 == EXT_LANG_BT_ERROR
))
827 return EXT_LANG_BT_ERROR
;
829 return EXT_LANG_BT_OK
;
832 /* Helper function for printing locals. This function largely just
833 creates the wrapping tuple, and calls enumerate_locals. Returns
834 EXT_LANG_BT_ERROR on error, or EXT_LANG_BT_OK on success. */
836 static enum ext_lang_bt_status
837 py_print_locals (PyObject
*filter
,
839 enum ext_lang_frame_args args_type
,
841 struct frame_info
*frame
)
843 gdbpy_ref
locals_iter (get_py_iter_from_func (filter
, "frame_locals"));
844 if (locals_iter
== NULL
)
845 return EXT_LANG_BT_ERROR
;
847 ui_out_emit_list
list_emitter (out
, "locals");
849 if (locals_iter
!= Py_None
850 && (enumerate_locals (locals_iter
.get (), out
, indent
, args_type
,
851 0, frame
) == EXT_LANG_BT_ERROR
))
852 return EXT_LANG_BT_ERROR
;
854 return EXT_LANG_BT_OK
;
857 /* Helper function for printing frame arguments. This function
858 largely just creates the wrapping tuple, and calls enumerate_args.
859 Returns EXT_LANG_BT_ERROR on error, with any GDB exceptions converted to
860 a Python exception, or EXT_LANG_BT_OK on success. */
862 static enum ext_lang_bt_status
863 py_print_args (PyObject
*filter
,
865 enum ext_lang_frame_args args_type
,
866 struct frame_info
*frame
)
868 gdbpy_ref
args_iter (get_py_iter_from_func (filter
, "frame_args"));
869 if (args_iter
== NULL
)
870 return EXT_LANG_BT_ERROR
;
872 ui_out_emit_list
list_emitter (out
, "args");
876 annotate_frame_args ();
877 if (! out
->is_mi_like_p ())
880 CATCH (except
, RETURN_MASK_ALL
)
882 gdbpy_convert_exception (except
);
883 return EXT_LANG_BT_ERROR
;
887 if (args_iter
!= Py_None
888 && (enumerate_args (args_iter
.get (), out
, args_type
, 0, frame
)
889 == EXT_LANG_BT_ERROR
))
890 return EXT_LANG_BT_ERROR
;
894 if (! out
->is_mi_like_p ())
897 CATCH (except
, RETURN_MASK_ALL
)
899 gdbpy_convert_exception (except
);
900 return EXT_LANG_BT_ERROR
;
904 return EXT_LANG_BT_OK
;
907 /* Print a single frame to the designated output stream, detecting
908 whether the output is MI or console, and formatting the output
909 according to the conventions of that protocol. FILTER is the
910 frame-filter associated with this frame. FLAGS is an integer
911 describing the various print options. The FLAGS variables is
912 described in "apply_frame_filter" function. ARGS_TYPE is an
913 enumerator describing the argument format. OUT is the output
914 stream to print, INDENT is the level of indention for this frame
915 (in the case of elided frames), and LEVELS_PRINTED is a hash-table
916 containing all the frames level that have already been printed.
917 If a frame level has been printed, do not print it again (in the
918 case of elided frames). Returns EXT_LANG_BT_ERROR on error, with any
919 GDB exceptions converted to a Python exception, or EXT_LANG_BT_COMPLETED
920 on success. It can also throw an exception RETURN_QUIT. */
922 static enum ext_lang_bt_status
923 py_print_frame (PyObject
*filter
, int flags
,
924 enum ext_lang_frame_args args_type
,
925 struct ui_out
*out
, int indent
, htab_t levels_printed
)
928 CORE_ADDR address
= 0;
929 struct gdbarch
*gdbarch
= NULL
;
930 struct frame_info
*frame
= NULL
;
931 struct value_print_options opts
;
932 int print_level
, print_frame_info
, print_args
, print_locals
;
933 gdb::unique_xmalloc_ptr
<char> function_to_free
;
935 /* Extract print settings from FLAGS. */
936 print_level
= (flags
& PRINT_LEVEL
) ? 1 : 0;
937 print_frame_info
= (flags
& PRINT_FRAME_INFO
) ? 1 : 0;
938 print_args
= (flags
& PRINT_ARGS
) ? 1 : 0;
939 print_locals
= (flags
& PRINT_LOCALS
) ? 1 : 0;
941 get_user_print_options (&opts
);
943 /* Get the underlying frame. This is needed to determine GDB
944 architecture, and also, in the cases of frame variables/arguments to
945 read them if they returned filter object requires us to do so. */
946 gdbpy_ref
py_inf_frame (PyObject_CallMethod (filter
, "inferior_frame", NULL
));
947 if (py_inf_frame
== NULL
)
948 return EXT_LANG_BT_ERROR
;
950 frame
= frame_object_to_frame_info (py_inf_frame
.get ());
952 return EXT_LANG_BT_ERROR
;
956 gdbarch
= get_frame_arch (frame
);
958 CATCH (except
, RETURN_MASK_ERROR
)
960 gdbpy_convert_exception (except
);
961 return EXT_LANG_BT_ERROR
;
965 /* stack-list-variables. */
966 if (print_locals
&& print_args
&& ! print_frame_info
)
968 if (py_mi_print_variables (filter
, out
, &opts
,
969 args_type
, frame
) == EXT_LANG_BT_ERROR
)
970 return EXT_LANG_BT_ERROR
;
971 return EXT_LANG_BT_COMPLETED
;
974 gdb::optional
<ui_out_emit_tuple
> tuple
;
976 /* -stack-list-locals does not require a
977 wrapping frame attribute. */
978 if (print_frame_info
|| (print_args
&& ! print_locals
))
979 tuple
.emplace (out
, "frame");
981 if (print_frame_info
)
983 /* Elided frames are also printed with this function (recursively)
984 and are printed with indention. */
989 out
->spaces (indent
* 4);
991 CATCH (except
, RETURN_MASK_ERROR
)
993 gdbpy_convert_exception (except
);
994 return EXT_LANG_BT_ERROR
;
999 /* The address is required for frame annotations, and also for
1000 address printing. */
1001 if (PyObject_HasAttrString (filter
, "address"))
1003 gdbpy_ref
paddr (PyObject_CallMethod (filter
, "address", NULL
));
1006 return EXT_LANG_BT_ERROR
;
1008 if (paddr
!= Py_None
)
1010 if (get_addr_from_python (paddr
.get (), &address
) < 0)
1011 return EXT_LANG_BT_ERROR
;
1018 /* Print frame level. MI does not require the level if
1019 locals/variables only are being printed. */
1020 if ((print_frame_info
|| print_args
) && print_level
)
1022 struct frame_info
**slot
;
1025 slot
= (struct frame_info
**) htab_find_slot (levels_printed
,
1029 level
= frame_relative_level (frame
);
1031 /* Check if this frame has already been printed (there are cases
1032 where elided synthetic dummy-frames have to 'borrow' the frame
1033 architecture from the eliding frame. If that is the case, do
1034 not print 'level', but print spaces. */
1036 out
->field_skip ("level");
1040 annotate_frame_begin (print_level
? level
: 0,
1043 out
->field_fmt_int (2, ui_left
, "level",
1047 CATCH (except
, RETURN_MASK_ERROR
)
1049 gdbpy_convert_exception (except
);
1050 return EXT_LANG_BT_ERROR
;
1055 if (print_frame_info
)
1057 /* Print address to the address field. If an address is not provided,
1059 if (opts
.addressprint
&& has_addr
)
1063 annotate_frame_address ();
1064 out
->field_core_addr ("addr", gdbarch
, address
);
1065 annotate_frame_address_end ();
1068 CATCH (except
, RETURN_MASK_ERROR
)
1070 gdbpy_convert_exception (except
);
1071 return EXT_LANG_BT_ERROR
;
1076 /* Print frame function name. */
1077 if (PyObject_HasAttrString (filter
, "function"))
1079 gdbpy_ref
py_func (PyObject_CallMethod (filter
, "function", NULL
));
1080 const char *function
= NULL
;
1082 if (py_func
== NULL
)
1083 return EXT_LANG_BT_ERROR
;
1085 if (gdbpy_is_string (py_func
.get ()))
1087 function_to_free
= python_string_to_host_string (py_func
.get ());
1089 if (function_to_free
== NULL
)
1090 return EXT_LANG_BT_ERROR
;
1092 function
= function_to_free
.get ();
1094 else if (PyLong_Check (py_func
.get ()))
1097 struct bound_minimal_symbol msymbol
;
1099 if (get_addr_from_python (py_func
.get (), &addr
) < 0)
1100 return EXT_LANG_BT_ERROR
;
1102 msymbol
= lookup_minimal_symbol_by_pc (addr
);
1103 if (msymbol
.minsym
!= NULL
)
1104 function
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1106 else if (py_func
!= Py_None
)
1108 PyErr_SetString (PyExc_RuntimeError
,
1109 _("FrameDecorator.function: expecting a " \
1110 "String, integer or None."));
1111 return EXT_LANG_BT_ERROR
;
1116 annotate_frame_function_name ();
1117 if (function
== NULL
)
1118 out
->field_skip ("func");
1120 out
->field_string ("func", function
);
1122 CATCH (except
, RETURN_MASK_ERROR
)
1124 gdbpy_convert_exception (except
);
1125 return EXT_LANG_BT_ERROR
;
1132 /* Frame arguments. Check the result, and error if something went
1136 if (py_print_args (filter
, out
, args_type
, frame
) == EXT_LANG_BT_ERROR
)
1137 return EXT_LANG_BT_ERROR
;
1140 /* File name/source/line number information. */
1141 if (print_frame_info
)
1145 annotate_frame_source_begin ();
1147 CATCH (except
, RETURN_MASK_ERROR
)
1149 gdbpy_convert_exception (except
);
1150 return EXT_LANG_BT_ERROR
;
1154 if (PyObject_HasAttrString (filter
, "filename"))
1156 gdbpy_ref
py_fn (PyObject_CallMethod (filter
, "filename", NULL
));
1159 return EXT_LANG_BT_ERROR
;
1161 if (py_fn
!= Py_None
)
1163 gdb::unique_xmalloc_ptr
<char>
1164 filename (python_string_to_host_string (py_fn
.get ()));
1166 if (filename
== NULL
)
1167 return EXT_LANG_BT_ERROR
;
1171 out
->wrap_hint (" ");
1173 annotate_frame_source_file ();
1174 out
->field_string ("file", filename
.get ());
1175 annotate_frame_source_file_end ();
1177 CATCH (except
, RETURN_MASK_ERROR
)
1179 gdbpy_convert_exception (except
);
1180 return EXT_LANG_BT_ERROR
;
1186 if (PyObject_HasAttrString (filter
, "line"))
1188 gdbpy_ref
py_line (PyObject_CallMethod (filter
, "line", NULL
));
1191 if (py_line
== NULL
)
1192 return EXT_LANG_BT_ERROR
;
1194 if (py_line
!= Py_None
)
1196 line
= PyLong_AsLong (py_line
.get ());
1197 if (PyErr_Occurred ())
1198 return EXT_LANG_BT_ERROR
;
1203 annotate_frame_source_line ();
1204 out
->field_int ("line", line
);
1206 CATCH (except
, RETURN_MASK_ERROR
)
1208 gdbpy_convert_exception (except
);
1209 return EXT_LANG_BT_ERROR
;
1216 /* For MI we need to deal with the "children" list population of
1217 elided frames, so if MI output detected do not send newline. */
1218 if (! out
->is_mi_like_p ())
1222 annotate_frame_end ();
1225 CATCH (except
, RETURN_MASK_ERROR
)
1227 gdbpy_convert_exception (except
);
1228 return EXT_LANG_BT_ERROR
;
1235 if (py_print_locals (filter
, out
, args_type
, indent
,
1236 frame
) == EXT_LANG_BT_ERROR
)
1237 return EXT_LANG_BT_ERROR
;
1241 /* Finally recursively print elided frames, if any. */
1242 gdbpy_ref
elided (get_py_iter_from_func (filter
, "elided"));
1244 return EXT_LANG_BT_ERROR
;
1246 if (elided
!= Py_None
)
1250 ui_out_emit_list
inner_list_emiter (out
, "children");
1252 if (! out
->is_mi_like_p ())
1255 while ((item
= PyIter_Next (elided
.get ())))
1257 gdbpy_ref
item_ref (item
);
1259 enum ext_lang_bt_status success
= py_print_frame (item
, flags
,
1264 if (success
== EXT_LANG_BT_ERROR
)
1265 return EXT_LANG_BT_ERROR
;
1267 if (item
== NULL
&& PyErr_Occurred ())
1268 return EXT_LANG_BT_ERROR
;
1272 return EXT_LANG_BT_COMPLETED
;
1275 /* Helper function to initiate frame filter invocation at starting
1279 bootstrap_python_frame_filters (struct frame_info
*frame
,
1280 int frame_low
, int frame_high
)
1282 gdbpy_ref
frame_obj (frame_info_to_frame_object (frame
));
1283 if (frame_obj
== NULL
)
1286 gdbpy_ref
module (PyImport_ImportModule ("gdb.frames"));
1290 gdbpy_ref
sort_func (PyObject_GetAttrString (module
.get (),
1291 "execute_frame_filters"));
1292 if (sort_func
== NULL
)
1295 gdbpy_ref
py_frame_low (PyInt_FromLong (frame_low
));
1296 if (py_frame_low
== NULL
)
1299 gdbpy_ref
py_frame_high (PyInt_FromLong (frame_high
));
1300 if (py_frame_high
== NULL
)
1303 gdbpy_ref
iterable (PyObject_CallFunctionObjArgs (sort_func
.get (),
1305 py_frame_low
.get (),
1306 py_frame_high
.get (),
1308 if (iterable
== NULL
)
1311 if (iterable
!= Py_None
)
1312 return PyObject_GetIter (iterable
.get ());
1314 return iterable
.release ();
1317 /* This is the only publicly exported function in this file. FRAME
1318 is the source frame to start frame-filter invocation. FLAGS is an
1319 integer holding the flags for printing. The following elements of
1320 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1321 PRINT_LEVEL is a flag indicating whether to print the frame's
1322 relative level in the output. PRINT_FRAME_INFO is a flag that
1323 indicates whether this function should print the frame
1324 information, PRINT_ARGS is a flag that indicates whether to print
1325 frame arguments, and PRINT_LOCALS, likewise, with frame local
1326 variables. ARGS_TYPE is an enumerator describing the argument
1327 format, OUT is the output stream to print. FRAME_LOW is the
1328 beginning of the slice of frames to print, and FRAME_HIGH is the
1329 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1330 or EXT_LANG_BT_COMPLETED on success. */
1332 enum ext_lang_bt_status
1333 gdbpy_apply_frame_filter (const struct extension_language_defn
*extlang
,
1334 struct frame_info
*frame
, int flags
,
1335 enum ext_lang_frame_args args_type
,
1336 struct ui_out
*out
, int frame_low
, int frame_high
)
1338 struct gdbarch
*gdbarch
= NULL
;
1339 enum ext_lang_bt_status success
= EXT_LANG_BT_ERROR
;
1341 if (!gdb_python_initialized
)
1342 return EXT_LANG_BT_NO_FILTERS
;
1346 gdbarch
= get_frame_arch (frame
);
1348 CATCH (except
, RETURN_MASK_ALL
)
1350 /* Let gdb try to print the stack trace. */
1351 return EXT_LANG_BT_NO_FILTERS
;
1355 gdbpy_enter
enter_py (gdbarch
, current_language
);
1357 gdbpy_ref
iterable (bootstrap_python_frame_filters (frame
, frame_low
,
1360 if (iterable
== NULL
)
1362 /* Normally if there is an error GDB prints the exception,
1363 abandons the backtrace and exits. The user can then call "bt
1364 no-filters", and get a default backtrace (it would be
1365 confusing to automatically start a standard backtrace halfway
1366 through a Python filtered backtrace). However in the case
1367 where GDB cannot initialize the frame filters (most likely
1368 due to incorrect auto-load paths), GDB has printed nothing.
1369 In this case it is OK to print the default backtrace after
1370 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1371 here to signify there are no filters after printing the
1372 initialization error. This return code will trigger a
1373 default backtrace. */
1375 gdbpy_print_stack ();
1376 return EXT_LANG_BT_NO_FILTERS
;
1379 /* If iterable is None, then there are no frame filters registered.
1380 If this is the case, defer to default GDB printing routines in MI
1382 if (iterable
== Py_None
)
1383 return EXT_LANG_BT_NO_FILTERS
;
1385 htab_up
levels_printed (htab_create (20,
1392 gdbpy_ref
item (PyIter_Next (iterable
.get ()));
1396 if (PyErr_Occurred ())
1398 gdbpy_print_stack ();
1399 return EXT_LANG_BT_ERROR
;
1404 success
= py_print_frame (item
.get (), flags
, args_type
, out
, 0,
1405 levels_printed
.get ());
1407 /* Do not exit on error printing a single frame. Print the
1408 error and continue with other frames. */
1409 if (success
== EXT_LANG_BT_ERROR
)
1410 gdbpy_print_stack ();