GDB (xrefs)

py-frame.c
Go to the documentation of this file.
1 /* Python interface to stack frames
2
3 Copyright (C) 2008-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 "charset.h"
22 #include "block.h"
23 #include "frame.h"
24 #include "symtab.h"
25 #include "stack.h"
26 #include "value.h"
27 #include "python-internal.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "user-regs.h"
31 #include "py-ref.h"
32
33 typedef struct {
34 PyObject_HEAD
35 struct frame_id frame_id;
36 struct gdbarch *gdbarch;
37
38 /* Marks that the FRAME_ID member actually holds the ID of the frame next
39 to this, and not this frames' ID itself. This is a hack to permit Python
40 frame objects which represent invalid frames (i.e., the last frame_info
41 in a corrupt stack). The problem arises from the fact that this code
42 relies on FRAME_ID to uniquely identify a frame, which is not always true
43 for the last "frame" in a corrupt stack (it can have a null ID, or the same
44 ID as the previous frame). Whenever get_prev_frame returns NULL, we
45 record the frame_id of the next frame and set FRAME_ID_IS_NEXT to 1. */
46 int frame_id_is_next;
47 } frame_object;
48
49 /* Require a valid frame. This must be called inside a TRY_CATCH, or
50 another context in which a gdb exception is allowed. */
51 #define FRAPY_REQUIRE_VALID(frame_obj, frame) \
52 do { \
53 frame = frame_object_to_frame_info (frame_obj); \
54 if (frame == NULL) \
55 error (_("Frame is invalid.")); \
56 } while (0)
57
58 /* Returns the frame_info object corresponding to the given Python Frame
59 object. If the frame doesn't exist anymore (the frame id doesn't
60 correspond to any frame in the inferior), returns NULL. */
61
62 struct frame_info *
63 frame_object_to_frame_info (PyObject *obj)
64 {
65 frame_object *frame_obj = (frame_object *) obj;
66 struct frame_info *frame;
67
68 frame = frame_find_by_id (frame_obj->frame_id);
69 if (frame == NULL)
70 return NULL;
71
72 if (frame_obj->frame_id_is_next)
73 frame = get_prev_frame (frame);
74
75 return frame;
76 }
77
78 /* Called by the Python interpreter to obtain string representation
79 of the object. */
80
81 static PyObject *
82 frapy_str (PyObject *self)
83 {
84 string_file strfile;
85
86 fprint_frame_id (&strfile, ((frame_object *) self)->frame_id);
87 return PyString_FromString (strfile.c_str ());
88 }
89
90 /* Implementation of gdb.Frame.is_valid (self) -> Boolean.
91 Returns True if the frame corresponding to the frame_id of this
92 object still exists in the inferior. */
93
94 static PyObject *
95 frapy_is_valid (PyObject *self, PyObject *args)
96 {
97 struct frame_info *frame = NULL;
98
99 TRY
100 {
101 frame = frame_object_to_frame_info (self);
102 }
103 CATCH (except, RETURN_MASK_ALL)
104 {
105 GDB_PY_HANDLE_EXCEPTION (except);
106 }
107 END_CATCH
108
109 if (frame == NULL)
110 Py_RETURN_FALSE;
111
112 Py_RETURN_TRUE;
113 }
114
115 /* Implementation of gdb.Frame.name (self) -> String.
116 Returns the name of the function corresponding to this frame. */
117
118 static PyObject *
119 frapy_name (PyObject *self, PyObject *args)
120 {
121 struct frame_info *frame;
122 gdb::unique_xmalloc_ptr<char> name;
123 enum language lang;
124 PyObject *result;
125
126 TRY
127 {
128 FRAPY_REQUIRE_VALID (self, frame);
129
130 name = find_frame_funname (frame, &lang, NULL);
131 }
132 CATCH (except, RETURN_MASK_ALL)
133 {
134 GDB_PY_HANDLE_EXCEPTION (except);
135 }
136 END_CATCH
137
138 if (name)
139 {
140 result = PyUnicode_Decode (name.get (), strlen (name.get ()),
141 host_charset (), NULL);
142 }
143 else
144 {
145 result = Py_None;
146 Py_INCREF (Py_None);
147 }
148
149 return result;
150 }
151
152 /* Implementation of gdb.Frame.type (self) -> Integer.
153 Returns the frame type, namely one of the gdb.*_FRAME constants. */
154
155 static PyObject *
156 frapy_type (PyObject *self, PyObject *args)
157 {
158 struct frame_info *frame;
159 enum frame_type type = NORMAL_FRAME;/* Initialize to appease gcc warning. */
160
161 TRY
162 {
163 FRAPY_REQUIRE_VALID (self, frame);
164
165 type = get_frame_type (frame);
166 }
167 CATCH (except, RETURN_MASK_ALL)
168 {
169 GDB_PY_HANDLE_EXCEPTION (except);
170 }
171 END_CATCH
172
173 return PyInt_FromLong (type);
174 }
175
176 /* Implementation of gdb.Frame.architecture (self) -> gdb.Architecture.
177 Returns the frame's architecture as a gdb.Architecture object. */
178
179 static PyObject *
180 frapy_arch (PyObject *self, PyObject *args)
181 {
182 struct frame_info *frame = NULL; /* Initialize to appease gcc warning. */
183 frame_object *obj = (frame_object *) self;
184
185 TRY
186 {
187 FRAPY_REQUIRE_VALID (self, frame);
188 }
189 CATCH (except, RETURN_MASK_ALL)
190 {
191 GDB_PY_HANDLE_EXCEPTION (except);
192 }
193 END_CATCH
194
195 return gdbarch_to_arch_object (obj->gdbarch);
196 }
197
198 /* Implementation of gdb.Frame.unwind_stop_reason (self) -> Integer.
199 Returns one of the gdb.FRAME_UNWIND_* constants. */
200
201 static PyObject *
202 frapy_unwind_stop_reason (PyObject *self, PyObject *args)
203 {
204 struct frame_info *frame = NULL; /* Initialize to appease gcc warning. */
205 enum unwind_stop_reason stop_reason;
206
207 TRY
208 {
209 FRAPY_REQUIRE_VALID (self, frame);
210 }
211 CATCH (except, RETURN_MASK_ALL)
212 {
213 GDB_PY_HANDLE_EXCEPTION (except);
214 }
215 END_CATCH
216
217 stop_reason = get_frame_unwind_stop_reason (frame);
218
219 return PyInt_FromLong (stop_reason);
220 }
221
222 /* Implementation of gdb.Frame.pc (self) -> Long.
223 Returns the frame's resume address. */
224
225 static PyObject *
226 frapy_pc (PyObject *self, PyObject *args)
227 {
228 CORE_ADDR pc = 0; /* Initialize to appease gcc warning. */
229 struct frame_info *frame;
230
231 TRY
232 {
233 FRAPY_REQUIRE_VALID (self, frame);
234
235 pc = get_frame_pc (frame);
236 }
237 CATCH (except, RETURN_MASK_ALL)
238 {
239 GDB_PY_HANDLE_EXCEPTION (except);
240 }
241 END_CATCH
242
243 return gdb_py_long_from_ulongest (pc);
244 }
245
246 /* Implementation of gdb.Frame.read_register (self, register) -> gdb.Value.
247 Returns the value of a register in this frame. */
248
249 static PyObject *
250 frapy_read_register (PyObject *self, PyObject *args)
251 {
252 const char *regnum_str;
253 struct value *val = NULL;
254
255 if (!PyArg_ParseTuple (args, "s", &regnum_str))
256 return NULL;
257
258 TRY
259 {
260 struct frame_info *frame;
261 int regnum;
262
263 FRAPY_REQUIRE_VALID (self, frame);
264
265 regnum = user_reg_map_name_to_regnum (get_frame_arch (frame),
266 regnum_str,
267 strlen (regnum_str));
268 if (regnum >= 0)
269 val = value_of_register (regnum, frame);
270
271 if (val == NULL)
272 PyErr_SetString (PyExc_ValueError, _("Unknown register."));
273 }
274 CATCH (except, RETURN_MASK_ALL)
275 {
276 GDB_PY_HANDLE_EXCEPTION (except);
277 }
278 END_CATCH
279
280 return val == NULL ? NULL : value_to_value_object (val);
281 }
282
283 /* Implementation of gdb.Frame.block (self) -> gdb.Block.
284 Returns the frame's code block. */
285
286 static PyObject *
287 frapy_block (PyObject *self, PyObject *args)
288 {
289 struct frame_info *frame;
290 const struct block *block = NULL, *fn_block;
291
292 TRY
293 {
294 FRAPY_REQUIRE_VALID (self, frame);
295 block = get_frame_block (frame, NULL);
296 }
297 CATCH (except, RETURN_MASK_ALL)
298 {
299 GDB_PY_HANDLE_EXCEPTION (except);
300 }
301 END_CATCH
302
303 for (fn_block = block;
304 fn_block != NULL && BLOCK_FUNCTION (fn_block) == NULL;
305 fn_block = BLOCK_SUPERBLOCK (fn_block))
306 ;
307
308 if (block == NULL || fn_block == NULL || BLOCK_FUNCTION (fn_block) == NULL)
309 {
310 PyErr_SetString (PyExc_RuntimeError,
311 _("Cannot locate block for frame."));
312 return NULL;
313 }
314
315 if (block)
316 {
317 return block_to_block_object
318 (block, symbol_objfile (BLOCK_FUNCTION (fn_block)));
319 }
320
321 Py_RETURN_NONE;
322 }
323
324
325 /* Implementation of gdb.Frame.function (self) -> gdb.Symbol.
326 Returns the symbol for the function corresponding to this frame. */
327
328 static PyObject *
329 frapy_function (PyObject *self, PyObject *args)
330 {
331 struct symbol *sym = NULL;
332 struct frame_info *frame;
333
334 TRY
335 {
336 enum language funlang;
337
338 FRAPY_REQUIRE_VALID (self, frame);
339
340 gdb::unique_xmalloc_ptr<char> funname
341 = find_frame_funname (frame, &funlang, &sym);
342 }
343 CATCH (except, RETURN_MASK_ALL)
344 {
345 GDB_PY_HANDLE_EXCEPTION (except);
346 }
347 END_CATCH
348
349 if (sym)
350 return symbol_to_symbol_object (sym);
351
352 Py_RETURN_NONE;
353 }
354
355 /* Convert a frame_info struct to a Python Frame object.
356 Sets a Python exception and returns NULL on error. */
357
358 PyObject *
359 frame_info_to_frame_object (struct frame_info *frame)
360 {
361 gdbpy_ref<frame_object> frame_obj (PyObject_New (frame_object,
362 &frame_object_type));
363 if (frame_obj == NULL)
364 return NULL;
365
366 TRY
367 {
368
369 /* Try to get the previous frame, to determine if this is the last frame
370 in a corrupt stack. If so, we need to store the frame_id of the next
371 frame and not of this one (which is possibly invalid). */
372 if (get_prev_frame (frame) == NULL
373 && get_frame_unwind_stop_reason (frame) != UNWIND_NO_REASON
374 && get_next_frame (frame) != NULL)
375 {
376 frame_obj->frame_id = get_frame_id (get_next_frame (frame));
377 frame_obj->frame_id_is_next = 1;
378 }
379 else
380 {
381 frame_obj->frame_id = get_frame_id (frame);
382 frame_obj->frame_id_is_next = 0;
383 }
384 frame_obj->gdbarch = get_frame_arch (frame);
385 }
386 CATCH (except, RETURN_MASK_ALL)
387 {
388 gdbpy_convert_exception (except);
389 return NULL;
390 }
391 END_CATCH
392
393 return (PyObject *) frame_obj.release ();
394 }
395
396 /* Implementation of gdb.Frame.older (self) -> gdb.Frame.
397 Returns the frame immediately older (outer) to this frame, or None if
398 there isn't one. */
399
400 static PyObject *
401 frapy_older (PyObject *self, PyObject *args)
402 {
403 struct frame_info *frame, *prev = NULL;
404 PyObject *prev_obj = NULL; /* Initialize to appease gcc warning. */
405
406 TRY
407 {
408 FRAPY_REQUIRE_VALID (self, frame);
409
410 prev = get_prev_frame (frame);
411 }
412 CATCH (except, RETURN_MASK_ALL)
413 {
414 GDB_PY_HANDLE_EXCEPTION (except);
415 }
416 END_CATCH
417
418 if (prev)
419 prev_obj = (PyObject *) frame_info_to_frame_object (prev);
420 else
421 {
422 Py_INCREF (Py_None);
423 prev_obj = Py_None;
424 }
425
426 return prev_obj;
427 }
428
429 /* Implementation of gdb.Frame.newer (self) -> gdb.Frame.
430 Returns the frame immediately newer (inner) to this frame, or None if
431 there isn't one. */
432
433 static PyObject *
434 frapy_newer (PyObject *self, PyObject *args)
435 {
436 struct frame_info *frame, *next = NULL;
437 PyObject *next_obj = NULL; /* Initialize to appease gcc warning. */
438
439 TRY
440 {
441 FRAPY_REQUIRE_VALID (self, frame);
442
443 next = get_next_frame (frame);
444 }
445 CATCH (except, RETURN_MASK_ALL)
446 {
447 GDB_PY_HANDLE_EXCEPTION (except);
448 }
449 END_CATCH
450
451 if (next)
452 next_obj = (PyObject *) frame_info_to_frame_object (next);
453 else
454 {
455 Py_INCREF (Py_None);
456 next_obj = Py_None;
457 }
458
459 return next_obj;
460 }
461
462 /* Implementation of gdb.Frame.find_sal (self) -> gdb.Symtab_and_line.
463 Returns the frame's symtab and line. */
464
465 static PyObject *
466 frapy_find_sal (PyObject *self, PyObject *args)
467 {
468 struct frame_info *frame;
469 PyObject *sal_obj = NULL; /* Initialize to appease gcc warning. */
470
471 TRY
472 {
473 FRAPY_REQUIRE_VALID (self, frame);
474
475 symtab_and_line sal = find_frame_sal (frame);
476 sal_obj = symtab_and_line_to_sal_object (sal);
477 }
478 CATCH (except, RETURN_MASK_ALL)
479 {
480 GDB_PY_HANDLE_EXCEPTION (except);
481 }
482 END_CATCH
483
484 return sal_obj;
485 }
486
487 /* Implementation of gdb.Frame.read_var_value (self, variable,
488 [block]) -> gdb.Value. If the optional block argument is provided
489 start the search from that block, otherwise search from the frame's
490 current block (determined by examining the resume address of the
491 frame). The variable argument must be a string or an instance of a
492 gdb.Symbol. The block argument must be an instance of gdb.Block. Returns
493 NULL on error, with a python exception set. */
494 static PyObject *
495 frapy_read_var (PyObject *self, PyObject *args)
496 {
497 struct frame_info *frame;
498 PyObject *sym_obj, *block_obj = NULL;
499 struct symbol *var = NULL; /* gcc-4.3.2 false warning. */
500 const struct block *block = NULL;
501 struct value *val = NULL;
502
503 if (!PyArg_ParseTuple (args, "O|O", &sym_obj, &block_obj))
504 return NULL;
505
506 if (PyObject_TypeCheck (sym_obj, &symbol_object_type))
507 var = symbol_object_to_symbol (sym_obj);
508 else if (gdbpy_is_string (sym_obj))
509 {
510 gdb::unique_xmalloc_ptr<char>
511 var_name (python_string_to_target_string (sym_obj));
512
513 if (!var_name)
514 return NULL;
515
516 if (block_obj)
517 {
518 block = block_object_to_block (block_obj);
519 if (!block)
520 {
521 PyErr_SetString (PyExc_RuntimeError,
522 _("Second argument must be block."));
523 return NULL;
524 }
525 }
526
527 TRY
528 {
529 struct block_symbol lookup_sym;
530 FRAPY_REQUIRE_VALID (self, frame);
531
532 if (!block)
533 block = get_frame_block (frame, NULL);
534 lookup_sym = lookup_symbol (var_name.get (), block, VAR_DOMAIN, NULL);
535 var = lookup_sym.symbol;
536 block = lookup_sym.block;
537 }
538 CATCH (except, RETURN_MASK_ALL)
539 {
540 gdbpy_convert_exception (except);
541 return NULL;
542 }
543 END_CATCH
544
545 if (!var)
546 {
547 PyErr_Format (PyExc_ValueError,
548 _("Variable '%s' not found."), var_name.get ());
549
550 return NULL;
551 }
552 }
553 else
554 {
555 PyErr_SetString (PyExc_TypeError,
556 _("Argument must be a symbol or string."));
557 return NULL;
558 }
559
560 TRY
561 {
562 FRAPY_REQUIRE_VALID (self, frame);
563
564 val = read_var_value (var, block, frame);
565 }
566 CATCH (except, RETURN_MASK_ALL)
567 {
568 GDB_PY_HANDLE_EXCEPTION (except);
569 }
570 END_CATCH
571
572 return value_to_value_object (val);
573 }
574
575 /* Select this frame. */
576
577 static PyObject *
578 frapy_select (PyObject *self, PyObject *args)
579 {
580 struct frame_info *fi;
581
582 TRY
583 {
584 FRAPY_REQUIRE_VALID (self, fi);
585
586 select_frame (fi);
587 }
588 CATCH (except, RETURN_MASK_ALL)
589 {
590 GDB_PY_HANDLE_EXCEPTION (except);
591 }
592 END_CATCH
593
594 Py_RETURN_NONE;
595 }
596
597 /* Implementation of gdb.newest_frame () -> gdb.Frame.
598 Returns the newest frame object. */
599
600 PyObject *
601 gdbpy_newest_frame (PyObject *self, PyObject *args)
602 {
603 struct frame_info *frame = NULL;
604
605 TRY
606 {
607 frame = get_current_frame ();
608 }
609 CATCH (except, RETURN_MASK_ALL)
610 {
611 GDB_PY_HANDLE_EXCEPTION (except);
612 }
613 END_CATCH
614
615 return frame_info_to_frame_object (frame);
616 }
617
618 /* Implementation of gdb.selected_frame () -> gdb.Frame.
619 Returns the selected frame object. */
620
621 PyObject *
622 gdbpy_selected_frame (PyObject *self, PyObject *args)
623 {
624 struct frame_info *frame = NULL;
625
626 TRY
627 {
628 frame = get_selected_frame ("No frame is currently selected.");
629 }
630 CATCH (except, RETURN_MASK_ALL)
631 {
632 GDB_PY_HANDLE_EXCEPTION (except);
633 }
634 END_CATCH
635
636 return frame_info_to_frame_object (frame);
637 }
638
639 /* Implementation of gdb.stop_reason_string (Integer) -> String.
640 Return a string explaining the unwind stop reason. */
641
642 PyObject *
643 gdbpy_frame_stop_reason_string (PyObject *self, PyObject *args)
644 {
645 int reason;
646 const char *str;
647
648 if (!PyArg_ParseTuple (args, "i", &reason))
649 return NULL;
650
651 if (reason < UNWIND_FIRST || reason > UNWIND_LAST)
652 {
653 PyErr_SetString (PyExc_ValueError,
654 _("Invalid frame stop reason."));
655 return NULL;
656 }
657
658 str = unwind_stop_reason_to_string ((enum unwind_stop_reason) reason);
659 return PyUnicode_Decode (str, strlen (str), host_charset (), NULL);
660 }
661
662 /* Implements the equality comparison for Frame objects.
663 All other comparison operators will throw a TypeError Python exception,
664 as they aren't valid for frames. */
665
666 static PyObject *
667 frapy_richcompare (PyObject *self, PyObject *other, int op)
668 {
669 int result;
670
671 if (!PyObject_TypeCheck (other, &frame_object_type)
672 || (op != Py_EQ && op != Py_NE))
673 {
674 Py_INCREF (Py_NotImplemented);
675 return Py_NotImplemented;
676 }
677
678 if (frame_id_eq (((frame_object *) self)->frame_id,
679 ((frame_object *) other)->frame_id))
680 result = Py_EQ;
681 else
682 result = Py_NE;
683
684 if (op == result)
685 Py_RETURN_TRUE;
686 Py_RETURN_FALSE;
687 }
688
689 /* Sets up the Frame API in the gdb module. */
690
691 int
692 gdbpy_initialize_frames (void)
693 {
694 frame_object_type.tp_new = PyType_GenericNew;
695 if (PyType_Ready (&frame_object_type) < 0)
696 return -1;
697
698 /* Note: These would probably be best exposed as class attributes of
699 Frame, but I don't know how to do it except by messing with the
700 type's dictionary. That seems too messy. */
701 if (PyModule_AddIntConstant (gdb_module, "NORMAL_FRAME", NORMAL_FRAME) < 0
702 || PyModule_AddIntConstant (gdb_module, "DUMMY_FRAME", DUMMY_FRAME) < 0
703 || PyModule_AddIntConstant (gdb_module, "INLINE_FRAME", INLINE_FRAME) < 0
704 || PyModule_AddIntConstant (gdb_module, "TAILCALL_FRAME",
705 TAILCALL_FRAME) < 0
706 || PyModule_AddIntConstant (gdb_module, "SIGTRAMP_FRAME",
707 SIGTRAMP_FRAME) < 0
708 || PyModule_AddIntConstant (gdb_module, "ARCH_FRAME", ARCH_FRAME) < 0
709 || PyModule_AddIntConstant (gdb_module, "SENTINEL_FRAME",
710 SENTINEL_FRAME) < 0)
711 return -1;
712
713 #define SET(name, description) \
714 if (PyModule_AddIntConstant (gdb_module, "FRAME_"#name, name) < 0) \
715 return -1;
716 #include "unwind_stop_reasons.def"
717 #undef SET
718
719 return gdb_pymodule_addobject (gdb_module, "Frame",
720 (PyObject *) &frame_object_type);
721 }
722
723
724
725 static PyMethodDef frame_object_methods[] = {
726 { "is_valid", frapy_is_valid, METH_NOARGS,
727 "is_valid () -> Boolean.\n\
728 Return true if this frame is valid, false if not." },
729 { "name", frapy_name, METH_NOARGS,
730 "name () -> String.\n\
731 Return the function name of the frame, or None if it can't be determined." },
732 { "type", frapy_type, METH_NOARGS,
733 "type () -> Integer.\n\
734 Return the type of the frame." },
735 { "architecture", frapy_arch, METH_NOARGS,
736 "architecture () -> gdb.Architecture.\n\
737 Return the architecture of the frame." },
738 { "unwind_stop_reason", frapy_unwind_stop_reason, METH_NOARGS,
739 "unwind_stop_reason () -> Integer.\n\
740 Return the reason why it's not possible to find frames older than this." },
741 { "pc", frapy_pc, METH_NOARGS,
742 "pc () -> Long.\n\
743 Return the frame's resume address." },
744 { "read_register", frapy_read_register, METH_VARARGS,
745 "read_register (register_name) -> gdb.Value\n\
746 Return the value of the register in the frame." },
747 { "block", frapy_block, METH_NOARGS,
748 "block () -> gdb.Block.\n\
749 Return the frame's code block." },
750 { "function", frapy_function, METH_NOARGS,
751 "function () -> gdb.Symbol.\n\
752 Returns the symbol for the function corresponding to this frame." },
753 { "older", frapy_older, METH_NOARGS,
754 "older () -> gdb.Frame.\n\
755 Return the frame that called this frame." },
756 { "newer", frapy_newer, METH_NOARGS,
757 "newer () -> gdb.Frame.\n\
758 Return the frame called by this frame." },
759 { "find_sal", frapy_find_sal, METH_NOARGS,
760 "find_sal () -> gdb.Symtab_and_line.\n\
761 Return the frame's symtab and line." },
762 { "read_var", frapy_read_var, METH_VARARGS,
763 "read_var (variable) -> gdb.Value.\n\
764 Return the value of the variable in this frame." },
765 { "select", frapy_select, METH_NOARGS,
766 "Select this frame as the user's current frame." },
767 {NULL} /* Sentinel */
768 };
769
770 PyTypeObject frame_object_type = {
771 PyVarObject_HEAD_INIT (NULL, 0)
772 "gdb.Frame", /* tp_name */
773 sizeof (frame_object), /* tp_basicsize */
774 0, /* tp_itemsize */
775 0, /* tp_dealloc */
776 0, /* tp_print */
777 0, /* tp_getattr */
778 0, /* tp_setattr */
779 0, /* tp_compare */
780 0, /* tp_repr */
781 0, /* tp_as_number */
782 0, /* tp_as_sequence */
783 0, /* tp_as_mapping */
784 0, /* tp_hash */
785 0, /* tp_call */
786 frapy_str, /* tp_str */
787 0, /* tp_getattro */
788 0, /* tp_setattro */
789 0, /* tp_as_buffer */
790 Py_TPFLAGS_DEFAULT, /* tp_flags */
791 "GDB frame object", /* tp_doc */
792 0, /* tp_traverse */
793 0, /* tp_clear */
794 frapy_richcompare, /* tp_richcompare */
795 0, /* tp_weaklistoffset */
796 0, /* tp_iter */
797 0, /* tp_iternext */
798 frame_object_methods, /* tp_methods */
799 0, /* tp_members */
800 0, /* tp_getset */
801 0, /* tp_base */
802 0, /* tp_dict */
803 0, /* tp_descr_get */
804 0, /* tp_descr_set */
805 0, /* tp_dictoffset */
806 0, /* tp_init */
807 0, /* tp_alloc */
808 };
frapy_arch
static PyObject * frapy_arch(PyObject *self, PyObject *args)
Definition: py-frame.c:180
gdbarch
Definition: gdbarch.c:127
frame_find_by_id
struct frame_info * frame_find_by_id(struct frame_id id)
Definition: frame.c:803
gdb_pymodule_addobject
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition: py-utils.c:376
gdbpy_selected_frame
PyObject * gdbpy_selected_frame(PyObject *self, PyObject *args)
Definition: py-frame.c:622
SENTINEL_FRAME
Definition: frame.h:260
get_selected_frame
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1638
block_to_block_object
PyObject * block_to_block_object(const struct block *block, struct objfile *objfile)
Definition: py-block.c:272
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
symtab_and_line_to_sal_object
PyObject * symtab_and_line_to_sal_object(struct symtab_and_line sal)
Definition: py-symtab.c:438
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
frapy_read_register
static PyObject * frapy_read_register(PyObject *self, PyObject *args)
Definition: py-frame.c:250
RETURN_MASK_ALL
Definition: common-exceptions.h:44
ARCH_FRAME
Definition: frame.h:257
frame_object::frame_id_is_next
int frame_id_is_next
Definition: py-frame.c:46
get_prev_frame
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2254
gdbpy_is_string
int gdbpy_is_string(PyObject *obj)
Definition: py-utils.c:173
frapy_newer
static PyObject * frapy_newer(PyObject *self, PyObject *args)
Definition: py-frame.c:434
frapy_unwind_stop_reason
static PyObject * frapy_unwind_stop_reason(PyObject *self, PyObject *args)
Definition: py-frame.c:202
charset.h
select_frame
void select_frame(struct frame_info *fi)
Definition: frame.c:1677
frapy_older
static PyObject * frapy_older(PyObject *self, PyObject *args)
Definition: py-frame.c:401
gdbpy_initialize_frames
int gdbpy_initialize_frames(void)
Definition: py-frame.c:692
frapy_block
static PyObject * frapy_block(PyObject *self, PyObject *args)
Definition: py-frame.c:287
frapy_find_sal
static PyObject * frapy_find_sal(PyObject *self, PyObject *args)
Definition: py-frame.c:466
frame_info_to_frame_object
PyObject * frame_info_to_frame_object(struct frame_info *frame)
Definition: py-frame.c:359
gdb_py_long_from_ulongest
#define gdb_py_long_from_ulongest
Definition: python-internal.h:174
SIGTRAMP_FRAME
Definition: frame.h:255
frapy_read_var
static PyObject * frapy_read_var(PyObject *self, PyObject *args)
Definition: py-frame.c:495
frame_info
Definition: frame.c:85
unwind_stop_reason
unwind_stop_reason
Definition: frame.h:504
frame_object
Definition: py-frame.c:33
frame_object::gdbarch
struct gdbarch * gdbarch
Definition: py-frame.c:36
lookup_symbol
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1893
_
#define _(String)
Definition: gdb_locale.h:35
symbol_object_to_symbol
struct symbol * symbol_object_to_symbol(PyObject *obj)
Definition: py-symbol.c:338
PyVarObject_HEAD_INIT
#define PyVarObject_HEAD_INIT(type, size)
Definition: python-internal.h:133
frapy_is_valid
static PyObject * frapy_is_valid(PyObject *self, PyObject *args)
Definition: py-frame.c:95
defs.h
frame_object_type
PyTypeObject frame_object_type
Definition: py-frame.c:770
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
symbol_objfile
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:5784
objfiles.h
BLOCK_FUNCTION
#define BLOCK_FUNCTION(bl)
Definition: block.h:107
GDB_PY_HANDLE_EXCEPTION
#define GDB_PY_HANDLE_EXCEPTION(Exception)
Definition: python-internal.h:663
symbol_object_type
PyTypeObject symbol_object_type
Definition: py-symbol.c:604
DUMMY_FRAME
Definition: frame.h:247
gdbarch_to_arch_object
PyObject * gdbarch_to_arch_object(struct gdbarch *gdbarch)
Definition: py-arch.c:81
TRY
#define TRY
Definition: common-exceptions.h:246
symtab.h
gdbpy_frame_stop_reason_string
PyObject * gdbpy_frame_stop_reason_string(PyObject *self, PyObject *args)
Definition: py-frame.c:643
frame_id_eq
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:674
unwind_stop_reason_to_string
const char * unwind_stop_reason_to_string(enum unwind_stop_reason reason)
Definition: frame.c:2815
name
const char *const name
Definition: aarch64-tdep.c:76
FRAPY_REQUIRE_VALID
#define FRAPY_REQUIRE_VALID(frame_obj, frame)
Definition: py-frame.c:51
get_frame_type
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2619
frapy_str
static PyObject * frapy_str(PyObject *self)
Definition: py-frame.c:82
get_frame_id
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:520
gdb::ref_ptr< T, gdbpy_ref_policy< T > >
NORMAL_FRAME
Definition: frame.h:244
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
get_frame_unwind_stop_reason
enum unwind_stop_reason get_frame_unwind_stop_reason(struct frame_info *frame)
Definition: frame.c:2803
read_var_value
struct value * read_var_value(struct symbol *var, const struct block *var_block, struct frame_info *frame)
Definition: findvar.c:807
block_symbol::block
const struct block * block
Definition: symtab.h:1140
get_frame_block
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
Definition: blockframe.c:55
frame_type
frame_type
Definition: frame.h:240
frapy_select
static PyObject * frapy_select(PyObject *self, PyObject *args)
Definition: py-frame.c:578
frame_info::prev
struct frame_info * prev
Definition: frame.c:149
block_symbol
Definition: symtab.h:1133
frame.h
gdbpy_newest_frame
PyObject * gdbpy_newest_frame(PyObject *self, PyObject *args)
Definition: py-frame.c:601
frame_object_methods
static PyMethodDef frame_object_methods[]
Definition: py-frame.c:725
type
Definition: gdbtypes.h:749
block_object_to_block
const struct block * block_object_to_block(PyObject *obj)
Definition: py-block.c:285
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
value_to_value_object
PyObject * value_to_value_object(struct value *val)
Definition: py-value.c:1579
python-internal.h
frame_object::frame_id
PyObject_HEAD struct frame_id frame_id
Definition: py-frame.c:35
regnum
int regnum
Definition: aarch64-tdep.c:77
frapy_type
static PyObject * frapy_type(PyObject *self, PyObject *args)
Definition: py-frame.c:156
user_reg_map_name_to_regnum
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition: user-regs.c:130
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
user-regs.h
block
Definition: block.h:60
value
Definition: value.c:169
find_frame_sal
symtab_and_line find_frame_sal(frame_info *frame)
Definition: frame.c:2487
symtab_and_line
Definition: symtab.h:1746
get_next_frame
struct frame_info * get_next_frame(struct frame_info *this_frame)
Definition: frame.c:1771
INLINE_FRAME
Definition: frame.h:250
frame_info::stop_reason
enum unwind_stop_reason stop_reason
Definition: frame.c:153
gdbpy_convert_exception
void gdbpy_convert_exception(struct gdb_exception exception)
Definition: py-utils.c:235
value_of_register
struct value * value_of_register(int regnum, struct frame_info *frame)
Definition: findvar.c:263
frapy_name
static PyObject * frapy_name(PyObject *self, PyObject *args)
Definition: py-frame.c:119
string_file::c_str
const char * c_str() const
Definition: ui-file.h:137
gdb::ref_ptr::release
T * release()
Definition: gdb_ref_ptr.h:138
find_frame_funname
gdb::unique_xmalloc_ptr< char > find_frame_funname(struct frame_info *frame, enum language *funlang, struct symbol **funcp)
Definition: stack.c:1039
VAR_DOMAIN
Definition: symtab.h:739
value.h
fprint_frame_id
void fprint_frame_id(struct ui_file *file, struct frame_id id)
Definition: frame.c:327
language
language
Definition: defs.h:203
frapy_richcompare
static PyObject * frapy_richcompare(PyObject *self, PyObject *other, int op)
Definition: py-frame.c:667
symbol
Definition: symtab.h:1049
frame_info::next
struct frame_info * next
Definition: frame.c:147
gdb_module
PyObject * gdb_module
Definition: python.c:116
TAILCALL_FRAME
Definition: frame.h:252
python_string_to_target_string
gdb::unique_xmalloc_ptr< char > python_string_to_target_string(PyObject *obj)
Definition: py-utils.c:124
host_charset
const char * host_charset(void)
Definition: charset.c:417
symbol_to_symbol_object
PyObject * symbol_to_symbol_object(struct symbol *sym)
Definition: py-symbol.c:325
frame_object_to_frame_info
struct frame_info * frame_object_to_frame_info(PyObject *obj)
Definition: py-frame.c:63
py-ref.h
stack.h
frapy_function
static PyObject * frapy_function(PyObject *self, PyObject *args)
Definition: py-frame.c:329
frapy_pc
static PyObject * frapy_pc(PyObject *self, PyObject *args)
Definition: py-frame.c:226
frame_id
Definition: frame.h:111
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
block.h
symfile.h
string_file
Definition: ui-file.h:106