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