gdb/python/py-frame.c

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