gdb/python/py-frame.c

   1 /* Python interface to stack frames
   2
   3    Copyright (C) 2008, 2009, 2010, 2011 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 "exceptions.h"
  25 #include "symtab.h"
  26 #include "stack.h"
  27 #include "value.h"
  28 #include "python-internal.h"
  29 #include "symfile.h"
  30 #include "objfiles.h"
  31
  32 typedef struct {
  33   PyObject_HEAD
  34   struct frame_id frame_id;
  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.  */
  45   int frame_id_is_next;
  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 static PyTypeObject frame_object_type;
  58
  59 /* Returns the frame_info object corresponding to the given Python Frame
  60    object.  If the frame doesn't exist anymore (the frame id doesn't
  61    correspond to any frame in the inferior), returns NULL.  */
  62
  63 static struct frame_info *
  64 frame_object_to_frame_info (frame_object *frame_obj)
  65 {
  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   char *s;
  85   PyObject *result;
  86   struct ui_file *strfile;
  87
  88   strfile = mem_fileopen ();
  89   fprint_frame_id (strfile, ((frame_object *) self)->frame_id);
  90   s = ui_file_xstrdup (strfile, NULL);
  91   result = PyString_FromString (s);
  92   xfree (s);
  93
  94   return result;
  95 }
  96
  97 /* Implementation of gdb.Frame.is_valid (self) -> Boolean.
  98    Returns True if the frame corresponding to the frame_id of this
  99    object still exists in the inferior.  */
 100
 101 static PyObject *
 102 frapy_is_valid (PyObject *self, PyObject *args)
 103 {
 104   struct frame_info *frame;
 105
 106   frame = frame_object_to_frame_info ((frame_object *) self);
 107   if (frame == NULL)
 108     Py_RETURN_FALSE;
 109
 110   Py_RETURN_TRUE;
 111 }
 112
 113 /* Implementation of gdb.Frame.name (self) -> String.
 114    Returns the name of the function corresponding to this frame.  */
 115
 116 static PyObject *
 117 frapy_name (PyObject *self, PyObject *args)
 118 {
 119   struct frame_info *frame;
 120   char *name;
 121   enum language lang;
 122   PyObject *result;
 123   volatile struct gdb_exception except;
 124
 125   TRY_CATCH (except, RETURN_MASK_ALL)
 126     {
 127       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 128
 129       find_frame_funname (frame, &name, &lang, NULL);
 130     }
 131   GDB_PY_HANDLE_EXCEPTION (except);
 132
 133   if (name)
 134     result = PyUnicode_Decode (name, strlen (name), host_charset (), NULL);
 135   else
 136     {
 137       result = Py_None;
 138       Py_INCREF (Py_None);
 139     }
 140
 141   return result;
 142 }
 143
 144 /* Implementation of gdb.Frame.type (self) -> Integer.
 145    Returns the frame type, namely one of the gdb.*_FRAME constants.  */
 146
 147 static PyObject *
 148 frapy_type (PyObject *self, PyObject *args)
 149 {
 150   struct frame_info *frame;
 151   enum frame_type type = NORMAL_FRAME;/* Initialize to appease gcc warning.  */
 152   volatile struct gdb_exception except;
 153
 154   TRY_CATCH (except, RETURN_MASK_ALL)
 155     {
 156       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 157
 158       type = get_frame_type (frame);
 159     }
 160   GDB_PY_HANDLE_EXCEPTION (except);
 161
 162   return PyInt_FromLong (type);
 163 }
 164
 165 /* Implementation of gdb.Frame.unwind_stop_reason (self) -> Integer.
 166    Returns one of the gdb.FRAME_UNWIND_* constants.  */
 167
 168 static PyObject *
 169 frapy_unwind_stop_reason (PyObject *self, PyObject *args)
 170 {
 171   struct frame_info *frame = NULL;    /* Initialize to appease gcc warning.  */
 172   volatile struct gdb_exception except;
 173   enum unwind_stop_reason stop_reason;
 174
 175   TRY_CATCH (except, RETURN_MASK_ALL)
 176     {
 177       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 178     }
 179   GDB_PY_HANDLE_EXCEPTION (except);
 180
 181   stop_reason = get_frame_unwind_stop_reason (frame);
 182
 183   return PyInt_FromLong (stop_reason);
 184 }
 185
 186 /* Implementation of gdb.Frame.pc (self) -> Long.
 187    Returns the frame's resume address.  */
 188
 189 static PyObject *
 190 frapy_pc (PyObject *self, PyObject *args)
 191 {
 192   CORE_ADDR pc = 0;           /* Initialize to appease gcc warning.  */
 193   struct frame_info *frame;
 194   volatile struct gdb_exception except;
 195
 196   TRY_CATCH (except, RETURN_MASK_ALL)
 197     {
 198       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 199
 200       pc = get_frame_pc (frame);
 201     }
 202   GDB_PY_HANDLE_EXCEPTION (except);
 203
 204   return PyLong_FromUnsignedLongLong (pc);
 205 }
 206
 207 /* Implementation of gdb.Frame.block (self) -> gdb.Block.
 208    Returns the frame's code block.  */
 209
 210 static PyObject *
 211 frapy_block (PyObject *self, PyObject *args)
 212 {
 213   struct frame_info *frame;
 214   struct block *block = NULL, *fn_block;
 215   volatile struct gdb_exception except;
 216
 217   TRY_CATCH (except, RETURN_MASK_ALL)
 218     {
 219       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 220       block = get_frame_block (frame, NULL);
 221     }
 222   GDB_PY_HANDLE_EXCEPTION (except);
 223
 224   for (fn_block = block;
 225        fn_block != NULL && BLOCK_FUNCTION (fn_block) == NULL;
 226        fn_block = BLOCK_SUPERBLOCK (fn_block))
 227     ;
 228
 229   if (block == NULL || fn_block == NULL || BLOCK_FUNCTION (fn_block) == NULL)
 230     {
 231       PyErr_SetString (PyExc_RuntimeError,
 232                        _("Cannot locate object file for block."));
 233       return NULL;
 234     }
 235
 236   if (block)
 237     {
 238       struct symtab *symt;
 239
 240       symt = SYMBOL_SYMTAB (BLOCK_FUNCTION (fn_block));
 241       return block_to_block_object (block, symt->objfile);
 242     }
 243
 244   Py_RETURN_NONE;
 245 }
 246
 247
 248 /* Implementation of gdb.Frame.function (self) -> gdb.Symbol.
 249    Returns the symbol for the function corresponding to this frame.  */
 250
 251 static PyObject *
 252 frapy_function (PyObject *self, PyObject *args)
 253 {
 254   struct symbol *sym = NULL;
 255   struct frame_info *frame;
 256   volatile struct gdb_exception except;
 257
 258   TRY_CATCH (except, RETURN_MASK_ALL)
 259     {
 260       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 261
 262       sym = find_pc_function (get_frame_address_in_block (frame));
 263     }
 264   GDB_PY_HANDLE_EXCEPTION (except);
 265
 266   if (sym)
 267     return symbol_to_symbol_object (sym);
 268
 269   Py_RETURN_NONE;
 270 }
 271
 272 /* Convert a frame_info struct to a Python Frame object.
 273    Sets a Python exception and returns NULL on error.  */
 274
 275 PyObject *
 276 frame_info_to_frame_object (struct frame_info *frame)
 277 {
 278   frame_object *frame_obj;
 279
 280   frame_obj = PyObject_New (frame_object, &frame_object_type);
 281   if (frame_obj == NULL)
 282     {
 283       PyErr_SetString (PyExc_MemoryError,
 284                        _("Could not allocate frame object."));
 285       return NULL;
 286     }
 287
 288   /* Try to get the previous frame, to determine if this is the last frame
 289      in a corrupt stack.  If so, we need to store the frame_id of the next
 290      frame and not of this one (which is possibly invalid).  */
 291   if (get_prev_frame (frame) == NULL
 292       && get_frame_unwind_stop_reason (frame) != UNWIND_NO_REASON
 293       && get_next_frame (frame) != NULL)
 294     {
 295       frame_obj->frame_id = get_frame_id (get_next_frame (frame));
 296       frame_obj->frame_id_is_next = 1;
 297     }
 298   else
 299     {
 300       frame_obj->frame_id = get_frame_id (frame);
 301       frame_obj->frame_id_is_next = 0;
 302     }
 303
 304   frame_obj->gdbarch = get_frame_arch (frame);
 305
 306   return (PyObject *) frame_obj;
 307 }
 308
 309 /* Implementation of gdb.Frame.older (self) -> gdb.Frame.
 310    Returns the frame immediately older (outer) to this frame, or None if
 311    there isn't one.  */
 312
 313 static PyObject *
 314 frapy_older (PyObject *self, PyObject *args)
 315 {
 316   struct frame_info *frame, *prev;
 317   volatile struct gdb_exception except;
 318   PyObject *prev_obj = NULL;   /* Initialize to appease gcc warning.  */
 319
 320   TRY_CATCH (except, RETURN_MASK_ALL)
 321     {
 322       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 323
 324       prev = get_prev_frame (frame);
 325       if (prev)
 326         prev_obj = (PyObject *) frame_info_to_frame_object (prev);
 327       else
 328         {
 329           Py_INCREF (Py_None);
 330           prev_obj = Py_None;
 331         }
 332     }
 333   GDB_PY_HANDLE_EXCEPTION (except);
 334
 335   return prev_obj;
 336 }
 337
 338 /* Implementation of gdb.Frame.newer (self) -> gdb.Frame.
 339    Returns the frame immediately newer (inner) to this frame, or None if
 340    there isn't one.  */
 341
 342 static PyObject *
 343 frapy_newer (PyObject *self, PyObject *args)
 344 {
 345   struct frame_info *frame, *next;
 346   volatile struct gdb_exception except;
 347   PyObject *next_obj = NULL;   /* Initialize to appease gcc warning.  */
 348
 349   TRY_CATCH (except, RETURN_MASK_ALL)
 350     {
 351       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 352
 353       next = get_next_frame (frame);
 354       if (next)
 355         next_obj = (PyObject *) frame_info_to_frame_object (next);
 356       else
 357         {
 358           Py_INCREF (Py_None);
 359           next_obj = Py_None;
 360         }
 361     }
 362   GDB_PY_HANDLE_EXCEPTION (except);
 363
 364   return next_obj;
 365 }
 366
 367 /* Implementation of gdb.Frame.find_sal (self) -> gdb.Symtab_and_line.
 368    Returns the frame's symtab and line.  */
 369
 370 static PyObject *
 371 frapy_find_sal (PyObject *self, PyObject *args)
 372 {
 373   struct frame_info *frame;
 374   struct symtab_and_line sal;
 375   volatile struct gdb_exception except;
 376   PyObject *sal_obj = NULL;   /* Initialize to appease gcc warning.  */
 377
 378   TRY_CATCH (except, RETURN_MASK_ALL)
 379     {
 380       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 381
 382       find_frame_sal (frame, &sal);
 383       sal_obj = symtab_and_line_to_sal_object (sal);
 384     }
 385   GDB_PY_HANDLE_EXCEPTION (except);
 386
 387   return sal_obj;
 388 }
 389
 390 /* Implementation of gdb.Frame.read_var_value (self, variable,
 391    [block]) -> gdb.Value.  If the optional block argument is provided
 392    start the search from that block, otherwise search from the frame's
 393    current block (determined by examining the resume address of the
 394    frame).  The variable argument must be a string or an instance of a
 395    gdb.Symbol.  The block argument must be an instance of gdb.Block.  Returns
 396    NULL on error, with a python exception set.  */
 397 static PyObject *
 398 frapy_read_var (PyObject *self, PyObject *args)
 399 {
 400   struct frame_info *frame;
 401   PyObject *sym_obj, *block_obj = NULL;
 402   struct symbol *var = NULL;    /* gcc-4.3.2 false warning.  */
 403   struct value *val = NULL;
 404   volatile struct gdb_exception except;
 405
 406   if (!PyArg_ParseTuple (args, "O|O", &sym_obj, &block_obj))
 407     return NULL;
 408
 409   if (PyObject_TypeCheck (sym_obj, &symbol_object_type))
 410     var = symbol_object_to_symbol (sym_obj);
 411   else if (gdbpy_is_string (sym_obj))
 412     {
 413       char *var_name;
 414       struct block *block = NULL;
 415       struct cleanup *cleanup;
 416       volatile struct gdb_exception except;
 417
 418       var_name = python_string_to_target_string (sym_obj);
 419       if (!var_name)
 420         return NULL;
 421       cleanup = make_cleanup (xfree, var_name);
 422
 423       if (block_obj)
 424         {
 425           block = block_object_to_block (block_obj);
 426           if (!block)
 427             {
 428               PyErr_SetString (PyExc_RuntimeError,
 429                                _("Second argument must be block."));
 430               return NULL;
 431             }
 432         }
 433
 434       TRY_CATCH (except, RETURN_MASK_ALL)
 435         {
 436           FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 437
 438           if (!block)
 439             block = block_for_pc (get_frame_address_in_block (frame));
 440           var = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);
 441         }
 442       GDB_PY_HANDLE_EXCEPTION (except);
 443
 444       if (!var)
 445         {
 446           PyErr_Format (PyExc_ValueError,
 447                         _("Variable '%s' not found."), var_name);
 448           do_cleanups (cleanup);
 449
 450           return NULL;
 451         }
 452
 453       do_cleanups (cleanup);
 454     }
 455   else
 456     {
 457       PyErr_SetString (PyExc_TypeError,
 458                        _("Argument must be a symbol or string."));
 459       return NULL;
 460     }
 461
 462   TRY_CATCH (except, RETURN_MASK_ALL)
 463     {
 464       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 465
 466       val = read_var_value (var, frame);
 467     }
 468   GDB_PY_HANDLE_EXCEPTION (except);
 469
 470   if (!val)
 471     {
 472       PyErr_Format (PyExc_ValueError,
 473                     _("Variable cannot be found for symbol '%s'."),
 474                     SYMBOL_NATURAL_NAME (var));
 475       return NULL;
 476     }
 477
 478   return value_to_value_object (val);
 479 }
 480
 481 /* Select this frame.  */
 482
 483 static PyObject *
 484 frapy_select (PyObject *self, PyObject *args)
 485 {
 486   struct frame_info *fi;
 487   frame_object *frame = (frame_object *) self;
 488   volatile struct gdb_exception except;
 489
 490   TRY_CATCH (except, RETURN_MASK_ALL)
 491     {
 492       FRAPY_REQUIRE_VALID (frame, fi);
 493
 494       select_frame (fi);
 495     }
 496   GDB_PY_HANDLE_EXCEPTION (except);
 497
 498   Py_RETURN_NONE;
 499 }
 500
 501 /* Implementation of gdb.selected_frame () -> gdb.Frame.
 502    Returns the selected frame object.  */
 503
 504 PyObject *
 505 gdbpy_selected_frame (PyObject *self, PyObject *args)
 506 {
 507   struct frame_info *frame;
 508   PyObject *frame_obj = NULL;   /* Initialize to appease gcc warning.  */
 509   volatile struct gdb_exception except;
 510
 511   TRY_CATCH (except, RETURN_MASK_ALL)
 512     {
 513       frame = get_selected_frame ("No frame is currently selected.");
 514       frame_obj = frame_info_to_frame_object (frame);
 515     }
 516   GDB_PY_HANDLE_EXCEPTION (except);
 517
 518   return frame_obj;
 519 }
 520
 521 /* Implementation of gdb.stop_reason_string (Integer) -> String.
 522    Return a string explaining the unwind stop reason.  */
 523
 524 PyObject *
 525 gdbpy_frame_stop_reason_string (PyObject *self, PyObject *args)
 526 {
 527   int reason;
 528   const char *str;
 529
 530   if (!PyArg_ParseTuple (args, "i", &reason))
 531     return NULL;
 532
 533   if (reason < 0 || reason > UNWIND_NO_SAVED_PC)
 534     {
 535       PyErr_SetString (PyExc_ValueError,
 536                        _("Invalid frame stop reason."));
 537       return NULL;
 538     }
 539
 540   str = frame_stop_reason_string (reason);
 541   return PyUnicode_Decode (str, strlen (str), host_charset (), NULL);
 542 }
 543
 544 /* Implements the equality comparison for Frame objects.
 545    All other comparison operators will throw a TypeError Python exception,
 546    as they aren't valid for frames.  */
 547
 548 static PyObject *
 549 frapy_richcompare (PyObject *self, PyObject *other, int op)
 550 {
 551   int result;
 552
 553   if (!PyObject_TypeCheck (other, &frame_object_type)
 554       || (op != Py_EQ && op != Py_NE))
 555     {
 556       Py_INCREF (Py_NotImplemented);
 557       return Py_NotImplemented;
 558     }
 559
 560   if (frame_id_eq (((frame_object *) self)->frame_id,
 561                    ((frame_object *) other)->frame_id))
 562     result = Py_EQ;
 563   else
 564     result = Py_NE;
 565
 566   if (op == result)
 567     Py_RETURN_TRUE;
 568   Py_RETURN_FALSE;
 569 }
 570
 571 /* Sets up the Frame API in the gdb module.  */
 572
 573 void
 574 gdbpy_initialize_frames (void)
 575 {
 576   if (PyType_Ready (&frame_object_type) < 0)
 577     return;
 578
 579   /* Note: These would probably be best exposed as class attributes of
 580      Frame, but I don't know how to do it except by messing with the
 581      type's dictionary.  That seems too messy.  */
 582   PyModule_AddIntConstant (gdb_module, "NORMAL_FRAME", NORMAL_FRAME);
 583   PyModule_AddIntConstant (gdb_module, "DUMMY_FRAME", DUMMY_FRAME);
 584   PyModule_AddIntConstant (gdb_module, "INLINE_FRAME", INLINE_FRAME);
 585   PyModule_AddIntConstant (gdb_module, "SIGTRAMP_FRAME", SIGTRAMP_FRAME);
 586   PyModule_AddIntConstant (gdb_module, "ARCH_FRAME", ARCH_FRAME);
 587   PyModule_AddIntConstant (gdb_module, "SENTINEL_FRAME", SENTINEL_FRAME);
 588   PyModule_AddIntConstant (gdb_module,
 589                            "FRAME_UNWIND_NO_REASON", UNWIND_NO_REASON);
 590   PyModule_AddIntConstant (gdb_module,
 591                            "FRAME_UNWIND_NULL_ID", UNWIND_NULL_ID);
 592   PyModule_AddIntConstant (gdb_module,
 593                            "FRAME_UNWIND_FIRST_ERROR", UNWIND_FIRST_ERROR);
 594   PyModule_AddIntConstant (gdb_module,
 595                            "FRAME_UNWIND_INNER_ID", UNWIND_INNER_ID);
 596   PyModule_AddIntConstant (gdb_module,
 597                            "FRAME_UNWIND_SAME_ID", UNWIND_SAME_ID);
 598   PyModule_AddIntConstant (gdb_module,
 599                            "FRAME_UNWIND_NO_SAVED_PC", UNWIND_NO_SAVED_PC);
 600
 601   Py_INCREF (&frame_object_type);
 602   PyModule_AddObject (gdb_module, "Frame", (PyObject *) &frame_object_type);
 603 }
 604
 605 \f
 606
 607 static PyMethodDef frame_object_methods[] = {
 608   { "is_valid", frapy_is_valid, METH_NOARGS,
 609     "is_valid () -> Boolean.\n\
 610 Return true if this frame is valid, false if not." },
 611   { "name", frapy_name, METH_NOARGS,
 612     "name () -> String.\n\
 613 Return the function name of the frame, or None if it can't be determined." },
 614   { "type", frapy_type, METH_NOARGS,
 615     "type () -> Integer.\n\
 616 Return the type of the frame." },
 617   { "unwind_stop_reason", frapy_unwind_stop_reason, METH_NOARGS,
 618     "unwind_stop_reason () -> Integer.\n\
 619 Return the reason why it's not possible to find frames older than this." },
 620   { "pc", frapy_pc, METH_NOARGS,
 621     "pc () -> Long.\n\
 622 Return the frame's resume address." },
 623   { "block", frapy_block, METH_NOARGS,
 624     "block () -> gdb.Block.\n\
 625 Return the frame's code block." },
 626   { "function", frapy_function, METH_NOARGS,
 627     "function () -> gdb.Symbol.\n\
 628 Returns the symbol for the function corresponding to this frame." },
 629   { "older", frapy_older, METH_NOARGS,
 630     "older () -> gdb.Frame.\n\
 631 Return the frame that called this frame." },
 632   { "newer", frapy_newer, METH_NOARGS,
 633     "newer () -> gdb.Frame.\n\
 634 Return the frame called by this frame." },
 635   { "find_sal", frapy_find_sal, METH_NOARGS,
 636     "find_sal () -> gdb.Symtab_and_line.\n\
 637 Return the frame's symtab and line." },
 638   { "read_var", frapy_read_var, METH_VARARGS,
 639     "read_var (variable) -> gdb.Value.\n\
 640 Return the value of the variable in this frame." },
 641   { "select", frapy_select, METH_NOARGS,
 642     "Select this frame as the user's current frame." },
 643   {NULL}  /* Sentinel */
 644 };
 645
 646 static PyTypeObject frame_object_type = {
 647   PyObject_HEAD_INIT (NULL)
 648   0,                              /* ob_size */
 649   "gdb.Frame",                    /* tp_name */
 650   sizeof (frame_object),          /* tp_basicsize */
 651   0,                              /* tp_itemsize */
 652   0,                              /* tp_dealloc */
 653   0,                              /* tp_print */
 654   0,                              /* tp_getattr */
 655   0,                              /* tp_setattr */
 656   0,                              /* tp_compare */
 657   0,                              /* tp_repr */
 658   0,                              /* tp_as_number */
 659   0,                              /* tp_as_sequence */
 660   0,                              /* tp_as_mapping */
 661   0,                              /* tp_hash  */
 662   0,                              /* tp_call */
 663   frapy_str,                      /* tp_str */
 664   0,                              /* tp_getattro */
 665   0,                              /* tp_setattro */
 666   0,                              /* tp_as_buffer */
 667   Py_TPFLAGS_DEFAULT,             /* tp_flags */
 668   "GDB frame object",             /* tp_doc */
 669   0,                              /* tp_traverse */
 670   0,                              /* tp_clear */
 671   frapy_richcompare,              /* tp_richcompare */
 672   0,                              /* tp_weaklistoffset */
 673   0,                              /* tp_iter */
 674   0,                              /* tp_iternext */
 675   frame_object_methods,           /* tp_methods */
 676   0,                              /* tp_members */
 677   0,                              /* tp_getset */
 678   0,                              /* tp_base */
 679   0,                              /* tp_dict */
 680   0,                              /* tp_descr_get */
 681   0,                              /* tp_descr_set */
 682   0,                              /* tp_dictoffset */
 683   0,                              /* tp_init */
 684   0,                              /* tp_alloc */
 685   PyType_GenericNew               /* tp_new */
 686 };