gdb/python/py-frame.c

   1 /* Python interface to stack frames
   2
   3    Copyright (C) 2008, 2009, 2010 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);
 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;
 215   volatile struct gdb_exception except;
 216   struct symtab_and_line sal;
 217
 218   TRY_CATCH (except, RETURN_MASK_ALL)
 219     {
 220       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 221
 222       find_frame_sal (frame, &sal);
 223       block = block_for_pc (get_frame_address_in_block (frame));
 224     }
 225   GDB_PY_HANDLE_EXCEPTION (except);
 226
 227   if (!sal.symtab || !sal.symtab->objfile)
 228     {
 229       PyErr_SetString (PyExc_RuntimeError,
 230                        "Cannot locate object file for block.");
 231       return NULL;
 232     }
 233
 234   if (block)
 235     return block_to_block_object (block, sal.symtab->objfile);
 236
 237   Py_RETURN_NONE;
 238 }
 239
 240
 241 /* Implementation of gdb.Frame.function (self) -> gdb.Symbol.
 242    Returns the symbol for the function corresponding to this frame.  */
 243
 244 static PyObject *
 245 frapy_function (PyObject *self, PyObject *args)
 246 {
 247   struct symbol *sym = NULL;
 248   struct frame_info *frame;
 249   volatile struct gdb_exception except;
 250
 251   TRY_CATCH (except, RETURN_MASK_ALL)
 252     {
 253       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 254
 255       sym = find_pc_function (get_frame_address_in_block (frame));
 256     }
 257   GDB_PY_HANDLE_EXCEPTION (except);
 258
 259   if (sym)
 260     return symbol_to_symbol_object (sym);
 261
 262   Py_RETURN_NONE;
 263 }
 264
 265 /* Convert a frame_info struct to a Python Frame object.
 266    Sets a Python exception and returns NULL on error.  */
 267
 268 static frame_object *
 269 frame_info_to_frame_object (struct frame_info *frame)
 270 {
 271   frame_object *frame_obj;
 272
 273   frame_obj = PyObject_New (frame_object, &frame_object_type);
 274   if (frame_obj == NULL)
 275     {
 276       PyErr_SetString (PyExc_MemoryError, "Could not allocate frame object.");
 277       return NULL;
 278     }
 279
 280   /* Try to get the previous frame, to determine if this is the last frame
 281      in a corrupt stack.  If so, we need to store the frame_id of the next
 282      frame and not of this one (which is possibly invalid).  */
 283   if (get_prev_frame (frame) == NULL
 284       && get_frame_unwind_stop_reason (frame) != UNWIND_NO_REASON
 285       && get_next_frame (frame) != NULL)
 286     {
 287       frame_obj->frame_id = get_frame_id (get_next_frame (frame));
 288       frame_obj->frame_id_is_next = 1;
 289     }
 290   else
 291     {
 292       frame_obj->frame_id = get_frame_id (frame);
 293       frame_obj->frame_id_is_next = 0;
 294     }
 295
 296   frame_obj->gdbarch = get_frame_arch (frame);
 297
 298   return frame_obj;
 299 }
 300
 301 /* Implementation of gdb.Frame.older (self) -> gdb.Frame.
 302    Returns the frame immediately older (outer) to this frame, or None if
 303    there isn't one.  */
 304
 305 static PyObject *
 306 frapy_older (PyObject *self, PyObject *args)
 307 {
 308   struct frame_info *frame, *prev;
 309   volatile struct gdb_exception except;
 310   PyObject *prev_obj = NULL;   /* Initialize to appease gcc warning.  */
 311
 312   TRY_CATCH (except, RETURN_MASK_ALL)
 313     {
 314       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 315
 316       prev = get_prev_frame (frame);
 317       if (prev)
 318         prev_obj = (PyObject *) frame_info_to_frame_object (prev);
 319       else
 320         {
 321           Py_INCREF (Py_None);
 322           prev_obj = Py_None;
 323         }
 324     }
 325   GDB_PY_HANDLE_EXCEPTION (except);
 326
 327   return prev_obj;
 328 }
 329
 330 /* Implementation of gdb.Frame.newer (self) -> gdb.Frame.
 331    Returns the frame immediately newer (inner) to this frame, or None if
 332    there isn't one.  */
 333
 334 static PyObject *
 335 frapy_newer (PyObject *self, PyObject *args)
 336 {
 337   struct frame_info *frame, *next;
 338   volatile struct gdb_exception except;
 339   PyObject *next_obj = NULL;   /* Initialize to appease gcc warning.  */
 340
 341   TRY_CATCH (except, RETURN_MASK_ALL)
 342     {
 343       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 344
 345       next = get_next_frame (frame);
 346       if (next)
 347         next_obj = (PyObject *) frame_info_to_frame_object (next);
 348       else
 349         {
 350           Py_INCREF (Py_None);
 351           next_obj = Py_None;
 352         }
 353     }
 354   GDB_PY_HANDLE_EXCEPTION (except);
 355
 356   return next_obj;
 357 }
 358
 359 /* Implementation of gdb.Frame.find_sal (self) -> gdb.Symtab_and_line.
 360    Returns the frame's symtab and line.  */
 361
 362 static PyObject *
 363 frapy_find_sal (PyObject *self, PyObject *args)
 364 {
 365   struct frame_info *frame;
 366   struct symtab_and_line sal;
 367   struct objfile *objfile = NULL;
 368   volatile struct gdb_exception except;
 369   PyObject *sal_obj = NULL;   /* Initialize to appease gcc warning.  */
 370
 371   TRY_CATCH (except, RETURN_MASK_ALL)
 372     {
 373       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 374
 375       find_frame_sal (frame, &sal);
 376       sal_obj = symtab_and_line_to_sal_object (sal);
 377     }
 378   GDB_PY_HANDLE_EXCEPTION (except);
 379
 380   return sal_obj;
 381 }
 382
 383 /* Implementation of gdb.Frame.read_var_value (self, variable) -> gdb.Value.
 384    Returns the value of the given variable in this frame.  The argument must be
 385    a string.  Returns None if GDB can't find the specified variable.  */
 386
 387 static PyObject *
 388 frapy_read_var (PyObject *self, PyObject *args)
 389 {
 390   struct frame_info *frame;
 391   PyObject *sym_obj;
 392   struct symbol *var = NULL;    /* gcc-4.3.2 false warning.  */
 393   struct value *val = NULL;
 394   volatile struct gdb_exception except;
 395
 396   if (!PyArg_ParseTuple (args, "O", &sym_obj))
 397     return NULL;
 398
 399   if (PyObject_TypeCheck (sym_obj, &symbol_object_type))
 400     var = symbol_object_to_symbol (sym_obj);
 401   else if (gdbpy_is_string (sym_obj))
 402     {
 403       char *var_name;
 404       struct block *block = NULL;
 405       struct cleanup *cleanup;
 406       volatile struct gdb_exception except;
 407
 408       var_name = python_string_to_target_string (sym_obj);
 409       if (!var_name)
 410         return NULL;
 411       cleanup = make_cleanup (xfree, var_name);
 412
 413       TRY_CATCH (except, RETURN_MASK_ALL)
 414         {
 415           FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 416
 417           block = block_for_pc (get_frame_address_in_block (frame));
 418           var = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);
 419         }
 420       GDB_PY_HANDLE_EXCEPTION (except);
 421
 422       if (!var)
 423         {
 424           PyErr_Format (PyExc_ValueError,
 425                         _("variable '%s' not found"), var_name);
 426           do_cleanups (cleanup);
 427
 428           return NULL;
 429         }
 430
 431       do_cleanups (cleanup);
 432     }
 433   else
 434     {
 435       PyErr_SetString (PyExc_TypeError,
 436                        _("argument must be a symbol or string"));
 437       return NULL;
 438     }
 439
 440   TRY_CATCH (except, RETURN_MASK_ALL)
 441     {
 442       FRAPY_REQUIRE_VALID ((frame_object *) self, frame);
 443
 444       val = read_var_value (var, frame);
 445     }
 446   GDB_PY_HANDLE_EXCEPTION (except);
 447
 448   if (val)
 449     return value_to_value_object (val);
 450
 451   Py_RETURN_NONE;
 452 }
 453
 454 /* Select this frame.  */
 455
 456 static PyObject *
 457 frapy_select (PyObject *self, PyObject *args)
 458 {
 459   struct frame_info *fi;
 460   frame_object *frame = (frame_object *) self;
 461   volatile struct gdb_exception except;
 462
 463   TRY_CATCH (except, RETURN_MASK_ALL)
 464     {
 465       FRAPY_REQUIRE_VALID (frame, fi);
 466
 467       select_frame (fi);
 468     }
 469   GDB_PY_HANDLE_EXCEPTION (except);
 470
 471   Py_RETURN_NONE;
 472 }
 473
 474 /* Implementation of gdb.selected_frame () -> gdb.Frame.
 475    Returns the selected frame object.  */
 476
 477 PyObject *
 478 gdbpy_selected_frame (PyObject *self, PyObject *args)
 479 {
 480   struct frame_info *frame;
 481   frame_object *frame_obj = NULL;   /* Initialize to appease gcc warning.  */
 482   volatile struct gdb_exception except;
 483
 484   TRY_CATCH (except, RETURN_MASK_ALL)
 485     {
 486       frame = get_selected_frame ("No frame is currently selected.");
 487       frame_obj = frame_info_to_frame_object (frame);
 488     }
 489   GDB_PY_HANDLE_EXCEPTION (except);
 490
 491   return (PyObject *) frame_obj;
 492 }
 493
 494 /* Implementation of gdb.stop_reason_string (Integer) -> String.
 495    Return a string explaining the unwind stop reason.  */
 496
 497 PyObject *
 498 gdbpy_frame_stop_reason_string (PyObject *self, PyObject *args)
 499 {
 500   int reason;
 501   const char *str;
 502
 503   if (!PyArg_ParseTuple (args, "i", &reason))
 504     return NULL;
 505
 506   if (reason < 0 || reason > UNWIND_NO_SAVED_PC)
 507     {
 508       PyErr_SetString (PyExc_ValueError, "Invalid frame stop reason.");
 509       return NULL;
 510     }
 511
 512   str = frame_stop_reason_string (reason);
 513   return PyUnicode_Decode (str, strlen (str), host_charset (), NULL);
 514 }
 515
 516 /* Implements the equality comparison for Frame objects.
 517    All other comparison operators will throw a TypeError Python exception,
 518    as they aren't valid for frames.  */
 519
 520 static PyObject *
 521 frapy_richcompare (PyObject *self, PyObject *other, int op)
 522 {
 523   int result;
 524
 525   if (!PyObject_TypeCheck (other, &frame_object_type)
 526       || (op != Py_EQ && op != Py_NE))
 527     {
 528       Py_INCREF (Py_NotImplemented);
 529       return Py_NotImplemented;
 530     }
 531
 532   if (frame_id_eq (((frame_object *) self)->frame_id,
 533                    ((frame_object *) other)->frame_id))
 534     result = Py_EQ;
 535   else
 536     result = Py_NE;
 537
 538   if (op == result)
 539     Py_RETURN_TRUE;
 540   Py_RETURN_FALSE;
 541 }
 542
 543 /* Sets up the Frame API in the gdb module.  */
 544
 545 void
 546 gdbpy_initialize_frames (void)
 547 {
 548   if (PyType_Ready (&frame_object_type) < 0)
 549     return;
 550
 551   /* Note: These would probably be best exposed as class attributes of Frame,
 552      but I don't know how to do it except by messing with the type's dictionary.
 553      That seems too messy.  */
 554   PyModule_AddIntConstant (gdb_module, "NORMAL_FRAME", NORMAL_FRAME);
 555   PyModule_AddIntConstant (gdb_module, "DUMMY_FRAME", DUMMY_FRAME);
 556   PyModule_AddIntConstant (gdb_module, "SIGTRAMP_FRAME", SIGTRAMP_FRAME);
 557   PyModule_AddIntConstant (gdb_module, "SENTINEL_FRAME", SENTINEL_FRAME);
 558   PyModule_AddIntConstant (gdb_module,
 559                            "FRAME_UNWIND_NO_REASON", UNWIND_NO_REASON);
 560   PyModule_AddIntConstant (gdb_module,
 561                            "FRAME_UNWIND_NULL_ID", UNWIND_NULL_ID);
 562   PyModule_AddIntConstant (gdb_module,
 563                            "FRAME_UNWIND_FIRST_ERROR", UNWIND_FIRST_ERROR);
 564   PyModule_AddIntConstant (gdb_module,
 565                            "FRAME_UNWIND_INNER_ID", UNWIND_INNER_ID);
 566   PyModule_AddIntConstant (gdb_module,
 567                            "FRAME_UNWIND_SAME_ID", UNWIND_SAME_ID);
 568   PyModule_AddIntConstant (gdb_module,
 569                            "FRAME_UNWIND_NO_SAVED_PC", UNWIND_NO_SAVED_PC);
 570
 571   Py_INCREF (&frame_object_type);
 572   PyModule_AddObject (gdb_module, "Frame", (PyObject *) &frame_object_type);
 573 }
 574
 575 \f
 576
 577 static PyMethodDef frame_object_methods[] = {
 578   { "is_valid", frapy_is_valid, METH_NOARGS,
 579     "is_valid () -> Boolean.\n\
 580 Return true if this frame is valid, false if not." },
 581   { "name", frapy_name, METH_NOARGS,
 582     "name () -> String.\n\
 583 Return the function name of the frame, or None if it can't be determined." },
 584   { "type", frapy_type, METH_NOARGS,
 585     "type () -> Integer.\n\
 586 Return the type of the frame." },
 587   { "unwind_stop_reason", frapy_unwind_stop_reason, METH_NOARGS,
 588     "unwind_stop_reason () -> Integer.\n\
 589 Return the reason why it's not possible to find frames older than this." },
 590   { "pc", frapy_pc, METH_NOARGS,
 591     "pc () -> Long.\n\
 592 Return the frame's resume address." },
 593   { "block", frapy_block, METH_NOARGS,
 594     "block () -> gdb.Block.\n\
 595 Return the frame's code block." },
 596   { "function", frapy_function, METH_NOARGS,
 597     "function () -> gdb.Symbol.\n\
 598 Returns the symbol for the function corresponding to this frame." },
 599   { "older", frapy_older, METH_NOARGS,
 600     "older () -> gdb.Frame.\n\
 601 Return the frame that called this frame." },
 602   { "newer", frapy_newer, METH_NOARGS,
 603     "newer () -> gdb.Frame.\n\
 604 Return the frame called by this frame." },
 605   { "find_sal", frapy_find_sal, METH_NOARGS,
 606     "find_sal () -> gdb.Symtab_and_line.\n\
 607 Return the frame's symtab and line." },
 608   { "read_var", frapy_read_var, METH_VARARGS,
 609     "read_var (variable) -> gdb.Value.\n\
 610 Return the value of the variable in this frame." },
 611   { "select", frapy_select, METH_NOARGS,
 612     "Select this frame as the user's current frame." },
 613   {NULL}  /* Sentinel */
 614 };
 615
 616 static PyTypeObject frame_object_type = {
 617   PyObject_HEAD_INIT (NULL)
 618   0,                              /* ob_size */
 619   "gdb.Frame",                    /* tp_name */
 620   sizeof (frame_object),          /* tp_basicsize */
 621   0,                              /* tp_itemsize */
 622   0,                              /* tp_dealloc */
 623   0,                              /* tp_print */
 624   0,                              /* tp_getattr */
 625   0,                              /* tp_setattr */
 626   0,                              /* tp_compare */
 627   0,                              /* tp_repr */
 628   0,                              /* tp_as_number */
 629   0,                              /* tp_as_sequence */
 630   0,                              /* tp_as_mapping */
 631   0,                              /* tp_hash  */
 632   0,                              /* tp_call */
 633   frapy_str,                      /* tp_str */
 634   0,                              /* tp_getattro */
 635   0,                              /* tp_setattro */
 636   0,                              /* tp_as_buffer */
 637   Py_TPFLAGS_DEFAULT,             /* tp_flags */
 638   "GDB frame object",             /* tp_doc */
 639   0,                              /* tp_traverse */
 640   0,                              /* tp_clear */
 641   frapy_richcompare,              /* tp_richcompare */
 642   0,                              /* tp_weaklistoffset */
 643   0,                              /* tp_iter */
 644   0,                              /* tp_iternext */
 645   frame_object_methods,           /* tp_methods */
 646   0,                              /* tp_members */
 647   0,                              /* tp_getset */
 648   0,                              /* tp_base */
 649   0,                              /* tp_dict */
 650   0,                              /* tp_descr_get */
 651   0,                              /* tp_descr_set */
 652   0,                              /* tp_dictoffset */
 653   0,                              /* tp_init */
 654   0,                              /* tp_alloc */
 655   PyType_GenericNew               /* tp_new */
 656 };