gdb/python/py-frame.c

   1 /* Python interface to stack frames
   2
   3    Copyright (C) 2008-2017 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
  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 /* 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 *
  62 frame_object_to_frame_info (PyObject *obj)
  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   PyObject *result;
  84   struct ui_file *strfile;
  85
  86   strfile = mem_fileopen ();
  87   fprint_frame_id (strfile, ((frame_object *) self)->frame_id);
  88   std::string s = ui_file_as_string (strfile);
  89   return PyString_FromString (s.c_str ());
  90 }
  91
  92 /* Implementation of gdb.Frame.is_valid (self) -> Boolean.
  93    Returns True if the frame corresponding to the frame_id of this
  94    object still exists in the inferior.  */
  95
  96 static PyObject *
  97 frapy_is_valid (PyObject *self, PyObject *args)
  98 {
  99   struct frame_info *frame = NULL;
 100
 101   TRY
 102     {
 103       frame = frame_object_to_frame_info (self);
 104     }
 105   CATCH (except, RETURN_MASK_ALL)
 106     {
 107       GDB_PY_HANDLE_EXCEPTION (except);
 108     }
 109   END_CATCH
 110
 111   if (frame == NULL)
 112     Py_RETURN_FALSE;
 113
 114   Py_RETURN_TRUE;
 115 }
 116
 117 /* Implementation of gdb.Frame.name (self) -> String.
 118    Returns the name of the function corresponding to this frame.  */
 119
 120 static PyObject *
 121 frapy_name (PyObject *self, PyObject *args)
 122 {
 123   struct frame_info *frame;
 124   char *name = NULL;
 125   enum language lang;
 126   PyObject *result;
 127
 128   TRY
 129     {
 130       FRAPY_REQUIRE_VALID (self, frame);
 131
 132       find_frame_funname (frame, &name, &lang, NULL);
 133     }
 134   CATCH (except, RETURN_MASK_ALL)
 135     {
 136       xfree (name);
 137       GDB_PY_HANDLE_EXCEPTION (except);
 138     }
 139   END_CATCH
 140
 141   if (name)
 142     {
 143       result = PyUnicode_Decode (name, strlen (name), host_charset (), NULL);
 144       xfree (name);
 145     }
 146   else
 147     {
 148       result = Py_None;
 149       Py_INCREF (Py_None);
 150     }
 151
 152   return result;
 153 }
 154
 155 /* Implementation of gdb.Frame.type (self) -> Integer.
 156    Returns the frame type, namely one of the gdb.*_FRAME constants.  */
 157
 158 static PyObject *
 159 frapy_type (PyObject *self, PyObject *args)
 160 {
 161   struct frame_info *frame;
 162   enum frame_type type = NORMAL_FRAME;/* Initialize to appease gcc warning.  */
 163
 164   TRY
 165     {
 166       FRAPY_REQUIRE_VALID (self, frame);
 167
 168       type = get_frame_type (frame);
 169     }
 170   CATCH (except, RETURN_MASK_ALL)
 171     {
 172       GDB_PY_HANDLE_EXCEPTION (except);
 173     }
 174   END_CATCH
 175
 176   return PyInt_FromLong (type);
 177 }
 178
 179 /* Implementation of gdb.Frame.architecture (self) -> gdb.Architecture.
 180    Returns the frame's architecture as a gdb.Architecture object.  */
 181
 182 static PyObject *
 183 frapy_arch (PyObject *self, PyObject *args)
 184 {
 185   struct frame_info *frame = NULL;    /* Initialize to appease gcc warning.  */
 186   frame_object *obj = (frame_object *) self;
 187
 188   TRY
 189     {
 190       FRAPY_REQUIRE_VALID (self, frame);
 191     }
 192   CATCH (except, RETURN_MASK_ALL)
 193     {
 194       GDB_PY_HANDLE_EXCEPTION (except);
 195     }
 196   END_CATCH
 197
 198   return gdbarch_to_arch_object (obj->gdbarch);
 199 }
 200
 201 /* Implementation of gdb.Frame.unwind_stop_reason (self) -> Integer.
 202    Returns one of the gdb.FRAME_UNWIND_* constants.  */
 203
 204 static PyObject *
 205 frapy_unwind_stop_reason (PyObject *self, PyObject *args)
 206 {
 207   struct frame_info *frame = NULL;    /* Initialize to appease gcc warning.  */
 208   enum unwind_stop_reason stop_reason;
 209
 210   TRY
 211     {
 212       FRAPY_REQUIRE_VALID (self, frame);
 213     }
 214   CATCH (except, RETURN_MASK_ALL)
 215     {
 216       GDB_PY_HANDLE_EXCEPTION (except);
 217     }
 218   END_CATCH
 219
 220   stop_reason = get_frame_unwind_stop_reason (frame);
 221
 222   return PyInt_FromLong (stop_reason);
 223 }
 224
 225 /* Implementation of gdb.Frame.pc (self) -> Long.
 226    Returns the frame's resume address.  */
 227
 228 static PyObject *
 229 frapy_pc (PyObject *self, PyObject *args)
 230 {
 231   CORE_ADDR pc = 0;           /* Initialize to appease gcc warning.  */
 232   struct frame_info *frame;
 233
 234   TRY
 235     {
 236       FRAPY_REQUIRE_VALID (self, frame);
 237
 238       pc = get_frame_pc (frame);
 239     }
 240   CATCH (except, RETURN_MASK_ALL)
 241     {
 242       GDB_PY_HANDLE_EXCEPTION (except);
 243     }
 244   END_CATCH
 245
 246   return gdb_py_long_from_ulongest (pc);
 247 }
 248
 249 /* Implementation of gdb.Frame.read_register (self, register) -> gdb.Value.
 250    Returns the value of a register in this frame.  */
 251
 252 static PyObject *
 253 frapy_read_register (PyObject *self, PyObject *args)
 254 {
 255   const char *regnum_str;
 256   struct value *val = NULL;
 257
 258   if (!PyArg_ParseTuple (args, "s", &regnum_str))
 259     return NULL;
 260
 261   TRY
 262     {
 263       struct frame_info *frame;
 264       int regnum;
 265
 266       FRAPY_REQUIRE_VALID (self, frame);
 267
 268       regnum = user_reg_map_name_to_regnum (get_frame_arch (frame),
 269                                             regnum_str,
 270                                             strlen (regnum_str));
 271       if (regnum >= 0)
 272         val = value_of_register (regnum, frame);
 273
 274       if (val == NULL)
 275         PyErr_SetString (PyExc_ValueError, _("Unknown register."));
 276     }
 277   CATCH (except, RETURN_MASK_ALL)
 278     {
 279       GDB_PY_HANDLE_EXCEPTION (except);
 280     }
 281   END_CATCH
 282
 283   return val == NULL ? NULL : value_to_value_object (val);
 284 }
 285
 286 /* Implementation of gdb.Frame.block (self) -> gdb.Block.
 287    Returns the frame's code block.  */
 288
 289 static PyObject *
 290 frapy_block (PyObject *self, PyObject *args)
 291 {
 292   struct frame_info *frame;
 293   const struct block *block = NULL, *fn_block;
 294
 295   TRY
 296     {
 297       FRAPY_REQUIRE_VALID (self, frame);
 298       block = get_frame_block (frame, NULL);
 299     }
 300   CATCH (except, RETURN_MASK_ALL)
 301     {
 302       GDB_PY_HANDLE_EXCEPTION (except);
 303     }
 304   END_CATCH
 305
 306   for (fn_block = block;
 307        fn_block != NULL && BLOCK_FUNCTION (fn_block) == NULL;
 308        fn_block = BLOCK_SUPERBLOCK (fn_block))
 309     ;
 310
 311   if (block == NULL || fn_block == NULL || BLOCK_FUNCTION (fn_block) == NULL)
 312     {
 313       PyErr_SetString (PyExc_RuntimeError,
 314                        _("Cannot locate block for frame."));
 315       return NULL;
 316     }
 317
 318   if (block)
 319     {
 320       return block_to_block_object
 321         (block, symbol_objfile (BLOCK_FUNCTION (fn_block)));
 322     }
 323
 324   Py_RETURN_NONE;
 325 }
 326
 327
 328 /* Implementation of gdb.Frame.function (self) -> gdb.Symbol.
 329    Returns the symbol for the function corresponding to this frame.  */
 330
 331 static PyObject *
 332 frapy_function (PyObject *self, PyObject *args)
 333 {
 334   struct symbol *sym = NULL;
 335   struct frame_info *frame;
 336
 337   TRY
 338     {
 339       char *funname;
 340       enum language funlang;
 341
 342       FRAPY_REQUIRE_VALID (self, frame);
 343
 344       find_frame_funname (frame, &funname, &funlang, &sym);
 345       xfree (funname);
 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 *
 363 frame_info_to_frame_object (struct frame_info *frame)
 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   const struct block *block = NULL;
 508   struct value *val = NULL;
 509
 510   if (!PyArg_ParseTuple (args, "O|O", &sym_obj, &block_obj))
 511     return NULL;
 512
 513   if (PyObject_TypeCheck (sym_obj, &symbol_object_type))
 514     var = symbol_object_to_symbol (sym_obj);
 515   else if (gdbpy_is_string (sym_obj))
 516     {
 517       gdb::unique_xmalloc_ptr<char>
 518         var_name (python_string_to_target_string (sym_obj));
 519
 520       if (!var_name)
 521         return NULL;
 522
 523       if (block_obj)
 524         {
 525           block = block_object_to_block (block_obj);
 526           if (!block)
 527             {
 528               PyErr_SetString (PyExc_RuntimeError,
 529                                _("Second argument must be block."));
 530               return NULL;
 531             }
 532         }
 533
 534       TRY
 535         {
 536           struct block_symbol lookup_sym;
 537           FRAPY_REQUIRE_VALID (self, frame);
 538
 539           if (!block)
 540             block = get_frame_block (frame, NULL);
 541           lookup_sym = lookup_symbol (var_name.get (), block, VAR_DOMAIN, NULL);
 542           var = lookup_sym.symbol;
 543           block = lookup_sym.block;
 544         }
 545       CATCH (except, RETURN_MASK_ALL)
 546         {
 547           gdbpy_convert_exception (except);
 548           return NULL;
 549         }
 550       END_CATCH
 551
 552       if (!var)
 553         {
 554           PyErr_Format (PyExc_ValueError,
 555                         _("Variable '%s' not found."), var_name.get ());
 556
 557           return NULL;
 558         }
 559     }
 560   else
 561     {
 562       PyErr_SetString (PyExc_TypeError,
 563                        _("Argument must be a symbol or string."));
 564       return NULL;
 565     }
 566
 567   TRY
 568     {
 569       FRAPY_REQUIRE_VALID (self, frame);
 570
 571       val = read_var_value (var, block, frame);
 572     }
 573   CATCH (except, RETURN_MASK_ALL)
 574     {
 575       GDB_PY_HANDLE_EXCEPTION (except);
 576     }
 577   END_CATCH
 578
 579   return value_to_value_object (val);
 580 }
 581
 582 /* Select this frame.  */
 583
 584 static PyObject *
 585 frapy_select (PyObject *self, PyObject *args)
 586 {
 587   struct frame_info *fi;
 588
 589   TRY
 590     {
 591       FRAPY_REQUIRE_VALID (self, fi);
 592
 593       select_frame (fi);
 594     }
 595   CATCH (except, RETURN_MASK_ALL)
 596     {
 597       GDB_PY_HANDLE_EXCEPTION (except);
 598     }
 599   END_CATCH
 600
 601   Py_RETURN_NONE;
 602 }
 603
 604 /* Implementation of gdb.newest_frame () -> gdb.Frame.
 605    Returns the newest frame object.  */
 606
 607 PyObject *
 608 gdbpy_newest_frame (PyObject *self, PyObject *args)
 609 {
 610   struct frame_info *frame = NULL;
 611
 612   TRY
 613     {
 614       frame = get_current_frame ();
 615     }
 616   CATCH (except, RETURN_MASK_ALL)
 617     {
 618       GDB_PY_HANDLE_EXCEPTION (except);
 619     }
 620   END_CATCH
 621
 622   return frame_info_to_frame_object (frame);
 623 }
 624
 625 /* Implementation of gdb.selected_frame () -> gdb.Frame.
 626    Returns the selected frame object.  */
 627
 628 PyObject *
 629 gdbpy_selected_frame (PyObject *self, PyObject *args)
 630 {
 631   struct frame_info *frame = NULL;
 632
 633   TRY
 634     {
 635       frame = get_selected_frame ("No frame is currently selected.");
 636     }
 637   CATCH (except, RETURN_MASK_ALL)
 638     {
 639       GDB_PY_HANDLE_EXCEPTION (except);
 640     }
 641   END_CATCH
 642
 643   return frame_info_to_frame_object (frame);
 644 }
 645
 646 /* Implementation of gdb.stop_reason_string (Integer) -> String.
 647    Return a string explaining the unwind stop reason.  */
 648
 649 PyObject *
 650 gdbpy_frame_stop_reason_string (PyObject *self, PyObject *args)
 651 {
 652   int reason;
 653   const char *str;
 654
 655   if (!PyArg_ParseTuple (args, "i", &reason))
 656     return NULL;
 657
 658   if (reason < UNWIND_FIRST || reason > UNWIND_LAST)
 659     {
 660       PyErr_SetString (PyExc_ValueError,
 661                        _("Invalid frame stop reason."));
 662       return NULL;
 663     }
 664
 665   str = unwind_stop_reason_to_string ((enum unwind_stop_reason) reason);
 666   return PyUnicode_Decode (str, strlen (str), host_charset (), NULL);
 667 }
 668
 669 /* Implements the equality comparison for Frame objects.
 670    All other comparison operators will throw a TypeError Python exception,
 671    as they aren't valid for frames.  */
 672
 673 static PyObject *
 674 frapy_richcompare (PyObject *self, PyObject *other, int op)
 675 {
 676   int result;
 677
 678   if (!PyObject_TypeCheck (other, &frame_object_type)
 679       || (op != Py_EQ && op != Py_NE))
 680     {
 681       Py_INCREF (Py_NotImplemented);
 682       return Py_NotImplemented;
 683     }
 684
 685   if (frame_id_eq (((frame_object *) self)->frame_id,
 686                    ((frame_object *) other)->frame_id))
 687     result = Py_EQ;
 688   else
 689     result = Py_NE;
 690
 691   if (op == result)
 692     Py_RETURN_TRUE;
 693   Py_RETURN_FALSE;
 694 }
 695
 696 /* Sets up the Frame API in the gdb module.  */
 697
 698 int
 699 gdbpy_initialize_frames (void)
 700 {
 701   frame_object_type.tp_new = PyType_GenericNew;
 702   if (PyType_Ready (&frame_object_type) < 0)
 703     return -1;
 704
 705   /* Note: These would probably be best exposed as class attributes of
 706      Frame, but I don't know how to do it except by messing with the
 707      type's dictionary.  That seems too messy.  */
 708   if (PyModule_AddIntConstant (gdb_module, "NORMAL_FRAME", NORMAL_FRAME) < 0
 709       || PyModule_AddIntConstant (gdb_module, "DUMMY_FRAME", DUMMY_FRAME) < 0
 710       || PyModule_AddIntConstant (gdb_module, "INLINE_FRAME", INLINE_FRAME) < 0
 711       || PyModule_AddIntConstant (gdb_module, "TAILCALL_FRAME",
 712                                   TAILCALL_FRAME) < 0
 713       || PyModule_AddIntConstant (gdb_module, "SIGTRAMP_FRAME",
 714                                   SIGTRAMP_FRAME) < 0
 715       || PyModule_AddIntConstant (gdb_module, "ARCH_FRAME", ARCH_FRAME) < 0
 716       || PyModule_AddIntConstant (gdb_module, "SENTINEL_FRAME",
 717                                   SENTINEL_FRAME) < 0)
 718     return -1;
 719
 720 #define SET(name, description) \
 721   if (PyModule_AddIntConstant (gdb_module, "FRAME_"#name, name) < 0) \
 722     return -1;
 723 #include "unwind_stop_reasons.def"
 724 #undef SET
 725
 726   return gdb_pymodule_addobject (gdb_module, "Frame",
 727                                  (PyObject *) &frame_object_type);
 728 }
 729
 730 \f
 731
 732 static PyMethodDef frame_object_methods[] = {
 733   { "is_valid", frapy_is_valid, METH_NOARGS,
 734     "is_valid () -> Boolean.\n\
 735 Return true if this frame is valid, false if not." },
 736   { "name", frapy_name, METH_NOARGS,
 737     "name () -> String.\n\
 738 Return the function name of the frame, or None if it can't be determined." },
 739   { "type", frapy_type, METH_NOARGS,
 740     "type () -> Integer.\n\
 741 Return the type of the frame." },
 742   { "architecture", frapy_arch, METH_NOARGS,
 743     "architecture () -> gdb.Architecture.\n\
 744 Return the architecture of the frame." },
 745   { "unwind_stop_reason", frapy_unwind_stop_reason, METH_NOARGS,
 746     "unwind_stop_reason () -> Integer.\n\
 747 Return the reason why it's not possible to find frames older than this." },
 748   { "pc", frapy_pc, METH_NOARGS,
 749     "pc () -> Long.\n\
 750 Return the frame's resume address." },
 751   { "read_register", frapy_read_register, METH_VARARGS,
 752     "read_register (register_name) -> gdb.Value\n\
 753 Return the value of the register in the frame." },
 754   { "block", frapy_block, METH_NOARGS,
 755     "block () -> gdb.Block.\n\
 756 Return the frame's code block." },
 757   { "function", frapy_function, METH_NOARGS,
 758     "function () -> gdb.Symbol.\n\
 759 Returns the symbol for the function corresponding to this frame." },
 760   { "older", frapy_older, METH_NOARGS,
 761     "older () -> gdb.Frame.\n\
 762 Return the frame that called this frame." },
 763   { "newer", frapy_newer, METH_NOARGS,
 764     "newer () -> gdb.Frame.\n\
 765 Return the frame called by this frame." },
 766   { "find_sal", frapy_find_sal, METH_NOARGS,
 767     "find_sal () -> gdb.Symtab_and_line.\n\
 768 Return the frame's symtab and line." },
 769   { "read_var", frapy_read_var, METH_VARARGS,
 770     "read_var (variable) -> gdb.Value.\n\
 771 Return the value of the variable in this frame." },
 772   { "select", frapy_select, METH_NOARGS,
 773     "Select this frame as the user's current 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 };