GDB (xrefs)

py-framefilter.c
Go to the documentation of this file.
1 /* Python frame filters
2
3 Copyright (C) 2013-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "objfiles.h"
22 #include "symtab.h"
23 #include "language.h"
24 #include "arch-utils.h"
25 #include "python.h"
26 #include "ui-out.h"
27 #include "valprint.h"
28 #include "annotate.h"
29 #include "hashtab.h"
30 #include "demangle.h"
31 #include "mi/mi-cmds.h"
32 #include "python-internal.h"
33 #include "py-ref.h"
34 #include "common/gdb_optional.h"
35
36 enum mi_print_types
37 {
38 MI_PRINT_ARGS,
39 MI_PRINT_LOCALS
40 };
41
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. */
55
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)
60 {
61 gdbpy_ref<> result (PyObject_CallMethod (obj, "symbol", NULL));
62
63 if (result == NULL)
64 return EXT_LANG_BT_ERROR;
65
66 /* For 'symbol' callback, the function can return a symbol or a
67 string. */
68 if (gdbpy_is_string (result.get ()))
69 {
70 *name = python_string_to_host_string (result.get ());
71
72 if (*name == NULL)
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
78 python_language. */
79 *language = python_language;
80 *sym = NULL;
81 *sym_block = NULL;
82 }
83 else
84 {
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). */
92 *sym_block = NULL;
93
94 if (*sym == NULL)
95 {
96 PyErr_SetString (PyExc_RuntimeError,
97 _("Unexpected value. Expecting a "
98 "gdb.Symbol or a Python string."));
99 return EXT_LANG_BT_ERROR;
100 }
101
102 /* Duplicate the symbol name, so the caller has consistency
103 in garbage collection. */
104 name->reset (xstrdup (SYMBOL_PRINT_NAME (*sym)));
105
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));
111 else
112 *language = current_language;
113 }
114
115 return EXT_LANG_BT_OK;
116 }
117
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
125 success. */
126
127 static enum ext_lang_bt_status
128 extract_value (PyObject *obj, struct value **value)
129 {
130 if (PyObject_HasAttrString (obj, "value"))
131 {
132 gdbpy_ref<> vresult (PyObject_CallMethod (obj, "value", NULL));
133
134 if (vresult == NULL)
135 return EXT_LANG_BT_ERROR;
136
137 /* The Python code has returned 'None' for a value, so we set
138 value to NULL. This flags that GDB should read the
139 value. */
140 if (vresult == Py_None)
141 {
142 *value = NULL;
143 return EXT_LANG_BT_OK;
144 }
145 else
146 {
147 *value = convert_value_from_python (vresult.get ());
148
149 if (*value == NULL)
150 return EXT_LANG_BT_ERROR;
151
152 return EXT_LANG_BT_OK;
153 }
154 }
155 else
156 *value = NULL;
157
158 return EXT_LANG_BT_OK;
159 }
160
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. */
165 static int
166 mi_should_print (struct symbol *sym, enum mi_print_types type)
167 {
168 int print_me = 0;
169
170 switch (SYMBOL_CLASS (sym))
171 {
172 default:
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 */
181 print_me = 0;
182 break;
183
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);
193 else
194 print_me = SYMBOL_IS_ARGUMENT (sym);
195 }
196 return print_me;
197 }
198
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
204 success. */
205
206 static enum ext_lang_bt_status
207 py_print_type (struct ui_out *out, struct value *val)
208 {
209
210 TRY
211 {
212 check_typedef (value_type (val));
213
214 string_file stb;
215 type_print (value_type (val), "", &stb, -1);
216 out->field_stream ("type", stb);
217 }
218 CATCH (except, RETURN_MASK_ALL)
219 {
220 gdbpy_convert_exception (except);
221 return EXT_LANG_BT_ERROR;
222 }
223 END_CATCH
224
225 return EXT_LANG_BT_OK;
226 }
227
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
235 success. */
236
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,
240 int indent,
241 enum ext_lang_frame_args args_type,
242 const struct language_defn *language)
243 {
244 int should_print = 0;
245
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)
251 {
252 struct type *type = NULL;
253
254 TRY
255 {
256 type = check_typedef (value_type (val));
257 }
258 CATCH (except, RETURN_MASK_ALL)
259 {
260 gdbpy_convert_exception (except);
261 return EXT_LANG_BT_ERROR;
262 }
263 END_CATCH
264
265 if (args_type == MI_PRINT_ALL_VALUES)
266 should_print = 1;
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)
271 should_print = 1;
272 }
273 else if (args_type != NO_VALUES)
274 should_print = 1;
275
276 if (should_print)
277 {
278 TRY
279 {
280 string_file stb;
281
282 common_val_print (val, &stb, indent, opts, language);
283 out->field_stream ("value", stb);
284 }
285 CATCH (except, RETURN_MASK_ALL)
286 {
287 gdbpy_convert_exception (except);
288 return EXT_LANG_BT_ERROR;
289 }
290 END_CATCH
291 }
292
293 return EXT_LANG_BT_OK;
294 }
295
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. */
302
303 static PyObject *
304 get_py_iter_from_func (PyObject *filter, const char *func)
305 {
306 if (PyObject_HasAttrString (filter, func))
307 {
308 gdbpy_ref<> result (PyObject_CallMethod (filter, func, NULL));
309
310 if (result != NULL)
311 {
312 if (result == Py_None)
313 {
314 return result.release ();
315 }
316 else
317 {
318 return PyObject_GetIter (result.get ());
319 }
320 }
321 }
322 else
323 Py_RETURN_NONE;
324
325 return NULL;
326 }
327
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. */
343
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,
348 struct value *fv,
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)
353 {
354 struct value *val;
355 enum ext_lang_bt_status retval = EXT_LANG_BT_OK;
356
357 if (fa != NULL)
358 {
359 if (fa->val == NULL && fa->error == NULL)
360 return EXT_LANG_BT_OK;
361 language = language_def (SYMBOL_LANGUAGE (fa->sym));
362 val = fa->val;
363 }
364 else
365 val = fv;
366
367 TRY
368 {
369 gdb::optional<ui_out_emit_tuple> maybe_tuple;
370
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 ())
378 {
379 if (print_args_field || args_type != NO_VALUES)
380 maybe_tuple.emplace (out, nullptr);
381 }
382
383 annotate_arg_begin ();
384
385 /* If frame argument is populated, check for entry-values and the
386 entry value options. */
387 if (fa != NULL)
388 {
389 string_file stb;
390
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)
395 {
396 stb.puts ("=");
397
398 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (fa->sym),
399 SYMBOL_LANGUAGE (fa->sym),
400 DMGL_PARAMS | DMGL_ANSI);
401 }
402 if (fa->entry_kind == print_entry_values_only
403 || fa->entry_kind == print_entry_values_compact)
404 stb.puts ("@entry");
405 out->field_stream ("name", stb);
406 }
407 else
408 /* Otherwise, just output the name. */
409 out->field_string ("name", sym_name);
410
411 annotate_arg_name_end ();
412
413 if (! out->is_mi_like_p ())
414 out->text ("=");
415
416 if (print_args_field)
417 out->field_int ("arg", 1);
418
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
421 types. */
422 if (args_type == MI_PRINT_SIMPLE_VALUES && val != NULL)
423 {
424 if (py_print_type (out, val) == EXT_LANG_BT_ERROR)
425 retval = EXT_LANG_BT_ERROR;
426 }
427
428 if (retval != EXT_LANG_BT_ERROR)
429 {
430 if (val != NULL)
431 annotate_arg_value (value_type (val));
432
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", "...");
437 else
438 {
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)
442 {
443 if (val == NULL)
444 {
445 gdb_assert (fa != NULL && fa->error != NULL);
446 out->field_fmt ("value",
447 _("<error reading variable: %s>"),
448 fa->error);
449 }
450 else if (py_print_value (out, val, opts, 0, args_type, language)
451 == EXT_LANG_BT_ERROR)
452 retval = EXT_LANG_BT_ERROR;
453 }
454 }
455 }
456 }
457 CATCH (except, RETURN_MASK_ERROR)
458 {
459 gdbpy_convert_exception (except);
460 }
461 END_CATCH
462
463 return retval;
464 }
465
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
475 success. */
476
477 static enum ext_lang_bt_status
478 enumerate_args (PyObject *iter,
479 struct ui_out *out,
480 enum ext_lang_frame_args args_type,
481 int print_args_field,
482 struct frame_info *frame)
483 {
484 struct value_print_options opts;
485
486 get_user_print_options (&opts);
487
488 if (args_type == CLI_SCALAR_VALUES)
489 {
490 /* True in "summary" mode, false otherwise. */
491 opts.summary = 1;
492 }
493
494 opts.deref_ref = 1;
495
496 TRY
497 {
498 annotate_frame_args ();
499 }
500 CATCH (except, RETURN_MASK_ALL)
501 {
502 gdbpy_convert_exception (except);
503 return EXT_LANG_BT_ERROR;
504 }
505 END_CATCH
506
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;
514
515 while (item != NULL)
516 {
517 const struct language_defn *language;
518 gdb::unique_xmalloc_ptr<char> sym_name;
519 struct symbol *sym;
520 struct block *sym_block;
521 struct value *val;
522 enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
523
524 success = extract_sym (item.get (), &sym_name, &sym, &sym_block,
525 &language);
526 if (success == EXT_LANG_BT_ERROR)
527 return EXT_LANG_BT_ERROR;
528
529 success = extract_value (item.get (), &val);
530 if (success == EXT_LANG_BT_ERROR)
531 return EXT_LANG_BT_ERROR;
532
533 if (sym && out->is_mi_like_p ()
534 && ! mi_should_print (sym, MI_PRINT_ARGS))
535 continue;
536
537 /* If the object did not provide a value, read it using
538 read_frame_args and account for entry values, if any. */
539 if (val == NULL)
540 {
541 struct frame_arg arg, entryarg;
542
543 /* If there is no value, and also no symbol, set error and
544 exit. */
545 if (sym == NULL)
546 {
547 PyErr_SetString (PyExc_RuntimeError,
548 _("No symbol or value provided."));
549 return EXT_LANG_BT_ERROR;
550 }
551
552 TRY
553 {
554 read_frame_arg (sym, frame, &arg, &entryarg);
555 }
556 CATCH (except, RETURN_MASK_ALL)
557 {
558 gdbpy_convert_exception (except);
559 return EXT_LANG_BT_ERROR;
560 }
561 END_CATCH
562
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. */
566
567 if (arg.entry_kind != print_entry_values_only)
568 {
569 if (py_print_single_arg (out, NULL, &arg,
570 NULL, &opts,
571 args_type,
572 print_args_field,
573 NULL) == EXT_LANG_BT_ERROR)
574 {
575 xfree (arg.error);
576 xfree (entryarg.error);
577 return EXT_LANG_BT_ERROR;
578 }
579 }
580
581 if (entryarg.entry_kind != print_entry_values_no)
582 {
583 if (arg.entry_kind != print_entry_values_only)
584 {
585 TRY
586 {
587 out->text (", ");
588 out->wrap_hint (" ");
589 }
590 CATCH (except, RETURN_MASK_ALL)
591 {
592 xfree (arg.error);
593 xfree (entryarg.error);
594 gdbpy_convert_exception (except);
595 return EXT_LANG_BT_ERROR;
596 }
597 END_CATCH
598 }
599
600 if (py_print_single_arg (out, NULL, &entryarg, NULL, &opts,
601 args_type, print_args_field, NULL)
602 == EXT_LANG_BT_ERROR)
603 {
604 xfree (arg.error);
605 xfree (entryarg.error);
606 return EXT_LANG_BT_ERROR;
607 }
608 }
609
610 xfree (arg.error);
611 xfree (entryarg.error);
612 }
613 else
614 {
615 /* If the object has provided a value, we just print that. */
616 if (val != NULL)
617 {
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;
622 }
623 }
624
625 /* Collect the next item from the iterator. If
626 this is the last item, do not print the
627 comma. */
628 item.reset (PyIter_Next (iter));
629 if (item != NULL)
630 {
631 TRY
632 {
633 out->text (", ");
634 }
635 CATCH (except, RETURN_MASK_ALL)
636 {
637 gdbpy_convert_exception (except);
638 return EXT_LANG_BT_ERROR;
639 }
640 END_CATCH
641 }
642 else if (PyErr_Occurred ())
643 return EXT_LANG_BT_ERROR;
644
645 TRY
646 {
647 annotate_arg_end ();
648 }
649 CATCH (except, RETURN_MASK_ALL)
650 {
651 gdbpy_convert_exception (except);
652 return EXT_LANG_BT_ERROR;
653 }
654 END_CATCH
655 }
656
657 return EXT_LANG_BT_OK;
658 }
659
660
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. */
671
672 static enum ext_lang_bt_status
673 enumerate_locals (PyObject *iter,
674 struct ui_out *out,
675 int indent,
676 enum ext_lang_frame_args args_type,
677 int print_args_field,
678 struct frame_info *frame)
679 {
680 struct value_print_options opts;
681
682 get_user_print_options (&opts);
683 opts.deref_ref = 1;
684
685 while (true)
686 {
687 const struct language_defn *language;
688 gdb::unique_xmalloc_ptr<char> sym_name;
689 struct value *val;
690 enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
691 struct symbol *sym;
692 struct block *sym_block;
693 int local_indent = 8 + (8 * indent);
694 gdb::optional<ui_out_emit_tuple> tuple;
695
696 gdbpy_ref<> item (PyIter_Next (iter));
697 if (item == NULL)
698 break;
699
700 success = extract_sym (item.get (), &sym_name, &sym, &sym_block,
701 &language);
702 if (success == EXT_LANG_BT_ERROR)
703 return EXT_LANG_BT_ERROR;
704
705 success = extract_value (item.get (), &val);
706 if (success == EXT_LANG_BT_ERROR)
707 return EXT_LANG_BT_ERROR;
708
709 if (sym != NULL && out->is_mi_like_p ()
710 && ! mi_should_print (sym, MI_PRINT_LOCALS))
711 continue;
712
713 /* If the object did not provide a value, read it. */
714 if (val == NULL)
715 {
716 TRY
717 {
718 val = read_var_value (sym, sym_block, frame);
719 }
720 CATCH (except, RETURN_MASK_ERROR)
721 {
722 gdbpy_convert_exception (except);
723 return EXT_LANG_BT_ERROR;
724 }
725 END_CATCH
726 }
727
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 ())
732 {
733 if (print_args_field || args_type != NO_VALUES)
734 tuple.emplace (out, nullptr);
735 }
736 TRY
737 {
738 if (! out->is_mi_like_p ())
739 {
740 /* If the output is not MI we indent locals. */
741 out->spaces (local_indent);
742 }
743
744 out->field_string ("name", sym_name.get ());
745
746 if (! out->is_mi_like_p ())
747 out->text (" = ");
748 }
749 CATCH (except, RETURN_MASK_ERROR)
750 {
751 gdbpy_convert_exception (except);
752 return EXT_LANG_BT_ERROR;
753 }
754 END_CATCH
755
756 if (args_type == MI_PRINT_SIMPLE_VALUES)
757 {
758 if (py_print_type (out, val) == EXT_LANG_BT_ERROR)
759 return EXT_LANG_BT_ERROR;
760 }
761
762 /* CLI always prints values for locals. MI uses the
763 simple/no/all system. */
764 if (! out->is_mi_like_p ())
765 {
766 int val_indent = (indent + 1) * 4;
767
768 if (py_print_value (out, val, &opts, val_indent, args_type,
769 language) == EXT_LANG_BT_ERROR)
770 return EXT_LANG_BT_ERROR;
771 }
772 else
773 {
774 if (args_type != NO_VALUES)
775 {
776 if (py_print_value (out, val, &opts, 0, args_type,
777 language) == EXT_LANG_BT_ERROR)
778 return EXT_LANG_BT_ERROR;
779 }
780 }
781
782 TRY
783 {
784 out->text ("\n");
785 }
786 CATCH (except, RETURN_MASK_ERROR)
787 {
788 gdbpy_convert_exception (except);
789 return EXT_LANG_BT_ERROR;
790 }
791 END_CATCH
792 }
793
794 if (!PyErr_Occurred ())
795 return EXT_LANG_BT_OK;
796
797 return EXT_LANG_BT_ERROR;
798 }
799
800 /* Helper function for -stack-list-variables. Returns EXT_LANG_BT_ERROR on
801 error, or EXT_LANG_BT_OK on success. */
802
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)
808 {
809 gdbpy_ref<> args_iter (get_py_iter_from_func (filter, "frame_args"));
810 if (args_iter == NULL)
811 return EXT_LANG_BT_ERROR;
812
813 gdbpy_ref<> locals_iter (get_py_iter_from_func (filter, "frame_locals"));
814 if (locals_iter == NULL)
815 return EXT_LANG_BT_ERROR;
816
817 ui_out_emit_list list_emitter (out, "variables");
818
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;
823
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;
828
829 return EXT_LANG_BT_OK;
830 }
831
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. */
835
836 static enum ext_lang_bt_status
837 py_print_locals (PyObject *filter,
838 struct ui_out *out,
839 enum ext_lang_frame_args args_type,
840 int indent,
841 struct frame_info *frame)
842 {
843 gdbpy_ref<> locals_iter (get_py_iter_from_func (filter, "frame_locals"));
844 if (locals_iter == NULL)
845 return EXT_LANG_BT_ERROR;
846
847 ui_out_emit_list list_emitter (out, "locals");
848
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;
853
854 return EXT_LANG_BT_OK;
855 }
856
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. */
861
862 static enum ext_lang_bt_status
863 py_print_args (PyObject *filter,
864 struct ui_out *out,
865 enum ext_lang_frame_args args_type,
866 struct frame_info *frame)
867 {
868 gdbpy_ref<> args_iter (get_py_iter_from_func (filter, "frame_args"));
869 if (args_iter == NULL)
870 return EXT_LANG_BT_ERROR;
871
872 ui_out_emit_list list_emitter (out, "args");
873
874 TRY
875 {
876 annotate_frame_args ();
877 if (! out->is_mi_like_p ())
878 out->text (" (");
879 }
880 CATCH (except, RETURN_MASK_ALL)
881 {
882 gdbpy_convert_exception (except);
883 return EXT_LANG_BT_ERROR;
884 }
885 END_CATCH
886
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;
891
892 TRY
893 {
894 if (! out->is_mi_like_p ())
895 out->text (")");
896 }
897 CATCH (except, RETURN_MASK_ALL)
898 {
899 gdbpy_convert_exception (except);
900 return EXT_LANG_BT_ERROR;
901 }
902 END_CATCH
903
904 return EXT_LANG_BT_OK;
905 }
906
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. */
921
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)
926 {
927 int has_addr = 0;
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;
934
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;
940
941 get_user_print_options (&opts);
942
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",
947 NULL));
948 if (py_inf_frame == NULL)
949 return EXT_LANG_BT_ERROR;
950
951 frame = frame_object_to_frame_info (py_inf_frame.get ());
952 if (frame == NULL)
953 return EXT_LANG_BT_ERROR;
954
955 TRY
956 {
957 gdbarch = get_frame_arch (frame);
958 }
959 CATCH (except, RETURN_MASK_ERROR)
960 {
961 gdbpy_convert_exception (except);
962 return EXT_LANG_BT_ERROR;
963 }
964 END_CATCH
965
966 /* stack-list-variables. */
967 if (print_locals && print_args && ! print_frame_info)
968 {
969 if (py_mi_print_variables (filter, out, &opts,
970 args_type, frame) == EXT_LANG_BT_ERROR)
971 return EXT_LANG_BT_ERROR;
972 return EXT_LANG_BT_COMPLETED;
973 }
974
975 gdb::optional<ui_out_emit_tuple> tuple;
976
977 /* -stack-list-locals does not require a
978 wrapping frame attribute. */
979 if (print_frame_info || (print_args && ! print_locals))
980 tuple.emplace (out, "frame");
981
982 if (print_frame_info)
983 {
984 /* Elided frames are also printed with this function (recursively)
985 and are printed with indention. */
986 if (indent > 0)
987 {
988 TRY
989 {
990 out->spaces (indent * 4);
991 }
992 CATCH (except, RETURN_MASK_ERROR)
993 {
994 gdbpy_convert_exception (except);
995 return EXT_LANG_BT_ERROR;
996 }
997 END_CATCH
998 }
999
1000 /* The address is required for frame annotations, and also for
1001 address printing. */
1002 if (PyObject_HasAttrString (filter, "address"))
1003 {
1004 gdbpy_ref<> paddr (PyObject_CallMethod (filter, "address", NULL));
1005
1006 if (paddr == NULL)
1007 return EXT_LANG_BT_ERROR;
1008
1009 if (paddr != Py_None)
1010 {
1011 if (get_addr_from_python (paddr.get (), &address) < 0)
1012 return EXT_LANG_BT_ERROR;
1013
1014 has_addr = 1;
1015 }
1016 }
1017 }
1018
1019 /* Print frame level. MI does not require the level if
1020 locals/variables only are being printed. */
1021 if ((print_frame_info || print_args) && print_level)
1022 {
1023 struct frame_info **slot;
1024 int level;
1025
1026 slot = (struct frame_info **) htab_find_slot (levels_printed,
1027 frame, INSERT);
1028 TRY
1029 {
1030 level = frame_relative_level (frame);
1031
1032 /* Check if this frame has already been printed (there are cases
1033 where elided synthetic dummy-frames have to 'borrow' the frame
1034 architecture from the eliding frame. If that is the case, do
1035 not print 'level', but print spaces. */
1036 if (*slot == frame)
1037 out->field_skip ("level");
1038 else
1039 {
1040 *slot = frame;
1041 annotate_frame_begin (print_level ? level : 0,
1042 gdbarch, address);
1043 out->text ("#");
1044 out->field_fmt_int (2, ui_left, "level",
1045 level);
1046 }
1047 }
1048 CATCH (except, RETURN_MASK_ERROR)
1049 {
1050 gdbpy_convert_exception (except);
1051 return EXT_LANG_BT_ERROR;
1052 }
1053 END_CATCH
1054 }
1055
1056 if (print_frame_info)
1057 {
1058 /* Print address to the address field. If an address is not provided,
1059 print nothing. */
1060 if (opts.addressprint && has_addr)
1061 {
1062 TRY
1063 {
1064 annotate_frame_address ();
1065 out->field_core_addr ("addr", gdbarch, address);
1066 annotate_frame_address_end ();
1067 out->text (" in ");
1068 }
1069 CATCH (except, RETURN_MASK_ERROR)
1070 {
1071 gdbpy_convert_exception (except);
1072 return EXT_LANG_BT_ERROR;
1073 }
1074 END_CATCH
1075 }
1076
1077 /* Print frame function name. */
1078 if (PyObject_HasAttrString (filter, "function"))
1079 {
1080 gdbpy_ref<> py_func (PyObject_CallMethod (filter, "function", NULL));
1081 const char *function = NULL;
1082
1083 if (py_func == NULL)
1084 return EXT_LANG_BT_ERROR;
1085
1086 if (gdbpy_is_string (py_func.get ()))
1087 {
1088 function_to_free = python_string_to_host_string (py_func.get ());
1089
1090 if (function_to_free == NULL)
1091 return EXT_LANG_BT_ERROR;
1092
1093 function = function_to_free.get ();
1094 }
1095 else if (PyLong_Check (py_func.get ()))
1096 {
1097 CORE_ADDR addr;
1098 struct bound_minimal_symbol msymbol;
1099
1100 if (get_addr_from_python (py_func.get (), &addr) < 0)
1101 return EXT_LANG_BT_ERROR;
1102
1103 msymbol = lookup_minimal_symbol_by_pc (addr);
1104 if (msymbol.minsym != NULL)
1105 function = MSYMBOL_PRINT_NAME (msymbol.minsym);
1106 }
1107 else if (py_func != Py_None)
1108 {
1109 PyErr_SetString (PyExc_RuntimeError,
1110 _("FrameDecorator.function: expecting a " \
1111 "String, integer or None."));
1112 return EXT_LANG_BT_ERROR;
1113 }
1114
1115 TRY
1116 {
1117 annotate_frame_function_name ();
1118 if (function == NULL)
1119 out->field_skip ("func");
1120 else
1121 out->field_string ("func", function);
1122 }
1123 CATCH (except, RETURN_MASK_ERROR)
1124 {
1125 gdbpy_convert_exception (except);
1126 return EXT_LANG_BT_ERROR;
1127 }
1128 END_CATCH
1129 }
1130 }
1131
1132
1133 /* Frame arguments. Check the result, and error if something went
1134 wrong. */
1135 if (print_args)
1136 {
1137 if (py_print_args (filter, out, args_type, frame) == EXT_LANG_BT_ERROR)
1138 return EXT_LANG_BT_ERROR;
1139 }
1140
1141 /* File name/source/line number information. */
1142 if (print_frame_info)
1143 {
1144 TRY
1145 {
1146 annotate_frame_source_begin ();
1147 }
1148 CATCH (except, RETURN_MASK_ERROR)
1149 {
1150 gdbpy_convert_exception (except);
1151 return EXT_LANG_BT_ERROR;
1152 }
1153 END_CATCH
1154
1155 if (PyObject_HasAttrString (filter, "filename"))
1156 {
1157 gdbpy_ref<> py_fn (PyObject_CallMethod (filter, "filename", NULL));
1158
1159 if (py_fn == NULL)
1160 return EXT_LANG_BT_ERROR;
1161
1162 if (py_fn != Py_None)
1163 {
1164 gdb::unique_xmalloc_ptr<char>
1165 filename (python_string_to_host_string (py_fn.get ()));
1166
1167 if (filename == NULL)
1168 return EXT_LANG_BT_ERROR;
1169
1170 TRY
1171 {
1172 out->wrap_hint (" ");
1173 out->text (" at ");
1174 annotate_frame_source_file ();
1175 out->field_string ("file", filename.get ());
1176 annotate_frame_source_file_end ();
1177 }
1178 CATCH (except, RETURN_MASK_ERROR)
1179 {
1180 gdbpy_convert_exception (except);
1181 return EXT_LANG_BT_ERROR;
1182 }
1183 END_CATCH
1184 }
1185 }
1186
1187 if (PyObject_HasAttrString (filter, "line"))
1188 {
1189 gdbpy_ref<> py_line (PyObject_CallMethod (filter, "line", NULL));
1190 int line;
1191
1192 if (py_line == NULL)
1193 return EXT_LANG_BT_ERROR;
1194
1195 if (py_line != Py_None)
1196 {
1197 line = PyLong_AsLong (py_line.get ());
1198 if (PyErr_Occurred ())
1199 return EXT_LANG_BT_ERROR;
1200
1201 TRY
1202 {
1203 out->text (":");
1204 annotate_frame_source_line ();
1205 out->field_int ("line", line);
1206 }
1207 CATCH (except, RETURN_MASK_ERROR)
1208 {
1209 gdbpy_convert_exception (except);
1210 return EXT_LANG_BT_ERROR;
1211 }
1212 END_CATCH
1213 }
1214 }
1215 }
1216
1217 /* For MI we need to deal with the "children" list population of
1218 elided frames, so if MI output detected do not send newline. */
1219 if (! out->is_mi_like_p ())
1220 {
1221 TRY
1222 {
1223 annotate_frame_end ();
1224 out->text ("\n");
1225 }
1226 CATCH (except, RETURN_MASK_ERROR)
1227 {
1228 gdbpy_convert_exception (except);
1229 return EXT_LANG_BT_ERROR;
1230 }
1231 END_CATCH
1232 }
1233
1234 if (print_locals)
1235 {
1236 if (py_print_locals (filter, out, args_type, indent,
1237 frame) == EXT_LANG_BT_ERROR)
1238 return EXT_LANG_BT_ERROR;
1239 }
1240
1241 {
1242 /* Finally recursively print elided frames, if any. */
1243 gdbpy_ref<> elided (get_py_iter_from_func (filter, "elided"));
1244 if (elided == NULL)
1245 return EXT_LANG_BT_ERROR;
1246
1247 if (elided != Py_None)
1248 {
1249 PyObject *item;
1250
1251 ui_out_emit_list inner_list_emiter (out, "children");
1252
1253 if (! out->is_mi_like_p ())
1254 indent++;
1255
1256 while ((item = PyIter_Next (elided.get ())))
1257 {
1258 gdbpy_ref<> item_ref (item);
1259
1260 enum ext_lang_bt_status success = py_print_frame (item, flags,
1261 args_type, out,
1262 indent,
1263 levels_printed);
1264
1265 if (success == EXT_LANG_BT_ERROR)
1266 return EXT_LANG_BT_ERROR;
1267 }
1268 if (item == NULL && PyErr_Occurred ())
1269 return EXT_LANG_BT_ERROR;
1270 }
1271 }
1272
1273 return EXT_LANG_BT_COMPLETED;
1274 }
1275
1276 /* Helper function to initiate frame filter invocation at starting
1277 frame FRAME. */
1278
1279 static PyObject *
1280 bootstrap_python_frame_filters (struct frame_info *frame,
1281 int frame_low, int frame_high)
1282 {
1283 gdbpy_ref<> frame_obj (frame_info_to_frame_object (frame));
1284 if (frame_obj == NULL)
1285 return NULL;
1286
1287 gdbpy_ref<> module (PyImport_ImportModule ("gdb.frames"));
1288 if (module == NULL)
1289 return NULL;
1290
1291 gdbpy_ref<> sort_func (PyObject_GetAttrString (module.get (),
1292 "execute_frame_filters"));
1293 if (sort_func == NULL)
1294 return NULL;
1295
1296 gdbpy_ref<> py_frame_low (PyInt_FromLong (frame_low));
1297 if (py_frame_low == NULL)
1298 return NULL;
1299
1300 gdbpy_ref<> py_frame_high (PyInt_FromLong (frame_high));
1301 if (py_frame_high == NULL)
1302 return NULL;
1303
1304 gdbpy_ref<> iterable (PyObject_CallFunctionObjArgs (sort_func.get (),
1305 frame_obj.get (),
1306 py_frame_low.get (),
1307 py_frame_high.get (),
1308 NULL));
1309 if (iterable == NULL)
1310 return NULL;
1311
1312 if (iterable != Py_None)
1313 return PyObject_GetIter (iterable.get ());
1314 else
1315 return iterable.release ();
1316 }
1317
1318 /* This is the only publicly exported function in this file. FRAME
1319 is the source frame to start frame-filter invocation. FLAGS is an
1320 integer holding the flags for printing. The following elements of
1321 the FRAME_FILTER_FLAGS enum denotes the make-up of FLAGS:
1322 PRINT_LEVEL is a flag indicating whether to print the frame's
1323 relative level in the output. PRINT_FRAME_INFO is a flag that
1324 indicates whether this function should print the frame
1325 information, PRINT_ARGS is a flag that indicates whether to print
1326 frame arguments, and PRINT_LOCALS, likewise, with frame local
1327 variables. ARGS_TYPE is an enumerator describing the argument
1328 format, OUT is the output stream to print. FRAME_LOW is the
1329 beginning of the slice of frames to print, and FRAME_HIGH is the
1330 upper limit of the frames to count. Returns EXT_LANG_BT_ERROR on error,
1331 or EXT_LANG_BT_COMPLETED on success. */
1332
1333 enum ext_lang_bt_status
1334 gdbpy_apply_frame_filter (const struct extension_language_defn *extlang,
1335 struct frame_info *frame, int flags,
1336 enum ext_lang_frame_args args_type,
1337 struct ui_out *out, int frame_low, int frame_high)
1338 {
1339 struct gdbarch *gdbarch = NULL;
1340 enum ext_lang_bt_status success = EXT_LANG_BT_ERROR;
1341
1342 if (!gdb_python_initialized)
1343 return EXT_LANG_BT_NO_FILTERS;
1344
1345 TRY
1346 {
1347 gdbarch = get_frame_arch (frame);
1348 }
1349 CATCH (except, RETURN_MASK_ALL)
1350 {
1351 /* Let gdb try to print the stack trace. */
1352 return EXT_LANG_BT_NO_FILTERS;
1353 }
1354 END_CATCH
1355
1356 gdbpy_enter enter_py (gdbarch, current_language);
1357
1358 gdbpy_ref<> iterable (bootstrap_python_frame_filters (frame, frame_low,
1359 frame_high));
1360
1361 if (iterable == NULL)
1362 {
1363 /* Normally if there is an error GDB prints the exception,
1364 abandons the backtrace and exits. The user can then call "bt
1365 no-filters", and get a default backtrace (it would be
1366 confusing to automatically start a standard backtrace halfway
1367 through a Python filtered backtrace). However in the case
1368 where GDB cannot initialize the frame filters (most likely
1369 due to incorrect auto-load paths), GDB has printed nothing.
1370 In this case it is OK to print the default backtrace after
1371 printing the error message. GDB returns EXT_LANG_BT_NO_FILTERS
1372 here to signify there are no filters after printing the
1373 initialization error. This return code will trigger a
1374 default backtrace. */
1375
1376 gdbpy_print_stack ();
1377 return EXT_LANG_BT_NO_FILTERS;
1378 }
1379
1380 /* If iterable is None, then there are no frame filters registered.
1381 If this is the case, defer to default GDB printing routines in MI
1382 and CLI. */
1383 if (iterable == Py_None)
1384 return EXT_LANG_BT_NO_FILTERS;
1385
1386 htab_up levels_printed (htab_create (20,
1387 htab_hash_pointer,
1388 htab_eq_pointer,
1389 NULL));
1390
1391 while (true)
1392 {
1393 gdbpy_ref<> item (PyIter_Next (iterable.get ()));
1394
1395 if (item == NULL)
1396 {
1397 if (PyErr_Occurred ())
1398 {
1399 gdbpy_print_stack ();
1400 return EXT_LANG_BT_ERROR;
1401 }
1402 break;
1403 }
1404
1405 success = py_print_frame (item.get (), flags, args_type, out, 0,
1406 levels_printed.get ());
1407
1408 /* Do not exit on error printing a single frame. Print the
1409 error and continue with other frames. */
1410 if (success == EXT_LANG_BT_ERROR)
1411 gdbpy_print_stack ();
1412 }
1413
1414 return success;
1415 }
gdbarch
Definition: gdbarch.c:127
annotate_frame_function_name
void annotate_frame_function_name(void)
Definition: annotate.c:471
EXT_LANG_BT_OK
Definition: extension.h:77
PyObject_GetAttrString
#define PyObject_GetAttrString(obj, attr)
Definition: python-internal.h:217
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
fprintf_symbol_filtered
void fprintf_symbol_filtered(struct ui_file *stream, const char *name, enum language lang, int arg_mode)
Definition: utils.c:2134
annotate_frame_source_file_end
void annotate_frame_source_file_end(void)
Definition: annotate.c:499
ui_out::field_core_addr
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition: ui-out.c:513
value_print_options::deref_ref
int deref_ref
Definition: valprint.h:75
SYMBOL_PRINT_NAME
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:542
ui_out::field_string
void field_string(const char *fldname, const char *string)
Definition: ui-out.c:544
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
ui_out_emit_type
Definition: ui-out.h:192
RETURN_MASK_ALL
Definition: common-exceptions.h:44
frame_arg::sym
struct symbol * sym
Definition: frame.h:761
frame_arg::val
struct value * val
Definition: frame.h:765
xfree
void xfree(void *)
LOC_BLOCK
Definition: symtab.h:854
frame_arg::entry_kind
const char * entry_kind
Definition: frame.h:780
mi-cmds.h
gdbpy_is_string
int gdbpy_is_string(PyObject *obj)
Definition: py-utils.c:173
func
void(* func)(char *)
Definition: remote-fileio.c:1104
ui_out::wrap_hint
void void wrap_hint(const char *identstring)
Definition: ui-out.c:597
gdbpy_apply_frame_filter
enum ext_lang_bt_status gdbpy_apply_frame_filter(const struct extension_language_defn *extlang, struct frame_info *frame, int flags, enum ext_lang_frame_args args_type, struct ui_out *out, int frame_low, int frame_high)
Definition: py-framefilter.c:1334
annotate_arg_begin
void annotate_arg_begin(void)
Definition: annotate.c:390
ui_out::field_skip
void field_skip(const char *fldname)
Definition: ui-out.c:532
common_val_print
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1136
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
gdbpy_enter
Definition: python-internal.h:627
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
language_def
const struct language_defn * language_def(enum language lang)
Definition: language.c:494
LOC_UNDEF
Definition: symtab.h:797
frame_info_to_frame_object
PyObject * frame_info_to_frame_object(struct frame_info *frame)
Definition: py-frame.c:359
type_print
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:358
frame_info
Definition: frame.c:85
py_mi_print_variables
static enum ext_lang_bt_status py_mi_print_variables(PyObject *filter, struct ui_out *out, struct value_print_options *opts, enum ext_lang_frame_args args_type, struct frame_info *frame)
Definition: py-framefilter.c:804
LOC_TYPEDEF
Definition: symtab.h:844
frame_arg
Definition: frame.h:758
_
#define _(String)
Definition: gdb_locale.h:35
symbol_object_to_symbol
struct symbol * symbol_object_to_symbol(PyObject *obj)
Definition: py-symbol.c:338
ui_left
Definition: ui-out.h:44
defs.h
annotate_arg_value
void annotate_arg_value(struct type *type)
Definition: annotate.c:404
LOC_ARG
Definition: symtab.h:823
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
ui_out::text
void text(const char *string)
Definition: ui-out.c:581
LOC_LOCAL
Definition: symtab.h:839
py_print_locals
static enum ext_lang_bt_status py_print_locals(PyObject *filter, struct ui_out *out, enum ext_lang_frame_args args_type, int indent, struct frame_info *frame)
Definition: py-framefilter.c:837
objfiles.h
ext_lang_bt_status
ext_lang_bt_status
Definition: extension.h:69
arch-utils.h
language_defn
Definition: language.h:132
LOC_REGISTER
Definition: symtab.h:819
flags
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1891
TRY
#define TRY
Definition: common-exceptions.h:246
symtab.h
MSYMBOL_PRINT_NAME
#define MSYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:708
py_print_single_arg
static enum ext_lang_bt_status py_print_single_arg(struct ui_out *out, const char *sym_name, struct frame_arg *fa, struct value *fv, const struct value_print_options *opts, enum ext_lang_frame_args args_type, int print_args_field, const struct language_defn *language)
Definition: py-framefilter.c:345
name
const char *const name
Definition: aarch64-tdep.c:76
annotate_frame_address
void annotate_frame_address(void)
Definition: annotate.c:457
print_entry_values_no
const char print_entry_values_no[]
Definition: stack.c:70
EXT_LANG_BT_ERROR
Definition: extension.h:73
annotate_frame_args
void annotate_frame_args(void)
Definition: annotate.c:478
gdb_optional.h
annotate_frame_source_file
void annotate_frame_source_file(void)
Definition: annotate.c:492
gdb::ref_ptr< T, gdbpy_ref_policy< T > >
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
LOC_CONST_BYTES
Definition: symtab.h:859
frame_info::level
int level
Definition: frame.c:96
PRINT_ARGS
Definition: extension.h:99
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
LOC_COMPUTED
Definition: symtab.h:892
value_print_options
Definition: valprint.h:25
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
read_var_value
struct value * read_var_value(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: findvar.c:807
py_print_args
static enum ext_lang_bt_status py_print_args(PyObject *filter, struct ui_out *out, enum ext_lang_frame_args args_type, struct frame_info *frame)
Definition: py-framefilter.c:863
bound_minimal_symbol
Definition: minsyms.h:29
htab_up
std::unique_ptr< htab, htab_deleter > htab_up
Definition: utils.h:266
print_entry_values_compact
const char print_entry_values_compact[]
Definition: stack.c:75
ext_lang_frame_args
ext_lang_frame_args
Definition: extension.h:108
TYPE_CODE_UNION
Definition: gdbtypes.h:107
MI_PRINT_ARGS
Definition: py-framefilter.c:38
type
Definition: gdbtypes.h:749
language.h
LOC_CONST
Definition: symtab.h:801
LOC_UNRESOLVED
Definition: symtab.h:883
MI_PRINT_LOCALS
Definition: py-framefilter.c:39
bootstrap_python_frame_filters
static PyObject * bootstrap_python_frame_filters(struct frame_info *frame, int frame_low, int frame_high)
Definition: py-framefilter.c:1280
value_print_options::summary
int summary
Definition: valprint.h:90
ui_out::field_stream
void field_stream(const char *fldname, string_file &stream)
Definition: ui-out.c:520
python.h
gdb_python_initialized
int gdb_python_initialized
Definition: python.c:108
LOC_STATIC
Definition: symtab.h:805
python-internal.h
language_mode
language_mode
Definition: language.h:468
python_string_to_host_string
gdb::unique_xmalloc_ptr< char > python_string_to_host_string(PyObject *obj)
Definition: py-utils.c:152
PRINT_LOCALS
Definition: extension.h:102
extension_language_defn
Definition: extension-priv.h:53
value_print_options::addressprint
int addressprint
Definition: valprint.h:43
ui_file::puts
virtual void puts(const char *str)
Definition: ui-file.h:63
LOC_REGPARM_ADDR
Definition: symtab.h:835
PRINT_FRAME_INFO
Definition: extension.h:96
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
ui_out::spaces
void void spaces(int numspaces)
Definition: ui-out.c:575
frame_arg::error
char * error
Definition: frame.h:769
LOC_REF_ARG
Definition: symtab.h:827
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
EXT_LANG_BT_COMPLETED
Definition: extension.h:81
MI_PRINT_ALL_VALUES
Definition: extension.h:113
value
Definition: value.c:169
ui_out
Definition: ui-out.h:77
annotate_frame_begin
void annotate_frame_begin(int level, struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: annotate.c:435
read_frame_arg
void read_frame_arg(struct symbol *sym, struct frame_info *frame, struct frame_arg *argp, struct frame_arg *entryargp)
Definition: stack.c:337
print_args
static void print_args(struct field *args, int nargs, int spaces)
Definition: gdbtypes.c:4208
language_mode_auto
Definition: language.h:470
gdb::optional::emplace
T & emplace(Args &&... args)
Definition: gdb_optional.h:152
current_language
const struct language_defn * current_language
Definition: language.c:81
print_entry_values_only
const char print_entry_values_only[]
Definition: stack.c:71
annotate_arg_end
void annotate_arg_end(void)
Definition: annotate.c:415
lookup_minimal_symbol_by_pc
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:928
py_print_frame
static enum ext_lang_bt_status py_print_frame(PyObject *filter, int flags, enum ext_lang_frame_args args_type, struct ui_out *out, int indent, htab_t levels_printed)
Definition: py-framefilter.c:923
gdb::optional
Definition: gdb_optional.h:51
mi_print_types
mi_print_types
Definition: py-framefilter.c:36
annotate_frame_end
void annotate_frame_end(void)
Definition: annotate.c:527
gdbpy_convert_exception
void gdbpy_convert_exception(struct gdb_exception exception)
Definition: py-utils.c:235
frame_relative_level
int frame_relative_level(struct frame_info *fi)
Definition: frame.c:2610
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
annotate_frame_source_begin
void annotate_frame_source_begin(void)
Definition: annotate.c:485
ui_out::field_int
void field_int(const char *fldname, int value)
Definition: ui-out.c:486
annotate_frame_address_end
void annotate_frame_address_end(void)
Definition: annotate.c:464
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
gdb::ref_ptr::release
T * release()
Definition: gdb_ref_ptr.h:138
PRINT_LEVEL
Definition: extension.h:93
gdbpy_print_stack
void gdbpy_print_stack(void)
Definition: python.c:1262
get_user_print_options
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:120
CLI_SCALAR_VALUES
Definition: extension.h:120
convert_value_from_python
struct value * convert_value_from_python(PyObject *obj)
Definition: py-value.c:1615
SYMBOL_LANGUAGE
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:469
LOC_LABEL
Definition: symtab.h:848
annotate_frame_source_line
void annotate_frame_source_line(void)
Definition: annotate.c:506
gdb::ref_ptr::get
T * get() const
Definition: gdb_ref_ptr.h:130
py_print_type
static enum ext_lang_bt_status py_print_type(struct ui_out *out, struct value *val)
Definition: py-framefilter.c:207
mi_should_print
static int mi_should_print(struct symbol *sym, enum mi_print_types type)
Definition: py-framefilter.c:166
language
language
Definition: defs.h:203
extract_sym
static enum ext_lang_bt_status extract_sym(PyObject *obj, gdb::unique_xmalloc_ptr< char > *name, struct symbol **sym, struct block **sym_block, const struct language_defn **language)
Definition: py-framefilter.c:57
get_addr_from_python
int get_addr_from_python(PyObject *obj, CORE_ADDR *addr)
Definition: py-utils.c:255
NO_VALUES
Definition: extension.h:111
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
frame_info::addr
CORE_ADDR addr
Definition: frame.c:128
symbol
Definition: symtab.h:1049
annotate_arg_name_end
void annotate_arg_name_end(void)
Definition: annotate.c:397
ui_out::field_fmt_int
void field_fmt_int(int width, ui_align align, const char *fldname, int value)
Definition: ui-out.c:498
LOC_OPTIMIZED_OUT
Definition: symtab.h:888
python_language
const struct language_defn * python_language
Definition: python.c:204
PyObject_CallMethod
#define PyObject_CallMethod
Definition: python-internal.h:251
extract_value
static enum ext_lang_bt_status extract_value(PyObject *obj, struct value **value)
Definition: py-framefilter.c:128
EXT_LANG_BT_NO_FILTERS
Definition: extension.h:85
MI_PRINT_SIMPLE_VALUES
Definition: extension.h:117
frame_object_to_frame_info
struct frame_info * frame_object_to_frame_info(PyObject *obj)
Definition: py-frame.c:63
annotate.h
print_frame_info
void print_frame_info(struct frame_info *, int print_level, enum print_what print_what, int args, int set_current_sal)
Definition: stack.c:786
valprint.h
py_print_value
static enum ext_lang_bt_status py_print_value(struct ui_out *out, struct value *val, const struct value_print_options *opts, int indent, enum ext_lang_frame_args args_type, const struct language_defn *language)
Definition: py-framefilter.c:238
py-ref.h
enumerate_locals
static enum ext_lang_bt_status enumerate_locals(PyObject *iter, struct ui_out *out, int indent, enum ext_lang_frame_args args_type, int print_args_field, struct frame_info *frame)
Definition: py-framefilter.c:673
get_py_iter_from_func
static PyObject * get_py_iter_from_func(PyObject *filter, const char *func)
Definition: py-framefilter.c:304
enumerate_args
static enum ext_lang_bt_status enumerate_args(PyObject *iter, struct ui_out *out, enum ext_lang_frame_args args_type, int print_args_field, struct frame_info *frame)
Definition: py-framefilter.c:478
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
PyObject_HasAttrString
#define PyObject_HasAttrString(obj, attr)
Definition: python-internal.h:230
ui_out::is_mi_like_p
bool is_mi_like_p()
Definition: ui-out.c:622
SYMBOL_IS_ARGUMENT
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:1157
ui_out::field_fmt
void field_fmt(const char *fldname, const char *format,...) ATTRIBUTE_PRINTF(3
Definition: ui-out.c:557
ui-out.h
string_file
Definition: ui-file.h:106