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