gdb/python/py-record.c

   1 /* Python interface to record targets.
   2
   3    Copyright 2016-2024 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 "py-instruction.h"
  21 #include "py-record.h"
  22 #include "py-record-btrace.h"
  23 #include "py-record-full.h"
  24 #include "target.h"
  25 #include "gdbthread.h"
  26
  27 /* Python Record type.  */
  28
  29 static PyTypeObject recpy_record_type = {
  30   PyVarObject_HEAD_INIT (NULL, 0)
  31 };
  32
  33 /* Python RecordInstruction type.  */
  34
  35 PyTypeObject recpy_insn_type = {
  36   PyVarObject_HEAD_INIT (NULL, 0)
  37 };
  38
  39 /* Python RecordFunctionSegment type.  */
  40
  41 PyTypeObject recpy_func_type = {
  42   PyVarObject_HEAD_INIT (NULL, 0)
  43 };
  44
  45 /* Python RecordGap type.  */
  46
  47 static PyTypeObject recpy_gap_type = {
  48   PyVarObject_HEAD_INIT (NULL, 0)
  49 };
  50
  51 /* Python RecordAuxiliary type.  */
  52
  53 PyTypeObject recpy_aux_type = {
  54   PyVarObject_HEAD_INIT (nullptr, 0)
  55 };
  56
  57 /* Python RecordGap object.  */
  58 struct recpy_gap_object
  59 {
  60   PyObject_HEAD
  61
  62   /* Reason code.  */
  63   int reason_code;
  64
  65   /* Reason message.  */
  66   const char *reason_string;
  67
  68   /* Element number.  */
  69   Py_ssize_t number;
  70 };
  71
  72 /* Implementation of record.method.  */
  73
  74 static PyObject *
  75 recpy_method (PyObject *self, void* closure)
  76 {
  77   const recpy_record_object * const obj = (recpy_record_object *) self;
  78
  79   if (obj->method == RECORD_METHOD_FULL)
  80     return recpy_full_method (self, closure);
  81
  82   if (obj->method == RECORD_METHOD_BTRACE)
  83     return recpy_bt_method (self, closure);
  84
  85   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
  86 }
  87
  88 /* Implementation of record.format.  */
  89
  90 static PyObject *
  91 recpy_format (PyObject *self, void* closure)
  92 {
  93   const recpy_record_object * const obj = (recpy_record_object *) self;
  94
  95   if (obj->method == RECORD_METHOD_FULL)
  96     return recpy_full_format (self, closure);
  97
  98   if (obj->method == RECORD_METHOD_BTRACE)
  99     return recpy_bt_format (self, closure);
 100
 101   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 102 }
 103
 104 /* Implementation of record.goto (instruction) -> None.  */
 105
 106 static PyObject *
 107 recpy_goto (PyObject *self, PyObject *value)
 108 {
 109   const recpy_record_object * const obj = (recpy_record_object *) self;
 110
 111   if (obj->method == RECORD_METHOD_BTRACE)
 112     return recpy_bt_goto (self, value);
 113
 114   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 115 }
 116
 117 /* Implementation of record.clear () -> None.  */
 118
 119 static PyObject *
 120 recpy_clear (PyObject *self, PyObject *value)
 121 {
 122   const recpy_record_object * const obj = (recpy_record_object *) self;
 123
 124   if (obj->method == RECORD_METHOD_BTRACE)
 125     return recpy_bt_clear (self, value);
 126
 127   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 128 }
 129
 130 /* Implementation of record.replay_position [instruction]  */
 131
 132 static PyObject *
 133 recpy_replay_position (PyObject *self, void *closure)
 134 {
 135   const recpy_record_object * const obj = (recpy_record_object *) self;
 136
 137   if (obj->method == RECORD_METHOD_BTRACE)
 138     return recpy_bt_replay_position (self, closure);
 139
 140   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 141 }
 142
 143 /* Implementation of record.instruction_history [list].  */
 144
 145 static PyObject *
 146 recpy_instruction_history (PyObject *self, void* closure)
 147 {
 148   const recpy_record_object * const obj = (recpy_record_object *) self;
 149
 150   if (obj->method == RECORD_METHOD_BTRACE)
 151     return recpy_bt_instruction_history (self, closure);
 152
 153   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 154 }
 155
 156 /* Implementation of record.function_call_history [list].  */
 157
 158 static PyObject *
 159 recpy_function_call_history (PyObject *self, void* closure)
 160 {
 161   const recpy_record_object * const obj = (recpy_record_object *) self;
 162
 163   if (obj->method == RECORD_METHOD_BTRACE)
 164     return recpy_bt_function_call_history (self, closure);
 165
 166   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 167 }
 168
 169 /* Implementation of record.begin [instruction].  */
 170
 171 static PyObject *
 172 recpy_begin (PyObject *self, void* closure)
 173 {
 174   const recpy_record_object * const obj = (recpy_record_object *) self;
 175
 176   if (obj->method == RECORD_METHOD_BTRACE)
 177     return recpy_bt_begin (self, closure);
 178
 179   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 180 }
 181
 182 /* Implementation of record.end [instruction].  */
 183
 184 static PyObject *
 185 recpy_end (PyObject *self, void* closure)
 186 {
 187   const recpy_record_object * const obj = (recpy_record_object *) self;
 188
 189   if (obj->method == RECORD_METHOD_BTRACE)
 190     return recpy_bt_end (self, closure);
 191
 192   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 193 }
 194
 195 /* Create a new gdb.RecordInstruction object.  */
 196
 197 PyObject *
 198 recpy_insn_new (thread_info *thread, enum record_method method,
 199                 Py_ssize_t number)
 200 {
 201   recpy_element_object * const obj = PyObject_New (recpy_element_object,
 202                                                    &recpy_insn_type);
 203
 204   if (obj == NULL)
 205    return NULL;
 206
 207   obj->thread = thread;
 208   obj->method = method;
 209   obj->number = number;
 210
 211   return (PyObject *) obj;
 212 }
 213
 214 /* Implementation of RecordInstruction.sal [gdb.Symtab_and_line].  */
 215
 216 static PyObject *
 217 recpy_insn_sal (PyObject *self, void *closure)
 218 {
 219   const recpy_element_object * const obj = (recpy_element_object *) self;
 220
 221   if (obj->method == RECORD_METHOD_BTRACE)
 222     return recpy_bt_insn_sal (self, closure);
 223
 224   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 225 }
 226
 227 /* Implementation of RecordInstruction.pc [int].  */
 228
 229 static PyObject *
 230 recpy_insn_pc (PyObject *self, void *closure)
 231 {
 232   const recpy_element_object * const obj = (recpy_element_object *) self;
 233
 234   if (obj->method == RECORD_METHOD_BTRACE)
 235     return recpy_bt_insn_pc (self, closure);
 236
 237   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 238 }
 239
 240 /* Implementation of RecordInstruction.data [buffer].  */
 241
 242 static PyObject *
 243 recpy_insn_data (PyObject *self, void *closure)
 244 {
 245   const recpy_element_object * const obj = (recpy_element_object *) self;
 246
 247   if (obj->method == RECORD_METHOD_BTRACE)
 248     return recpy_bt_insn_data (self, closure);
 249
 250   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 251 }
 252
 253 /* Implementation of RecordInstruction.decoded [str].  */
 254
 255 static PyObject *
 256 recpy_insn_decoded (PyObject *self, void *closure)
 257 {
 258   const recpy_element_object * const obj = (recpy_element_object *) self;
 259
 260   if (obj->method == RECORD_METHOD_BTRACE)
 261     return recpy_bt_insn_decoded (self, closure);
 262
 263   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 264 }
 265
 266 /* Implementation of RecordInstruction.size [int].  */
 267
 268 static PyObject *
 269 recpy_insn_size (PyObject *self, void *closure)
 270 {
 271   const recpy_element_object * const obj = (recpy_element_object *) self;
 272
 273   if (obj->method == RECORD_METHOD_BTRACE)
 274     return recpy_bt_insn_size (self, closure);
 275
 276   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 277 }
 278
 279 /* Implementation of RecordInstruction.is_speculative [bool].  */
 280
 281 static PyObject *
 282 recpy_insn_is_speculative (PyObject *self, void *closure)
 283 {
 284   const recpy_element_object * const obj = (recpy_element_object *) self;
 285
 286   if (obj->method == RECORD_METHOD_BTRACE)
 287     return recpy_bt_insn_is_speculative (self, closure);
 288
 289   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 290 }
 291
 292 /* Create a new gdb.RecordFunctionSegment object.  */
 293
 294 PyObject *
 295 recpy_func_new (thread_info *thread, enum record_method method,
 296                 Py_ssize_t number)
 297 {
 298   recpy_element_object * const obj = PyObject_New (recpy_element_object,
 299                                                    &recpy_func_type);
 300
 301   if (obj == NULL)
 302    return NULL;
 303
 304   obj->thread = thread;
 305   obj->method = method;
 306   obj->number = number;
 307
 308   return (PyObject *) obj;
 309 }
 310
 311 /* Implementation of RecordFunctionSegment.level [int].  */
 312
 313 static PyObject *
 314 recpy_func_level (PyObject *self, void *closure)
 315 {
 316   const recpy_element_object * const obj = (recpy_element_object *) self;
 317
 318   if (obj->method == RECORD_METHOD_BTRACE)
 319     return recpy_bt_func_level (self, closure);
 320
 321   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 322 }
 323
 324 /* Implementation of RecordFunctionSegment.symbol [gdb.Symbol].  */
 325
 326 static PyObject *
 327 recpy_func_symbol (PyObject *self, void *closure)
 328 {
 329   const recpy_element_object * const obj = (recpy_element_object *) self;
 330
 331   if (obj->method == RECORD_METHOD_BTRACE)
 332     return recpy_bt_func_symbol (self, closure);
 333
 334   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 335 }
 336
 337 /* Implementation of RecordFunctionSegment.instructions [list].  */
 338
 339 static PyObject *
 340 recpy_func_instructions (PyObject *self, void *closure)
 341 {
 342   const recpy_element_object * const obj = (recpy_element_object *) self;
 343
 344   if (obj->method == RECORD_METHOD_BTRACE)
 345     return recpy_bt_func_instructions (self, closure);
 346
 347   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 348 }
 349
 350 /* Implementation of RecordFunctionSegment.up [RecordFunctionSegment].  */
 351
 352 static PyObject *
 353 recpy_func_up (PyObject *self, void *closure)
 354 {
 355   const recpy_element_object * const obj = (recpy_element_object *) self;
 356
 357   if (obj->method == RECORD_METHOD_BTRACE)
 358     return recpy_bt_func_up (self, closure);
 359
 360   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 361 }
 362
 363 /* Implementation of RecordFunctionSegment.prev [RecordFunctionSegment].  */
 364
 365 static PyObject *
 366 recpy_func_prev (PyObject *self, void *closure)
 367 {
 368   const recpy_element_object * const obj = (recpy_element_object *) self;
 369
 370   if (obj->method == RECORD_METHOD_BTRACE)
 371     return recpy_bt_func_prev (self, closure);
 372
 373   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 374 }
 375
 376 /* Implementation of RecordFunctionSegment.next [RecordFunctionSegment].  */
 377
 378 static PyObject *
 379 recpy_func_next (PyObject *self, void *closure)
 380 {
 381   const recpy_element_object * const obj = (recpy_element_object *) self;
 382
 383   if (obj->method == RECORD_METHOD_BTRACE)
 384     return recpy_bt_func_next (self, closure);
 385
 386   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 387 }
 388
 389 /* Implementation of RecordInstruction.number [int] and
 390    RecordFunctionSegment.number [int].  */
 391
 392 static PyObject *
 393 recpy_element_number (PyObject *self, void* closure)
 394 {
 395   const recpy_element_object * const obj = (recpy_element_object *) self;
 396
 397   return gdb_py_object_from_longest (obj->number).release ();
 398 }
 399
 400 /* Implementation of RecordInstruction.__hash__ [int] and
 401    RecordFunctionSegment.__hash__ [int].  */
 402
 403 static Py_hash_t
 404 recpy_element_hash (PyObject *self)
 405 {
 406   const recpy_element_object * const obj = (recpy_element_object *) self;
 407
 408   return obj->number;
 409 }
 410
 411 /* Implementation of operator == and != of RecordInstruction,
 412    RecordFunctionSegment and RecordAuxiliary.  */
 413
 414 static PyObject *
 415 recpy_element_richcompare (PyObject *self, PyObject *other, int op)
 416 {
 417   const recpy_element_object * const obj1 = (recpy_element_object *) self;
 418   const recpy_element_object * const obj2 = (recpy_element_object *) other;
 419
 420   if (Py_TYPE (self) != Py_TYPE (other))
 421     {
 422       Py_INCREF (Py_NotImplemented);
 423       return Py_NotImplemented;
 424     }
 425
 426   switch (op)
 427   {
 428     case Py_EQ:
 429       if (obj1->thread == obj2->thread
 430           && obj1->method == obj2->method
 431           && obj1->number == obj2->number)
 432         Py_RETURN_TRUE;
 433       else
 434         Py_RETURN_FALSE;
 435
 436     case Py_NE:
 437       if (obj1->thread != obj2->thread
 438           || obj1->method != obj2->method
 439           || obj1->number != obj2->number)
 440         Py_RETURN_TRUE;
 441       else
 442         Py_RETURN_FALSE;
 443
 444     default:
 445       break;
 446   }
 447
 448   Py_INCREF (Py_NotImplemented);
 449   return Py_NotImplemented;
 450 }
 451
 452 /* Create a new gdb.RecordGap object.  */
 453
 454 PyObject *
 455 recpy_gap_new (int reason_code, const char *reason_string, Py_ssize_t number)
 456 {
 457   recpy_gap_object * const obj = PyObject_New (recpy_gap_object,
 458                                                &recpy_gap_type);
 459
 460   if (obj == NULL)
 461    return NULL;
 462
 463   obj->reason_code = reason_code;
 464   obj->reason_string = reason_string;
 465   obj->number = number;
 466
 467   return (PyObject *) obj;
 468 }
 469
 470 /* Implementation of RecordGap.number [int].  */
 471
 472 static PyObject *
 473 recpy_gap_number (PyObject *self, void *closure)
 474 {
 475   const recpy_gap_object * const obj = (const recpy_gap_object *) self;
 476
 477   return gdb_py_object_from_longest (obj->number).release ();
 478 }
 479
 480 /* Implementation of RecordGap.error_code [int].  */
 481
 482 static PyObject *
 483 recpy_gap_reason_code (PyObject *self, void *closure)
 484 {
 485   const recpy_gap_object * const obj = (const recpy_gap_object *) self;
 486
 487   return gdb_py_object_from_longest (obj->reason_code).release ();
 488 }
 489
 490 /* Implementation of RecordGap.error_string [str].  */
 491
 492 static PyObject *
 493 recpy_gap_reason_string (PyObject *self, void *closure)
 494 {
 495   const recpy_gap_object * const obj = (const recpy_gap_object *) self;
 496
 497   return PyUnicode_FromString (obj->reason_string);
 498 }
 499
 500 /* Create a new gdb.Auxiliary object.  */
 501
 502 PyObject *
 503 recpy_aux_new (thread_info *thread, enum record_method method,
 504                Py_ssize_t number)
 505 {
 506   recpy_element_object * const obj = PyObject_New (recpy_element_object,
 507                                                    &recpy_aux_type);
 508
 509   if (obj == NULL)
 510    return NULL;
 511
 512   obj->thread = thread;
 513   obj->method = method;
 514   obj->number = number;
 515
 516   return (PyObject *) obj;
 517 }
 518
 519 /* Implementation of Auxiliary.data [buffer].  */
 520
 521 static PyObject *
 522 recpy_aux_data (PyObject *self, void *closure)
 523 {
 524   const recpy_element_object * const obj = (recpy_element_object *) self;
 525
 526   if (obj->method == RECORD_METHOD_BTRACE)
 527     return recpy_bt_aux_data (self, closure);
 528
 529   return PyErr_Format (PyExc_NotImplementedError, _("Not implemented."));
 530 }
 531
 532 /* Record method list.  */
 533
 534 static PyMethodDef recpy_record_methods[] = {
 535   { "goto", recpy_goto, METH_VARARGS,
 536     "goto (instruction|function_call) -> None.\n\
 537 Rewind to given location."},
 538   { "clear", recpy_clear, METH_VARARGS,
 539     "clear () -> None.\n\
 540 Clears the trace."},
 541   { NULL }
 542 };
 543
 544 /* Record member list.  */
 545
 546 static gdb_PyGetSetDef recpy_record_getset[] = {
 547   { "method", recpy_method, NULL, "Current recording method.", NULL },
 548   { "format", recpy_format, NULL, "Current recording format.", NULL },
 549   { "replay_position", recpy_replay_position, NULL, "Current replay position.",
 550     NULL },
 551   { "instruction_history", recpy_instruction_history, NULL,
 552     "List of instructions in current recording.", NULL },
 553   { "function_call_history", recpy_function_call_history, NULL,
 554     "List of function calls in current recording.", NULL },
 555   { "begin", recpy_begin, NULL,
 556     "First instruction in current recording.", NULL },
 557   { "end", recpy_end, NULL,
 558     "One past the last instruction in current recording.  This is typically \
 559 the current instruction and is used for e.g. record.goto (record.end).", NULL },
 560   { NULL }
 561 };
 562
 563 /* RecordInstruction member list.  */
 564
 565 static gdb_PyGetSetDef recpy_insn_getset[] = {
 566   { "number", recpy_element_number, NULL, "instruction number", NULL},
 567   { "sal", recpy_insn_sal, NULL, "associated symbol and line", NULL},
 568   { "pc", recpy_insn_pc, NULL, "instruction address", NULL},
 569   { "data", recpy_insn_data, NULL, "raw instruction data", NULL},
 570   { "decoded", recpy_insn_decoded, NULL, "decoded instruction", NULL},
 571   { "size", recpy_insn_size, NULL, "instruction size in byte", NULL},
 572   { "is_speculative", recpy_insn_is_speculative, NULL, "if the instruction was \
 573   executed speculatively", NULL},
 574   { NULL }
 575 };
 576
 577 /* RecordFunctionSegment member list.  */
 578
 579 static gdb_PyGetSetDef recpy_func_getset[] = {
 580   { "number", recpy_element_number, NULL, "function segment number", NULL},
 581   { "level", recpy_func_level, NULL, "call stack level", NULL},
 582   { "symbol", recpy_func_symbol, NULL, "associated line and symbol", NULL},
 583   { "instructions", recpy_func_instructions, NULL, "list of instructions in \
 584 this function segment", NULL},
 585   { "up", recpy_func_up, NULL, "caller or returned-to function segment", NULL},
 586   { "prev", recpy_func_prev, NULL, "previous segment of this function", NULL},
 587   { "next", recpy_func_next, NULL, "next segment of this function", NULL},
 588   { NULL }
 589 };
 590
 591 /* RecordGap member list.  */
 592
 593 static gdb_PyGetSetDef recpy_gap_getset[] = {
 594   { "number", recpy_gap_number, NULL, "element number", NULL},
 595   { "reason_code", recpy_gap_reason_code, NULL, "reason code", NULL},
 596   { "reason_string", recpy_gap_reason_string, NULL, "reason string", NULL},
 597   { NULL }
 598 };
 599
 600 /* RecordAuxiliary member list.  */
 601
 602 static gdb_PyGetSetDef recpy_aux_getset[] = {
 603   { "number", recpy_element_number, nullptr, "element number", nullptr},
 604   { "data", recpy_aux_data, nullptr, "data", nullptr},
 605   { nullptr }
 606 };
 607
 608 /* Sets up the record API in the gdb module.  */
 609
 610 static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
 611 gdbpy_initialize_record (void)
 612 {
 613   recpy_record_type.tp_new = PyType_GenericNew;
 614   recpy_record_type.tp_flags = Py_TPFLAGS_DEFAULT;
 615   recpy_record_type.tp_basicsize = sizeof (recpy_record_object);
 616   recpy_record_type.tp_name = "gdb.Record";
 617   recpy_record_type.tp_doc = "GDB record object";
 618   recpy_record_type.tp_methods = recpy_record_methods;
 619   recpy_record_type.tp_getset = recpy_record_getset;
 620
 621   recpy_insn_type.tp_new = PyType_GenericNew;
 622   recpy_insn_type.tp_flags = Py_TPFLAGS_DEFAULT;
 623   recpy_insn_type.tp_basicsize = sizeof (recpy_element_object);
 624   recpy_insn_type.tp_name = "gdb.RecordInstruction";
 625   recpy_insn_type.tp_doc = "GDB recorded instruction object";
 626   recpy_insn_type.tp_getset = recpy_insn_getset;
 627   recpy_insn_type.tp_richcompare = recpy_element_richcompare;
 628   recpy_insn_type.tp_hash = recpy_element_hash;
 629   recpy_insn_type.tp_base = py_insn_get_insn_type ();
 630
 631   recpy_func_type.tp_new = PyType_GenericNew;
 632   recpy_func_type.tp_flags = Py_TPFLAGS_DEFAULT;
 633   recpy_func_type.tp_basicsize = sizeof (recpy_element_object);
 634   recpy_func_type.tp_name = "gdb.RecordFunctionSegment";
 635   recpy_func_type.tp_doc = "GDB record function segment object";
 636   recpy_func_type.tp_getset = recpy_func_getset;
 637   recpy_func_type.tp_richcompare = recpy_element_richcompare;
 638   recpy_func_type.tp_hash = recpy_element_hash;
 639
 640   recpy_gap_type.tp_new = PyType_GenericNew;
 641   recpy_gap_type.tp_flags = Py_TPFLAGS_DEFAULT;
 642   recpy_gap_type.tp_basicsize = sizeof (recpy_gap_object);
 643   recpy_gap_type.tp_name = "gdb.RecordGap";
 644   recpy_gap_type.tp_doc = "GDB recorded gap object";
 645   recpy_gap_type.tp_getset = recpy_gap_getset;
 646
 647   recpy_aux_type.tp_new = PyType_GenericNew;
 648   recpy_aux_type.tp_flags = Py_TPFLAGS_DEFAULT;
 649   recpy_aux_type.tp_basicsize = sizeof (recpy_element_object);
 650   recpy_aux_type.tp_name = "gdb.RecordAuxiliary";
 651   recpy_aux_type.tp_doc = "GDB recorded auxiliary object";
 652   recpy_aux_type.tp_getset = recpy_aux_getset;
 653   recpy_aux_type.tp_richcompare = recpy_element_richcompare;
 654   recpy_aux_type.tp_hash = recpy_element_hash;
 655
 656   if (gdbpy_type_ready (&recpy_record_type) < 0
 657       || gdbpy_type_ready (&recpy_insn_type) < 0
 658       || gdbpy_type_ready (&recpy_func_type) < 0
 659       || gdbpy_type_ready (&recpy_gap_type) < 0
 660       || gdbpy_type_ready (&recpy_aux_type) < 0)
 661     return -1;
 662   else
 663     return 0;
 664 }
 665
 666 /* Implementation of gdb.start_recording (method) -> gdb.Record.  */
 667
 668 PyObject *
 669 gdbpy_start_recording (PyObject *self, PyObject *args)
 670 {
 671   const char *method = NULL;
 672   const char *format = NULL;
 673
 674   if (!PyArg_ParseTuple (args, "|ss", &method, &format))
 675     return NULL;
 676
 677   try
 678     {
 679       record_start (method, format, 0);
 680       return gdbpy_current_recording (self, args);
 681     }
 682   catch (const gdb_exception &except)
 683     {
 684       return gdbpy_handle_gdb_exception (nullptr, except);
 685     }
 686 }
 687
 688 /* Implementation of gdb.current_recording (self) -> gdb.Record.  */
 689
 690 PyObject *
 691 gdbpy_current_recording (PyObject *self, PyObject *args)
 692 {
 693   recpy_record_object *ret = NULL;
 694
 695   if (find_record_target () == NULL)
 696     Py_RETURN_NONE;
 697
 698   ret = PyObject_New (recpy_record_object, &recpy_record_type);
 699   ret->thread = inferior_thread ();
 700   ret->method = target_record_method (ret->thread->ptid);
 701
 702   return (PyObject *) ret;
 703 }
 704
 705 /* Implementation of gdb.stop_recording (self) -> None.  */
 706
 707 PyObject *
 708 gdbpy_stop_recording (PyObject *self, PyObject *args)
 709 {
 710   try
 711     {
 712       record_stop (0);
 713     }
 714   catch (const gdb_exception &except)
 715     {
 716       return gdbpy_handle_gdb_exception (nullptr, except);
 717     }
 718
 719   Py_RETURN_NONE;
 720 }
 721
 722 GDBPY_INITIALIZE_FILE (gdbpy_initialize_record);