gdb/python/py-record-btrace.c

   1 /* Python interface to btrace instruction history.
   2
   3    Copyright 2016-2021 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 "gdbcore.h"
  22 #include "gdbcmd.h"
  23 #include "gdbthread.h"
  24 #include "btrace.h"
  25 #include "py-record.h"
  26 #include "py-record-btrace.h"
  27 #include "record-btrace.h"
  28 #include "disasm.h"
  29 #include "gdbarch.h"
  30
  31 #if defined (IS_PY3K)
  32
  33 #define BTPY_PYSLICE(x) (x)
  34
  35 #else
  36
  37 #define BTPY_PYSLICE(x) ((PySliceObject *) x)
  38
  39 #endif
  40
  41 /* Python object for btrace record lists.  */
  42
  43 struct btpy_list_object {
  44   PyObject_HEAD
  45
  46   /* The thread this list belongs to.  */
  47   thread_info *thread;
  48
  49   /* The first index being part of this list.  */
  50   Py_ssize_t first;
  51
  52   /* The last index begin part of this list.  */
  53   Py_ssize_t last;
  54
  55   /* Stride size.  */
  56   Py_ssize_t step;
  57
  58   /* Either &BTPY_CALL_TYPE or &RECPY_INSN_TYPE.  */
  59   PyTypeObject* element_type;
  60 };
  61
  62 /* Python type for btrace lists.  */
  63
  64 static PyTypeObject btpy_list_type = {
  65   PyVarObject_HEAD_INIT (NULL, 0)
  66 };
  67
  68 /* Returns either a btrace_insn for the given Python gdb.RecordInstruction
  69    object or sets an appropriate Python exception and returns NULL.  */
  70
  71 static const btrace_insn *
  72 btrace_insn_from_recpy_insn (const PyObject * const pyobject)
  73 {
  74   const btrace_insn *insn;
  75   const recpy_element_object *obj;
  76   thread_info *tinfo;
  77   btrace_insn_iterator iter;
  78
  79   if (Py_TYPE (pyobject) != &recpy_insn_type)
  80     {
  81       PyErr_Format (gdbpy_gdb_error, _("Must be gdb.RecordInstruction"));
  82       return NULL;
  83     }
  84
  85   obj = (const recpy_element_object *) pyobject;
  86   tinfo = obj->thread;
  87
  88   if (tinfo == NULL || btrace_is_empty (tinfo))
  89     {
  90       PyErr_Format (gdbpy_gdb_error, _("No such instruction."));
  91       return NULL;
  92     }
  93
  94   if (btrace_find_insn_by_number (&iter, &tinfo->btrace, obj->number) == 0)
  95     {
  96       PyErr_Format (gdbpy_gdb_error, _("No such instruction."));
  97       return NULL;
  98     }
  99
 100   insn = btrace_insn_get (&iter);
 101   if (insn == NULL)
 102     {
 103       PyErr_Format (gdbpy_gdb_error, _("Not a valid instruction."));
 104       return NULL;
 105     }
 106
 107   return insn;
 108 }
 109
 110 /* Returns either a btrace_function for the given Python
 111    gdb.RecordFunctionSegment object or sets an appropriate Python exception and
 112    returns NULL.  */
 113
 114 static const btrace_function *
 115 btrace_func_from_recpy_func (const PyObject * const pyobject)
 116 {
 117   const btrace_function *func;
 118   const recpy_element_object *obj;
 119   thread_info *tinfo;
 120   btrace_call_iterator iter;
 121
 122   if (Py_TYPE (pyobject) != &recpy_func_type)
 123     {
 124       PyErr_Format (gdbpy_gdb_error, _("Must be gdb.RecordFunctionSegment"));
 125       return NULL;
 126     }
 127
 128   obj = (const recpy_element_object *) pyobject;
 129   tinfo = obj->thread;
 130
 131   if (tinfo == NULL || btrace_is_empty (tinfo))
 132     {
 133       PyErr_Format (gdbpy_gdb_error, _("No such function segment."));
 134       return NULL;
 135     }
 136
 137   if (btrace_find_call_by_number (&iter, &tinfo->btrace, obj->number) == 0)
 138     {
 139       PyErr_Format (gdbpy_gdb_error, _("No such function segment."));
 140       return NULL;
 141     }
 142
 143   func = btrace_call_get (&iter);
 144   if (func == NULL)
 145     {
 146       PyErr_Format (gdbpy_gdb_error, _("Not a valid function segment."));
 147       return NULL;
 148     }
 149
 150   return func;
 151 }
 152
 153 /* Looks at the recorded item with the number NUMBER and create a
 154    gdb.RecordInstruction or gdb.RecordGap object for it accordingly.  */
 155
 156 static PyObject *
 157 btpy_insn_or_gap_new (thread_info *tinfo, Py_ssize_t number)
 158 {
 159   btrace_insn_iterator iter;
 160   int err_code;
 161
 162   btrace_find_insn_by_number (&iter, &tinfo->btrace, number);
 163   err_code = btrace_insn_get_error (&iter);
 164
 165   if (err_code != 0)
 166     {
 167       const btrace_config *config;
 168       const char *err_string;
 169
 170       config = btrace_conf (&tinfo->btrace);
 171       err_string = btrace_decode_error (config->format, err_code);
 172
 173       return recpy_gap_new (err_code, err_string, number);
 174     }
 175
 176   return recpy_insn_new (tinfo, RECORD_METHOD_BTRACE, number);
 177 }
 178
 179 /* Create a new gdb.BtraceList object.  */
 180
 181 static PyObject *
 182 btpy_list_new (thread_info *thread, Py_ssize_t first, Py_ssize_t last, Py_ssize_t step,
 183                PyTypeObject *element_type)
 184 {
 185   btpy_list_object * const obj = PyObject_New (btpy_list_object,
 186                                                &btpy_list_type);
 187
 188   if (obj == NULL)
 189     return NULL;
 190
 191   obj->thread = thread;
 192   obj->first = first;
 193   obj->last = last;
 194   obj->step = step;
 195   obj->element_type = element_type;
 196
 197   return (PyObject *) obj;
 198 }
 199
 200 /* Implementation of RecordInstruction.sal [gdb.Symtab_and_line] for btrace.
 201    Returns the SAL associated with this instruction.  */
 202
 203 PyObject *
 204 recpy_bt_insn_sal (PyObject *self, void *closure)
 205 {
 206   const btrace_insn * const insn = btrace_insn_from_recpy_insn (self);
 207   PyObject *result = NULL;
 208
 209   if (insn == NULL)
 210     return NULL;
 211
 212   try
 213     {
 214       result = symtab_and_line_to_sal_object (find_pc_line (insn->pc, 0));
 215     }
 216   catch (const gdb_exception &except)
 217     {
 218       GDB_PY_HANDLE_EXCEPTION (except);
 219     }
 220
 221   return result;
 222 }
 223
 224 /* Implementation of RecordInstruction.pc [int] for btrace.
 225    Returns the instruction address.  */
 226
 227 PyObject *
 228 recpy_bt_insn_pc (PyObject *self, void *closure)
 229 {
 230   const btrace_insn * const insn = btrace_insn_from_recpy_insn (self);
 231
 232   if (insn == NULL)
 233     return NULL;
 234
 235   return gdb_py_object_from_ulongest (insn->pc).release ();
 236 }
 237
 238 /* Implementation of RecordInstruction.size [int] for btrace.
 239    Returns the instruction size.  */
 240
 241 PyObject *
 242 recpy_bt_insn_size (PyObject *self, void *closure)
 243 {
 244   const btrace_insn * const insn = btrace_insn_from_recpy_insn (self);
 245
 246   if (insn == NULL)
 247     return NULL;
 248
 249   return gdb_py_object_from_longest (insn->size).release ();
 250 }
 251
 252 /* Implementation of RecordInstruction.is_speculative [bool] for btrace.
 253    Returns if this instruction was executed speculatively.  */
 254
 255 PyObject *
 256 recpy_bt_insn_is_speculative (PyObject *self, void *closure)
 257 {
 258   const btrace_insn * const insn = btrace_insn_from_recpy_insn (self);
 259
 260   if (insn == NULL)
 261     return NULL;
 262
 263   if (insn->flags & BTRACE_INSN_FLAG_SPECULATIVE)
 264     Py_RETURN_TRUE;
 265   else
 266     Py_RETURN_FALSE;
 267 }
 268
 269 /* Implementation of RecordInstruction.data [buffer] for btrace.
 270    Returns raw instruction data.  */
 271
 272 PyObject *
 273 recpy_bt_insn_data (PyObject *self, void *closure)
 274 {
 275   const btrace_insn * const insn = btrace_insn_from_recpy_insn (self);
 276   gdb::byte_vector buffer;
 277   PyObject *object;
 278
 279   if (insn == NULL)
 280     return NULL;
 281
 282   try
 283     {
 284       buffer.resize (insn->size);
 285       read_memory (insn->pc, buffer.data (), insn->size);
 286     }
 287   catch (const gdb_exception &except)
 288     {
 289       GDB_PY_HANDLE_EXCEPTION (except);
 290     }
 291
 292   object = PyBytes_FromStringAndSize ((const char *) buffer.data (),
 293                                       insn->size);
 294
 295   if (object == NULL)
 296     return NULL;
 297
 298 #ifdef IS_PY3K
 299   return PyMemoryView_FromObject (object);
 300 #else
 301   return PyBuffer_FromObject (object, 0, Py_END_OF_BUFFER);
 302 #endif
 303
 304 }
 305
 306 /* Implementation of RecordInstruction.decoded [str] for btrace.
 307    Returns the instruction as human readable string.  */
 308
 309 PyObject *
 310 recpy_bt_insn_decoded (PyObject *self, void *closure)
 311 {
 312   const btrace_insn * const insn = btrace_insn_from_recpy_insn (self);
 313   string_file strfile;
 314
 315   if (insn == NULL)
 316     return NULL;
 317
 318   try
 319     {
 320       gdb_print_insn (target_gdbarch (), insn->pc, &strfile, NULL);
 321     }
 322   catch (const gdb_exception &except)
 323     {
 324       gdbpy_convert_exception (except);
 325       return NULL;
 326     }
 327
 328
 329   return PyBytes_FromString (strfile.string ().c_str ());
 330 }
 331
 332 /* Implementation of RecordFunctionSegment.level [int] for btrace.
 333    Returns the call level.  */
 334
 335 PyObject *
 336 recpy_bt_func_level (PyObject *self, void *closure)
 337 {
 338   const btrace_function * const func = btrace_func_from_recpy_func (self);
 339   thread_info *tinfo;
 340
 341   if (func == NULL)
 342     return NULL;
 343
 344   tinfo = ((recpy_element_object *) self)->thread;
 345   return gdb_py_object_from_longest (tinfo->btrace.level
 346                                      + func->level).release ();
 347 }
 348
 349 /* Implementation of RecordFunctionSegment.symbol [gdb.Symbol] for btrace.
 350    Returns the symbol associated with this function call.  */
 351
 352 PyObject *
 353 recpy_bt_func_symbol (PyObject *self, void *closure)
 354 {
 355   const btrace_function * const func = btrace_func_from_recpy_func (self);
 356
 357   if (func == NULL)
 358     return NULL;
 359
 360   if (func->sym == NULL)
 361     Py_RETURN_NONE;
 362
 363   return symbol_to_symbol_object (func->sym);
 364 }
 365
 366 /* Implementation of RecordFunctionSegment.instructions [list] for btrace.
 367    Returns the list of instructions that belong to this function call.  */
 368
 369 PyObject *
 370 recpy_bt_func_instructions (PyObject *self, void *closure)
 371 {
 372   const btrace_function * const func = btrace_func_from_recpy_func (self);
 373   unsigned int len;
 374
 375   if (func == NULL)
 376     return NULL;
 377
 378   len = func->insn.size ();
 379
 380   /* Gaps count as one instruction.  */
 381   if (len == 0)
 382     len = 1;
 383
 384   return btpy_list_new (((recpy_element_object *) self)->thread,
 385                         func->insn_offset, func->insn_offset + len, 1,
 386                         &recpy_insn_type);
 387 }
 388
 389 /* Implementation of RecordFunctionSegment.up [RecordFunctionSegment] for
 390    btrace.  Returns the caller / returnee of this function.  */
 391
 392 PyObject *
 393 recpy_bt_func_up (PyObject *self, void *closure)
 394 {
 395   const btrace_function * const func = btrace_func_from_recpy_func (self);
 396
 397   if (func == NULL)
 398     return NULL;
 399
 400   if (func->up == 0)
 401     Py_RETURN_NONE;
 402
 403   return recpy_func_new (((recpy_element_object *) self)->thread,
 404                          RECORD_METHOD_BTRACE, func->up);
 405 }
 406
 407 /* Implementation of RecordFunctionSegment.prev [RecordFunctionSegment] for
 408    btrace.  Returns a previous segment of this function.  */
 409
 410 PyObject *
 411 recpy_bt_func_prev (PyObject *self, void *closure)
 412 {
 413   const btrace_function * const func = btrace_func_from_recpy_func (self);
 414
 415   if (func == NULL)
 416     return NULL;
 417
 418   if (func->prev == 0)
 419     Py_RETURN_NONE;
 420
 421   return recpy_func_new (((recpy_element_object *) self)->thread,
 422                          RECORD_METHOD_BTRACE, func->prev);
 423 }
 424
 425 /* Implementation of RecordFunctionSegment.next [RecordFunctionSegment] for
 426    btrace.  Returns a following segment of this function.  */
 427
 428 PyObject *
 429 recpy_bt_func_next (PyObject *self, void *closure)
 430 {
 431   const btrace_function * const func = btrace_func_from_recpy_func (self);
 432
 433   if (func == NULL)
 434     return NULL;
 435
 436   if (func->next == 0)
 437     Py_RETURN_NONE;
 438
 439   return recpy_func_new (((recpy_element_object *) self)->thread,
 440                          RECORD_METHOD_BTRACE, func->next);
 441 }
 442
 443 /* Implementation of BtraceList.__len__ (self) -> int.  */
 444
 445 static Py_ssize_t
 446 btpy_list_length (PyObject *self)
 447 {
 448   const btpy_list_object * const obj = (btpy_list_object *) self;
 449   const Py_ssize_t distance = obj->last - obj->first;
 450   const Py_ssize_t result = distance / obj->step;
 451
 452   if ((distance % obj->step) == 0)
 453     return result;
 454
 455   return result + 1;
 456 }
 457
 458 /* Implementation of
 459    BtraceList.__getitem__ (self, key) -> BtraceInstruction and
 460    BtraceList.__getitem__ (self, key) -> BtraceFunctionCall.  */
 461
 462 static PyObject *
 463 btpy_list_item (PyObject *self, Py_ssize_t index)
 464 {
 465   const btpy_list_object * const obj = (btpy_list_object *) self;
 466   Py_ssize_t number;
 467
 468   if (index < 0 || index >= btpy_list_length (self))
 469     return PyErr_Format (PyExc_IndexError, _("Index out of range: %zd."),
 470                          index);
 471
 472   number = obj->first + (obj->step * index);
 473
 474   if (obj->element_type == &recpy_insn_type)
 475     return recpy_insn_new (obj->thread, RECORD_METHOD_BTRACE, number);
 476   else
 477     return recpy_func_new (obj->thread, RECORD_METHOD_BTRACE, number);
 478 }
 479
 480 /* Implementation of BtraceList.__getitem__ (self, slice) -> BtraceList.  */
 481
 482 static PyObject *
 483 btpy_list_slice (PyObject *self, PyObject *value)
 484 {
 485   const btpy_list_object * const obj = (btpy_list_object *) self;
 486   const Py_ssize_t length = btpy_list_length (self);
 487   Py_ssize_t start, stop, step, slicelength;
 488
 489   if (PyInt_Check (value))
 490     {
 491       Py_ssize_t index = PyInt_AsSsize_t (value);
 492
 493       /* Emulate Python behavior for negative indices.  */
 494       if (index < 0)
 495         index += length;
 496
 497       return btpy_list_item (self, index);
 498     }
 499
 500   if (!PySlice_Check (value))
 501     return PyErr_Format (PyExc_TypeError, _("Index must be int or slice."));
 502
 503   if (0 != PySlice_GetIndicesEx (BTPY_PYSLICE (value), length, &start, &stop,
 504                                  &step, &slicelength))
 505     return NULL;
 506
 507   return btpy_list_new (obj->thread, obj->first + obj->step * start,
 508                         obj->first + obj->step * stop, obj->step * step,
 509                         obj->element_type);
 510 }
 511
 512 /* Helper function that returns the position of an element in a BtraceList
 513    or -1 if the element is not in the list.  */
 514
 515 static LONGEST
 516 btpy_list_position (PyObject *self, PyObject *value)
 517 {
 518   const btpy_list_object * const list_obj = (btpy_list_object *) self;
 519   const recpy_element_object * const obj = (const recpy_element_object *) value;
 520   Py_ssize_t index = obj->number;
 521
 522   if (list_obj->element_type != Py_TYPE (value))
 523     return -1;
 524
 525   if (list_obj->thread != obj->thread)
 526     return -1;
 527
 528   if (index < list_obj->first || index > list_obj->last)
 529     return -1;
 530
 531   index -= list_obj->first;
 532
 533   if (index % list_obj->step != 0)
 534     return -1;
 535
 536   return index / list_obj->step;
 537 }
 538
 539 /* Implementation of "in" operator for BtraceLists.  */
 540
 541 static int
 542 btpy_list_contains (PyObject *self, PyObject *value)
 543 {
 544   if (btpy_list_position (self, value) < 0)
 545     return 0;
 546
 547   return 1;
 548 }
 549
 550 /* Implementation of BtraceLists.index (self, value) -> int.  */
 551
 552 static PyObject *
 553 btpy_list_index (PyObject *self, PyObject *value)
 554 {
 555   const LONGEST index = btpy_list_position (self, value);
 556
 557   if (index < 0)
 558     return PyErr_Format (PyExc_ValueError, _("Not in list."));
 559
 560   return gdb_py_object_from_longest (index).release ();
 561 }
 562
 563 /* Implementation of BtraceList.count (self, value) -> int.  */
 564
 565 static PyObject *
 566 btpy_list_count (PyObject *self, PyObject *value)
 567 {
 568   /* We know that if an element is in the list, it is so exactly one time,
 569      enabling us to reuse the "is element of" check.  */
 570   return gdb_py_object_from_longest (btpy_list_contains (self,
 571                                                          value)).release ();
 572 }
 573
 574 /* Python rich compare function to allow for equality and inequality checks
 575    in Python.  */
 576
 577 static PyObject *
 578 btpy_list_richcompare (PyObject *self, PyObject *other, int op)
 579 {
 580   const btpy_list_object * const obj1 = (btpy_list_object *) self;
 581   const btpy_list_object * const obj2 = (btpy_list_object *) other;
 582
 583   if (Py_TYPE (self) != Py_TYPE (other))
 584     {
 585       Py_INCREF (Py_NotImplemented);
 586       return Py_NotImplemented;
 587     }
 588
 589   switch (op)
 590   {
 591     case Py_EQ:
 592       if (obj1->thread == obj2->thread
 593           && obj1->element_type == obj2->element_type
 594           && obj1->first == obj2->first
 595           && obj1->last == obj2->last
 596           && obj1->step == obj2->step)
 597         Py_RETURN_TRUE;
 598       else
 599         Py_RETURN_FALSE;
 600
 601     case Py_NE:
 602       if (obj1->thread != obj2->thread
 603           || obj1->element_type != obj2->element_type
 604           || obj1->first != obj2->first
 605           || obj1->last != obj2->last
 606           || obj1->step != obj2->step)
 607         Py_RETURN_TRUE;
 608       else
 609         Py_RETURN_FALSE;
 610
 611     default:
 612       break;
 613   }
 614
 615   Py_INCREF (Py_NotImplemented);
 616   return Py_NotImplemented;
 617 }
 618
 619 /* Implementation of
 620    BtraceRecord.method [str].  */
 621
 622 PyObject *
 623 recpy_bt_method (PyObject *self, void *closure)
 624 {
 625   return PyString_FromString ("btrace");
 626 }
 627
 628 /* Implementation of
 629    BtraceRecord.format [str].  */
 630
 631 PyObject *
 632 recpy_bt_format (PyObject *self, void *closure)
 633 {
 634   const recpy_record_object * const record = (recpy_record_object *) self;
 635   const struct thread_info * const tinfo = record->thread;
 636   const struct btrace_config * config;
 637
 638   if (tinfo == NULL)
 639     Py_RETURN_NONE;
 640
 641   config = btrace_conf (&tinfo->btrace);
 642
 643   if (config == NULL)
 644     Py_RETURN_NONE;
 645
 646   return PyString_FromString (btrace_format_short_string (config->format));
 647 }
 648
 649 /* Implementation of
 650    BtraceRecord.replay_position [BtraceInstruction].  */
 651
 652 PyObject *
 653 recpy_bt_replay_position (PyObject *self, void *closure)
 654 {
 655   const recpy_record_object * const record = (recpy_record_object *) self;
 656   thread_info * tinfo = record->thread;
 657
 658   if (tinfo == NULL)
 659     Py_RETURN_NONE;
 660
 661   if (tinfo->btrace.replay == NULL)
 662     Py_RETURN_NONE;
 663
 664   return btpy_insn_or_gap_new (tinfo,
 665                                btrace_insn_number (tinfo->btrace.replay));
 666 }
 667
 668 /* Implementation of
 669    BtraceRecord.begin [BtraceInstruction].  */
 670
 671 PyObject *
 672 recpy_bt_begin (PyObject *self, void *closure)
 673 {
 674   const recpy_record_object * const record = (recpy_record_object *) self;
 675   thread_info *const tinfo = record->thread;
 676   struct btrace_insn_iterator iterator;
 677
 678   if (tinfo == NULL)
 679     Py_RETURN_NONE;
 680
 681   btrace_fetch (tinfo, record_btrace_get_cpu ());
 682
 683   if (btrace_is_empty (tinfo))
 684     Py_RETURN_NONE;
 685
 686   btrace_insn_begin (&iterator, &tinfo->btrace);
 687   return btpy_insn_or_gap_new (tinfo, btrace_insn_number (&iterator));
 688 }
 689
 690 /* Implementation of
 691    BtraceRecord.end [BtraceInstruction].  */
 692
 693 PyObject *
 694 recpy_bt_end (PyObject *self, void *closure)
 695 {
 696   const recpy_record_object * const record = (recpy_record_object *) self;
 697   thread_info *const tinfo = record->thread;
 698   struct btrace_insn_iterator iterator;
 699
 700   if (tinfo == NULL)
 701     Py_RETURN_NONE;
 702
 703   btrace_fetch (tinfo, record_btrace_get_cpu ());
 704
 705   if (btrace_is_empty (tinfo))
 706     Py_RETURN_NONE;
 707
 708   btrace_insn_end (&iterator, &tinfo->btrace);
 709   return btpy_insn_or_gap_new (tinfo, btrace_insn_number (&iterator));
 710 }
 711
 712 /* Implementation of
 713    BtraceRecord.instruction_history [list].  */
 714
 715 PyObject *
 716 recpy_bt_instruction_history (PyObject *self, void *closure)
 717 {
 718   const recpy_record_object * const record = (recpy_record_object *) self;
 719   thread_info *const tinfo = record->thread;
 720   struct btrace_insn_iterator iterator;
 721   unsigned long first = 0;
 722   unsigned long last = 0;
 723
 724    if (tinfo == NULL)
 725      Py_RETURN_NONE;
 726
 727    btrace_fetch (tinfo, record_btrace_get_cpu ());
 728
 729    if (btrace_is_empty (tinfo))
 730      Py_RETURN_NONE;
 731
 732    btrace_insn_begin (&iterator, &tinfo->btrace);
 733    first = btrace_insn_number (&iterator);
 734
 735    btrace_insn_end (&iterator, &tinfo->btrace);
 736    last = btrace_insn_number (&iterator);
 737
 738    return btpy_list_new (tinfo, first, last, 1, &recpy_insn_type);
 739 }
 740
 741 /* Implementation of
 742    BtraceRecord.function_call_history [list].  */
 743
 744 PyObject *
 745 recpy_bt_function_call_history (PyObject *self, void *closure)
 746 {
 747   const recpy_record_object * const record = (recpy_record_object *) self;
 748   thread_info *const tinfo = record->thread;
 749   struct btrace_call_iterator iterator;
 750   unsigned long first = 0;
 751   unsigned long last = 0;
 752
 753   if (tinfo == NULL)
 754     Py_RETURN_NONE;
 755
 756   btrace_fetch (tinfo, record_btrace_get_cpu ());
 757
 758   if (btrace_is_empty (tinfo))
 759     Py_RETURN_NONE;
 760
 761   btrace_call_begin (&iterator, &tinfo->btrace);
 762   first = btrace_call_number (&iterator);
 763
 764   btrace_call_end (&iterator, &tinfo->btrace);
 765   last = btrace_call_number (&iterator);
 766
 767   return btpy_list_new (tinfo, first, last, 1, &recpy_func_type);
 768 }
 769
 770 /* Implementation of BtraceRecord.goto (self, BtraceInstruction) -> None.  */
 771
 772 PyObject *
 773 recpy_bt_goto (PyObject *self, PyObject *args)
 774 {
 775   const recpy_record_object * const record = (recpy_record_object *) self;
 776   thread_info *const tinfo = record->thread;
 777   const recpy_element_object *obj;
 778   PyObject *parse_obj;
 779
 780   if (tinfo == NULL || btrace_is_empty (tinfo))
 781         return PyErr_Format (gdbpy_gdb_error, _("Empty branch trace."));
 782
 783   if (!PyArg_ParseTuple (args, "O", &parse_obj))
 784     return NULL;
 785
 786   if (Py_TYPE (parse_obj) != &recpy_insn_type)
 787     return PyErr_Format (PyExc_TypeError, _("Argument must be instruction."));
 788   obj = (const recpy_element_object *) parse_obj;
 789
 790   try
 791     {
 792       struct btrace_insn_iterator iter;
 793
 794       btrace_insn_end (&iter, &tinfo->btrace);
 795
 796       if (btrace_insn_number (&iter) == obj->number)
 797         target_goto_record_end ();
 798       else
 799         target_goto_record (obj->number);
 800     }
 801   catch (const gdb_exception &except)
 802     {
 803       GDB_PY_HANDLE_EXCEPTION (except);
 804     }
 805
 806   Py_RETURN_NONE;
 807 }
 808
 809 /* BtraceList methods.  */
 810
 811 static PyMethodDef btpy_list_methods[] =
 812 {
 813   { "count", btpy_list_count, METH_O, "count number of occurrences"},
 814   { "index", btpy_list_index, METH_O, "index of entry"},
 815   {NULL}
 816 };
 817
 818 /* BtraceList sequence methods.  */
 819
 820 static PySequenceMethods btpy_list_sequence_methods =
 821 {
 822   NULL
 823 };
 824
 825 /* BtraceList mapping methods.  Necessary for slicing.  */
 826
 827 static PyMappingMethods btpy_list_mapping_methods =
 828 {
 829   NULL
 830 };
 831
 832 /* Sets up the btrace record API.  */
 833
 834 int
 835 gdbpy_initialize_btrace (void)
 836 {
 837   btpy_list_type.tp_new = PyType_GenericNew;
 838   btpy_list_type.tp_flags = Py_TPFLAGS_DEFAULT;
 839   btpy_list_type.tp_basicsize = sizeof (btpy_list_object);
 840   btpy_list_type.tp_name = "gdb.BtraceObjectList";
 841   btpy_list_type.tp_doc = "GDB btrace list object";
 842   btpy_list_type.tp_methods = btpy_list_methods;
 843   btpy_list_type.tp_as_sequence = &btpy_list_sequence_methods;
 844   btpy_list_type.tp_as_mapping = &btpy_list_mapping_methods;
 845   btpy_list_type.tp_richcompare = btpy_list_richcompare;
 846
 847   btpy_list_sequence_methods.sq_item = btpy_list_item;
 848   btpy_list_sequence_methods.sq_length = btpy_list_length;
 849   btpy_list_sequence_methods.sq_contains = btpy_list_contains;
 850
 851   btpy_list_mapping_methods.mp_subscript = btpy_list_slice;
 852
 853   return PyType_Ready (&btpy_list_type);
 854 }