1 /* Python interface to btrace instruction history.
3 Copyright 2016-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "gdbthread.h"
25 #include "py-record.h"
26 #include "py-record-btrace.h"
31 #define BTPY_PYSLICE(x) (x)
35 #define BTPY_PYSLICE(x) ((PySliceObject *) x)
39 /* Python object for btrace record lists. */
44 /* The thread this list belongs to. */
47 /* The first index being part of this list. */
50 /* The last index begin part of this list. */
56 /* Either &BTPY_CALL_TYPE or &RECPY_INSN_TYPE. */
57 PyTypeObject
* element_type
;
60 /* Python type for btrace lists. */
62 static PyTypeObject btpy_list_type
= {
63 PyVarObject_HEAD_INIT (NULL
, 0)
66 /* Returns either a btrace_insn for the given Python gdb.RecordInstruction
67 object or sets an appropriate Python exception and returns NULL. */
69 static const btrace_insn
*
70 btrace_insn_from_recpy_insn (const PyObject
* const pyobject
)
72 const btrace_insn
*insn
;
73 const recpy_element_object
*obj
;
75 btrace_insn_iterator iter
;
77 if (Py_TYPE (pyobject
) != &recpy_insn_type
)
79 PyErr_Format (gdbpy_gdb_error
, _("Must be gdb.RecordInstruction"));
83 obj
= (const recpy_element_object
*) pyobject
;
84 tinfo
= find_thread_ptid (obj
->ptid
);
86 if (tinfo
== NULL
|| btrace_is_empty (tinfo
))
88 PyErr_Format (gdbpy_gdb_error
, _("No such instruction."));
92 if (btrace_find_insn_by_number (&iter
, &tinfo
->btrace
, obj
->number
) == 0)
94 PyErr_Format (gdbpy_gdb_error
, _("No such instruction."));
98 insn
= btrace_insn_get (&iter
);
101 PyErr_Format (gdbpy_gdb_error
, _("Not a valid instruction."));
108 /* Returns either a btrace_function for the given Python
109 gdb.RecordFunctionSegment object or sets an appropriate Python exception and
112 static const btrace_function
*
113 btrace_func_from_recpy_func (const PyObject
* const pyobject
)
115 const btrace_function
*func
;
116 const recpy_element_object
*obj
;
118 btrace_call_iterator iter
;
120 if (Py_TYPE (pyobject
) != &recpy_func_type
)
122 PyErr_Format (gdbpy_gdb_error
, _("Must be gdb.RecordFunctionSegment"));
126 obj
= (const recpy_element_object
*) pyobject
;
127 tinfo
= find_thread_ptid (obj
->ptid
);
129 if (tinfo
== NULL
|| btrace_is_empty (tinfo
))
131 PyErr_Format (gdbpy_gdb_error
, _("No such function segment."));
135 if (btrace_find_call_by_number (&iter
, &tinfo
->btrace
, obj
->number
) == 0)
137 PyErr_Format (gdbpy_gdb_error
, _("No such function segment."));
141 func
= btrace_call_get (&iter
);
144 PyErr_Format (gdbpy_gdb_error
, _("Not a valid function segment."));
151 /* Looks at the recorded item with the number NUMBER and create a
152 gdb.RecordInstruction or gdb.RecordGap object for it accordingly. */
155 btpy_insn_or_gap_new (const thread_info
*tinfo
, Py_ssize_t number
)
157 btrace_insn_iterator iter
;
160 btrace_find_insn_by_number (&iter
, &tinfo
->btrace
, number
);
161 err_code
= btrace_insn_get_error (&iter
);
165 const btrace_config
*config
;
166 const char *err_string
;
168 config
= btrace_conf (&tinfo
->btrace
);
169 err_string
= btrace_decode_error (config
->format
, err_code
);
171 return recpy_gap_new (err_code
, err_string
, number
);
174 return recpy_insn_new (tinfo
->ptid
, RECORD_METHOD_BTRACE
, number
);
177 /* Create a new gdb.BtraceList object. */
180 btpy_list_new (ptid_t ptid
, Py_ssize_t first
, Py_ssize_t last
, Py_ssize_t step
,
181 PyTypeObject
*element_type
)
183 btpy_list_object
* const obj
= PyObject_New (btpy_list_object
,
193 obj
->element_type
= element_type
;
195 return (PyObject
*) obj
;
198 /* Implementation of RecordInstruction.sal [gdb.Symtab_and_line] for btrace.
199 Returns the SAL associated with this instruction. */
202 recpy_bt_insn_sal (PyObject
*self
, void *closure
)
204 const btrace_insn
* const insn
= btrace_insn_from_recpy_insn (self
);
205 PyObject
*result
= NULL
;
212 result
= symtab_and_line_to_sal_object (find_pc_line (insn
->pc
, 0));
214 CATCH (except
, RETURN_MASK_ALL
)
216 GDB_PY_HANDLE_EXCEPTION (except
);
223 /* Implementation of RecordInstruction.pc [int] for btrace.
224 Returns the instruction address. */
227 recpy_bt_insn_pc (PyObject
*self
, void *closure
)
229 const btrace_insn
* const insn
= btrace_insn_from_recpy_insn (self
);
234 return gdb_py_long_from_ulongest (insn
->pc
);
237 /* Implementation of RecordInstruction.size [int] for btrace.
238 Returns the instruction size. */
241 recpy_bt_insn_size (PyObject
*self
, void *closure
)
243 const btrace_insn
* const insn
= btrace_insn_from_recpy_insn (self
);
248 return PyInt_FromLong (insn
->size
);
251 /* Implementation of RecordInstruction.is_speculative [bool] for btrace.
252 Returns if this instruction was executed speculatively. */
255 recpy_bt_insn_is_speculative (PyObject
*self
, void *closure
)
257 const btrace_insn
* const insn
= btrace_insn_from_recpy_insn (self
);
262 if (insn
->flags
& BTRACE_INSN_FLAG_SPECULATIVE
)
268 /* Implementation of RecordInstruction.data [buffer] for btrace.
269 Returns raw instruction data. */
272 recpy_bt_insn_data (PyObject
*self
, void *closure
)
274 const btrace_insn
* const insn
= btrace_insn_from_recpy_insn (self
);
275 gdb_byte
*buffer
= NULL
;
283 buffer
= (gdb_byte
*) xmalloc (insn
->size
);
284 read_memory (insn
->pc
, buffer
, insn
->size
);
286 CATCH (except
, RETURN_MASK_ALL
)
289 GDB_PY_HANDLE_EXCEPTION (except
);
293 object
= PyBytes_FromStringAndSize ((const char*) buffer
, insn
->size
);
300 return PyMemoryView_FromObject (object
);
302 return PyBuffer_FromObject (object
, 0, Py_END_OF_BUFFER
);
307 /* Implementation of RecordInstruction.decoded [str] for btrace.
308 Returns the instruction as human readable string. */
311 recpy_bt_insn_decoded (PyObject
*self
, void *closure
)
313 const btrace_insn
* const insn
= btrace_insn_from_recpy_insn (self
);
321 gdb_print_insn (target_gdbarch (), insn
->pc
, &strfile
, NULL
);
323 CATCH (except
, RETURN_MASK_ALL
)
325 gdbpy_convert_exception (except
);
331 return PyBytes_FromString (strfile
.string ().c_str ());
334 /* Implementation of RecordFunctionSegment.level [int] for btrace.
335 Returns the call level. */
338 recpy_bt_func_level (PyObject
*self
, void *closure
)
340 const btrace_function
* const func
= btrace_func_from_recpy_func (self
);
346 tinfo
= find_thread_ptid (((recpy_element_object
*) self
)->ptid
);
347 return PyInt_FromLong (tinfo
->btrace
.level
+ func
->level
);
350 /* Implementation of RecordFunctionSegment.symbol [gdb.Symbol] for btrace.
351 Returns the symbol associated with this function call. */
354 recpy_bt_func_symbol (PyObject
*self
, void *closure
)
356 const btrace_function
* const func
= btrace_func_from_recpy_func (self
);
361 if (func
->sym
== NULL
)
364 return symbol_to_symbol_object (func
->sym
);
367 /* Implementation of RecordFunctionSegment.instructions [list] for btrace.
368 Returns the list of instructions that belong to this function call. */
371 recpy_bt_func_instructions (PyObject
*self
, void *closure
)
373 const btrace_function
* const func
= btrace_func_from_recpy_func (self
);
379 len
= VEC_length (btrace_insn_s
, func
->insn
);
381 /* Gaps count as one instruction. */
385 return btpy_list_new (((recpy_element_object
*) self
)->ptid
,
386 func
->insn_offset
, func
->insn_offset
+ len
, 1,
390 /* Implementation of RecordFunctionSegment.up [RecordFunctionSegment] for
391 btrace. Returns the caller / returnee of this function. */
394 recpy_bt_func_up (PyObject
*self
, void *closure
)
396 const btrace_function
* const func
= btrace_func_from_recpy_func (self
);
404 return recpy_func_new (((recpy_element_object
*) self
)->ptid
,
405 RECORD_METHOD_BTRACE
, func
->up
);
408 /* Implementation of RecordFunctionSegment.prev [RecordFunctionSegment] for
409 btrace. Returns a previous segment of this function. */
412 recpy_bt_func_prev (PyObject
*self
, void *closure
)
414 const btrace_function
* const func
= btrace_func_from_recpy_func (self
);
419 if (func
->segment
.prev
== NULL
)
422 return recpy_func_new (((recpy_element_object
*) self
)->ptid
,
423 RECORD_METHOD_BTRACE
, func
->segment
.prev
->number
);
426 /* Implementation of RecordFunctionSegment.next [RecordFunctionSegment] for
427 btrace. Returns a following segment of this function. */
430 recpy_bt_func_next (PyObject
*self
, void *closure
)
432 const btrace_function
* const func
= btrace_func_from_recpy_func (self
);
437 if (func
->segment
.next
== NULL
)
440 return recpy_func_new (((recpy_element_object
*) self
)->ptid
,
441 RECORD_METHOD_BTRACE
, func
->segment
.next
->number
);
444 /* Implementation of BtraceList.__len__ (self) -> int. */
447 btpy_list_length (PyObject
*self
)
449 const btpy_list_object
* const obj
= (btpy_list_object
*) self
;
450 const Py_ssize_t distance
= obj
->last
- obj
->first
;
451 const Py_ssize_t result
= distance
/ obj
->step
;
453 if ((distance
% obj
->step
) == 0)
460 BtraceList.__getitem__ (self, key) -> BtraceInstruction and
461 BtraceList.__getitem__ (self, key) -> BtraceFunctionCall. */
464 btpy_list_item (PyObject
*self
, Py_ssize_t index
)
466 const btpy_list_object
* const obj
= (btpy_list_object
*) self
;
467 struct thread_info
* const tinfo
= find_thread_ptid (obj
->ptid
);
470 if (index
< 0 || index
>= btpy_list_length (self
))
471 return PyErr_Format (PyExc_IndexError
, _("Index out of range: %zd."),
474 number
= obj
->first
+ (obj
->step
* index
);
476 if (obj
->element_type
== &recpy_insn_type
)
477 return recpy_insn_new (obj
->ptid
, RECORD_METHOD_BTRACE
, number
);
479 return recpy_func_new (obj
->ptid
, RECORD_METHOD_BTRACE
, number
);
482 /* Implementation of BtraceList.__getitem__ (self, slice) -> BtraceList. */
485 btpy_list_slice (PyObject
*self
, PyObject
*value
)
487 const btpy_list_object
* const obj
= (btpy_list_object
*) self
;
488 const Py_ssize_t length
= btpy_list_length (self
);
489 Py_ssize_t start
, stop
, step
, slicelength
;
491 if (PyInt_Check (value
))
493 Py_ssize_t index
= PyInt_AsSsize_t (value
);
495 /* Emulate Python behavior for negative indices. */
499 return btpy_list_item (self
, index
);
502 if (!PySlice_Check (value
))
503 return PyErr_Format (PyExc_TypeError
, _("Index must be int or slice."));
505 if (0 != PySlice_GetIndicesEx (BTPY_PYSLICE (value
), length
, &start
, &stop
,
506 &step
, &slicelength
))
509 return btpy_list_new (obj
->ptid
, obj
->first
+ obj
->step
* start
,
510 obj
->first
+ obj
->step
* stop
, obj
->step
* step
,
514 /* Helper function that returns the position of an element in a BtraceList
515 or -1 if the element is not in the list. */
518 btpy_list_position (PyObject
*self
, PyObject
*value
)
520 const btpy_list_object
* const list_obj
= (btpy_list_object
*) self
;
521 const recpy_element_object
* const obj
= (const recpy_element_object
*) value
;
522 Py_ssize_t index
= obj
->number
;
524 if (list_obj
->element_type
!= Py_TYPE (value
))
527 if (!ptid_equal (list_obj
->ptid
, obj
->ptid
))
530 if (index
< list_obj
->first
|| index
> list_obj
->last
)
533 index
-= list_obj
->first
;
535 if (index
% list_obj
->step
!= 0)
538 return index
/ list_obj
->step
;
541 /* Implementation of "in" operator for BtraceLists. */
544 btpy_list_contains (PyObject
*self
, PyObject
*value
)
546 if (btpy_list_position (self
, value
) < 0)
552 /* Implementation of BtraceLists.index (self, value) -> int. */
555 btpy_list_index (PyObject
*self
, PyObject
*value
)
557 const LONGEST index
= btpy_list_position (self
, value
);
560 return PyErr_Format (PyExc_ValueError
, _("Not in list."));
562 return gdb_py_long_from_longest (index
);
565 /* Implementation of BtraceList.count (self, value) -> int. */
568 btpy_list_count (PyObject
*self
, PyObject
*value
)
570 /* We know that if an element is in the list, it is so exactly one time,
571 enabling us to reuse the "is element of" check. */
572 return PyInt_FromLong (btpy_list_contains (self
, value
));
575 /* Python rich compare function to allow for equality and inequality checks
579 btpy_list_richcompare (PyObject
*self
, PyObject
*other
, int op
)
581 const btpy_list_object
* const obj1
= (btpy_list_object
*) self
;
582 const btpy_list_object
* const obj2
= (btpy_list_object
*) other
;
584 if (Py_TYPE (self
) != Py_TYPE (other
))
586 Py_INCREF (Py_NotImplemented
);
587 return Py_NotImplemented
;
593 if (ptid_equal (obj1
->ptid
, obj2
->ptid
)
594 && obj1
->element_type
== obj2
->element_type
595 && obj1
->first
== obj2
->first
596 && obj1
->last
== obj2
->last
597 && obj1
->step
== obj2
->step
)
603 if (!ptid_equal (obj1
->ptid
, obj2
->ptid
)
604 || obj1
->element_type
!= obj2
->element_type
605 || obj1
->first
!= obj2
->first
606 || obj1
->last
!= obj2
->last
607 || obj1
->step
!= obj2
->step
)
616 Py_INCREF (Py_NotImplemented
);
617 return Py_NotImplemented
;
621 BtraceRecord.method [str]. */
624 recpy_bt_method (PyObject
*self
, void *closure
)
626 return PyString_FromString ("btrace");
630 BtraceRecord.format [str]. */
633 recpy_bt_format (PyObject
*self
, void *closure
)
635 const recpy_record_object
* const record
= (recpy_record_object
*) self
;
636 const struct thread_info
* const tinfo
= find_thread_ptid (record
->ptid
);
637 const struct btrace_config
* config
;
642 config
= btrace_conf (&tinfo
->btrace
);
647 return PyString_FromString (btrace_format_short_string (config
->format
));
651 BtraceRecord.replay_position [BtraceInstruction]. */
654 recpy_bt_replay_position (PyObject
*self
, void *closure
)
656 const recpy_record_object
* const record
= (recpy_record_object
*) self
;
657 const struct thread_info
* const tinfo
= find_thread_ptid (record
->ptid
);
662 if (tinfo
->btrace
.replay
== NULL
)
665 return btpy_insn_or_gap_new (tinfo
,
666 btrace_insn_number (tinfo
->btrace
.replay
));
670 BtraceRecord.begin [BtraceInstruction]. */
673 recpy_bt_begin (PyObject
*self
, void *closure
)
675 const recpy_record_object
* const record
= (recpy_record_object
*) self
;
676 struct thread_info
* const tinfo
= find_thread_ptid (record
->ptid
);
677 struct btrace_insn_iterator iterator
;
682 btrace_fetch (tinfo
);
684 if (btrace_is_empty (tinfo
))
687 btrace_insn_begin (&iterator
, &tinfo
->btrace
);
688 return btpy_insn_or_gap_new (tinfo
, btrace_insn_number (&iterator
));
692 BtraceRecord.end [BtraceInstruction]. */
695 recpy_bt_end (PyObject
*self
, void *closure
)
697 const recpy_record_object
* const record
= (recpy_record_object
*) self
;
698 struct thread_info
* const tinfo
= find_thread_ptid (record
->ptid
);
699 struct btrace_insn_iterator iterator
;
704 btrace_fetch (tinfo
);
706 if (btrace_is_empty (tinfo
))
709 btrace_insn_end (&iterator
, &tinfo
->btrace
);
710 return btpy_insn_or_gap_new (tinfo
, btrace_insn_number (&iterator
));
714 BtraceRecord.instruction_history [list]. */
717 recpy_bt_instruction_history (PyObject
*self
, void *closure
)
719 const recpy_record_object
* const record
= (recpy_record_object
*) self
;
720 struct thread_info
* const tinfo
= find_thread_ptid (record
->ptid
);
721 struct btrace_insn_iterator iterator
;
722 unsigned long first
= 0;
723 unsigned long last
= 0;
728 btrace_fetch (tinfo
);
730 if (btrace_is_empty (tinfo
))
733 btrace_insn_begin (&iterator
, &tinfo
->btrace
);
734 first
= btrace_insn_number (&iterator
);
736 btrace_insn_end (&iterator
, &tinfo
->btrace
);
737 last
= btrace_insn_number (&iterator
);
739 return btpy_list_new (record
->ptid
, first
, last
, 1, &recpy_insn_type
);
743 BtraceRecord.function_call_history [list]. */
746 recpy_bt_function_call_history (PyObject
*self
, void *closure
)
748 const recpy_record_object
* const record
= (recpy_record_object
*) self
;
749 struct thread_info
* const tinfo
= find_thread_ptid (record
->ptid
);
750 struct btrace_call_iterator iterator
;
751 unsigned long first
= 0;
752 unsigned long last
= 0;
757 btrace_fetch (tinfo
);
759 if (btrace_is_empty (tinfo
))
762 btrace_call_begin (&iterator
, &tinfo
->btrace
);
763 first
= btrace_call_number (&iterator
);
765 btrace_call_end (&iterator
, &tinfo
->btrace
);
766 last
= btrace_call_number (&iterator
);
768 return btpy_list_new (record
->ptid
, first
, last
, 1, &recpy_func_type
);
771 /* Implementation of BtraceRecord.goto (self, BtraceInstruction) -> None. */
774 recpy_bt_goto (PyObject
*self
, PyObject
*args
)
776 const recpy_record_object
* const record
= (recpy_record_object
*) self
;
777 struct thread_info
* const tinfo
= find_thread_ptid (record
->ptid
);
778 const recpy_element_object
*obj
;
780 if (tinfo
== NULL
|| btrace_is_empty (tinfo
))
781 return PyErr_Format (gdbpy_gdb_error
, _("Empty branch trace."));
783 if (!PyArg_ParseTuple (args
, "O", &obj
))
786 if (Py_TYPE (obj
) != &recpy_insn_type
)
787 return PyErr_Format (PyExc_TypeError
, _("Argument must be instruction."));
791 struct btrace_insn_iterator iter
;
793 btrace_insn_end (&iter
, &tinfo
->btrace
);
795 if (btrace_insn_number (&iter
) == obj
->number
)
796 target_goto_record_end ();
798 target_goto_record (obj
->number
);
800 CATCH (except
, RETURN_MASK_ALL
)
802 GDB_PY_HANDLE_EXCEPTION (except
);
809 /* BtraceList methods. */
811 struct PyMethodDef btpy_list_methods
[] =
813 { "count", btpy_list_count
, METH_O
, "count number of occurences"},
814 { "index", btpy_list_index
, METH_O
, "index of entry"},
818 /* BtraceList sequence methods. */
820 static PySequenceMethods btpy_list_sequence_methods
=
825 /* BtraceList mapping methods. Necessary for slicing. */
827 static PyMappingMethods btpy_list_mapping_methods
=
832 /* Sets up the btrace record API. */
835 gdbpy_initialize_btrace (void)
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
;
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
;
851 btpy_list_mapping_methods
.mp_subscript
= btpy_list_slice
;
853 return PyType_Ready (&btpy_list_type
);