From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 23067 invoked by alias); 13 Feb 2017 17:12:41 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 23041 invoked by uid 89); 13 Feb 2017 17:12:40 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=1.3 required=5.0 tests=AWL,BAYES_50,FREEMAIL_ENVFROM_END_DIGIT,FREEMAIL_FROM,RCVD_IN_DNSWL_NONE,RCVD_IN_SORBS_SPAM,SPF_PASS autolearn=no version=3.3.2 spammy=slice, 73,6, error_code, btraceh X-HELO: mail-ot0-f195.google.com Received: from mail-ot0-f195.google.com (HELO mail-ot0-f195.google.com) (74.125.82.195) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 13 Feb 2017 17:12:30 +0000 Received: by mail-ot0-f195.google.com with SMTP id 65so12464028otq.2 for ; Mon, 13 Feb 2017 09:12:29 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:references:date:in-reply-to :message-id:user-agent:mime-version; bh=meWZl9BljR3PY5FItBcTOpaYk/bH5p8YUCkgV6+xtOM=; b=RqLgIhr5552AZxzG864QASBCHrlBLRgdCWavZi8UgreT5UaW29jxbUfZMikTtvoDo/ APbSWU7lDbVQ/W0Vbn7gVz63wXpx6NXufaqhTRdYoy6nD3yCaKhLbSd8hyvAw0eFvlRf QOIBgWBS8xQ5RA97wao3W2P0/UW82CnqDveFgZEdgfOZLmt8Ee0+Q6JwAIO9OuxXAylt xcvCEPX3etDjkbBfhQO5e5JtNNaXUmV4OBmv8RWVIQrTit2xcMjnI9Ji+N8+3JVaTQRP yQQ5fvRK5EW+OZW5iptEYrkK398N+xKjlXgomLcs9IbnNcO14+z8nSAHX1BtNrMlt2f9 WnvQ== X-Gm-Message-State: AMke39kFwZHQxUvVpBIGEHBDEYMIXQS08q+kJovgk2SnCVQRvxznUA8VPzE8ElONYCkohg== X-Received: by 10.98.89.21 with SMTP id n21mr27279881pfb.163.1487005947480; Mon, 13 Feb 2017 09:12:27 -0800 (PST) Received: from seba.sebabeach.org.gmail.com (173-13-178-53-sfba.hfc.comcastbusiness.net. [173.13.178.53]) by smtp.gmail.com with ESMTPSA id w125sm22172568pgb.11.2017.02.13.09.12.26 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 13 Feb 2017 09:12:26 -0800 (PST) From: Doug Evans To: Tim Wiederhake Cc: gdb-patches@sourceware.org, markus.t.metzger@intel.com, palves@redhat.com Subject: Re: [PATCH v6 7/9] python: Implement btrace Python bindings for record history. References: <1486989450-11313-1-git-send-email-tim.wiederhake@intel.com> <1486989450-11313-8-git-send-email-tim.wiederhake@intel.com> Date: Mon, 13 Feb 2017 17:12:00 -0000 In-Reply-To: <1486989450-11313-8-git-send-email-tim.wiederhake@intel.com> (Tim Wiederhake's message of "Mon, 13 Feb 2017 13:37:28 +0100") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-IsSubscribed: yes X-SW-Source: 2017-02/txt/msg00349.txt.bz2 > This patch implements the gdb.Record Python object methods and fields for > record target btrace. Also, implement a stub for record target full. > > 2017-02-13 Tim Wiederhake > > gdb/ChangeLog: > > * Makefile.in (SUBDIR_PYTHON_OBS): Add py-record-btrace.o, > py-record-full.o. > (SUBDIR_PYTHON_SRCS): Add py-record-btrace.c, py-record-full.c. > * python/py-record-btrace.c, python/py-record-btrace.h, > python/py-record-full.c, python/py-record-full.h: New file. > * python/py-record.c: Add include for py-record-btrace.h and > py-record-full.h. > (recpy_method, recpy_format, recpy_goto, recpy_replay_position, > recpy_instruction_history, recpy_function_call_history, recpy_begin, > recpy_end): Use functions from py-record-btrace.c and py-record-full.c. > * python/python-internal.h (PyInt_FromSsize_t, PyInt_AsSsize_t): > New definition. > (gdbpy_initialize_btrace): New export. > * python/python.c (_initialize_python): Add gdbpy_initialize_btrace. In the immortal words of Shrek, "hold the phone". :-) I see there's more comments than just one in the reply here: https://sourceware.org/ml/gdb-patches/2017-02/msg00347.html but the subject line got mixed with patch 8/9. https://sourceware.org/ml/gdb-patches/2017-02/msg00334.html This one, 7/9, still LGTM. > --- > gdb/Makefile.in | 4 + > gdb/python/py-record-btrace.c | 1001 +++++++++++++++++++++++++++++++++++++++++ > gdb/python/py-record-btrace.h | 49 ++ > gdb/python/py-record-full.c | 39 ++ > gdb/python/py-record-full.h | 31 ++ > gdb/python/py-record.c | 48 ++ > gdb/python/python-internal.h | 4 + > gdb/python/python.c | 1 + > 8 files changed, 1177 insertions(+) > create mode 100644 gdb/python/py-record-btrace.c > create mode 100644 gdb/python/py-record-btrace.h > create mode 100644 gdb/python/py-record-full.c > create mode 100644 gdb/python/py-record-full.h > > diff --git a/gdb/Makefile.in b/gdb/Makefile.in > index b4419f0..43253d3 100644 > --- a/gdb/Makefile.in > +++ b/gdb/Makefile.in > @@ -461,6 +461,8 @@ SUBDIR_PYTHON_OBS = \ > py-prettyprint.o \ > py-progspace.o \ > py-record.o \ > + py-record-btrace.o \ > + py-record-full.o \ > py-signalevent.o \ > py-stopevent.o \ > py-symbol.o \ > @@ -502,6 +504,8 @@ SUBDIR_PYTHON_SRCS = \ > python/py-prettyprint.c \ > python/py-progspace.c \ > python/py-record.c \ > + python/py-record-btrace.c \ > + python/py-record-full.c \ > python/py-signalevent.c \ > python/py-stopevent.c \ > python/py-symbol.c \ > diff --git a/gdb/python/py-record-btrace.c b/gdb/python/py-record-btrace.c > new file mode 100644 > index 0000000..6158f31 > --- /dev/null > +++ b/gdb/python/py-record-btrace.c > @@ -0,0 +1,1001 @@ > +/* Python interface to btrace instruction history. > + > + Copyright 2016-2017 Free Software Foundation, Inc. > + > + This file is part of GDB. > + > + This program is free software; you can redistribute it and/or modify > + it under the terms of the GNU General Public License as published by > + the Free Software Foundation; either version 3 of the License, or > + (at your option) any later version. > + > + This program is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + GNU General Public License for more details. > + > + You should have received a copy of the GNU General Public License > + along with this program. If not, see . */ > + > +#include "defs.h" > +#include "gdbcore.h" > +#include "gdbcmd.h" > +#include "gdbthread.h" > +#include "btrace.h" > +#include "py-record-btrace.h" > +#include "disasm.h" > + > +#if defined (IS_PY3K) > + > +#define BTPY_PYSLICE(x) (x) > + > +#else > + > +#define BTPY_PYSLICE(x) ((PySliceObject *) x) > + > +#endif > + > +#define BTPY_REQUIRE_VALID_INSN(obj, iter) \ > + do { \ > + struct thread_info *tinfo = find_thread_ptid (obj->ptid); \ > + if (tinfo == NULL || btrace_is_empty (tinfo)) \ > + return PyErr_Format (gdbpy_gdb_error, _("Empty branch trace."));\ > + if (0 == btrace_find_insn_by_number (&iter, &tinfo->btrace, \ > + obj->number)) \ > + return PyErr_Format (gdbpy_gdb_error, _("No such instruction."));\ > + } while (0) > + > +#define BTPY_REQUIRE_VALID_CALL(obj, iter) \ > + do { \ > + struct thread_info *tinfo = find_thread_ptid (obj->ptid); \ > + if (tinfo == NULL || btrace_is_empty (tinfo)) \ > + return PyErr_Format (gdbpy_gdb_error, _("Empty branch trace."));\ > + if (0 == btrace_find_call_by_number (&iter, &tinfo->btrace, \ > + obj->number)) \ > + return PyErr_Format (gdbpy_gdb_error, _("No such call segment."));\ > + } while (0) > + > +/* This can either be a btrace instruction or a function call segment, > + depending on the chosen type. */ > + > +typedef struct { > + PyObject_HEAD > + > + /* The thread this object belongs to. */ > + ptid_t ptid; > + > + /* Instruction number or function call segment number, depending on the type > + of this object. */ > + Py_ssize_t number; > +} btpy_object; > + > +/* Python object for btrace record lists. */ > + > +typedef struct { > + PyObject_HEAD > + > + /* The thread this list belongs to. */ > + ptid_t ptid; > + > + /* The first index being part of this list. */ > + Py_ssize_t first; > + > + /* The last index begin part of this list. */ > + Py_ssize_t last; > + > + /* Stride size. */ > + Py_ssize_t step; > + > + /* Either &BTPY_CALL_TYPE or &BTPY_INSN_TYPE. */ > + PyTypeObject* element_type; > +} btpy_list_object; > + > +/* Python type for btrace instructions. */ > + > +static PyTypeObject btpy_insn_type = { > + PyVarObject_HEAD_INIT (NULL, 0) > +}; > + > +/* Python type for btrace function-calls. */ > + > +static PyTypeObject btpy_call_type = { > + PyVarObject_HEAD_INIT (NULL, 0) > +}; > + > +/* Python type for btrace lists. */ > + > +static PyTypeObject btpy_list_type = { > + PyVarObject_HEAD_INIT (NULL, 0) > +}; > + > +/* Create a new gdb.BtraceInstruction or gdb.BtraceFunctionCall object, > + depending on TYPE. */ > + > +static PyObject * > +btpy_new (ptid_t ptid, Py_ssize_t number, PyTypeObject* type) > +{ > + btpy_object * const obj = PyObject_New (btpy_object, type); > + > + if (obj == NULL) > + return NULL; > + > + obj->ptid = ptid; > + obj->number = number; > + > + return (PyObject *) obj; > +} > + > +/* Create a new gdb.BtraceInstruction object. */ > + > +static PyObject * > +btpy_insn_new (ptid_t ptid, Py_ssize_t number) > +{ > + return btpy_new (ptid, number, &btpy_insn_type); > +} > + > +/* Create a new gdb.BtraceFunctionCall object. */ > + > +static PyObject * > +btpy_call_new (ptid_t ptid, Py_ssize_t number) > +{ > + return btpy_new (ptid, number, &btpy_call_type); > +} > + > +/* Create a new gdb.BtraceList object. */ > + > +static PyObject * > +btpy_list_new (ptid_t ptid, Py_ssize_t first, Py_ssize_t last, Py_ssize_t step, > + PyTypeObject *element_type) > +{ > + btpy_list_object * const obj = PyObject_New (btpy_list_object, > + &btpy_list_type); > + > + if (obj == NULL) > + return NULL; > + > + obj->ptid = ptid; > + obj->first = first; > + obj->last = last; > + obj->step = step; > + obj->element_type = element_type; > + > + return (PyObject *) obj; > +} > + > +/* Implementation of BtraceInstruction.number [int] and > + BtraceFunctionCall.number [int]. */ > + > +static PyObject * > +btpy_number (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + > + return PyInt_FromSsize_t (obj->number); > +} > + > +/* Implementation of BtraceInstruction.__hash__ () -> int and > + BtraceFunctionCall.__hash__ () -> int. */ > + > +static Py_hash_t > +btpy_hash (PyObject *self) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + > + return obj->number; > +} > + > +/* Implementation of BtraceInstruction.error [int]. Returns the > + error code for gaps. */ > + > +static PyObject * > +btpy_insn_error (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + struct btrace_insn_iterator iter; > + int error; > + > + BTPY_REQUIRE_VALID_INSN (obj, iter); > + > + error = btrace_insn_get_error (&iter); > + > + if (error == 0) > + Py_RETURN_NONE; > + > + return PyInt_FromLong (error); > +} > + > +/* Implementation of BtraceInstruction.sal [gdb.Symtab_and_line]. > + Return the SAL associated with this instruction. */ > + > +static PyObject * > +btpy_insn_sal (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_insn *insn; > + struct btrace_insn_iterator iter; > + PyObject *result = NULL; > + > + BTPY_REQUIRE_VALID_INSN (obj, iter); > + > + insn = btrace_insn_get (&iter); > + if (insn == NULL) > + Py_RETURN_NONE; > + > + TRY > + { > + result = symtab_and_line_to_sal_object (find_pc_line (insn->pc, 0)); > + } > + CATCH (except, RETURN_MASK_ALL) > + { > + GDB_PY_HANDLE_EXCEPTION (except); > + } > + END_CATCH > + > + return result; > +} > + > +/* Implementation of BtraceInstruction.pc [int]. Returns > + the instruction address. */ > + > +static PyObject * > +btpy_insn_pc (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_insn *insn; > + struct btrace_insn_iterator iter; > + > + BTPY_REQUIRE_VALID_INSN (obj, iter); > + > + insn = btrace_insn_get (&iter); > + if (insn == NULL) > + Py_RETURN_NONE; > + > + return gdb_py_long_from_ulongest (insn->pc); > +} > + > +/* Implementation of BtraceInstruction.size [int]. Returns > + the instruction size. */ > + > +static PyObject * > +btpy_insn_size (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_insn *insn; > + struct btrace_insn_iterator iter; > + > + BTPY_REQUIRE_VALID_INSN (obj, iter); > + > + insn = btrace_insn_get (&iter); > + if (insn == NULL) > + Py_RETURN_NONE; > + > + return PyInt_FromLong (insn->size); > +} > + > +/* Implementation of BtraceInstruction.is_speculative [bool]. > + Returns if this instruction was executed speculatively. */ > + > +static PyObject * > +btpy_insn_is_speculative (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_insn *insn; > + struct btrace_insn_iterator iter; > + > + BTPY_REQUIRE_VALID_INSN (obj, iter); > + > + insn = btrace_insn_get (&iter); > + if (insn == NULL) > + Py_RETURN_NONE; > + > + if (insn->flags & BTRACE_INSN_FLAG_SPECULATIVE) > + Py_RETURN_TRUE; > + else > + Py_RETURN_FALSE; > +} > + > +/* Implementation of BtraceInstruction.data [buffer]. > + Returns raw instruction data. */ > + > +static PyObject * > +btpy_insn_data (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_insn *insn; > + struct btrace_insn_iterator iter; > + gdb_byte *buffer = NULL; > + PyObject *object; > + > + BTPY_REQUIRE_VALID_INSN (obj, iter); > + > + insn = btrace_insn_get (&iter); > + if (insn == NULL) > + Py_RETURN_NONE; > + > + TRY > + { > + buffer = (gdb_byte *) xmalloc (insn->size); > + read_memory (insn->pc, buffer, insn->size); > + } > + CATCH (except, RETURN_MASK_ALL) > + { > + xfree (buffer); > + GDB_PY_HANDLE_EXCEPTION (except); > + } > + END_CATCH > + > + object = PyBytes_FromStringAndSize ((const char*) buffer, insn->size); > + xfree (buffer); > + > + if (object == NULL) > + return NULL; > + > + return PyMemoryView_FromObject (object); > +} > + > +/* Implementation of BtraceInstruction.decode [str]. Returns > + the instruction as human readable string. */ > + > +static PyObject * > +btpy_insn_decode (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_insn *insn; > + struct btrace_insn_iterator iter; > + string_file strfile; > + > + BTPY_REQUIRE_VALID_INSN (obj, iter); > + > + insn = btrace_insn_get (&iter); > + if (insn == NULL) > + { > + int error_code = btrace_insn_get_error (&iter); > + const struct btrace_config *config; > + > + config = btrace_conf (&find_thread_ptid (obj->ptid)->btrace); > + return PyBytes_FromString (btrace_decode_error (config->format, > + error_code)); > + } > + > + TRY > + { > + gdb_print_insn (target_gdbarch (), insn->pc, &strfile, NULL); > + } > + CATCH (except, RETURN_MASK_ALL) > + { > + gdbpy_convert_exception (except); > + return NULL; > + } > + END_CATCH > + > + > + return PyBytes_FromString (strfile.string ().c_str ()); > +} > + > +/* Implementation of BtraceFunctionCall.level [int]. Returns the > + call level. */ > + > +static PyObject * > +btpy_call_level (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_function *func; > + struct btrace_call_iterator iter; > + > + BTPY_REQUIRE_VALID_CALL (obj, iter); > + > + func = btrace_call_get (&iter); > + if (func == NULL) > + Py_RETURN_NONE; > + > + return PyInt_FromLong (iter.btinfo->level + func->level); > +} > + > +/* Implementation of BtraceFunctionCall.symbol [gdb.Symbol]. Returns > + the symbol associated with this function call. */ > + > +static PyObject * > +btpy_call_symbol (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_function *func; > + struct btrace_call_iterator iter; > + > + BTPY_REQUIRE_VALID_CALL (obj, iter); > + > + func = btrace_call_get (&iter); > + if (func == NULL) > + Py_RETURN_NONE; > + > + if (func->sym == NULL) > + Py_RETURN_NONE; > + > + return symbol_to_symbol_object (func->sym); > +} > + > +/* Implementation of BtraceFunctionCall.instructions [list]. > + Return the list of instructions that belong to this function call. */ > + > +static PyObject * > +btpy_call_instructions (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_function *func; > + struct btrace_call_iterator iter; > + unsigned int len; > + > + BTPY_REQUIRE_VALID_CALL (obj, iter); > + > + func = btrace_call_get (&iter); > + if (func == NULL) > + Py_RETURN_NONE; > + > + len = VEC_length (btrace_insn_s, func->insn); > + > + /* Gaps count as one instruction. */ > + if (len == 0) > + len = 1; > + > + return btpy_list_new (obj->ptid, func->insn_offset, func->insn_offset + len, > + 1, &btpy_insn_type); > +} > + > +/* Implementation of BtraceFunctionCall.up [gdb.BtraceRecordCall]. > + Return the caller / returnee of this function. */ > + > +static PyObject * > +btpy_call_up (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_function *func; > + struct btrace_call_iterator iter; > + > + BTPY_REQUIRE_VALID_CALL (obj, iter); > + > + func = btrace_call_get (&iter); > + if (func == NULL) > + Py_RETURN_NONE; > + > + if (func->up == NULL) > + Py_RETURN_NONE; > + > + return btpy_call_new (obj->ptid, func->up->number); > +} > + > +/* Implementation of BtraceFunctionCall.prev_sibling [BtraceFunctionCall]. > + Return a previous segment of this function. */ > + > +static PyObject * > +btpy_call_prev_sibling (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_function *func; > + struct btrace_call_iterator iter; > + > + BTPY_REQUIRE_VALID_CALL (obj, iter); > + > + func = btrace_call_get (&iter); > + if (func == NULL) > + Py_RETURN_NONE; > + > + if (func->segment.prev == NULL) > + Py_RETURN_NONE; > + > + return btpy_call_new (obj->ptid, func->segment.prev->number); > +} > + > +/* Implementation of BtraceFunctionCall.next_sibling [BtraceFunctionCall]. > + Return a following segment of this function. */ > + > +static PyObject * > +btpy_call_next_sibling (PyObject *self, void *closure) > +{ > + const btpy_object * const obj = (btpy_object *) self; > + const struct btrace_function *func; > + struct btrace_call_iterator iter; > + > + BTPY_REQUIRE_VALID_CALL (obj, iter); > + > + func = btrace_call_get (&iter); > + if (func == NULL) > + Py_RETURN_NONE; > + > + if (func->segment.next == NULL) > + Py_RETURN_NONE; > + > + return btpy_call_new (obj->ptid, func->segment.next->number); > +} > + > +/* Python rich compare function to allow for equality and inequality checks > + in Python. */ > + > +static PyObject * > +btpy_richcompare (PyObject *self, PyObject *other, int op) > +{ > + const btpy_object * const obj1 = (btpy_object *) self; > + const btpy_object * const obj2 = (btpy_object *) other; > + > + if (Py_TYPE (self) != Py_TYPE (other)) > + { > + Py_INCREF (Py_NotImplemented); > + return Py_NotImplemented; > + } > + > + switch (op) > + { > + case Py_EQ: > + if (ptid_equal (obj1->ptid, obj2->ptid) && obj1->number == obj2->number) > + Py_RETURN_TRUE; > + else > + Py_RETURN_FALSE; > + > + case Py_NE: > + if (!ptid_equal (obj1->ptid, obj2->ptid) || obj1->number != obj2->number) > + Py_RETURN_TRUE; > + else > + Py_RETURN_FALSE; > + > + default: > + break; > + } > + > + Py_INCREF (Py_NotImplemented); > + return Py_NotImplemented; > +} > + > +/* Implementation of BtraceList.__len__ (self) -> int. */ > + > +static Py_ssize_t > +btpy_list_length (PyObject *self) > +{ > + const btpy_list_object * const obj = (btpy_list_object *) self; > + const Py_ssize_t distance = obj->last - obj->first; > + const Py_ssize_t result = distance / obj->step; > + > + if ((distance % obj->step) == 0) > + return result; > + > + return result + 1; > +} > + > +/* Implementation of > + BtraceList.__getitem__ (self, key) -> BtraceInstruction and > + BtraceList.__getitem__ (self, key) -> BtraceFunctionCall. */ > + > +static PyObject * > +btpy_list_item (PyObject *self, Py_ssize_t index) > +{ > + const btpy_list_object * const obj = (btpy_list_object *) self; > + struct thread_info * const tinfo = find_thread_ptid (obj->ptid); > + > + if (index < 0 || index >= btpy_list_length (self)) > + return PyErr_Format (PyExc_IndexError, _("Index out of range: %zd."), > + index); > + > + return btpy_new (obj->ptid, obj->first + (obj->step * index), > + obj->element_type); > +} > + > +/* Implementation of BtraceList.__getitem__ (self, slice) -> BtraceList. */ > + > +static PyObject * > +btpy_list_slice (PyObject *self, PyObject *value) > +{ > + const btpy_list_object * const obj = (btpy_list_object *) self; > + const Py_ssize_t length = btpy_list_length (self); > + Py_ssize_t start, stop, step, slicelength; > + > + if (PyInt_Check (value)) > + { > + Py_ssize_t index = PyInt_AsSsize_t (value); > + > + /* Emulate Python behavior for negative indices. */ > + if (index < 0) > + index += length; > + > + return btpy_list_item (self, index); > + } > + > + if (!PySlice_Check (value)) > + return PyErr_Format (PyExc_TypeError, _("Index must be int or slice.")); > + > + if (0 != PySlice_GetIndicesEx (BTPY_PYSLICE (value), length, &start, &stop, > + &step, &slicelength)) > + return NULL; > + > + return btpy_list_new (obj->ptid, obj->first + obj->step * start, > + obj->first + obj->step * stop, obj->step * step, > + obj->element_type); > +} > + > +/* Helper function that returns the position of an element in a BtraceList > + or -1 if the element is not in the list. */ > + > +static LONGEST > +btpy_list_position (PyObject *self, PyObject *value) > +{ > + const btpy_list_object * const list_obj = (btpy_list_object *) self; > + const btpy_object * const obj = (btpy_object *) value; > + Py_ssize_t index = obj->number; > + > + if (list_obj->element_type != Py_TYPE (value)) > + return -1; > + > + if (!ptid_equal (list_obj->ptid, obj->ptid)) > + return -1; > + > + if (index < list_obj->first || index > list_obj->last) > + return -1; > + > + index -= list_obj->first; > + > + if (index % list_obj->step != 0) > + return -1; > + > + return index / list_obj->step; > +} > + > +/* Implementation of "in" operator for BtraceLists. */ > + > +static int > +btpy_list_contains (PyObject *self, PyObject *value) > +{ > + if (btpy_list_position (self, value) < 0) > + return 0; > + > + return 1; > +} > + > +/* Implementation of BtraceLists.index (self, value) -> int. */ > + > +static PyObject * > +btpy_list_index (PyObject *self, PyObject *value) > +{ > + const LONGEST index = btpy_list_position (self, value); > + > + if (index < 0) > + return PyErr_Format (PyExc_ValueError, _("Not in list.")); > + > + return gdb_py_long_from_longest (index); > +} > + > +/* Implementation of BtraceList.count (self, value) -> int. */ > + > +static PyObject * > +btpy_list_count (PyObject *self, PyObject *value) > +{ > + /* We know that if an element is in the list, it is so exactly one time, > + enabling us to reuse the "is element of" check. */ > + return PyInt_FromLong (btpy_list_contains (self, value)); > +} > + > +/* Python rich compare function to allow for equality and inequality checks > + in Python. */ > + > +static PyObject * > +btpy_list_richcompare (PyObject *self, PyObject *other, int op) > +{ > + const btpy_list_object * const obj1 = (btpy_list_object *) self; > + const btpy_list_object * const obj2 = (btpy_list_object *) other; > + > + if (Py_TYPE (self) != Py_TYPE (other)) > + { > + Py_INCREF (Py_NotImplemented); > + return Py_NotImplemented; > + } > + > + switch (op) > + { > + case Py_EQ: > + if (ptid_equal (obj1->ptid, obj2->ptid) > + && obj1->element_type == obj2->element_type > + && obj1->first == obj2->first > + && obj1->last == obj2->last > + && obj1->step == obj2->step) > + Py_RETURN_TRUE; > + else > + Py_RETURN_FALSE; > + > + case Py_NE: > + if (!ptid_equal (obj1->ptid, obj2->ptid) > + || obj1->element_type != obj2->element_type > + || obj1->first != obj2->first > + || obj1->last != obj2->last > + || obj1->step != obj2->step) > + Py_RETURN_TRUE; > + else > + Py_RETURN_FALSE; > + > + default: > + break; > + } > + > + Py_INCREF (Py_NotImplemented); > + return Py_NotImplemented; > +} > + > +/* Implementation of > + BtraceRecord.method [str]. */ > + > +PyObject * > +recpy_bt_method (PyObject *self, void *closure) > +{ > + return PyString_FromString ("btrace"); > +} > + > +/* Implementation of > + BtraceRecord.format [str]. */ > + > +PyObject * > +recpy_bt_format (PyObject *self, void *closure) > +{ > + const struct thread_info * const tinfo = find_thread_ptid (inferior_ptid); > + const struct btrace_config * config; > + > + if (tinfo == NULL) > + Py_RETURN_NONE; > + > + config = btrace_conf (&tinfo->btrace); > + > + if (config == NULL) > + Py_RETURN_NONE; > + > + return PyString_FromString (btrace_format_short_string (config->format)); > +} > + > +/* Implementation of > + BtraceRecord.replay_position [BtraceInstruction]. */ > + > +PyObject * > +recpy_bt_replay_position (PyObject *self, void *closure) > +{ > + const struct thread_info * const tinfo = find_thread_ptid (inferior_ptid); > + > + if (tinfo == NULL) > + Py_RETURN_NONE; > + > + if (tinfo->btrace.replay == NULL) > + Py_RETURN_NONE; > + > + return btpy_insn_new (inferior_ptid, > + btrace_insn_number (tinfo->btrace.replay)); > +} > + > +/* Implementation of > + BtraceRecord.begin [BtraceInstruction]. */ > + > +PyObject * > +recpy_bt_begin (PyObject *self, void *closure) > +{ > + struct thread_info * const tinfo = find_thread_ptid (inferior_ptid); > + struct btrace_insn_iterator iterator; > + > + if (tinfo == NULL) > + Py_RETURN_NONE; > + > + btrace_fetch (tinfo); > + > + if (btrace_is_empty (tinfo)) > + Py_RETURN_NONE; > + > + btrace_insn_begin (&iterator, &tinfo->btrace); > + return btpy_insn_new (inferior_ptid, btrace_insn_number (&iterator)); > +} > + > +/* Implementation of > + BtraceRecord.end [BtraceInstruction]. */ > + > +PyObject * > +recpy_bt_end (PyObject *self, void *closure) > +{ > + struct thread_info * const tinfo = find_thread_ptid (inferior_ptid); > + struct btrace_insn_iterator iterator; > + > + if (tinfo == NULL) > + Py_RETURN_NONE; > + > + btrace_fetch (tinfo); > + > + if (btrace_is_empty (tinfo)) > + Py_RETURN_NONE; > + > + btrace_insn_end (&iterator, &tinfo->btrace); > + return btpy_insn_new (inferior_ptid, btrace_insn_number (&iterator)); > +} > + > +/* Implementation of > + BtraceRecord.instruction_history [list]. */ > + > +PyObject * > +recpy_bt_instruction_history (PyObject *self, void *closure) > +{ > + struct thread_info * const tinfo = find_thread_ptid (inferior_ptid); > + struct btrace_insn_iterator iterator; > + unsigned long first = 0; > + unsigned long last = 0; > + > + if (tinfo == NULL) > + Py_RETURN_NONE; > + > + btrace_fetch (tinfo); > + > + if (btrace_is_empty (tinfo)) > + Py_RETURN_NONE; > + > + btrace_insn_begin (&iterator, &tinfo->btrace); > + first = btrace_insn_number (&iterator); > + > + btrace_insn_end (&iterator, &tinfo->btrace); > + last = btrace_insn_number (&iterator); > + > + return btpy_list_new (inferior_ptid, first, last, 1, &btpy_insn_type); > +} > + > +/* Implementation of > + BtraceRecord.function_call_history [list]. */ > + > +PyObject * > +recpy_bt_function_call_history (PyObject *self, void *closure) > +{ > + struct thread_info * const tinfo = find_thread_ptid (inferior_ptid); > + struct btrace_call_iterator iterator; > + unsigned long first = 0; > + unsigned long last = 0; > + > + if (tinfo == NULL) > + Py_RETURN_NONE; > + > + btrace_fetch (tinfo); > + > + if (btrace_is_empty (tinfo)) > + Py_RETURN_NONE; > + > + btrace_call_begin (&iterator, &tinfo->btrace); > + first = btrace_call_number (&iterator); > + > + btrace_call_end (&iterator, &tinfo->btrace); > + last = btrace_call_number (&iterator); > + > + return btpy_list_new (inferior_ptid, first, last, 1, &btpy_call_type); > +} > + > +/* Implementation of BtraceRecord.goto (self, BtraceInstruction) -> None. */ > + > +PyObject * > +recpy_bt_goto (PyObject *self, PyObject *args) > +{ > + struct thread_info * const tinfo = find_thread_ptid (inferior_ptid); > + const btpy_object *obj; > + > + if (tinfo == NULL || btrace_is_empty (tinfo)) > + return PyErr_Format (gdbpy_gdb_error, _("Empty branch trace.")); > + > + if (!PyArg_ParseTuple (args, "O", &obj)) > + return NULL; > + > + if (Py_TYPE (obj) != &btpy_insn_type) > + return PyErr_Format (PyExc_TypeError, _("Argument must be instruction.")); > + > + TRY > + { > + struct btrace_insn_iterator iter; > + > + btrace_insn_end (&iter, &tinfo->btrace); > + > + if (btrace_insn_number (&iter) == obj->number) > + target_goto_record_end (); > + else > + target_goto_record (obj->number); > + } > + CATCH (except, RETURN_MASK_ALL) > + { > + GDB_PY_HANDLE_EXCEPTION (except); > + } > + END_CATCH > + > + Py_RETURN_NONE; > +} > + > +/* BtraceInstruction members. */ > + > +struct PyGetSetDef btpy_insn_getset[] = > +{ > + { "number", btpy_number, NULL, "instruction number", NULL}, > + { "error", btpy_insn_error, NULL, "error number for gaps", NULL}, > + { "sal", btpy_insn_sal, NULL, "associated symbol and line", NULL}, > + { "pc", btpy_insn_pc, NULL, "instruction address", NULL}, > + { "data", btpy_insn_data, NULL, "raw instruction data", NULL}, > + { "decoded", btpy_insn_decode, NULL, "decoded instruction or error message \ > +if the instruction is a gap", NULL}, > + { "size", btpy_insn_size, NULL, "instruction size in byte", NULL}, > + { "is_speculative", btpy_insn_is_speculative, NULL, "if the instruction was \ > +executed speculatively", NULL}, > + {NULL} > +}; > + > +/* BtraceFunctionCall members. */ > + > +static PyGetSetDef btpy_call_getset[] = > +{ > + { "number", btpy_number, NULL, "function call number", NULL}, > + { "level", btpy_call_level, NULL, "call stack level", NULL}, > + { "symbol", btpy_call_symbol, NULL, "associated line and symbol", NULL}, > + { "instructions", btpy_call_instructions, NULL, "list of instructions in \ > +this function segment", NULL}, > + { "up", btpy_call_up, NULL, "caller or returned-to function segment", NULL}, > + { "prev_sibling", btpy_call_prev_sibling, NULL, "previous segment of this \ > +function", NULL}, > + { "next_sibling", btpy_call_next_sibling, NULL, "next segment of this \ > +function", NULL}, > + {NULL} > +}; > + > +/* BtraceList methods. */ > + > +struct PyMethodDef btpy_list_methods[] = > +{ > + { "count", btpy_list_count, METH_O, "count number of occurences"}, > + { "index", btpy_list_index, METH_O, "index of entry"}, > + {NULL} > +}; > + > +/* BtraceList sequence methods. */ > + > +static PySequenceMethods btpy_list_sequence_methods = > +{ > + NULL > +}; > + > +/* BtraceList mapping methods. Necessary for slicing. */ > + > +static PyMappingMethods btpy_list_mapping_methods = > +{ > + NULL > +}; > + > +/* Sets up the btrace record API. */ > + > +int > +gdbpy_initialize_btrace (void) > +{ > + btpy_insn_type.tp_new = PyType_GenericNew; > + btpy_insn_type.tp_flags = Py_TPFLAGS_DEFAULT; > + btpy_insn_type.tp_basicsize = sizeof (btpy_object); > + btpy_insn_type.tp_name = "gdb.BtraceInstruction"; > + btpy_insn_type.tp_doc = "GDB btrace instruction object"; > + btpy_insn_type.tp_getset = btpy_insn_getset; > + btpy_insn_type.tp_richcompare = btpy_richcompare; > + btpy_insn_type.tp_hash = btpy_hash; > + > + btpy_call_type.tp_new = PyType_GenericNew; > + btpy_call_type.tp_flags = Py_TPFLAGS_DEFAULT; > + btpy_call_type.tp_basicsize = sizeof (btpy_object); > + btpy_call_type.tp_name = "gdb.BtraceFunctionCall"; > + btpy_call_type.tp_doc = "GDB btrace call object"; > + btpy_call_type.tp_getset = btpy_call_getset; > + btpy_call_type.tp_richcompare = btpy_richcompare; > + btpy_call_type.tp_hash = btpy_hash; > + > + btpy_list_type.tp_new = PyType_GenericNew; > + btpy_list_type.tp_flags = Py_TPFLAGS_DEFAULT; > + btpy_list_type.tp_basicsize = sizeof (btpy_list_object); > + btpy_list_type.tp_name = "gdb.BtraceObjectList"; > + btpy_list_type.tp_doc = "GDB btrace list object"; > + btpy_list_type.tp_methods = btpy_list_methods; > + btpy_list_type.tp_as_sequence = &btpy_list_sequence_methods; > + btpy_list_type.tp_as_mapping = &btpy_list_mapping_methods; > + btpy_list_type.tp_richcompare = btpy_list_richcompare; > + > + btpy_list_sequence_methods.sq_item = btpy_list_item; > + btpy_list_sequence_methods.sq_length = btpy_list_length; > + btpy_list_sequence_methods.sq_contains = btpy_list_contains; > + > + btpy_list_mapping_methods.mp_subscript = btpy_list_slice; > + > + if (PyType_Ready (&btpy_insn_type) < 0 > + || PyType_Ready (&btpy_call_type) < 0 > + || PyType_Ready (&btpy_list_type) < 0) > + return -1; > + else > + return 0; > +} > diff --git a/gdb/python/py-record-btrace.h b/gdb/python/py-record-btrace.h > new file mode 100644 > index 0000000..aefb1e4 > --- /dev/null > +++ b/gdb/python/py-record-btrace.h > @@ -0,0 +1,49 @@ > +/* Python interface to btrace record targets. > + > + Copyright 2016-2017 Free Software Foundation, Inc. > + > + This file is part of GDB. > + > + This program is free software; you can redistribute it and/or modify > + it under the terms of the GNU General Public License as published by > + the Free Software Foundation; either version 3 of the License, or > + (at your option) any later version. > + > + This program is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + GNU General Public License for more details. > + > + You should have received a copy of the GNU General Public License > + along with this program. If not, see . */ > + > +#ifndef GDB_PY_RECORD_BTRACE_H > +#define GDB_PY_RECORD_BTRACE_H > + > +#include "python-internal.h" > + > +/* Implementation of record.method [str]. */ > +extern PyObject *recpy_bt_method (PyObject *self, void *closure); > + > +/* Implementation of record.format [str]. */ > +extern PyObject *recpy_bt_format (PyObject *self, void *closure); > + > +/* Implementation of record.goto (instruction) -> None. */ > +extern PyObject *recpy_bt_goto (PyObject *self, PyObject *value); > + > +/* Implementation of record.instruction_history [list]. */ > +extern PyObject *recpy_bt_instruction_history (PyObject *self, void *closure); > + > +/* Implementation of record.function_call_history [list]. */ > +extern PyObject *recpy_bt_function_call_history (PyObject *self, void *closure); > + > +/* Implementation of record.replay_position [instruction]. */ > +extern PyObject *recpy_bt_replay_position (PyObject *self, void *closure); > + > +/* Implementation of record.begin [instruction]. */ > +extern PyObject *recpy_bt_begin (PyObject *self, void *closure); > + > +/* Implementation of record.end [instruction]. */ > +extern PyObject *recpy_bt_end (PyObject *self, void *closure); > + > +#endif /* GDB_PY_RECORD_BTRACE_H */ > diff --git a/gdb/python/py-record-full.c b/gdb/python/py-record-full.c > new file mode 100644 > index 0000000..06e6693 > --- /dev/null > +++ b/gdb/python/py-record-full.c > @@ -0,0 +1,39 @@ > +/* Python interface to btrace instruction history. > + > + Copyright 2016-2017 Free Software Foundation, Inc. > + > + This file is part of GDB. > + > + This program is free software; you can redistribute it and/or modify > + it under the terms of the GNU General Public License as published by > + the Free Software Foundation; either version 3 of the License, or > + (at your option) any later version. > + > + This program is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + GNU General Public License for more details. > + > + You should have received a copy of the GNU General Public License > + along with this program. If not, see . */ > + > +#include "defs.h" > +#include "py-record-full.h" > + > +/* Implementation of > + BtraceRecord.method [str]. */ > + > +PyObject * > +recpy_full_method (PyObject *self, void *closure) > +{ > + return PyString_FromString ("full"); > +} > + > +/* Implementation of > + BtraceRecord.format [str]. */ > + > +PyObject * > +recpy_full_format (PyObject *self, void *closure) > +{ > + return PyString_FromString ("full"); > +} > diff --git a/gdb/python/py-record-full.h b/gdb/python/py-record-full.h > new file mode 100644 > index 0000000..30acc51 > --- /dev/null > +++ b/gdb/python/py-record-full.h > @@ -0,0 +1,31 @@ > +/* Python interface to full record targets. > + > + Copyright 2016-2017 Free Software Foundation, Inc. > + > + This file is part of GDB. > + > + This program is free software; you can redistribute it and/or modify > + it under the terms of the GNU General Public License as published by > + the Free Software Foundation; either version 3 of the License, or > + (at your option) any later version. > + > + This program is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + GNU General Public License for more details. > + > + You should have received a copy of the GNU General Public License > + along with this program. If not, see . */ > + > +#ifndef GDB_PY_RECORD_FULL_H > +#define GDB_PY_RECORD_FULL_H > + > +#include "python-internal.h" > + > +/* Implementation of record.method [str]. */ > +extern PyObject *recpy_full_method (PyObject *self, void *value); > + > +/* Implementation of record.format [str]. */ > +extern PyObject *recpy_full_format (PyObject *self, void *value); > + > +#endif /* GDB_PY_RECORD_FULL_H */ > diff --git a/gdb/python/py-record.c b/gdb/python/py-record.c > index 27ecbb6..72922a4 100644 > --- a/gdb/python/py-record.c > +++ b/gdb/python/py-record.c > @@ -21,6 +21,8 @@ > #include "inferior.h" > #include "record.h" > #include "python-internal.h" > +#include "py-record-btrace.h" > +#include "py-record-full.h" > #include "target.h" > > /* Python Record object. */ > @@ -57,6 +59,14 @@ recpy_ptid (PyObject *self, void* closure) > static PyObject * > recpy_method (PyObject *self, void* closure) > { > + const recpy_record_object * const obj = (recpy_record_object *) self; > + > + if (obj->method == RECORD_METHOD_FULL) > + return recpy_full_method (self, closure); > + > + if (obj->method == RECORD_METHOD_BTRACE) > + return recpy_bt_method (self, closure); > + > return PyErr_Format (PyExc_NotImplementedError, _("Not implemented.")); > } > > @@ -65,6 +75,14 @@ recpy_method (PyObject *self, void* closure) > static PyObject * > recpy_format (PyObject *self, void* closure) > { > + const recpy_record_object * const obj = (recpy_record_object *) self; > + > + if (obj->method == RECORD_METHOD_FULL) > + return recpy_full_format (self, closure); > + > + if (obj->method == RECORD_METHOD_BTRACE) > + return recpy_bt_format (self, closure); > + > return PyErr_Format (PyExc_NotImplementedError, _("Not implemented.")); > } > > @@ -73,6 +91,11 @@ recpy_format (PyObject *self, void* closure) > static PyObject * > recpy_goto (PyObject *self, PyObject *value) > { > + const recpy_record_object * const obj = (recpy_record_object *) self; > + > + if (obj->method == RECORD_METHOD_BTRACE) > + return recpy_bt_goto (self, value); > + > return PyErr_Format (PyExc_NotImplementedError, _("Not implemented.")); > } > > @@ -81,6 +104,11 @@ recpy_goto (PyObject *self, PyObject *value) > static PyObject * > recpy_replay_position (PyObject *self, void *closure) > { > + const recpy_record_object * const obj = (recpy_record_object *) self; > + > + if (obj->method == RECORD_METHOD_BTRACE) > + return recpy_bt_replay_position (self, closure); > + > return PyErr_Format (PyExc_NotImplementedError, _("Not implemented.")); > } > > @@ -89,6 +117,11 @@ recpy_replay_position (PyObject *self, void *closure) > static PyObject * > recpy_instruction_history (PyObject *self, void* closure) > { > + const recpy_record_object * const obj = (recpy_record_object *) self; > + > + if (obj->method == RECORD_METHOD_BTRACE) > + return recpy_bt_instruction_history (self, closure); > + > return PyErr_Format (PyExc_NotImplementedError, _("Not implemented.")); > } > > @@ -97,6 +130,11 @@ recpy_instruction_history (PyObject *self, void* closure) > static PyObject * > recpy_function_call_history (PyObject *self, void* closure) > { > + const recpy_record_object * const obj = (recpy_record_object *) self; > + > + if (obj->method == RECORD_METHOD_BTRACE) > + return recpy_bt_function_call_history (self, closure); > + > return PyErr_Format (PyExc_NotImplementedError, _("Not implemented.")); > } > > @@ -105,6 +143,11 @@ recpy_function_call_history (PyObject *self, void* closure) > static PyObject * > recpy_begin (PyObject *self, void* closure) > { > + const recpy_record_object * const obj = (recpy_record_object *) self; > + > + if (obj->method == RECORD_METHOD_BTRACE) > + return recpy_bt_begin (self, closure); > + > return PyErr_Format (PyExc_NotImplementedError, _("Not implemented.")); > } > > @@ -113,6 +156,11 @@ recpy_begin (PyObject *self, void* closure) > static PyObject * > recpy_end (PyObject *self, void* closure) > { > + const recpy_record_object * const obj = (recpy_record_object *) self; > + > + if (obj->method == RECORD_METHOD_BTRACE) > + return recpy_bt_end (self, closure); > + > return PyErr_Format (PyExc_NotImplementedError, _("Not implemented.")); > } > > diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h > index c6af9f7..4dd413d 100644 > --- a/gdb/python/python-internal.h > +++ b/gdb/python/python-internal.h > @@ -104,7 +104,9 @@ > > #define PyInt_Check PyLong_Check > #define PyInt_FromLong PyLong_FromLong > +#define PyInt_FromSsize_t PyLong_FromSsize_t > #define PyInt_AsLong PyLong_AsLong > +#define PyInt_AsSsize_t PyLong_AsSsize_t > > #define PyString_FromString PyUnicode_FromString > #define PyString_Decode PyUnicode_Decode > @@ -439,6 +441,8 @@ int gdbpy_initialize_values (void) > CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; > int gdbpy_initialize_frames (void) > CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; > +int gdbpy_initialize_btrace (void) > + CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; > int gdbpy_initialize_record (void) > CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; > int gdbpy_initialize_symtabs (void) > diff --git a/gdb/python/python.c b/gdb/python/python.c > index f8b9f7e..f878f9a 100644 > --- a/gdb/python/python.c > +++ b/gdb/python/python.c > @@ -1629,6 +1629,7 @@ do_start_initialization () > || gdbpy_initialize_frames () < 0 > || gdbpy_initialize_commands () < 0 > || gdbpy_initialize_record () < 0 > + || gdbpy_initialize_btrace () < 0 > || gdbpy_initialize_symbols () < 0 > || gdbpy_initialize_symtabs () < 0 > || gdbpy_initialize_blocks () < 0