1 /* Python frame unwinder interface. 2 3 Copyright (C) 2015-2016 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 "arch-utils.h" 22 #include "frame-unwind.h" 23 #include "gdb_obstack.h" 24 #include "gdbcmd.h" 25 #include "language.h" 26 #include "observer.h" 27 #include "python-internal.h" 28 #include "regcache.h" 29 #include "valprint.h" 30 #include "user-regs.h" 31 32 #define TRACE_PY_UNWIND(level, args...) if (pyuw_debug >= level) \ 33 { fprintf_unfiltered (gdb_stdlog, args); } 34 35 typedef struct 36 { 37 PyObject_HEAD 38 39 /* Frame we are unwinding. */ 40 struct frame_info *frame_info; 41 42 /* Its architecture, passed by the sniffer caller. */ 43 struct gdbarch *gdbarch; 44 } pending_frame_object; 45 46 /* Saved registers array item. */ 47 48 typedef struct 49 { 50 int number; 51 PyObject *value; 52 } saved_reg; 53 DEF_VEC_O (saved_reg); 54 55 /* The data we keep for the PyUnwindInfo: pending_frame, saved registers 56 and frame ID. */ 57 58 typedef struct 59 { 60 PyObject_HEAD 61 62 /* gdb.PendingFrame for the frame we are unwinding. */ 63 PyObject *pending_frame; 64 65 /* Its ID. */ 66 struct frame_id frame_id; 67 68 /* Saved registers array. */ 69 VEC (saved_reg) *saved_regs; 70 } unwind_info_object; 71 72 /* The data we keep for a frame we can unwind: frame ID and an array of 73 (register_number, register_value) pairs. */ 74 75 struct reg_info 76 { 77 /* Register number. */ 78 int number; 79 80 /* Register data bytes pointer. */ 81 gdb_byte data[MAX_REGISTER_SIZE]; 82 }; 83 84 typedef struct 85 { 86 /* Frame ID. */ 87 struct frame_id frame_id; 88 89 /* GDB Architecture. */ 90 struct gdbarch *gdbarch; 91 92 /* Length of the `reg' array below. */ 93 int reg_count; 94 95 struct reg_info reg[]; 96 } cached_frame_info; 97 98 extern PyTypeObject pending_frame_object_type 99 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pending_frame_object"); 100 101 extern PyTypeObject unwind_info_object_type 102 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("unwind_info_object"); 103 104 static unsigned int pyuw_debug = 0; 105 106 static struct gdbarch_data *pyuw_gdbarch_data; 107 108 /* Parses register id, which can be either a number or a name. 109 Returns 1 on success, 0 otherwise. */ 110 111 static int 112 pyuw_parse_register_id (struct gdbarch *gdbarch, PyObject *pyo_reg_id, 113 int *reg_num) 114 { 115 if (pyo_reg_id == NULL) 116 return 0; 117 if (gdbpy_is_string (pyo_reg_id)) 118 { 119 const char *reg_name = gdbpy_obj_to_string (pyo_reg_id); 120 121 if (reg_name == NULL) 122 return 0; 123 *reg_num = user_reg_map_name_to_regnum (gdbarch, reg_name, 124 strlen (reg_name)); 125 return *reg_num >= 0; 126 } 127 else if (PyInt_Check (pyo_reg_id)) 128 { 129 long value; 130 if (gdb_py_int_as_long (pyo_reg_id, &value) && (int) value == value) 131 { 132 *reg_num = (int) value; 133 return user_reg_map_regnum_to_name (gdbarch, *reg_num) != NULL; 134 } 135 } 136 return 0; 137 } 138 139 /* Convert gdb.Value instance to inferior's pointer. Return 1 on success, 140 0 on failure. */ 141 142 static int 143 pyuw_value_obj_to_pointer (PyObject *pyo_value, CORE_ADDR *addr) 144 { 145 int rc = 0; 146 struct value *value; 147 148 TRY 149 { 150 if ((value = value_object_to_value (pyo_value)) != NULL) 151 { 152 *addr = unpack_pointer (value_type (value), 153 value_contents (value)); 154 rc = 1; 155 } 156 } 157 CATCH (except, RETURN_MASK_ALL) 158 { 159 gdbpy_convert_exception (except); 160 } 161 END_CATCH 162 return rc; 163 } 164 165 /* Get attribute from an object and convert it to the inferior's 166 pointer value. Return 1 if attribute exists and its value can be 167 converted. Otherwise, if attribute does not exist or its value is 168 None, return 0. In all other cases set Python error and return 169 0. */ 170 171 static int 172 pyuw_object_attribute_to_pointer (PyObject *pyo, const char *attr_name, 173 CORE_ADDR *addr) 174 { 175 int rc = 0; 176 177 if (PyObject_HasAttrString (pyo, attr_name)) 178 { 179 PyObject *pyo_value = PyObject_GetAttrString (pyo, attr_name); 180 181 if (pyo_value != NULL && pyo_value != Py_None) 182 { 183 rc = pyuw_value_obj_to_pointer (pyo_value, addr); 184 if (!rc) 185 PyErr_Format ( 186 PyExc_ValueError, 187 _("The value of the '%s' attribute is not a pointer."), 188 attr_name); 189 } 190 Py_XDECREF (pyo_value); 191 } 192 return rc; 193 } 194 195 /* Called by the Python interpreter to obtain string representation 196 of the UnwindInfo object. */ 197 198 static PyObject * 199 unwind_infopy_str (PyObject *self) 200 { 201 struct ui_file *strfile = mem_fileopen (); 202 unwind_info_object *unwind_info = (unwind_info_object *) self; 203 PyObject *result; 204 205 fprintf_unfiltered (strfile, "Frame ID: "); 206 fprint_frame_id (strfile, unwind_info->frame_id); 207 { 208 char *sep = ""; 209 int i; 210 struct value_print_options opts; 211 saved_reg *reg; 212 213 get_user_print_options (&opts); 214 fprintf_unfiltered (strfile, "\nSaved registers: ("); 215 for (i = 0; 216 i < VEC_iterate (saved_reg, unwind_info->saved_regs, i, reg); 217 i++) 218 { 219 struct value *value = value_object_to_value (reg->value); 220 221 fprintf_unfiltered (strfile, "%s(%d, ", sep, reg->number); 222 if (value != NULL) 223 { 224 TRY 225 { 226 value_print (value, strfile, &opts); 227 fprintf_unfiltered (strfile, ")"); 228 } 229 CATCH (except, RETURN_MASK_ALL) 230 { 231 GDB_PY_HANDLE_EXCEPTION (except); 232 } 233 END_CATCH 234 } 235 else 236 fprintf_unfiltered (strfile, "<BAD>)"); 237 sep = ", "; 238 } 239 fprintf_unfiltered (strfile, ")"); 240 } 241 { 242 char *s = ui_file_xstrdup (strfile, NULL); 243 244 result = PyString_FromString (s); 245 xfree (s); 246 } 247 ui_file_delete (strfile); 248 return result; 249 } 250 251 /* Create UnwindInfo instance for given PendingFrame and frame ID. 252 Sets Python error and returns NULL on error. */ 253 254 static PyObject * 255 pyuw_create_unwind_info (PyObject *pyo_pending_frame, 256 struct frame_id frame_id) 257 { 258 unwind_info_object *unwind_info 259 = PyObject_New (unwind_info_object, &unwind_info_object_type); 260 261 if (((pending_frame_object *) pyo_pending_frame)->frame_info == NULL) 262 { 263 PyErr_SetString (PyExc_ValueError, 264 "Attempting to use stale PendingFrame"); 265 return NULL; 266 } 267 unwind_info->frame_id = frame_id; 268 Py_INCREF (pyo_pending_frame); 269 unwind_info->pending_frame = pyo_pending_frame; 270 unwind_info->saved_regs = VEC_alloc (saved_reg, 4); 271 return (PyObject *) unwind_info; 272 } 273 274 /* The implementation of 275 gdb.UnwindInfo.add_saved_register (REG, VALUE) -> None. */ 276 277 static PyObject * 278 unwind_infopy_add_saved_register (PyObject *self, PyObject *args) 279 { 280 unwind_info_object *unwind_info = (unwind_info_object *) self; 281 pending_frame_object *pending_frame 282 = (pending_frame_object *) (unwind_info->pending_frame); 283 PyObject *pyo_reg_id; 284 PyObject *pyo_reg_value; 285 int regnum; 286 287 if (pending_frame->frame_info == NULL) 288 { 289 PyErr_SetString (PyExc_ValueError, 290 "UnwindInfo instance refers to a stale PendingFrame"); 291 return NULL; 292 } 293 if (!PyArg_UnpackTuple (args, "previous_frame_register", 2, 2, 294 &pyo_reg_id, &pyo_reg_value)) 295 return NULL; 296 if (!pyuw_parse_register_id (pending_frame->gdbarch, pyo_reg_id, ®num)) 297 { 298 PyErr_SetString (PyExc_ValueError, "Bad register"); 299 return NULL; 300 } 301 { 302 struct value *value; 303 size_t data_size; 304 305 if (pyo_reg_value == NULL 306 || (value = value_object_to_value (pyo_reg_value)) == NULL) 307 { 308 PyErr_SetString (PyExc_ValueError, "Bad register value"); 309 return NULL; 310 } 311 data_size = register_size (pending_frame->gdbarch, regnum); 312 if (data_size != TYPE_LENGTH (value_type (value))) 313 { 314 PyErr_Format ( 315 PyExc_ValueError, 316 "The value of the register returned by the Python " 317 "sniffer has unexpected size: %u instead of %u.", 318 (unsigned) TYPE_LENGTH (value_type (value)), 319 (unsigned) data_size); 320 return NULL; 321 } 322 } 323 { 324 int i; 325 saved_reg *reg; 326 327 for (i = 0; VEC_iterate (saved_reg, unwind_info->saved_regs, i, reg); i++) 328 { 329 if (regnum == reg->number) 330 { 331 Py_DECREF (reg->value); 332 break; 333 } 334 } 335 if (reg == NULL) 336 { 337 reg = VEC_safe_push (saved_reg, unwind_info->saved_regs, NULL); 338 reg->number = regnum; 339 } 340 Py_INCREF (pyo_reg_value); 341 reg->value = pyo_reg_value; 342 } 343 Py_RETURN_NONE; 344 } 345 346 /* UnwindInfo cleanup. */ 347 348 static void 349 unwind_infopy_dealloc (PyObject *self) 350 { 351 unwind_info_object *unwind_info = (unwind_info_object *) self; 352 int i; 353 saved_reg *reg; 354 355 Py_XDECREF (unwind_info->pending_frame); 356 for (i = 0; VEC_iterate (saved_reg, unwind_info->saved_regs, i, reg); i++) 357 Py_DECREF (reg->value); 358 VEC_free (saved_reg, unwind_info->saved_regs); 359 Py_TYPE (self)->tp_free (self); 360 } 361 362 /* Called by the Python interpreter to obtain string representation 363 of the PendingFrame object. */ 364 365 static PyObject * 366 pending_framepy_str (PyObject *self) 367 { 368 struct frame_info *frame = ((pending_frame_object *) self)->frame_info; 369 const char *sp_str = NULL; 370 const char *pc_str = NULL; 371 372 if (frame == NULL) 373 return PyString_FromString ("Stale PendingFrame instance"); 374 TRY 375 { 376 sp_str = core_addr_to_string_nz (get_frame_sp (frame)); 377 pc_str = core_addr_to_string_nz (get_frame_pc (frame)); 378 } 379 CATCH (except, RETURN_MASK_ALL) 380 { 381 GDB_PY_HANDLE_EXCEPTION (except); 382 } 383 END_CATCH 384 385 return PyString_FromFormat ("SP=%s,PC=%s", sp_str, pc_str); 386 } 387 388 /* Implementation of gdb.PendingFrame.read_register (self, reg) -> gdb.Value. 389 Returns the value of register REG as gdb.Value instance. */ 390 391 static PyObject * 392 pending_framepy_read_register (PyObject *self, PyObject *args) 393 { 394 pending_frame_object *pending_frame = (pending_frame_object *) self; 395 struct value *val = NULL; 396 int regnum; 397 PyObject *pyo_reg_id; 398 399 if (pending_frame->frame_info == NULL) 400 { 401 PyErr_SetString (PyExc_ValueError, 402 "Attempting to read register from stale PendingFrame"); 403 return NULL; 404 } 405 if (!PyArg_UnpackTuple (args, "read_register", 1, 1, &pyo_reg_id)) 406 return NULL; 407 if (!pyuw_parse_register_id (pending_frame->gdbarch, pyo_reg_id, ®num)) 408 { 409 PyErr_SetString (PyExc_ValueError, "Bad register"); 410 return NULL; 411 } 412 413 TRY 414 { 415 val = get_frame_register_value (pending_frame->frame_info, regnum); 416 if (val == NULL) 417 PyErr_Format (PyExc_ValueError, 418 "Cannot read register %d from frame.", 419 regnum); 420 } 421 CATCH (except, RETURN_MASK_ALL) 422 { 423 GDB_PY_HANDLE_EXCEPTION (except); 424 } 425 END_CATCH 426 427 return val == NULL ? NULL : value_to_value_object (val); 428 } 429 430 /* Implementation of 431 PendingFrame.create_unwind_info (self, frameId) -> UnwindInfo. */ 432 433 static PyObject * 434 pending_framepy_create_unwind_info (PyObject *self, PyObject *args) 435 { 436 PyObject *pyo_frame_id; 437 CORE_ADDR sp; 438 CORE_ADDR pc; 439 CORE_ADDR special; 440 441 if (!PyArg_ParseTuple (args, "O:create_unwind_info", &pyo_frame_id)) 442 return NULL; 443 if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "sp", &sp)) 444 { 445 PyErr_SetString (PyExc_ValueError, 446 _("frame_id should have 'sp' attribute.")); 447 return NULL; 448 } 449 450 /* The logic of building frame_id depending on the attributes of 451 the frame_id object: 452 Has Has Has Function to call 453 'sp'? 'pc'? 'special'? 454 ------|------|--------------|------------------------- 455 Y N * frame_id_build_wild (sp) 456 Y Y N frame_id_build (sp, pc) 457 Y Y Y frame_id_build_special (sp, pc, special) 458 */ 459 if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "pc", &pc)) 460 return pyuw_create_unwind_info (self, frame_id_build_wild (sp)); 461 if (!pyuw_object_attribute_to_pointer (pyo_frame_id, "special", &special)) 462 return pyuw_create_unwind_info (self, frame_id_build (sp, pc)); 463 else 464 return pyuw_create_unwind_info (self, 465 frame_id_build_special (sp, pc, special)); 466 } 467 468 /* Invalidate PendingFrame instance. */ 469 470 static void 471 pending_frame_invalidate (void *pyo_pending_frame) 472 { 473 if (pyo_pending_frame != NULL) 474 ((pending_frame_object *) pyo_pending_frame)->frame_info = NULL; 475 } 476 477 /* frame_unwind.this_id method. */ 478 479 static void 480 pyuw_this_id (struct frame_info *this_frame, void **cache_ptr, 481 struct frame_id *this_id) 482 { 483 *this_id = ((cached_frame_info *) *cache_ptr)->frame_id; 484 if (pyuw_debug >= 1) 485 { 486 fprintf_unfiltered (gdb_stdlog, "%s: frame_id: ", __FUNCTION__); 487 fprint_frame_id (gdb_stdlog, *this_id); 488 fprintf_unfiltered (gdb_stdlog, "\n"); 489 } 490 } 491 492 /* frame_unwind.prev_register. */ 493 494 static struct value * 495 pyuw_prev_register (struct frame_info *this_frame, void **cache_ptr, 496 int regnum) 497 { 498 cached_frame_info *cached_frame = (cached_frame_info *) *cache_ptr; 499 struct reg_info *reg_info = cached_frame->reg; 500 struct reg_info *reg_info_end = reg_info + cached_frame->reg_count; 501 502 TRACE_PY_UNWIND (1, "%s (frame=%p,...,reg=%d)\n", __FUNCTION__, this_frame, 503 regnum); 504 for (; reg_info < reg_info_end; ++reg_info) 505 { 506 if (regnum == reg_info->number) 507 return frame_unwind_got_bytes (this_frame, regnum, reg_info->data); 508 } 509 510 return frame_unwind_got_optimized (this_frame, regnum); 511 } 512 513 /* Frame sniffer dispatch. */ 514 515 static int 516 pyuw_sniffer (const struct frame_unwind *self, struct frame_info *this_frame, 517 void **cache_ptr) 518 { 519 struct gdbarch *gdbarch = (struct gdbarch *) (self->unwind_data); 520 struct cleanup *cleanups = ensure_python_env (gdbarch, current_language); 521 PyObject *pyo_execute; 522 PyObject *pyo_pending_frame; 523 PyObject *pyo_unwind_info; 524 cached_frame_info *cached_frame; 525 526 TRACE_PY_UNWIND (3, "%s (SP=%s, PC=%s)\n", __FUNCTION__, 527 paddress (gdbarch, get_frame_sp (this_frame)), 528 paddress (gdbarch, get_frame_pc (this_frame))); 529 530 /* Create PendingFrame instance to pass to sniffers. */ 531 pyo_pending_frame = (PyObject *) PyObject_New (pending_frame_object, 532 &pending_frame_object_type); 533 if (pyo_pending_frame == NULL) 534 goto error; 535 ((pending_frame_object *) pyo_pending_frame)->gdbarch = gdbarch; 536 ((pending_frame_object *) pyo_pending_frame)->frame_info = this_frame; 537 make_cleanup_py_decref (pyo_pending_frame); 538 make_cleanup (pending_frame_invalidate, (void *) pyo_pending_frame); 539 540 /* Run unwinders. */ 541 if (gdb_python_module == NULL 542 || ! PyObject_HasAttrString (gdb_python_module, "execute_unwinders")) 543 { 544 PyErr_SetString (PyExc_NameError, 545 "Installation error: gdb.execute_unwinders function " 546 "is missing"); 547 goto error; 548 } 549 pyo_execute = PyObject_GetAttrString (gdb_python_module, "execute_unwinders"); 550 if (pyo_execute == NULL) 551 goto error; 552 make_cleanup_py_decref (pyo_execute); 553 pyo_unwind_info 554 = PyObject_CallFunctionObjArgs (pyo_execute, pyo_pending_frame, NULL); 555 if (pyo_unwind_info == NULL) 556 goto error; 557 make_cleanup_py_decref (pyo_unwind_info); 558 if (pyo_unwind_info == Py_None) 559 goto cannot_unwind; 560 561 /* Received UnwindInfo, cache data. */ 562 if (PyObject_IsInstance (pyo_unwind_info, 563 (PyObject *) &unwind_info_object_type) <= 0) 564 error (_("A Unwinder should return gdb.UnwindInfo instance.")); 565 566 { 567 unwind_info_object *unwind_info = (unwind_info_object *) pyo_unwind_info; 568 int reg_count = VEC_length (saved_reg, unwind_info->saved_regs); 569 saved_reg *reg; 570 int i; 571 572 cached_frame 573 = ((cached_frame_info *) 574 xmalloc (sizeof (*cached_frame) 575 + reg_count * sizeof (cached_frame->reg[0]))); 576 cached_frame->gdbarch = gdbarch; 577 cached_frame->frame_id = unwind_info->frame_id; 578 cached_frame->reg_count = reg_count; 579 580 /* Populate registers array. */ 581 for (i = 0; VEC_iterate (saved_reg, unwind_info->saved_regs, i, reg); i++) 582 { 583 struct value *value = value_object_to_value (reg->value); 584 size_t data_size = register_size (gdbarch, reg->number); 585 586 cached_frame->reg[i].number = reg->number; 587 588 /* `value' validation was done before, just assert. */ 589 gdb_assert (value != NULL); 590 gdb_assert (data_size == TYPE_LENGTH (value_type (value))); 591 gdb_assert (data_size <= MAX_REGISTER_SIZE); 592 593 memcpy (cached_frame->reg[i].data, value_contents (value), data_size); 594 } 595 } 596 597 *cache_ptr = cached_frame; 598 do_cleanups (cleanups); 599 return 1; 600 601 error: 602 gdbpy_print_stack (); 603 /* Fallthrough. */ 604 cannot_unwind: 605 do_cleanups (cleanups); 606 return 0; 607 } 608 609 /* Frame cache release shim. */ 610 611 static void 612 pyuw_dealloc_cache (struct frame_info *this_frame, void *cache) 613 { 614 TRACE_PY_UNWIND (3, "%s: enter", __FUNCTION__); 615 xfree (cache); 616 } 617 618 struct pyuw_gdbarch_data_type 619 { 620 /* Has the unwinder shim been prepended? */ 621 int unwinder_registered; 622 }; 623 624 static void * 625 pyuw_gdbarch_data_init (struct gdbarch *gdbarch) 626 { 627 return GDBARCH_OBSTACK_ZALLOC (gdbarch, struct pyuw_gdbarch_data_type); 628 } 629 630 /* New inferior architecture callback: register the Python unwinders 631 intermediary. */ 632 633 static void 634 pyuw_on_new_gdbarch (struct gdbarch *newarch) 635 { 636 struct pyuw_gdbarch_data_type *data 637 = (struct pyuw_gdbarch_data_type *) gdbarch_data (newarch, 638 pyuw_gdbarch_data); 639 640 if (!data->unwinder_registered) 641 { 642 struct frame_unwind *unwinder 643 = GDBARCH_OBSTACK_ZALLOC (newarch, struct frame_unwind); 644 645 unwinder->type = NORMAL_FRAME; 646 unwinder->stop_reason = default_frame_unwind_stop_reason; 647 unwinder->this_id = pyuw_this_id; 648 unwinder->prev_register = pyuw_prev_register; 649 unwinder->unwind_data = (const struct frame_data *) newarch; 650 unwinder->sniffer = pyuw_sniffer; 651 unwinder->dealloc_cache = pyuw_dealloc_cache; 652 frame_unwind_prepend_unwinder (newarch, unwinder); 653 data->unwinder_registered = 1; 654 } 655 } 656 657 /* Initialize unwind machinery. */ 658 659 int 660 gdbpy_initialize_unwind (void) 661 { 662 int rc; 663 add_setshow_zuinteger_cmd 664 ("py-unwind", class_maintenance, &pyuw_debug, 665 _("Set Python unwinder debugging."), 666 _("Show Python unwinder debugging."), 667 _("When non-zero, Python unwinder debugging is enabled."), 668 NULL, 669 NULL, 670 &setdebuglist, &showdebuglist); 671 pyuw_gdbarch_data 672 = gdbarch_data_register_post_init (pyuw_gdbarch_data_init); 673 observer_attach_architecture_changed (pyuw_on_new_gdbarch); 674 675 if (PyType_Ready (&pending_frame_object_type) < 0) 676 return -1; 677 rc = gdb_pymodule_addobject (gdb_module, "PendingFrame", 678 (PyObject *) &pending_frame_object_type); 679 if (rc) 680 return rc; 681 682 if (PyType_Ready (&unwind_info_object_type) < 0) 683 return -1; 684 return gdb_pymodule_addobject (gdb_module, "UnwindInfo", 685 (PyObject *) &unwind_info_object_type); 686 } 687 688 static PyMethodDef pending_frame_object_methods[] = 689 { 690 { "read_register", pending_framepy_read_register, METH_VARARGS, 691 "read_register (REG) -> gdb.Value\n" 692 "Return the value of the REG in the frame." }, 693 { "create_unwind_info", 694 pending_framepy_create_unwind_info, METH_VARARGS, 695 "create_unwind_info (FRAME_ID) -> gdb.UnwindInfo\n" 696 "Construct UnwindInfo for this PendingFrame, using FRAME_ID\n" 697 "to identify it." }, 698 {NULL} /* Sentinel */ 699 }; 700 701 PyTypeObject pending_frame_object_type = 702 { 703 PyVarObject_HEAD_INIT (NULL, 0) 704 "gdb.PendingFrame", /* tp_name */ 705 sizeof (pending_frame_object), /* tp_basicsize */ 706 0, /* tp_itemsize */ 707 0, /* tp_dealloc */ 708 0, /* tp_print */ 709 0, /* tp_getattr */ 710 0, /* tp_setattr */ 711 0, /* tp_compare */ 712 0, /* tp_repr */ 713 0, /* tp_as_number */ 714 0, /* tp_as_sequence */ 715 0, /* tp_as_mapping */ 716 0, /* tp_hash */ 717 0, /* tp_call */ 718 pending_framepy_str, /* tp_str */ 719 0, /* tp_getattro */ 720 0, /* tp_setattro */ 721 0, /* tp_as_buffer */ 722 Py_TPFLAGS_DEFAULT, /* tp_flags */ 723 "GDB PendingFrame object", /* tp_doc */ 724 0, /* tp_traverse */ 725 0, /* tp_clear */ 726 0, /* tp_richcompare */ 727 0, /* tp_weaklistoffset */ 728 0, /* tp_iter */ 729 0, /* tp_iternext */ 730 pending_frame_object_methods, /* tp_methods */ 731 0, /* tp_members */ 732 0, /* tp_getset */ 733 0, /* tp_base */ 734 0, /* tp_dict */ 735 0, /* tp_descr_get */ 736 0, /* tp_descr_set */ 737 0, /* tp_dictoffset */ 738 0, /* tp_init */ 739 0, /* tp_alloc */ 740 }; 741 742 static PyMethodDef unwind_info_object_methods[] = 743 { 744 { "add_saved_register", 745 unwind_infopy_add_saved_register, METH_VARARGS, 746 "add_saved_register (REG, VALUE) -> None\n" 747 "Set the value of the REG in the previous frame to VALUE." }, 748 { NULL } /* Sentinel */ 749 }; 750 751 PyTypeObject unwind_info_object_type = 752 { 753 PyVarObject_HEAD_INIT (NULL, 0) 754 "gdb.UnwindInfo", /* tp_name */ 755 sizeof (unwind_info_object), /* tp_basicsize */ 756 0, /* tp_itemsize */ 757 unwind_infopy_dealloc, /* tp_dealloc */ 758 0, /* tp_print */ 759 0, /* tp_getattr */ 760 0, /* tp_setattr */ 761 0, /* tp_compare */ 762 0, /* tp_repr */ 763 0, /* tp_as_number */ 764 0, /* tp_as_sequence */ 765 0, /* tp_as_mapping */ 766 0, /* tp_hash */ 767 0, /* tp_call */ 768 unwind_infopy_str, /* tp_str */ 769 0, /* tp_getattro */ 770 0, /* tp_setattro */ 771 0, /* tp_as_buffer */ 772 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ 773 "GDB UnwindInfo object", /* tp_doc */ 774 0, /* tp_traverse */ 775 0, /* tp_clear */ 776 0, /* tp_richcompare */ 777 0, /* tp_weaklistoffset */ 778 0, /* tp_iter */ 779 0, /* tp_iternext */ 780 unwind_info_object_methods, /* tp_methods */ 781 0, /* tp_members */ 782 0, /* tp_getset */ 783 0, /* tp_base */ 784 0, /* tp_dict */ 785 0, /* tp_descr_get */ 786 0, /* tp_descr_set */ 787 0, /* tp_dictoffset */ 788 0, /* tp_init */ 789 0, /* tp_alloc */ 790 }; 791