From 90298e32a478da3b4514d2c021d49dee56ac910a Mon Sep 17 00:00:00 2001 From: Kosmonit Date: Fri, 20 Feb 2015 12:18:44 +0300 Subject: [PATCH 1/2] Support Windows under MS Visual Studio 2005 or higher --- IMG.cpp | 157 +++---- IMG.h | 62 +-- INS.cpp | 1039 +++++++++++++++++++++++---------------------- INS.h | 242 +++++------ Python_Pin.cpp | 185 ++++---- Python_Pin.sln | 19 + Python_Pin.vcproj | 263 ++++++++++++ README.md | 4 + REG.cpp | 125 +++--- REG.h | 32 +- RTN.cpp | 312 +++++++------- RTN.h | 34 +- SYS.cpp | 53 +-- SYS.h | 10 +- TRACE.cpp | 167 ++++---- TRACE.h | 54 +-- python_pin.h | 42 +- 17 files changed, 1557 insertions(+), 1243 deletions(-) create mode 100644 Python_Pin.sln create mode 100644 Python_Pin.vcproj diff --git a/IMG.cpp b/IMG.cpp index 6683ff2..853cf65 100644 --- a/IMG.cpp +++ b/IMG.cpp @@ -9,205 +9,208 @@ */ -#include #include "pin.H" -#include +namespace SPPY +{ +#include +} +#include #include #include "IMG.h" -PyObject* Python_IMG_Next(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Next(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG* img_object = (IMG*) malloc(sizeof(IMG)); *img_object = IMG_Next(*(IMG*)PyInt_AsLong(img)); - return Py_BuildValue("k", img_object); + return SPPY::Py_BuildValue("k", img_object); } -PyObject* Python_IMG_Prev(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Prev(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG* img_object = (IMG*) malloc(sizeof(IMG)); *img_object = IMG_Prev(*(IMG*)PyInt_AsLong(img)); - return Py_BuildValue("k", img_object); + return SPPY::Py_BuildValue("k", img_object); } -PyObject* Python_IMG_Invalid(PyObject* self, PyObject* args) { +SPPY::PyObject* Python_IMG_Invalid(SPPY::PyObject* self, SPPY::PyObject* args) { IMG* img_object = (IMG*) malloc(sizeof(IMG)); *img_object = IMG_Invalid(); - return Py_BuildValue("k", img_object); + return SPPY::Py_BuildValue("k", img_object); } -PyObject* Python_IMG_Valid(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Valid(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); if (IMG_Valid(img_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } -PyObject* Python_IMG_SecHead(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_SecHead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); SEC* sec = (SEC*) malloc(sizeof(SEC)); *sec = IMG_SecHead(img_object); - return Py_BuildValue("k", sec); + return SPPY::Py_BuildValue("k", sec); } -PyObject* Python_IMG_SecTail(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_SecTail(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); SEC* sec = (SEC*) malloc(sizeof(SEC)); *sec = IMG_SecTail(img_object); - return Py_BuildValue("k", sec); + return SPPY::Py_BuildValue("k", sec); } -PyObject* Python_IMG_RegsymHead(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_RegsymHead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); // IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_IMG_Entry(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Entry(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_Entry(img_object)); + return SPPY::Py_BuildValue("k", IMG_Entry(img_object)); } -PyObject* Python_IMG_Name(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Name(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("s", IMG_Name(img_object).c_str()); + return SPPY::Py_BuildValue("s", IMG_Name(img_object).c_str()); } -PyObject* Python_IMG_Gp(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Gp(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_Gp(img_object)); + return SPPY::Py_BuildValue("k", IMG_Gp(img_object)); } -PyObject* Python_IMG_LoadOffset(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_LoadOffset(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_LoadOffset(img_object)); + return SPPY::Py_BuildValue("k", IMG_LoadOffset(img_object)); } -PyObject* Python_IMG_LowAddress(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_LowAddress(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_LowAddress(img_object)); + return SPPY::Py_BuildValue("k", IMG_LowAddress(img_object)); } -PyObject* Python_IMG_HighAddress(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_HighAddress(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_HighAddress(img_object)); + return SPPY::Py_BuildValue("k", IMG_HighAddress(img_object)); } -PyObject* Python_IMG_StartAddress(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_StartAddress(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_StartAddress(img_object)); + return SPPY::Py_BuildValue("k", IMG_StartAddress(img_object)); } -PyObject* Python_IMG_SizeMapped(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_SizeMapped(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_SizeMapped(img_object)); + return SPPY::Py_BuildValue("k", IMG_SizeMapped(img_object)); } -PyObject* Python_IMG_Type(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Type(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_Type(img_object)); + return SPPY::Py_BuildValue("k", IMG_Type(img_object)); } -PyObject* Python_IMG_IsMainExecutable(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_IsMainExecutable(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); if (IMG_IsMainExecutable(img_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } -PyObject* Python_IMG_IsStaticExecutable(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_IsStaticExecutable(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); if (IMG_IsStaticExecutable(img_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } -PyObject* Python_IMG_Id(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Id(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); - return Py_BuildValue("k", IMG_Id(img_object)); + return SPPY::Py_BuildValue("k", IMG_Id(img_object)); } -PyObject* Python_IMG_FindImgById(PyObject* self, PyObject* args) { - PyObject* id; +SPPY::PyObject* Python_IMG_FindImgById(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* id; PyArg_ParseTuple(args, "O", &id); IMG* img = (IMG*) malloc(sizeof(IMG)); *img = IMG_FindImgById((UINT32) PyInt_AsLong(id)); - return Py_BuildValue("k", img); + return SPPY::Py_BuildValue("k", img); } -PyObject* Python_IMG_FindByAddress(PyObject* self, PyObject* args) { - PyObject* address; +SPPY::PyObject* Python_IMG_FindByAddress(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* address; PyArg_ParseTuple(args, "O", &address); IMG* img = (IMG*) malloc(sizeof(IMG)); *img = IMG_FindByAddress((ADDRINT) PyInt_AsLong(address)); - return Py_BuildValue("k", img); + return SPPY::Py_BuildValue("k", img); } -PyObject* Python_IMG_Open(PyObject* self, PyObject* args) { - PyObject* filename; +SPPY::PyObject* Python_IMG_Open(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* filename; PyArg_ParseTuple(args, "O", &filename); IMG* img = (IMG*) malloc(sizeof(IMG)); *img = IMG_Open(PyString_AsString(filename)); - return Py_BuildValue("k", img); + return SPPY::Py_BuildValue("k", img); } -PyObject* Python_IMG_Close(PyObject* self, PyObject* args) { - PyObject* img; +SPPY::PyObject* Python_IMG_Close(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; PyArg_ParseTuple(args, "O", &img); IMG img_object = *(IMG*)PyInt_AsLong(img); IMG_Close(img_object); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_APP_ImgHead(PyObject* self, PyObject* args) { +SPPY::PyObject* Python_APP_ImgHead(SPPY::PyObject* self, SPPY::PyObject* args) { IMG* img = (IMG*) malloc(sizeof(IMG)); *img = APP_ImgHead(); - return Py_BuildValue("k", img); + return SPPY::Py_BuildValue("k", img); } -PyObject* Python_APP_ImgTail(PyObject* self, PyObject* args) { +SPPY::PyObject* Python_APP_ImgTail(SPPY::PyObject* self, SPPY::PyObject* args) { IMG* img = (IMG*) malloc(sizeof(IMG)); *img = APP_ImgTail(); - return Py_BuildValue("k", img); + return SPPY::Py_BuildValue("k", img); } diff --git a/IMG.h b/IMG.h index bca6cdc..2cffd84 100644 --- a/IMG.h +++ b/IMG.h @@ -1,16 +1,16 @@ #ifndef A_H #define A_H -// void add_hook(PyObject*** hooks, PyObject* new_hook); -// PyObject** hooks_list = *hooks; +// void add_hook(SPPY::PyObject*** hooks, SPPY::PyObject* new_hook); +// SPPY::PyObject** hooks_list = *hooks; // if (hooks_list == NULL) { -// hooks_list = (PyObject**) malloc(sizeof(PyObject*)*2); +// hooks_list = (SPPY::PyObject**) malloc(sizeof(SPPY::PyObject*)*2); // hooks_list[0] = new_hook; // hooks_list[1] = NULL; // } else { // int hook_count; // for(hook_count=0; hooks_list[hook_count]; hook_count++); -// hooks_list = (PyObject**) realloc(hooks_list, sizeof(PyObject*)*(hook_count+2)); +// hooks_list = (SPPY::PyObject**) realloc(hooks_list, sizeof(SPPY::PyObject*)*(hook_count+2)); // hooks_list[hook_count] = new_hook; // hooks_list[hook_count+1] = NULL; // } @@ -18,32 +18,32 @@ // *hooks = hooks_list; // } // ------------------- auto generated -PyObject* Python_IMG_Next(PyObject* self, PyObject* args); -PyObject* Python_IMG_Prev(PyObject* self, PyObject* args); -PyObject* Python_IMG_Invalid(PyObject* self, PyObject* args); -PyObject* Python_IMG_Valid(PyObject* self, PyObject* args); -PyObject* Python_IMG_SecHead(PyObject* self, PyObject* args); -PyObject* Python_IMG_SecTail(PyObject* self, PyObject* args); -PyObject* Python_IMG_RegsymHead(PyObject* self, PyObject* args); -PyObject* Python_IMG_Entry(PyObject* self, PyObject* args); -PyObject* Python_IMG_Name(PyObject* self, PyObject* args) ; -PyObject* Python_IMG_Gp(PyObject* self, PyObject* args) ; -PyObject* Python_IMG_LoadOffset(PyObject* self, PyObject* args) ; -PyObject* Python_IMG_LowAddress(PyObject* self, PyObject* args); -PyObject* Python_IMG_HighAddress(PyObject* self, PyObject* args); -PyObject* Python_IMG_StartAddress(PyObject* self, PyObject* args); -PyObject* Python_IMG_SizeMapped(PyObject* self, PyObject* args); -PyObject* Python_IMG_Type(PyObject* self, PyObject* args); -PyObject* Python_IMG_IsMainExecutable(PyObject* self, PyObject* args); -PyObject* Python_IMG_IsStaticExecutable(PyObject* self, PyObject* args); -PyObject* Python_IMG_Id(PyObject* self, PyObject* args); -PyObject* Python_IMG_FindImgById(PyObject* self, PyObject* args); -PyObject* Python_IMG_FindByAddress(PyObject* self, PyObject* args); -PyObject* Python_IMG_AddInstrumentFunction(PyObject* self, PyObject* args); -PyObject* Python_IMG_AddUnloadFunction(PyObject* self, PyObject* args); -PyObject* Python_IMG_Open(PyObject* self, PyObject* args); -PyObject* Python_IMG_Close(PyObject* self, PyObject* args); -PyObject* Python_APP_ImgHead(PyObject* self, PyObject* args); -PyObject* Python_APP_ImgTail(PyObject* self, PyObject* args); +SPPY::PyObject* Python_IMG_Next(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Prev(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Invalid(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Valid(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_SecHead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_SecTail(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_RegsymHead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Entry(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Name(SPPY::PyObject* self, SPPY::PyObject* args) ; +SPPY::PyObject* Python_IMG_Gp(SPPY::PyObject* self, SPPY::PyObject* args) ; +SPPY::PyObject* Python_IMG_LoadOffset(SPPY::PyObject* self, SPPY::PyObject* args) ; +SPPY::PyObject* Python_IMG_LowAddress(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_HighAddress(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_StartAddress(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_SizeMapped(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Type(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_IsMainExecutable(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_IsStaticExecutable(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Id(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_FindImgById(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_FindByAddress(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_AddInstrumentFunction(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_AddUnloadFunction(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Open(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_IMG_Close(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_APP_ImgHead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_APP_ImgTail(SPPY::PyObject* self, SPPY::PyObject* args); #endif diff --git a/INS.cpp b/INS.cpp index fcb19e3..14ed9b5 100644 --- a/INS.cpp +++ b/INS.cpp @@ -1,29 +1,32 @@ -#include #include "pin.H" +namespace SPPY +{ +#include +} #include "INS.h" -void INS_IPOINT_BEFORE(PyObject* callback, INS ins_object, UINT32 num_operands, unsigned int rax, unsigned int rbx, unsigned int rcx, unsigned int rdx, unsigned int rdi, unsigned int rsi, unsigned int rbp, unsigned int rsp, UINT64 memop0, unsigned int memop1, unsigned int memop2) { - PyObject* dict = PyDict_New(); - PyObject* arguments = PyTuple_New(1); +void INS_IPOINT_BEFORE(SPPY::PyObject* callback, INS ins_object, UINT32 num_operands, unsigned int rax, unsigned int rbx, unsigned int rcx, unsigned int rdx, unsigned int rdi, unsigned int rsi, unsigned int rbp, unsigned int rsp, UINT64 memop0, unsigned int memop1, unsigned int memop2) { + SPPY::PyObject* dict = SPPY::PyDict_New(); + SPPY::PyObject* arguments = SPPY::PyTuple_New(1); #ifdef __i386__ - PyDict_SetItemString(dict, "REG_EAX", PyInt_FromLong(rax)); - PyDict_SetItemString(dict, "REG_EBX", PyInt_FromLong(rbx)); - PyDict_SetItemString(dict, "REG_ECX", PyInt_FromLong(rcx)); - PyDict_SetItemString(dict, "REG_EDX", PyInt_FromLong(rdx)); - PyDict_SetItemString(dict, "REG_EDI", PyInt_FromLong(rdi)); - PyDict_SetItemString(dict, "REG_ESI", PyInt_FromLong(rsi)); - PyDict_SetItemString(dict, "REG_EBP", PyInt_FromLong(rbp)); - PyDict_SetItemString(dict, "REG_ESP", PyInt_FromLong(rsp)); + SPPY::PyDict_SetItemString(dict, "REG_EAX", SPPY::PyInt_FromLong(rax)); + SPPY::PyDict_SetItemString(dict, "REG_EBX", SPPY::PyInt_FromLong(rbx)); + SPPY::PyDict_SetItemString(dict, "REG_ECX", SPPY::PyInt_FromLong(rcx)); + SPPY::PyDict_SetItemString(dict, "REG_EDX", SPPY::PyInt_FromLong(rdx)); + SPPY::PyDict_SetItemString(dict, "REG_EDI", SPPY::PyInt_FromLong(rdi)); + SPPY::PyDict_SetItemString(dict, "REG_ESI", SPPY::PyInt_FromLong(rsi)); + SPPY::PyDict_SetItemString(dict, "REG_EBP", SPPY::PyInt_FromLong(rbp)); + SPPY::PyDict_SetItemString(dict, "REG_ESP", SPPY::PyInt_FromLong(rsp)); switch (num_operands) { case 0: break; case 1: - PyDict_SetItemString(dict, "MEM_OP0", PyInt_FromLong(memop0)); + SPPY::PyDict_SetItemString(dict, "MEM_OP0", SPPY::PyInt_FromLong(memop0)); case 2: - PyDict_SetItemString(dict, "MEM_OP1", PyInt_FromLong(memop1)); + SPPY::PyDict_SetItemString(dict, "MEM_OP1", SPPY::PyInt_FromLong(memop1)); case 3: - PyDict_SetItemString(dict, "MEM_OP2", PyInt_FromLong(memop2)); + SPPY::PyDict_SetItemString(dict, "MEM_OP2", SPPY::PyInt_FromLong(memop2)); break; } @@ -43,51 +46,51 @@ void INS_IPOINT_BEFORE(PyObject* callback, INS ins_object, UINT32 num_operands, } - PyDict_SetItemString(dict, "VAL", PyInt_FromLong(k)); - PyDict_SetItemString(dict, "REG_RAX", PyInt_FromLong(rax)); - PyDict_SetItemString(dict, "REG_RBX", PyInt_FromLong(rbx)); - PyDict_SetItemString(dict, "REG_RCX", PyInt_FromLong(rcx)); - PyDict_SetItemString(dict, "REG_RDX", PyInt_FromLong(rdx)); - PyDict_SetItemString(dict, "REG_RDI", PyInt_FromLong(rdi)); - PyDict_SetItemString(dict, "REG_RSI", PyInt_FromLong(rsi)); - PyDict_SetItemString(dict, "REG_RBP", PyInt_FromLong(rbp)); - PyDict_SetItemString(dict, "REG_RSP", PyInt_FromLong(rsp)); - PyDict_SetItemString(dict, "IP", PyInt_FromLong(INS_Address(ins_object))); - // PyDict_SetItemString(dict, "EA", PyInt_FromLong(ea)); - PyDict_SetItemString(dict, "mnemonic", PyString_FromString(INS_Disassemble(ins_object).c_str())); + SPPY::PyDict_SetItemString(dict, "VAL", SPPY::PyInt_FromLong(k)); + SPPY::PyDict_SetItemString(dict, "REG_RAX", SPPY::PyInt_FromLong(rax)); + SPPY::PyDict_SetItemString(dict, "REG_RBX", SPPY::PyInt_FromLong(rbx)); + SPPY::PyDict_SetItemString(dict, "REG_RCX", SPPY::PyInt_FromLong(rcx)); + SPPY::PyDict_SetItemString(dict, "REG_RDX", SPPY::PyInt_FromLong(rdx)); + SPPY::PyDict_SetItemString(dict, "REG_RDI", SPPY::PyInt_FromLong(rdi)); + SPPY::PyDict_SetItemString(dict, "REG_RSI", SPPY::PyInt_FromLong(rsi)); + SPPY::PyDict_SetItemString(dict, "REG_RBP", SPPY::PyInt_FromLong(rbp)); + SPPY::PyDict_SetItemString(dict, "REG_RSP", SPPY::PyInt_FromLong(rsp)); + SPPY::PyDict_SetItemString(dict, "IP", SPPY::PyInt_FromLong(INS_Address(ins_object))); + // SPPY::PyDict_SetItemString(dict, "EA", SPPY::PyInt_FromLong(ea)); + SPPY::PyDict_SetItemString(dict, "mnemonic", SPPY::PyString_FromString(INS_Disassemble(ins_object).c_str())); switch (num_operands) { case 0: break; case 1: - PyDict_SetItemString(dict, "MEM_OP0", PyInt_FromLong(memop0)); + SPPY::PyDict_SetItemString(dict, "MEM_OP0", SPPY::PyInt_FromLong(memop0)); break; case 2: - PyDict_SetItemString(dict, "MEM_OP0", PyInt_FromLong(memop0)); - PyDict_SetItemString(dict, "MEM_OP1", PyInt_FromLong(memop1)); + SPPY::PyDict_SetItemString(dict, "MEM_OP0", SPPY::PyInt_FromLong(memop0)); + SPPY::PyDict_SetItemString(dict, "MEM_OP1", SPPY::PyInt_FromLong(memop1)); break; case 3: - PyDict_SetItemString(dict, "MEM_OP0", PyInt_FromLong(memop0)); - PyDict_SetItemString(dict, "MEM_OP1", PyInt_FromLong(memop1)); - PyDict_SetItemString(dict, "MEM_OP2", PyInt_FromLong(memop2)); + SPPY::PyDict_SetItemString(dict, "MEM_OP0", SPPY::PyInt_FromLong(memop0)); + SPPY::PyDict_SetItemString(dict, "MEM_OP1", SPPY::PyInt_FromLong(memop1)); + SPPY::PyDict_SetItemString(dict, "MEM_OP2", SPPY::PyInt_FromLong(memop2)); break; } #endif PyTuple_SetItem(arguments, 0, dict); - PyObject_CallObject(callback, arguments); + SPPY::PyObject_CallObject(callback, arguments); } -void INS_IPOINT_AFTER(PyObject* callback, INS ins_object, UINT32 num_operands, UINT64 rax) { +void INS_IPOINT_AFTER(SPPY::PyObject* callback, INS ins_object, UINT32 num_operands, UINT64 rax) { } -PyObject* Python_INS_InsertCall(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* callable; - PyObject* ipoint; +SPPY::PyObject* Python_INS_InsertCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* callable; + SPPY::PyObject* ipoint; PyArg_ParseTuple(args, "k|k|O", &ipoint, &ins, &callable); if (!PyCallable_Check(callable)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } INS ins_object = *(INS*) ins; @@ -129,1268 +132,1268 @@ PyObject* Python_INS_InsertCall(PyObject* self, PyObject* args) { #endif IARG_END ); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else if ((long int) ipoint == IPOINT_AFTER) { } - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_INS_Category(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_Category(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_Category(ins_object)); + return SPPY::Py_BuildValue("k", INS_Category(ins_object)); } -PyObject* Python_INS_Extension(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_Extension(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_Extension(ins_object)); + return SPPY::Py_BuildValue("k", INS_Extension(ins_object)); } -PyObject* Python_INS_MemoryOperandSize(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* memoryop; +SPPY::PyObject* Python_INS_MemoryOperandSize(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* memoryop; PyArg_ParseTuple(args, "k|O", &ins, &memoryop); INS ins_object = *(INS*) ins; UINT32 memoryop_object = (UINT32) PyInt_AsLong(memoryop); - return Py_BuildValue("k", INS_MemoryOperandSize(ins_object, memoryop_object)); + return SPPY::Py_BuildValue("k", INS_MemoryOperandSize(ins_object, memoryop_object)); } -PyObject* Python_INS_MemoryWriteSize(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_MemoryWriteSize(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_MemoryWriteSize(ins_object)); + return SPPY::Py_BuildValue("k", INS_MemoryWriteSize(ins_object)); } -PyObject* Python_INS_GetPredicate(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_GetPredicate(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_GetPredicate(ins_object)); + return SPPY::Py_BuildValue("k", INS_GetPredicate(ins_object)); } -PyObject* Python_INS_MemoryReadSize(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_MemoryReadSize(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_MemoryReadSize(ins_object)); + return SPPY::Py_BuildValue("k", INS_MemoryReadSize(ins_object)); } -PyObject* Python_INS_IsMemoryRead(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsMemoryRead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsMemoryRead(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsMemoryWrite(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsMemoryWrite(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsMemoryWrite(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_HasMemoryRead2(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_HasMemoryRead2(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_HasMemoryRead2(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_HasFallThrough(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_HasFallThrough(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_HasFallThrough(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsLea(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsLea(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsLea(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsNop(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsNop(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsNop(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_OPCODE_StringShort(PyObject* self, PyObject* args) { - PyObject* opcode; +SPPY::PyObject* Python_OPCODE_StringShort(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* opcode; PyArg_ParseTuple(args, "O", &opcode); UINT32 opcode_object = (UINT32) PyInt_AsLong(opcode); - return Py_BuildValue("s", OPCODE_StringShort(opcode_object).c_str()); + return SPPY::Py_BuildValue("s", OPCODE_StringShort(opcode_object).c_str()); } -PyObject* Python_INS_Mnemonic(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_Mnemonic(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("s", INS_Mnemonic(ins_object).c_str()); + return SPPY::Py_BuildValue("s", INS_Mnemonic(ins_object).c_str()); } -PyObject* Python_INS_IsBranch(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsBranch(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsBranch(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsDirectBranch(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsDirectBranch(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsDirectBranch(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsDirectCall(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsDirectCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsDirectCall(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsDirectBranchOrCall(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsDirectBranchOrCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsDirectBranchOrCall(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsBranchOrCall(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsBranchOrCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsBranchOrCall(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_Stutters(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_Stutters(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_Stutters(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsCall(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsCall(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsProcedureCall(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsProcedureCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsProcedureCall(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsRet(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsRet(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsRet(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsSysret(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsSysret(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsSysret(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsPrefetch(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsPrefetch(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsPrefetch(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsAtomicUpdate(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsAtomicUpdate(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsAtomicUpdate(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsIndirectBranchOrCall(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsIndirectBranchOrCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsIndirectBranchOrCall(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_RegR(PyObject* self, PyObject* args) { - PyObject* x; - PyObject* k; +SPPY::PyObject* Python_INS_RegR(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; + SPPY::PyObject* k; PyArg_ParseTuple(args, "k|O", &x, &k); INS x_object = *(INS*) x; UINT32 k_object = (UINT32) PyInt_AsLong(k); REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_RegR(x_object, k_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_RegW(PyObject* self, PyObject* args) { - PyObject* x; - PyObject* k; +SPPY::PyObject* Python_INS_RegW(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; + SPPY::PyObject* k; PyArg_ParseTuple(args, "k|O", &x, &k); INS x_object = *(INS*) x; UINT32 k_object = (UINT32) PyInt_AsLong(k); REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_RegW(x_object, k_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_Opcode(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_Opcode(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; OPCODE* opcode_return = (OPCODE*) malloc(sizeof(OPCODE)); *opcode_return = INS_Opcode(ins_object); - return Py_BuildValue("k", opcode_return); + return SPPY::Py_BuildValue("k", opcode_return); } -PyObject* Python_CATEGORY_StringShort(PyObject* self, PyObject* args) { - PyObject* num; +SPPY::PyObject* Python_CATEGORY_StringShort(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* num; PyArg_ParseTuple(args, "O", &num); UINT32 num_object = (UINT32) PyInt_AsLong(num); - return Py_BuildValue("s", CATEGORY_StringShort(num_object).c_str()); + return SPPY::Py_BuildValue("s", CATEGORY_StringShort(num_object).c_str()); } -PyObject* Python_EXTENSION_StringShort(PyObject* self, PyObject* args) { - PyObject* num; +SPPY::PyObject* Python_EXTENSION_StringShort(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* num; PyArg_ParseTuple(args, "O", &num); UINT32 num_object = (UINT32) PyInt_AsLong(num); - return Py_BuildValue("s", EXTENSION_StringShort(num_object).c_str()); + return SPPY::Py_BuildValue("s", EXTENSION_StringShort(num_object).c_str()); } -PyObject* Python_INS_MaxNumRRegs(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_INS_MaxNumRRegs(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); INS x_object = *(INS*) x; - return Py_BuildValue("k", INS_MaxNumRRegs(x_object)); + return SPPY::Py_BuildValue("k", INS_MaxNumRRegs(x_object)); } -PyObject* Python_INS_MaxNumWRegs(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_INS_MaxNumWRegs(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); INS x_object = *(INS*) x; - return Py_BuildValue("k", INS_MaxNumWRegs(x_object)); + return SPPY::Py_BuildValue("k", INS_MaxNumWRegs(x_object)); } -PyObject* Python_INS_RegRContain(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* reg; +SPPY::PyObject* Python_INS_RegRContain(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k|k", &ins, ®); INS ins_object = *(INS*) ins; REG reg_object = *(REG*) reg; if (INS_RegRContain(ins_object, reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_RegWContain(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* reg; +SPPY::PyObject* Python_INS_RegWContain(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k|k", &ins, ®); INS ins_object = *(INS*) ins; REG reg_object = *(REG*) reg; if (INS_RegWContain(ins_object, reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsStackRead(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsStackRead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsStackRead(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsStackWrite(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsStackWrite(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsStackWrite(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsIpRelRead(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsIpRelRead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsIpRelRead(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsIpRelWrite(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsIpRelWrite(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsIpRelWrite(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsPredicated(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsPredicated(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsPredicated(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsOriginal(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsOriginal(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsOriginal(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_Disassemble(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_Disassemble(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("s", INS_Disassemble(ins_object).c_str()); + return SPPY::Py_BuildValue("s", INS_Disassemble(ins_object).c_str()); } -PyObject* Python_INS_MemoryOperandCount(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_MemoryOperandCount(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_MemoryOperandCount(ins_object)); + return SPPY::Py_BuildValue("k", INS_MemoryOperandCount(ins_object)); } -PyObject* Python_INS_OperandIsAddressGenerator(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandIsAddressGenerator(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandIsAddressGenerator(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_MemoryOperandIsRead(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* memopidx; +SPPY::PyObject* Python_INS_MemoryOperandIsRead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* memopidx; PyArg_ParseTuple(args, "k|O", &ins, &memopidx); INS ins_object = *(INS*) ins; UINT32 memopidx_object = (UINT32) PyInt_AsLong(memopidx); if (INS_MemoryOperandIsRead(ins_object, memopidx_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_MemoryOperandIsWritten(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* memopidx; +SPPY::PyObject* Python_INS_MemoryOperandIsWritten(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* memopidx; PyArg_ParseTuple(args, "k|O", &ins, &memopidx); INS ins_object = *(INS*) ins; UINT32 memopidx_object = (UINT32) PyInt_AsLong(memopidx); if (INS_MemoryOperandIsWritten(ins_object, memopidx_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsSyscall(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsSyscall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsSyscall(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_SyscallStd(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_SyscallStd(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_SyscallStd(ins_object)); + return SPPY::Py_BuildValue("k", INS_SyscallStd(ins_object)); } -PyObject* Python_INS_Rtn(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_INS_Rtn(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); INS x_object = *(INS*) x; RTN* rtn_return = (RTN*) malloc(sizeof(RTN)); *rtn_return = INS_Rtn(x_object); - return Py_BuildValue("k", rtn_return); + return SPPY::Py_BuildValue("k", rtn_return); } -PyObject* Python_INS_Next(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_INS_Next(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); INS x_object = *(INS*) x; INS* ins_return = (INS*) malloc(sizeof(INS)); *ins_return = INS_Next(x_object); - return Py_BuildValue("k", ins_return); + return SPPY::Py_BuildValue("k", ins_return); } -PyObject* Python_INS_Prev(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_INS_Prev(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); INS x_object = *(INS*) x; INS* ins_return = (INS*) malloc(sizeof(INS)); *ins_return = INS_Prev(x_object); - return Py_BuildValue("k", ins_return); + return SPPY::Py_BuildValue("k", ins_return); } -PyObject* Python_INS_Invalid(PyObject* self, PyObject* args) { +SPPY::PyObject* Python_INS_Invalid(SPPY::PyObject* self, SPPY::PyObject* args) { INS* ins_return = (INS*) malloc(sizeof(INS)); *ins_return = INS_Invalid(); - return Py_BuildValue("k", ins_return); + return SPPY::Py_BuildValue("k", ins_return); } -PyObject* Python_INS_Valid(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_INS_Valid(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); INS x_object = *(INS*) x; if (INS_Valid(x_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_Address(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_Address(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_Address(ins_object)); + return SPPY::Py_BuildValue("k", INS_Address(ins_object)); } -PyObject* Python_INS_Size(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_Size(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_Size(ins_object)); + return SPPY::Py_BuildValue("k", INS_Size(ins_object)); } -PyObject* Python_INS_DirectBranchOrCallTargetAddress(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_DirectBranchOrCallTargetAddress(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_DirectBranchOrCallTargetAddress(ins_object)); + return SPPY::Py_BuildValue("k", INS_DirectBranchOrCallTargetAddress(ins_object)); } -PyObject* Python_INS_NextAddress(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_NextAddress(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_NextAddress(ins_object)); + return SPPY::Py_BuildValue("k", INS_NextAddress(ins_object)); } -PyObject* Python_INS_EffectiveAddressWidth(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_EffectiveAddressWidth(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_EffectiveAddressWidth(ins_object)); + return SPPY::Py_BuildValue("k", INS_EffectiveAddressWidth(ins_object)); } -PyObject* Python_INS_IsSysenter(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsSysenter(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsSysenter(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsXbegin(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsXbegin(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsXbegin(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsXend(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsXend(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsXend(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsHalt(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsHalt(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsHalt(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsPcMaterialization(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsPcMaterialization(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsPcMaterialization(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsFarCall(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsFarCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsFarCall(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsFarJump(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsFarJump(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsFarJump(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsDirectFarJump(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsDirectFarJump(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsDirectFarJump(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsVgather(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsVgather(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsVgather(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsVscatter(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsVscatter(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsVscatter(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_HasMemoryVector(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_HasMemoryVector(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_HasMemoryVector(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsInterrupt(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsInterrupt(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsInterrupt(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsFarRet(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsFarRet(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsFarRet(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsSub(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsSub(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsSub(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsMov(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsMov(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsMov(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsMovFullRegRegSame(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsMovFullRegRegSame(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsMovFullRegRegSame(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsRDTSC(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsRDTSC(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsRDTSC(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsMaskMov(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsMaskMov(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsMaskMov(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsMaskedJump(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsMaskedJump(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsMaskedJump(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_RepCountRegister(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_RepCountRegister(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_RepCountRegister(ins_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_SegmentRegPrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_SegmentRegPrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_SegmentRegPrefix(ins_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_SegPrefixIsMemoryRead(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_SegPrefixIsMemoryRead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_SegPrefixIsMemoryRead(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_SegPrefixIsMemoryWrite(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_SegPrefixIsMemoryWrite(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_SegPrefixIsMemoryWrite(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_AddressSizePrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_AddressSizePrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_AddressSizePrefix(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_BranchNotTakenPrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_BranchNotTakenPrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_BranchNotTakenPrefix(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_BranchTakenPrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_BranchTakenPrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_BranchTakenPrefix(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_LockPrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_LockPrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_LockPrefix(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandSizePrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_OperandSizePrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_OperandSizePrefix(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_RepPrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_RepPrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_RepPrefix(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_RepnePrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_RepnePrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_RepnePrefix(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_SegmentPrefix(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_SegmentPrefix(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_SegmentPrefix(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsXchg(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsXchg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsXchg(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsStringop(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsStringop(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsStringop(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_IsIRet(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_IsIRet(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_IsIRet(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_FullRegRContain(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* reg; +SPPY::PyObject* Python_INS_FullRegRContain(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k|k", &ins, ®); INS ins_object = *(INS*) ins; REG reg_object = *(REG*) reg; if (INS_FullRegRContain(ins_object, reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_FullRegWContain(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* reg; +SPPY::PyObject* Python_INS_FullRegWContain(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k|k", &ins, ®); INS ins_object = *(INS*) ins; REG reg_object = *(REG*) reg; if (INS_FullRegWContain(ins_object, reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_HasRealRep(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_HasRealRep(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; if (INS_HasRealRep(ins_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_MemoryDisplacement(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_MemoryDisplacement(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_MemoryDisplacement(ins_object)); + return SPPY::Py_BuildValue("k", INS_MemoryDisplacement(ins_object)); } -PyObject* Python_INS_MemoryBaseReg(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_MemoryBaseReg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_MemoryBaseReg(ins_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_MemoryIndexReg(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_MemoryIndexReg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_MemoryIndexReg(ins_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_MemoryScale(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_MemoryScale(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_MemoryScale(ins_object)); + return SPPY::Py_BuildValue("k", INS_MemoryScale(ins_object)); } -PyObject* Python_INS_ChangeReg(PyObject* self, PyObject* args) { - return Py_BuildValue("O", Py_False); +SPPY::PyObject* Python_INS_ChangeReg(SPPY::PyObject* self, SPPY::PyObject* args) { + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } -PyObject* Python_INS_OperandCount(PyObject* self, PyObject* args) { - PyObject* ins; +SPPY::PyObject* Python_INS_OperandCount(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; PyArg_ParseTuple(args, "k", &ins); INS ins_object = *(INS*) ins; - return Py_BuildValue("k", INS_OperandCount(ins_object)); + return SPPY::Py_BuildValue("k", INS_OperandCount(ins_object)); } -PyObject* Python_INS_OperandNameId(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandNameId(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); - return Py_BuildValue("k", INS_OperandNameId(ins_object, n_object)); + return SPPY::Py_BuildValue("k", INS_OperandNameId(ins_object, n_object)); } -PyObject* Python_INS_OperandIsMemory(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandIsMemory(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandIsMemory(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandMemoryBaseReg(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandMemoryBaseReg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_OperandMemoryBaseReg(ins_object, n_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_OperandMemoryIndexReg(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandMemoryIndexReg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_OperandMemoryIndexReg(ins_object, n_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_OperandMemorySegmentReg(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandMemorySegmentReg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_OperandMemorySegmentReg(ins_object, n_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_OperandMemoryScale(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandMemoryScale(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); - return Py_BuildValue("k", INS_OperandMemoryScale(ins_object, n_object)); + return SPPY::Py_BuildValue("k", INS_OperandMemoryScale(ins_object, n_object)); } -PyObject* Python_INS_OperandMemoryDisplacement(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandMemoryDisplacement(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); - return Py_BuildValue("k", INS_OperandMemoryDisplacement(ins_object, n_object)); + return SPPY::Py_BuildValue("k", INS_OperandMemoryDisplacement(ins_object, n_object)); } -PyObject* Python_INS_OperandIsFixedMemop(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandIsFixedMemop(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandIsFixedMemop(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandIsBranchDisplacement(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandIsBranchDisplacement(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandIsBranchDisplacement(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandIsReg(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandIsReg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandIsReg(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandReg(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandReg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = INS_OperandReg(ins_object, n_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_INS_OperandIsImmediate(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandIsImmediate(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandIsImmediate(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandImmediate(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandImmediate(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); - return Py_BuildValue("k", INS_OperandImmediate(ins_object, n_object)); + return SPPY::Py_BuildValue("k", INS_OperandImmediate(ins_object, n_object)); } -PyObject* Python_INS_OperandIsImplicit(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandIsImplicit(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandIsImplicit(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandWidth(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandWidth(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); - return Py_BuildValue("k", INS_OperandWidth(ins_object, n_object)); + return SPPY::Py_BuildValue("k", INS_OperandWidth(ins_object, n_object)); } -PyObject* Python_INS_OperandRead(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandRead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandRead(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandWritten(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandWritten(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandWritten(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandReadOnly(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandReadOnly(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandReadOnly(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandWrittenOnly(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandWrittenOnly(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandWrittenOnly(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_OperandReadAndWritten(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* n; +SPPY::PyObject* Python_INS_OperandReadAndWritten(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* n; PyArg_ParseTuple(args, "k|O", &ins, &n); INS ins_object = *(INS*) ins; UINT32 n_object = (UINT32) PyInt_AsLong(n); if (INS_OperandReadAndWritten(ins_object, n_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_INS_MemoryOperandIndexToOperandIndex(PyObject* self, PyObject* args) { - PyObject* ins; - PyObject* memopidx; +SPPY::PyObject* Python_INS_MemoryOperandIndexToOperandIndex(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* ins; + SPPY::PyObject* memopidx; PyArg_ParseTuple(args, "k|O", &ins, &memopidx); INS ins_object = *(INS*) ins; UINT32 memopidx_object = (UINT32) PyInt_AsLong(memopidx); - return Py_BuildValue("k", INS_MemoryOperandIndexToOperandIndex(ins_object, memopidx_object)); + return SPPY::Py_BuildValue("k", INS_MemoryOperandIndexToOperandIndex(ins_object, memopidx_object)); } \ No newline at end of file diff --git a/INS.h b/INS.h index c9475d9..04f8d12 100644 --- a/INS.h +++ b/INS.h @@ -2,129 +2,129 @@ #define G_H -PyObject* Python_INS_Category(PyObject* self, PyObject* args); -PyObject* Python_INS_Extension(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryOperandSize(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryWriteSize(PyObject* self, PyObject* args); -PyObject* Python_INS_GetPredicate(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryReadSize(PyObject* self, PyObject* args); -PyObject* Python_INS_IsMemoryRead(PyObject* self, PyObject* args); -PyObject* Python_INS_IsMemoryWrite(PyObject* self, PyObject* args); -PyObject* Python_INS_HasMemoryRead2(PyObject* self, PyObject* args); -PyObject* Python_INS_HasFallThrough(PyObject* self, PyObject* args); -PyObject* Python_INS_IsLea(PyObject* self, PyObject* args); -PyObject* Python_INS_IsNop(PyObject* self, PyObject* args); -PyObject* Python_OPCODE_StringShort(PyObject* self, PyObject* args); -PyObject* Python_INS_Mnemonic(PyObject* self, PyObject* args); -PyObject* Python_INS_InsertCall(PyObject* self, PyObject* args); -PyObject* Python_INS_IsBranch(PyObject* self, PyObject* args); -PyObject* Python_INS_IsDirectBranch(PyObject* self, PyObject* args); -PyObject* Python_INS_IsDirectCall(PyObject* self, PyObject* args); -PyObject* Python_INS_IsDirectBranchOrCall(PyObject* self, PyObject* args); -PyObject* Python_INS_IsBranchOrCall(PyObject* self, PyObject* args); -PyObject* Python_INS_Stutters(PyObject* self, PyObject* args); -PyObject* Python_INS_IsCall(PyObject* self, PyObject* args); -PyObject* Python_INS_IsProcedureCall(PyObject* self, PyObject* args); -PyObject* Python_INS_IsRet(PyObject* self, PyObject* args); -PyObject* Python_INS_IsSysret(PyObject* self, PyObject* args); -PyObject* Python_INS_IsPrefetch(PyObject* self, PyObject* args); -PyObject* Python_INS_IsAtomicUpdate(PyObject* self, PyObject* args); -PyObject* Python_INS_IsIndirectBranchOrCall(PyObject* self, PyObject* args); -PyObject* Python_INS_RegR(PyObject* self, PyObject* args); -PyObject* Python_INS_RegW(PyObject* self, PyObject* args); -PyObject* Python_INS_Opcode(PyObject* self, PyObject* args); -PyObject* Python_CATEGORY_StringShort(PyObject* self, PyObject* args); -PyObject* Python_EXTENSION_StringShort(PyObject* self, PyObject* args); -PyObject* Python_INS_MaxNumRRegs(PyObject* self, PyObject* args); -PyObject* Python_INS_MaxNumWRegs(PyObject* self, PyObject* args); -PyObject* Python_INS_RegRContain(PyObject* self, PyObject* args); -PyObject* Python_INS_RegWContain(PyObject* self, PyObject* args); -PyObject* Python_INS_IsStackRead(PyObject* self, PyObject* args); -PyObject* Python_INS_IsStackWrite(PyObject* self, PyObject* args); -PyObject* Python_INS_IsIpRelRead(PyObject* self, PyObject* args); -PyObject* Python_INS_IsIpRelWrite(PyObject* self, PyObject* args); -PyObject* Python_INS_IsPredicated(PyObject* self, PyObject* args); -PyObject* Python_INS_IsOriginal(PyObject* self, PyObject* args); -PyObject* Python_INS_Disassemble(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryOperandCount(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandIsAddressGenerator(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryOperandIsRead(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryOperandIsWritten(PyObject* self, PyObject* args); -PyObject* Python_INS_IsSyscall(PyObject* self, PyObject* args); -PyObject* Python_INS_SyscallStd(PyObject* self, PyObject* args); -PyObject* Python_INS_Rtn(PyObject* self, PyObject* args); -PyObject* Python_INS_Next(PyObject* self, PyObject* args); -PyObject* Python_INS_Prev(PyObject* self, PyObject* args); -PyObject* Python_INS_Invalid(PyObject* self, PyObject* args); -PyObject* Python_INS_Valid(PyObject* self, PyObject* args); -PyObject* Python_INS_Address(PyObject* self, PyObject* args); -PyObject* Python_INS_Size(PyObject* self, PyObject* args); -PyObject* Python_INS_DirectBranchOrCallTargetAddress(PyObject* self, PyObject* args); -PyObject* Python_INS_NextAddress(PyObject* self, PyObject* args); +SPPY::PyObject* Python_INS_Category(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Extension(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryOperandSize(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryWriteSize(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_GetPredicate(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryReadSize(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsMemoryRead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsMemoryWrite(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_HasMemoryRead2(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_HasFallThrough(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsLea(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsNop(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_OPCODE_StringShort(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Mnemonic(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_InsertCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsBranch(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsDirectBranch(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsDirectCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsDirectBranchOrCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsBranchOrCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Stutters(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsProcedureCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsRet(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsSysret(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsPrefetch(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsAtomicUpdate(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsIndirectBranchOrCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_RegR(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_RegW(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Opcode(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_CATEGORY_StringShort(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_EXTENSION_StringShort(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MaxNumRRegs(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MaxNumWRegs(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_RegRContain(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_RegWContain(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsStackRead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsStackWrite(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsIpRelRead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsIpRelWrite(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsPredicated(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsOriginal(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Disassemble(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryOperandCount(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandIsAddressGenerator(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryOperandIsRead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryOperandIsWritten(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsSyscall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_SyscallStd(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Rtn(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Next(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Prev(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Invalid(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Valid(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Address(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_Size(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_DirectBranchOrCallTargetAddress(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_NextAddress(SPPY::PyObject* self, SPPY::PyObject* args); /*AUTO GENERATED SKELETONS INSPECTION API*/ -PyObject* Python_INS_EffectiveAddressWidth(PyObject* self, PyObject* args); -PyObject* Python_INS_IsSysenter(PyObject* self, PyObject* args); -PyObject* Python_INS_IsXbegin(PyObject* self, PyObject* args); -PyObject* Python_INS_IsXend(PyObject* self, PyObject* args); -PyObject* Python_INS_IsHalt(PyObject* self, PyObject* args); -PyObject* Python_INS_IsPcMaterialization(PyObject* self, PyObject* args); -PyObject* Python_INS_IsFarCall(PyObject* self, PyObject* args); -PyObject* Python_INS_IsFarJump(PyObject* self, PyObject* args); -PyObject* Python_INS_IsDirectFarJump(PyObject* self, PyObject* args); -PyObject* Python_INS_IsVgather(PyObject* self, PyObject* args); -PyObject* Python_INS_IsVscatter(PyObject* self, PyObject* args); -PyObject* Python_INS_HasMemoryVector(PyObject* self, PyObject* args); -PyObject* Python_INS_IsInterrupt(PyObject* self, PyObject* args); -PyObject* Python_INS_IsFarRet(PyObject* self, PyObject* args); -PyObject* Python_INS_IsSub(PyObject* self, PyObject* args); -PyObject* Python_INS_IsMov(PyObject* self, PyObject* args); -PyObject* Python_INS_IsMovFullRegRegSame(PyObject* self, PyObject* args); -PyObject* Python_INS_IsRDTSC(PyObject* self, PyObject* args); -PyObject* Python_INS_IsMaskMov(PyObject* self, PyObject* args); -PyObject* Python_INS_IsMaskedJump(PyObject* self, PyObject* args); -PyObject* Python_INS_RepCountRegister(PyObject* self, PyObject* args); -PyObject* Python_INS_SegmentRegPrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_SegPrefixIsMemoryRead(PyObject* self, PyObject* args); -PyObject* Python_INS_SegPrefixIsMemoryWrite(PyObject* self, PyObject* args); -PyObject* Python_INS_AddressSizePrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_BranchNotTakenPrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_BranchTakenPrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_LockPrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandSizePrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_RepPrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_RepnePrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_SegmentPrefix(PyObject* self, PyObject* args); -PyObject* Python_INS_IsXchg(PyObject* self, PyObject* args); -PyObject* Python_INS_IsStringop(PyObject* self, PyObject* args); -PyObject* Python_INS_IsIRet(PyObject* self, PyObject* args); -PyObject* Python_INS_HasRealRep(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryDisplacement(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryBaseReg(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryIndexReg(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryScale(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandCount(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandNameId(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandIsMemory(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandMemoryBaseReg(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandMemoryIndexReg(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandMemorySegmentReg(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandMemoryScale(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandMemoryDisplacement(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandIsFixedMemop(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandIsBranchDisplacement(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandIsReg(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandReg(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandIsImmediate(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandImmediate(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandIsImplicit(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandWidth(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandRead(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandWritten(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandReadOnly(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandWrittenOnly(PyObject* self, PyObject* args); -PyObject* Python_INS_OperandReadAndWritten(PyObject* self, PyObject* args); -PyObject* Python_INS_MemoryOperandIndexToOperandIndex(PyObject* self, PyObject* args); +SPPY::PyObject* Python_INS_EffectiveAddressWidth(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsSysenter(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsXbegin(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsXend(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsHalt(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsPcMaterialization(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsFarCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsFarJump(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsDirectFarJump(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsVgather(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsVscatter(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_HasMemoryVector(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsInterrupt(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsFarRet(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsSub(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsMov(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsMovFullRegRegSame(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsRDTSC(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsMaskMov(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsMaskedJump(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_RepCountRegister(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_SegmentRegPrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_SegPrefixIsMemoryRead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_SegPrefixIsMemoryWrite(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_AddressSizePrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_BranchNotTakenPrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_BranchTakenPrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_LockPrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandSizePrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_RepPrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_RepnePrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_SegmentPrefix(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsXchg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsStringop(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_IsIRet(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_HasRealRep(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryDisplacement(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryBaseReg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryIndexReg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryScale(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandCount(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandNameId(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandIsMemory(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandMemoryBaseReg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandMemoryIndexReg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandMemorySegmentReg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandMemoryScale(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandMemoryDisplacement(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandIsFixedMemop(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandIsBranchDisplacement(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandIsReg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandReg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandIsImmediate(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandImmediate(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandIsImplicit(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandWidth(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandRead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandWritten(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandReadOnly(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandWrittenOnly(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_OperandReadAndWritten(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_MemoryOperandIndexToOperandIndex(SPPY::PyObject* self, SPPY::PyObject* args); #endif diff --git a/Python_Pin.cpp b/Python_Pin.cpp index 14bad8c..3477be3 100644 --- a/Python_Pin.cpp +++ b/Python_Pin.cpp @@ -1,25 +1,27 @@ -#include -//#include #include "pin.H" +namespace SPPY +{ +#include +} #include "IMG.h" #include "INS.h" #include "RTN.h" #include "SYS.h" #include "TRACE.h" #include "./python_pin.h" -#include +#include #include -void add_hook(PyObject*** hooks, PyObject* new_hook) { - PyObject** hooks_list = *hooks; +void add_hook(SPPY::PyObject*** hooks, SPPY::PyObject* new_hook) { + SPPY::PyObject** hooks_list = *hooks; if (hooks_list == NULL) { - hooks_list = (PyObject**) malloc(sizeof(PyObject*)*2); + hooks_list = (SPPY::PyObject**) malloc(sizeof(SPPY::PyObject*)*2); hooks_list[0] = new_hook; hooks_list[1] = NULL; } else { int hook_count; for(hook_count=0; hooks_list[hook_count]; hook_count++); - hooks_list = (PyObject**) realloc(hooks_list, sizeof(PyObject*)*(hook_count+2)); + hooks_list = (SPPY::PyObject**) realloc(hooks_list, sizeof(SPPY::PyObject*)*(hook_count+2)); hooks_list[hook_count] = new_hook; hooks_list[hook_count+1] = NULL; } @@ -29,131 +31,133 @@ void add_hook(PyObject*** hooks, PyObject* new_hook) { void Fini(INT32, VOID*) { for (int i=0; fini_functions[i]; i++) { - if (PyObject_CallObject(fini_functions[i], NULL) == NULL) { - PyErr_Print(); + if (SPPY::PyObject_CallObject(fini_functions[i], NULL) == NULL) { + SPPY::PyErr_Print(); exit(1); } } return; } -PyObject* Python_AddFiniFunction(PyObject* self, PyObject* args) { - PyObject* callback; - PyObject* v; +SPPY::PyObject* Python_AddFiniFunction(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* callback; + SPPY::PyObject* v; PyArg_ParseTuple(args, "O|O", &callback, &v); if (!PyCallable_Check(callback)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } add_hook(&fini_functions, callback); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_TRACE_AddInstrumentFunction(PyObject* self, PyObject* args) { - PyObject* callback; - PyObject* v; +SPPY::PyObject* Python_TRACE_AddInstrumentFunction(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* callback; + SPPY::PyObject* v; PyArg_ParseTuple(args, "O|O", &callback, &v); if (!PyCallable_Check(callback)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } add_hook(&hooks_trace_instrument, callback); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_INS_AddInstrumentFunction(PyObject* self, PyObject* args) { - PyObject* callback; - PyObject* v; +SPPY::PyObject* Python_INS_AddInstrumentFunction(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* callback; + SPPY::PyObject* v; PyArg_ParseTuple(args, "O|O", &callback, &v); if (!PyCallable_Check(callback)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } add_hook(&hooks_instruction, callback); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_IMG_AddInstrumentFunction(PyObject* self, PyObject* args) { - PyObject* callback; - PyObject* v; +SPPY::PyObject* Python_IMG_AddInstrumentFunction(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* callback; + SPPY::PyObject* v; PyArg_ParseTuple(args, "O|O", &callback, &v); if (!PyCallable_Check(callback)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } add_hook(&hooks_img_load, callback); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_IMG_AddUnloadFunction(PyObject* self, PyObject* args) { - PyObject* callback; - PyObject* v; +SPPY::PyObject* Python_IMG_AddUnloadFunction(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* callback; + SPPY::PyObject* v; PyArg_ParseTuple(args, "O|O", &callback, &v); if (!PyCallable_Check(callback)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } add_hook(&hooks_img_unload, callback); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_RTN_AddInstrumentFunction(PyObject* self, PyObject* args) { - PyObject* callback = (PyObject*) malloc(sizeof(PyObject)); +SPPY::PyObject* Python_RTN_AddInstrumentFunction(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* callback = (SPPY::PyObject*) malloc(sizeof(SPPY::PyObject)); PyArg_ParseTuple(args, "O", &callback); if (!PyCallable_Check(callback)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } add_hook(&hooks_instrument_function, callback); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_PIN_AddSyscallExitFunction(PyObject* self, PyObject* args) { - PyObject* callback = (PyObject*) malloc(sizeof(PyObject)); +SPPY::PyObject* Python_PIN_AddSyscallExitFunction(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* callback = (SPPY::PyObject*) malloc(sizeof(SPPY::PyObject)); PyArg_ParseTuple(args, "O", &callback); if (!PyCallable_Check(callback)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } add_hook(&hooks_syscall_exit, callback); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_PIN_AddSyscallEntryFunction(PyObject* self, PyObject* args) { - PyObject* callback = (PyObject*) malloc(sizeof(PyObject)); +SPPY::PyObject* Python_PIN_AddSyscallEntryFunction(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* callback = (SPPY::PyObject*) malloc(sizeof(SPPY::PyObject)); PyArg_ParseTuple(args, "O", &callback); if (!PyCallable_Check(callback)) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } add_hook(&hooks_syscall_entry, callback); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } KNOB KnobPythonModule(KNOB_MODE_WRITEONCE, "pintool", "m", "", "the python pintool to import"); int main(int argc, char** argv) { PIN_InitSymbols(); - Py_Initialize(); - PyRun_SimpleString("import sys; sys.path.append('.')\n"); + SPPY::Py_Initialize(); + SPPY::PyRun_SimpleString("import sys; sys.path.append('.')\n"); if (PIN_Init(argc, argv)) { printf("Failed to initialize pin.\n"); exit(1); } - PyObject* pin_module = Py_InitModule("pin", methods); + SPPY::PyObject* pin_module = + Py_InitModule4("pin", methods, (char *)NULL, (SPPY::PyObject *)NULL, PYTHON_API_VERSION); + //PyObject* pin_module = Py_InitModule("pin", methods); if (pin_module == NULL) { printf("Failed to initialize internal pin module\n"); - PyErr_Print(); + SPPY::PyErr_Print(); exit(1); } @@ -251,15 +255,18 @@ int main(int argc, char** argv) { PyModule_AddIntConstant(pin_module, "CALL_ORDER_DEFAULT", CALL_ORDER_DEFAULT); PyModule_AddIntConstant(pin_module, "CALL_ORDER_LAST", CALL_ORDER_LAST); - const char* filename = KnobPythonModule.Value().c_str(); - FILE* tool = fopen(filename, "r"); - if (tool == NULL) { - perror("fopen"); - exit(1); - } + const char* filename = KnobPythonModule.Value().c_str(); +// FILE* tool = fopen(filename, "r"); +// if (tool == NULL) { +// perror("fopen"); +// exit(1); +// } +// +// PyRun_SimpleFile(tool, filename); +// fclose(tool); - PyRun_SimpleFile(tool, filename); - fclose(tool); + SPPY::PyObject* PyFileObject = SPPY::PyFile_FromString((char *)filename, "r"); + SPPY::PyRun_SimpleFile(SPPY::PyFile_AsFile(PyFileObject), filename); if (fini_functions) { PIN_AddFiniFunction(Fini, 0); @@ -294,17 +301,17 @@ int main(int argc, char** argv) { PIN_StartProgram(); - Py_Finalize(); + SPPY::Py_Finalize(); return 0; } void Ins_Hook(INS ins, VOID *v){ - PyObject* arguments = PyTuple_New(1); - PyTuple_SetItem(arguments, 0, PyInt_FromLong((long int)&ins)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(1); + PyTuple_SetItem(arguments, 0, SPPY::PyInt_FromLong((long int)&ins)); for (int i=0; hooks_instruction[i]; i++) { - if (PyObject_CallObject(hooks_instruction[i], arguments) == NULL) { - PyErr_Print(); + if (SPPY::PyObject_CallObject(hooks_instruction[i], arguments) == NULL) { + SPPY::PyErr_Print(); exit(1); } } @@ -312,12 +319,12 @@ void Ins_Hook(INS ins, VOID *v){ } void Trace(TRACE trace, VOID *v){ - PyObject* arguments = PyTuple_New(1); - PyTuple_SetItem(arguments, 0, PyInt_FromLong((long int)&trace)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(1); + PyTuple_SetItem(arguments, 0, SPPY::PyInt_FromLong((long int)&trace)); for (int i=0; hooks_trace_instrument[i]; i++) { - if (PyObject_CallObject(hooks_trace_instrument[i], arguments) == NULL) { - PyErr_Print(); + if (SPPY::PyObject_CallObject(hooks_trace_instrument[i], arguments) == NULL) { + SPPY::PyErr_Print(); exit(1); } } @@ -325,62 +332,62 @@ void Trace(TRACE trace, VOID *v){ } void InstrumentFunction(RTN rtn, VOID *v) { - PyObject* arguments = PyTuple_New(1); - PyTuple_SetItem(arguments, 0, PyInt_FromLong((long int)&rtn)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(1); + PyTuple_SetItem(arguments, 0, SPPY::PyInt_FromLong((long int)&rtn)); for (int i=0; hooks_instrument_function[i]; i++) { - if (PyObject_CallObject(hooks_instrument_function[i], arguments) == NULL) { - PyErr_Print(); + if (SPPY::PyObject_CallObject(hooks_instrument_function[i], arguments) == NULL) { + SPPY::PyErr_Print(); exit(1); } } } void SyscallExit(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v) { - PyObject* arguments = PyTuple_New(2); - PyTuple_SetItem(arguments, 0, PyInt_FromLong((long int)&ctxt)); - PyTuple_SetItem(arguments, 1, PyInt_FromLong((long int)&std)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(2); + PyTuple_SetItem(arguments, 0, SPPY::PyInt_FromLong((long int)&ctxt)); + PyTuple_SetItem(arguments, 1, SPPY::PyInt_FromLong((long int)&std)); for (int i=0; hooks_syscall_entry[i]; i++) { - if (PyObject_CallObject(hooks_syscall_exit[i], arguments) == NULL) { - PyErr_Print(); + if (SPPY::PyObject_CallObject(hooks_syscall_exit[i], arguments) == NULL) { + SPPY::PyErr_Print(); exit(1); } } } void SyscallEntry(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v) { - PyObject* arguments = PyTuple_New(2); - PyTuple_SetItem(arguments, 0, PyInt_FromLong((long int)&ctxt)); - PyTuple_SetItem(arguments, 1, PyInt_FromLong((long int)&std)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(2); + PyTuple_SetItem(arguments, 0, SPPY::PyInt_FromLong((long int)&ctxt)); + PyTuple_SetItem(arguments, 1, SPPY::PyInt_FromLong((long int)&std)); for (int i=0; hooks_syscall_entry[i]; i++) { - if (PyObject_CallObject(hooks_syscall_entry[i], arguments) == NULL) { - PyErr_Print(); + if (SPPY::PyObject_CallObject(hooks_syscall_entry[i], arguments) == NULL) { + SPPY::PyErr_Print(); exit(1); } } } void ImageLoad(IMG img, VOID *v) { - PyObject* arguments = PyTuple_New(1); - PyTuple_SetItem(arguments, 0, PyInt_FromLong((long int)&img)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(1); + PyTuple_SetItem(arguments, 0, SPPY::PyInt_FromLong((long int)&img)); for (int i=0; hooks_img_load[i]; i++) { - if (PyObject_CallObject(hooks_img_load[i], arguments) == NULL) { - PyErr_Print(); + if (SPPY::PyObject_CallObject(hooks_img_load[i], arguments) == NULL) { + SPPY::PyErr_Print(); exit(1); } } } void ImageUnload(IMG img, VOID* v) { - PyObject* arguments = PyTuple_New(1); - PyTuple_SetItem(arguments, 0, PyInt_FromLong((long int)&img)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(1); + PyTuple_SetItem(arguments, 0, SPPY::PyInt_FromLong((long int)&img)); for (int i=0; hooks_img_unload[i]; i++) { - if (PyObject_CallObject(hooks_img_unload[i], arguments) == NULL) { - PyErr_Print(); + if (SPPY::PyObject_CallObject(hooks_img_unload[i], arguments) == NULL) { + SPPY::PyErr_Print(); exit(1); } } diff --git a/Python_Pin.sln b/Python_Pin.sln new file mode 100644 index 0000000..e4a58e0 --- /dev/null +++ b/Python_Pin.sln @@ -0,0 +1,19 @@ +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Python_Pin", "Python_Pin.vcproj", "{684C442B-C507-4358-A091-14A1CA2ACE4E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {684C442B-C507-4358-A091-14A1CA2ACE4E}.Debug|Win32.ActiveCfg = Debug|Win32 + {684C442B-C507-4358-A091-14A1CA2ACE4E}.Debug|Win32.Build.0 = Debug|Win32 + {684C442B-C507-4358-A091-14A1CA2ACE4E}.Release|Win32.ActiveCfg = Release|Win32 + {684C442B-C507-4358-A091-14A1CA2ACE4E}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Python_Pin.vcproj b/Python_Pin.vcproj new file mode 100644 index 0000000..58782d1 --- /dev/null +++ b/Python_Pin.vcproj @@ -0,0 +1,263 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/README.md b/README.md index 324e661..0eda483 100644 --- a/README.md +++ b/README.md @@ -27,3 +27,7 @@ To run a specific python script, for example the strace script: 1. Some Python modules are compiled as shared objects without symbols. These modules can't be loaded from within the python pin tool. (solution is to either not use those modules, or have a custom build of python alongside the pintool) 2. Need to work on compiling for Mac and Windows. Code should be portable but makefile may need to be updated. + +==================================================== +# REMARK +=================================================== \ No newline at end of file diff --git a/REG.cpp b/REG.cpp index 6a56279..0021b5f 100644 --- a/REG.cpp +++ b/REG.cpp @@ -1,183 +1,186 @@ -#include #include "pin.H" +namespace SPPY +{ +#include +} #include "REG.h" -PyObject* Python_REG_is_reg(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_reg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_reg(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_pseudo(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_pseudo(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_pseudo(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_gr(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_gr(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_gr(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_fr(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_fr(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_fr(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_br(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_br(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_br(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_gr64(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_gr64(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_gr64(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_gr32(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_gr32(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_gr32(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_gr16(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_gr16(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_gr16(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_gr8(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_gr8(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_gr8(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_seg(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_seg(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_seg(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_pin_gr(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_pin_gr(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_pin_gr(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_INVALID(PyObject* self, PyObject* args) { - return Py_BuildValue("k", REG_INVALID()); +SPPY::PyObject* Python_REG_INVALID(SPPY::PyObject* self, SPPY::PyObject* args) { + return SPPY::Py_BuildValue("k", REG_INVALID()); } -PyObject* Python_REG_valid(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_valid(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_valid(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_is_pin64(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_is_pin64(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; if (REG_is_pin64(reg_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_REG_FullRegName(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_FullRegName(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; REG* reg_return = (REG*) malloc(sizeof(REG)); *reg_return = REG_FullRegName(reg_object); - return Py_BuildValue("k", reg_return); + return SPPY::Py_BuildValue("k", reg_return); } -PyObject* Python_REG_StringShort(PyObject* self, PyObject* args) { - PyObject* reg; +SPPY::PyObject* Python_REG_StringShort(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* reg; PyArg_ParseTuple(args, "k", ®); REG reg_object = *(REG*) reg; - return Py_BuildValue("s", REG_StringShort(reg_object).c_str()); + return SPPY::Py_BuildValue("s", REG_StringShort(reg_object).c_str()); } diff --git a/REG.h b/REG.h index 29fc4cc..15e8be3 100644 --- a/REG.h +++ b/REG.h @@ -1,21 +1,21 @@ #ifndef F_H #define F_H -PyObject* Python_REG_is_reg(PyObject* self, PyObject* args); -PyObject* Python_REG_is_pseudo(PyObject* self, PyObject* args); -PyObject* Python_REG_is_gr(PyObject* self, PyObject* args); -PyObject* Python_REG_is_fr(PyObject* self, PyObject* args); -PyObject* Python_REG_is_br(PyObject* self, PyObject* args); -PyObject* Python_REG_is_gr64(PyObject* self, PyObject* args); -PyObject* Python_REG_is_gr32(PyObject* self, PyObject* args); -PyObject* Python_REG_is_gr16(PyObject* self, PyObject* args); -PyObject* Python_REG_is_gr8(PyObject* self, PyObject* args); -PyObject* Python_REG_is_seg(PyObject* self, PyObject* args); -PyObject* Python_REG_is_pin_gr(PyObject* self, PyObject* args); -PyObject* Python_REG_INVALID(PyObject* self, PyObject* args); -PyObject* Python_REG_valid(PyObject* self, PyObject* args); -PyObject* Python_REG_is_pin64(PyObject* self, PyObject* args); -PyObject* Python_REG_FullRegName(PyObject* self, PyObject* args); -PyObject* Python_REG_StringShort(PyObject* self, PyObject* args); +SPPY::PyObject* Python_REG_is_reg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_pseudo(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_gr(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_fr(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_br(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_gr64(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_gr32(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_gr16(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_gr8(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_seg(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_pin_gr(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_INVALID(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_valid(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_is_pin64(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_FullRegName(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_REG_StringShort(SPPY::PyObject* self, SPPY::PyObject* args); #endif diff --git a/RTN.cpp b/RTN.cpp index b443e25..262ed61 100644 --- a/RTN.cpp +++ b/RTN.cpp @@ -1,50 +1,54 @@ -#include #include "pin.H" +namespace SPPY +{ +#include +} + #include "RTN.h" -PyObject* get_pointer(PyObject* self, PyObject* args) { - PyObject* target; +SPPY::PyObject* get_pointer(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* target; PyArg_ParseTuple(args, "k", &target); - return PyInt_FromLong(*(ADDRINT*)target); + return SPPY::PyInt_FromLong(*(ADDRINT*)target); } -PyObject* set_pointer(PyObject* self, PyObject* args) { - PyObject* target; - PyObject* value; +SPPY::PyObject* set_pointer(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* target; + SPPY::PyObject* value; PyArg_ParseTuple(args, "O|O", &target, &value); ADDRINT* p_target = (ADDRINT*) PyInt_AsLong(target); ADDRINT p_value = (ADDRINT) PyInt_AsLong(value); //printf("*%p = %lx\n", p_target, p_value); *p_target = p_value; - return Py_True; + return ((SPPY::PyObject *) &SPPY::_Py_TrueStruct); } void RTN_IPOINT_AFTER( - char* name, PyObject* callback, long int return_value, + char* name, SPPY::PyObject* callback, long int return_value, ADDRINT* reg_gax, ADDRINT* reg_gbx, ADDRINT* reg_gcx, ADDRINT* reg_gdx, ADDRINT* reg_gbp, ADDRINT* reg_gsp, ADDRINT* reg_gdi, ADDRINT* reg_gsi ) { - PyObject* arguments = PyTuple_New(1); - - PyObject* everything = PyDict_New(); - PyDict_SetItemString(everything, "function", PyString_FromString(name)); - PyDict_SetItemString(everything, "return", PyInt_FromLong(return_value)); - PyDict_SetItemString(everything, "reg_gax", Py_BuildValue("k", reg_gax)); - PyDict_SetItemString(everything, "reg_gbx", Py_BuildValue("k", reg_gbx)); - PyDict_SetItemString(everything, "reg_gcx", Py_BuildValue("k", reg_gcx)); - PyDict_SetItemString(everything, "reg_gdx", Py_BuildValue("k", reg_gdx)); - PyDict_SetItemString(everything, "reg_gbp", Py_BuildValue("k", reg_gbp)); - PyDict_SetItemString(everything, "reg_gsp", Py_BuildValue("k", reg_gsp)); - PyDict_SetItemString(everything, "reg_gdi", Py_BuildValue("k", reg_gdi)); - PyDict_SetItemString(everything, "reg_gsi", Py_BuildValue("k", reg_gsi)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(1); + + SPPY::PyObject* everything = SPPY::PyDict_New(); + SPPY::PyDict_SetItemString(everything, "function", SPPY::PyString_FromString(name)); + SPPY::PyDict_SetItemString(everything, "return", SPPY::PyInt_FromLong(return_value)); + SPPY::PyDict_SetItemString(everything, "reg_gax", SPPY::Py_BuildValue("k", reg_gax)); + SPPY::PyDict_SetItemString(everything, "reg_gbx", SPPY::Py_BuildValue("k", reg_gbx)); + SPPY::PyDict_SetItemString(everything, "reg_gcx", SPPY::Py_BuildValue("k", reg_gcx)); + SPPY::PyDict_SetItemString(everything, "reg_gdx", SPPY::Py_BuildValue("k", reg_gdx)); + SPPY::PyDict_SetItemString(everything, "reg_gbp", SPPY::Py_BuildValue("k", reg_gbp)); + SPPY::PyDict_SetItemString(everything, "reg_gsp", SPPY::Py_BuildValue("k", reg_gsp)); + SPPY::PyDict_SetItemString(everything, "reg_gdi", SPPY::Py_BuildValue("k", reg_gdi)); + SPPY::PyDict_SetItemString(everything, "reg_gsi", SPPY::Py_BuildValue("k", reg_gsi)); PyTuple_SetItem(arguments, 0, everything); - PyObject_CallObject(callback, arguments); + SPPY::PyObject_CallObject(callback, arguments); } void RTN_IPOINT_BEFORE( - char* name, int num_args, PyObject* callback, + char* name, int num_args, SPPY::PyObject* callback, long int arg0, long int arg1, long int arg2, long int arg3, long int arg4, long int arg5, long int arg6, long int arg7, long int arg8, long int arg9, long int arg10, ADDRINT* ref_arg0, ADDRINT* ref_arg1, ADDRINT* ref_arg2, ADDRINT* ref_arg3, ADDRINT* ref_arg4, @@ -52,60 +56,60 @@ void RTN_IPOINT_BEFORE( ADDRINT* reg_gax, ADDRINT* reg_gbx, ADDRINT* reg_gcx, ADDRINT* reg_gdx, ADDRINT* reg_gbp, ADDRINT* reg_gsp, ADDRINT* reg_gdi, ADDRINT* reg_gsi ) { - PyObject* arguments = PyTuple_New(1); - - PyObject* everything = PyDict_New(); - PyDict_SetItemString(everything, "function", PyString_FromString(name)); - PyDict_SetItemString(everything, "arg_0", PyInt_FromLong(arg0)); - PyDict_SetItemString(everything, "arg_1", PyInt_FromLong(arg1)); - PyDict_SetItemString(everything, "arg_2", PyInt_FromLong(arg2)); - PyDict_SetItemString(everything, "arg_3", PyInt_FromLong(arg3)); - PyDict_SetItemString(everything, "arg_4", PyInt_FromLong(arg4)); - PyDict_SetItemString(everything, "arg_5", PyInt_FromLong(arg5)); - PyDict_SetItemString(everything, "arg_6", PyInt_FromLong(arg6)); - PyDict_SetItemString(everything, "arg_7", PyInt_FromLong(arg7)); - PyDict_SetItemString(everything, "arg_8", PyInt_FromLong(arg8)); - PyDict_SetItemString(everything, "arg_9", PyInt_FromLong(arg9)); - PyDict_SetItemString(everything, "arg_10", PyInt_FromLong(arg10)); - PyDict_SetItemString(everything, "ref_arg_0", PyInt_FromLong((long int) ref_arg0)); - PyDict_SetItemString(everything, "ref_arg_1", PyInt_FromLong((long int) ref_arg1)); - PyDict_SetItemString(everything, "ref_arg_2", PyInt_FromLong((long int) ref_arg2)); - PyDict_SetItemString(everything, "ref_arg_3", PyInt_FromLong((long int) ref_arg3)); - PyDict_SetItemString(everything, "ref_arg_4", PyInt_FromLong((long int) ref_arg4)); - PyDict_SetItemString(everything, "ref_arg_5", PyInt_FromLong((long int) ref_arg5)); - PyDict_SetItemString(everything, "ref_arg_6", PyInt_FromLong((long int) ref_arg6)); - PyDict_SetItemString(everything, "ref_arg_7", PyInt_FromLong((long int) ref_arg7)); - PyDict_SetItemString(everything, "ref_arg_8", PyInt_FromLong((long int) ref_arg8)); - PyDict_SetItemString(everything, "ref_arg_9", PyInt_FromLong((long int) ref_arg9)); - PyDict_SetItemString(everything, "ref_arg_10", PyInt_FromLong((long int) ref_arg10)); - PyDict_SetItemString(everything, "reg_gax", Py_BuildValue("k", reg_gax)); - PyDict_SetItemString(everything, "reg_gbx", Py_BuildValue("k", reg_gbx)); - PyDict_SetItemString(everything, "reg_gcx", Py_BuildValue("k", reg_gcx)); - PyDict_SetItemString(everything, "reg_gdx", Py_BuildValue("k", reg_gdx)); - PyDict_SetItemString(everything, "reg_gbp", Py_BuildValue("k", reg_gbp)); - PyDict_SetItemString(everything, "reg_gsp", Py_BuildValue("k", reg_gsp)); - PyDict_SetItemString(everything, "reg_gdi", Py_BuildValue("k", reg_gdi)); - PyDict_SetItemString(everything, "reg_gsi", Py_BuildValue("k", reg_gsi)); + SPPY::PyObject* arguments = SPPY::PyTuple_New(1); + + SPPY::PyObject* everything = SPPY::PyDict_New(); + SPPY::PyDict_SetItemString(everything, "function", SPPY::PyString_FromString(name)); + SPPY::PyDict_SetItemString(everything, "arg_0", SPPY::PyInt_FromLong(arg0)); + SPPY::PyDict_SetItemString(everything, "arg_1", SPPY::PyInt_FromLong(arg1)); + SPPY::PyDict_SetItemString(everything, "arg_2", SPPY::PyInt_FromLong(arg2)); + SPPY::PyDict_SetItemString(everything, "arg_3", SPPY::PyInt_FromLong(arg3)); + SPPY::PyDict_SetItemString(everything, "arg_4", SPPY::PyInt_FromLong(arg4)); + SPPY::PyDict_SetItemString(everything, "arg_5", SPPY::PyInt_FromLong(arg5)); + SPPY::PyDict_SetItemString(everything, "arg_6", SPPY::PyInt_FromLong(arg6)); + SPPY::PyDict_SetItemString(everything, "arg_7", SPPY::PyInt_FromLong(arg7)); + SPPY::PyDict_SetItemString(everything, "arg_8", SPPY::PyInt_FromLong(arg8)); + SPPY::PyDict_SetItemString(everything, "arg_9", SPPY::PyInt_FromLong(arg9)); + SPPY::PyDict_SetItemString(everything, "arg_10", SPPY::PyInt_FromLong(arg10)); + SPPY::PyDict_SetItemString(everything, "ref_arg_0", SPPY::PyInt_FromLong((long int) ref_arg0)); + SPPY::PyDict_SetItemString(everything, "ref_arg_1", SPPY::PyInt_FromLong((long int) ref_arg1)); + SPPY::PyDict_SetItemString(everything, "ref_arg_2", SPPY::PyInt_FromLong((long int) ref_arg2)); + SPPY::PyDict_SetItemString(everything, "ref_arg_3", SPPY::PyInt_FromLong((long int) ref_arg3)); + SPPY::PyDict_SetItemString(everything, "ref_arg_4", SPPY::PyInt_FromLong((long int) ref_arg4)); + SPPY::PyDict_SetItemString(everything, "ref_arg_5", SPPY::PyInt_FromLong((long int) ref_arg5)); + SPPY::PyDict_SetItemString(everything, "ref_arg_6", SPPY::PyInt_FromLong((long int) ref_arg6)); + SPPY::PyDict_SetItemString(everything, "ref_arg_7", SPPY::PyInt_FromLong((long int) ref_arg7)); + SPPY::PyDict_SetItemString(everything, "ref_arg_8", SPPY::PyInt_FromLong((long int) ref_arg8)); + SPPY::PyDict_SetItemString(everything, "ref_arg_9", SPPY::PyInt_FromLong((long int) ref_arg9)); + SPPY::PyDict_SetItemString(everything, "ref_arg_10", SPPY::PyInt_FromLong((long int) ref_arg10)); + SPPY::PyDict_SetItemString(everything, "reg_gax", SPPY::Py_BuildValue("k", reg_gax)); + SPPY::PyDict_SetItemString(everything, "reg_gbx", SPPY::Py_BuildValue("k", reg_gbx)); + SPPY::PyDict_SetItemString(everything, "reg_gcx", SPPY::Py_BuildValue("k", reg_gcx)); + SPPY::PyDict_SetItemString(everything, "reg_gdx", SPPY::Py_BuildValue("k", reg_gdx)); + SPPY::PyDict_SetItemString(everything, "reg_gbp", SPPY::Py_BuildValue("k", reg_gbp)); + SPPY::PyDict_SetItemString(everything, "reg_gsp", SPPY::Py_BuildValue("k", reg_gsp)); + SPPY::PyDict_SetItemString(everything, "reg_gdi", SPPY::Py_BuildValue("k", reg_gdi)); + SPPY::PyDict_SetItemString(everything, "reg_gsi", SPPY::Py_BuildValue("k", reg_gsi)); PyTuple_SetItem(arguments, 0, everything); - if (PyObject_CallObject(callback, arguments)) { + if (SPPY::PyObject_CallObject(callback, arguments)) { } else { printf("no\n"); - PyErr_Print(); + SPPY::PyErr_Print(); } } -PyObject* Python_RTN_InsertCall(PyObject* self, PyObject* args) { - PyObject* num_args; - PyObject* function_name; - PyObject* rtn; - PyObject* callable; - PyObject* ipoint; +SPPY::PyObject* Python_RTN_InsertCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* num_args; + SPPY::PyObject* function_name; + SPPY::PyObject* rtn; + SPPY::PyObject* callable; + SPPY::PyObject* ipoint; PyArg_ParseTuple(args, "k|O|k|k|O", &ipoint, &function_name, &rtn, &num_args, &callable); if (!PyCallable_Check(callable) || (long int) num_args > 10 || (long int) num_args < 0) { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } //cout << "function_name: " << PyString_AsString(function_name) << endl; @@ -161,10 +165,10 @@ PyObject* Python_RTN_InsertCall(PyObject* self, PyObject* args) { IARG_REG_REFERENCE, REG_GSI, IARG_END); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); /* for (int i=0; i < PyTuple_Size(args); i++) { cur = PyTuple_GetItem(args, i); @@ -175,231 +179,231 @@ PyObject* Python_RTN_InsertCall(PyObject* self, PyObject* args) { } } - return Py_BuildValue("O", Py_False);*/ + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct));*/ } -PyObject* Python_RTN_Next(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_RTN_Next(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); RTN x_object = *(RTN*) x; RTN* rtn_return = (RTN*) malloc(sizeof(RTN)); *rtn_return = RTN_Next(x_object); - return Py_BuildValue("k", rtn_return); + return SPPY::Py_BuildValue("k", rtn_return); } -PyObject* Python_RTN_Prev(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_RTN_Prev(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); RTN x_object = *(RTN*) x; RTN* rtn_return = (RTN*) malloc(sizeof(RTN)); *rtn_return = RTN_Prev(x_object); - return Py_BuildValue("k", rtn_return); + return SPPY::Py_BuildValue("k", rtn_return); } -PyObject* Python_RTN_Invalid(PyObject* self, PyObject* args) { +SPPY::PyObject* Python_RTN_Invalid(SPPY::PyObject* self, SPPY::PyObject* args) { RTN* rtn_return = (RTN*) malloc(sizeof(RTN)); *rtn_return = RTN_Invalid(); - return Py_BuildValue("k", rtn_return); + return SPPY::Py_BuildValue("k", rtn_return); } -PyObject* Python_RTN_Valid(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_RTN_Valid(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); RTN x_object = *(RTN*) x; if (RTN_Valid(x_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_RTN_Name(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_RTN_Name(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); RTN x_object = *(RTN*) x; - return Py_BuildValue("s", RTN_Name(x_object).c_str()); + return SPPY::Py_BuildValue("s", RTN_Name(x_object).c_str()); } -PyObject* Python_RTN_Sym(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_RTN_Sym(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); RTN x_object = *(RTN*) x; SYM* sym_return = (SYM*) malloc(sizeof(SYM)); *sym_return = RTN_Sym(x_object); - return Py_BuildValue("k", sym_return); + return SPPY::Py_BuildValue("k", sym_return); } -PyObject* Python_RTN_Id(PyObject* self, PyObject* args) { - PyObject* x; +SPPY::PyObject* Python_RTN_Id(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* x; PyArg_ParseTuple(args, "k", &x); RTN x_object = *(RTN*) x; - return Py_BuildValue("k", RTN_Id(x_object)); + return SPPY::Py_BuildValue("k", RTN_Id(x_object)); } -PyObject* Python_RTN_Range(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_Range(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; - return Py_BuildValue("k", RTN_Range(rtn_object)); + return SPPY::Py_BuildValue("k", RTN_Range(rtn_object)); } -PyObject* Python_RTN_Size(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_Size(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; - return Py_BuildValue("k", RTN_Size(rtn_object)); + return SPPY::Py_BuildValue("k", RTN_Size(rtn_object)); } -PyObject* Python_RTN_FindNameByAddress(PyObject* self, PyObject* args) { - PyObject* address; +SPPY::PyObject* Python_RTN_FindNameByAddress(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* address; PyArg_ParseTuple(args, "k", &address); ADDRINT address_object = (ADDRINT) address; - return Py_BuildValue("s", RTN_FindNameByAddress(address_object).c_str()); + return SPPY::Py_BuildValue("s", RTN_FindNameByAddress(address_object).c_str()); } -PyObject* Python_RTN_FindByAddress(PyObject* self, PyObject* args) { - PyObject* address; +SPPY::PyObject* Python_RTN_FindByAddress(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* address; PyArg_ParseTuple(args, "k", &address); ADDRINT address_object = (ADDRINT) address; RTN* rtn_return = (RTN*) malloc(sizeof(RTN)); *rtn_return = RTN_FindByAddress(address_object); - return Py_BuildValue("k", rtn_return); + return SPPY::Py_BuildValue("k", rtn_return); } -PyObject* Python_RTN_FindByName(PyObject* self, PyObject* args) { - PyObject* img; - PyObject* name; +SPPY::PyObject* Python_RTN_FindByName(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* img; + SPPY::PyObject* name; PyArg_ParseTuple(args, "k|O", &img, &name); IMG img_object = *(IMG*) img; char* name_object = PyString_AsString(name); RTN* rtn_return = (RTN*) malloc(sizeof(RTN)); *rtn_return = RTN_FindByName(img_object, name_object); - return Py_BuildValue("k", rtn_return); + return SPPY::Py_BuildValue("k", rtn_return); } -PyObject* Python_RTN_Open(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_Open(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; RTN_Open(rtn_object); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_RTN_Close(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_Close(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; RTN_Close(rtn_object); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_RTN_InsHead(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_InsHead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; INS* ins_return = (INS*) malloc(sizeof(INS)); *ins_return = RTN_InsHead(rtn_object); - return Py_BuildValue("k", ins_return); + return SPPY::Py_BuildValue("k", ins_return); } -PyObject* Python_RTN_InsHeadOnly(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_InsHeadOnly(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; INS* ins_return = (INS*) malloc(sizeof(INS)); *ins_return = RTN_InsHeadOnly(rtn_object); - return Py_BuildValue("k", ins_return); + return SPPY::Py_BuildValue("k", ins_return); } -PyObject* Python_RTN_InsTail(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_InsTail(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; INS* ins_return = (INS*) malloc(sizeof(INS)); *ins_return = RTN_InsTail(rtn_object); - return Py_BuildValue("k", ins_return); + return SPPY::Py_BuildValue("k", ins_return); } -PyObject* Python_RTN_NumIns(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_NumIns(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; - return Py_BuildValue("k", RTN_NumIns(rtn_object)); + return SPPY::Py_BuildValue("k", RTN_NumIns(rtn_object)); } -PyObject* Python_RTN_Address(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_Address(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; - return Py_BuildValue("k", RTN_Address(rtn_object)); + return SPPY::Py_BuildValue("k", RTN_Address(rtn_object)); } -PyObject* Python_RTN_CreateAt(PyObject* self, PyObject* args) { - PyObject* address; - PyObject* name; +SPPY::PyObject* Python_RTN_CreateAt(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* address; + SPPY::PyObject* name; PyArg_ParseTuple(args, "k|s", &address, &name); ADDRINT address_object = (ADDRINT) address; char* name_object = PyString_AsString(name); RTN* rtn_return = (RTN*) malloc(sizeof(RTN)); *rtn_return = RTN_CreateAt(address_object, name_object); - return Py_BuildValue("k", rtn_return); + return SPPY::Py_BuildValue("k", rtn_return); } -PyObject* Python_RTN_IsDynamic(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_IsDynamic(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; if (RTN_IsDynamic(rtn_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_RTN_IsSafeForProbedInsertion(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_IsSafeForProbedInsertion(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; if (RTN_IsSafeForProbedInsertion(rtn_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_RTN_IsSafeForProbedInsertionEx(PyObject* self, PyObject* args) { - PyObject* rtn; - PyObject* mode; +SPPY::PyObject* Python_RTN_IsSafeForProbedInsertionEx(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; + SPPY::PyObject* mode; PyArg_ParseTuple(args, "k|k", &rtn, &mode); RTN rtn_object = *(RTN*) rtn; PROBE_MODE mode_object = *(PROBE_MODE*) mode; if (RTN_IsSafeForProbedInsertionEx(rtn_object, mode_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_RTN_IsSafeForProbedReplacement(PyObject* self, PyObject* args) { - PyObject* rtn; +SPPY::PyObject* Python_RTN_IsSafeForProbedReplacement(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; PyArg_ParseTuple(args, "k", &rtn); RTN rtn_object = *(RTN*) rtn; if (RTN_IsSafeForProbedReplacement(rtn_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } -PyObject* Python_RTN_IsSafeForProbedReplacementEx(PyObject* self, PyObject* args) { - PyObject* rtn; - PyObject* mode; +SPPY::PyObject* Python_RTN_IsSafeForProbedReplacementEx(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* rtn; + SPPY::PyObject* mode; PyArg_ParseTuple(args, "k|k", &rtn, &mode); RTN rtn_object = *(RTN*) rtn; PROBE_MODE mode_object = *(PROBE_MODE*) mode; if (RTN_IsSafeForProbedReplacementEx(rtn_object, mode_object)) { - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } else { - return Py_BuildValue("O", Py_False); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_ZeroStruct)); } } \ No newline at end of file diff --git a/RTN.h b/RTN.h index 5686d3e..62a041c 100644 --- a/RTN.h +++ b/RTN.h @@ -1,24 +1,24 @@ #ifndef C_H #define C_H -PyObject* Python_RTN_InsertCall(PyObject* self, PyObject* args); -PyObject* Python_RTN_Name(PyObject* self, PyObject* args); -PyObject* Python_RTN_Address(PyObject* self, PyObject* args); +SPPY::PyObject* Python_RTN_InsertCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_Name(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_Address(SPPY::PyObject* self, SPPY::PyObject* args); /*AUTO GENERATED SKELETONS*/ -PyObject* Python_RTN_Valid(PyObject* self, PyObject* args); -PyObject* Python_RTN_Id(PyObject* self, PyObject* args); -PyObject* Python_RTN_Range(PyObject* self, PyObject* args); -PyObject* Python_RTN_Size(PyObject* self, PyObject* args); -PyObject* Python_RTN_IsDynamic(PyObject* self, PyObject* args); -PyObject* Python_RTN_IsSafeForProbedInsertion(PyObject* self, PyObject* args); -PyObject* Python_RTN_IsSafeForProbedReplacement(PyObject* self, PyObject* args); +SPPY::PyObject* Python_RTN_Valid(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_Id(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_Range(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_Size(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_IsDynamic(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_IsSafeForProbedInsertion(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_IsSafeForProbedReplacement(SPPY::PyObject* self, SPPY::PyObject* args); -PyObject* Python_RTN_FindNameByAddress(PyObject* self, PyObject* args); -PyObject* Python_RTN_FindByName(PyObject* self, PyObject* args); -PyObject* Python_RTN_Open(PyObject* self, PyObject* args); -PyObject* Python_RTN_Close(PyObject* self, PyObject* args); -PyObject* Python_RTN_InsHead(PyObject* self, PyObject* args); +SPPY::PyObject* Python_RTN_FindNameByAddress(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_FindByName(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_Open(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_Close(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_InsHead(SPPY::PyObject* self, SPPY::PyObject* args); -PyObject* Python_RTN_InsTail(PyObject* self, PyObject* args); -PyObject* Python_RTN_NumIns(PyObject* self, PyObject* args); +SPPY::PyObject* Python_RTN_InsTail(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_RTN_NumIns(SPPY::PyObject* self, SPPY::PyObject* args); #endif diff --git a/SYS.cpp b/SYS.cpp index 634d1a9..c2df768 100644 --- a/SYS.cpp +++ b/SYS.cpp @@ -1,49 +1,52 @@ -#include #include "pin.H" +namespace SPPY +{ +#include +} -PyObject* Python_PIN_GetSyscallArgument(PyObject* self, PyObject* args) { - PyObject* context; - PyObject* std; - PyObject* number; +SPPY::PyObject* Python_PIN_GetSyscallArgument(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* context; + SPPY::PyObject* std; + SPPY::PyObject* number; PyArg_ParseTuple(args, "O|O|O", &context, &std, &number); - return Py_BuildValue("k", PIN_GetSyscallArgument((CONTEXT*) *(CONTEXT**)PyInt_AsLong(context), (SYSCALL_STANDARD) *(SYSCALL_STANDARD*)PyInt_AsLong(std), (int) PyInt_AsLong(number))); + return SPPY::Py_BuildValue("k", PIN_GetSyscallArgument((CONTEXT*) *(CONTEXT**)PyInt_AsLong(context), (SYSCALL_STANDARD) *(SYSCALL_STANDARD*)PyInt_AsLong(std), (int) PyInt_AsLong(number))); } -PyObject* Python_PIN_GetSyscallReturn(PyObject* self, PyObject* args) { - PyObject* context; - PyObject* std; +SPPY::PyObject* Python_PIN_GetSyscallReturn(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* context; + SPPY::PyObject* std; PyArg_ParseTuple(args, "O|O", &context, &std); - return Py_BuildValue("k", PIN_GetSyscallReturn((CONTEXT*) *(CONTEXT**)PyInt_AsLong(context), (SYSCALL_STANDARD) *(SYSCALL_STANDARD*)PyInt_AsLong(std))); + return SPPY::Py_BuildValue("k", PIN_GetSyscallReturn((CONTEXT*) *(CONTEXT**)PyInt_AsLong(context), (SYSCALL_STANDARD) *(SYSCALL_STANDARD*)PyInt_AsLong(std))); } -PyObject* Python_PIN_GetSyscallNumber(PyObject* self, PyObject* args) { - PyObject* context; - PyObject* std; +SPPY::PyObject* Python_PIN_GetSyscallNumber(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* context; + SPPY::PyObject* std; PyArg_ParseTuple(args, "O|O", &context, &std); - return Py_BuildValue("k", PIN_GetSyscallNumber((CONTEXT*) *(CONTEXT**)PyInt_AsLong(context), (SYSCALL_STANDARD) *(SYSCALL_STANDARD*)PyInt_AsLong(std))); + return SPPY::Py_BuildValue("k", PIN_GetSyscallNumber((CONTEXT*) *(CONTEXT**)PyInt_AsLong(context), (SYSCALL_STANDARD) *(SYSCALL_STANDARD*)PyInt_AsLong(std))); } -PyObject* Python_PIN_SetSyscallArgument(PyObject* self, PyObject* args) { - PyObject* context; - PyObject* std; - PyObject* number; - PyObject* value; +SPPY::PyObject* Python_PIN_SetSyscallArgument(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* context; + SPPY::PyObject* std; + SPPY::PyObject* number; + SPPY::PyObject* value; PyArg_ParseTuple(args, "O|O|O|O", &context, &std, &number, &value); PIN_SetSyscallArgument((CONTEXT*) *(CONTEXT**)PyInt_AsLong(context), (SYSCALL_STANDARD) *(SYSCALL_STANDARD*)PyInt_AsLong(std), (int) PyInt_AsLong(number), (ADDRINT) PyInt_AsLong(value)); - return Py_BuildValue("O", Py_None); + return SPPY::Py_BuildValue("O", (&SPPY::_Py_NoneStruct)); } -PyObject* Python_PIN_SetSyscallNumber(PyObject* self, PyObject* args) { - PyObject* context; - PyObject* std; - PyObject* value; +SPPY::PyObject* Python_PIN_SetSyscallNumber(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* context; + SPPY::PyObject* std; + SPPY::PyObject* value; PyArg_ParseTuple(args, "O|O|O", &context, &std, &value); PIN_SetSyscallNumber((CONTEXT*) *(CONTEXT**)PyInt_AsLong(context), (SYSCALL_STANDARD) *(SYSCALL_STANDARD*)PyInt_AsLong(std), (ADDRINT) PyInt_AsLong(value)); - return Py_BuildValue("O", Py_None); + return SPPY::Py_BuildValue("O", (&SPPY::_Py_NoneStruct)); } diff --git a/SYS.h b/SYS.h index f5fd8df..ba5310f 100644 --- a/SYS.h +++ b/SYS.h @@ -1,10 +1,10 @@ #ifndef D_H #define D_H -PyObject* Python_PIN_GetSyscallArgument(PyObject* self, PyObject* args); -PyObject* Python_PIN_GetSyscallReturn(PyObject* self, PyObject* args); -PyObject* Python_PIN_GetSyscallNumber(PyObject* self, PyObject* args); -PyObject* Python_PIN_SetSyscallArgument(PyObject* self, PyObject* args); -PyObject* Python_PIN_SetSyscallNumber(PyObject* self, PyObject* args); +SPPY::PyObject* Python_PIN_GetSyscallArgument(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_PIN_GetSyscallReturn(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_PIN_GetSyscallNumber(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_PIN_SetSyscallArgument(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_PIN_SetSyscallNumber(SPPY::PyObject* self, SPPY::PyObject* args); #endif \ No newline at end of file diff --git a/TRACE.cpp b/TRACE.cpp index a1f31cd..66a2d23 100644 --- a/TRACE.cpp +++ b/TRACE.cpp @@ -1,223 +1,226 @@ -#include #include "pin.H" +namespace SPPY +{ +#include +} #include "TRACE.h" /********* TRACE STUFF ****************/ /* VERIFIED */ -PyObject* Python_TRACE_Address(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_Address(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); //EACH LONG IS LIKE A DEREFERENCE SO FIRST IS AN ADDRESS TO THE ACTUAL VALUE SECOND IS THE VALUE - return Py_BuildValue("k", Py_BuildValue("k", TRACE_Address((TRACE)PyInt_AsLong(trace)))); + return SPPY::Py_BuildValue("k", SPPY::Py_BuildValue("k", TRACE_Address((TRACE)PyInt_AsLong(trace)))); } /* VERIFIED */ -PyObject* Python_TRACE_Original(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_Original(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("k", TRACE_Original((TRACE)PyInt_AsLong(trace))); + return SPPY::Py_BuildValue("k", TRACE_Original((TRACE)PyInt_AsLong(trace))); } /* VERIFIED */ -PyObject* Python_TRACE_BblHead(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_BblHead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); BBL *need = (BBL*) malloc(sizeof(BBL)); *need = TRACE_BblHead(*(TRACE*) PyInt_AsLong(trace)); - return Py_BuildValue("k", need); + return SPPY::Py_BuildValue("k", need); } /* VERIFIED */ -PyObject* Python_TRACE_BblTail(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_BblTail(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); BBL *need = (BBL*) malloc(sizeof(BBL)); *need = TRACE_BblTail(*(TRACE*) PyInt_AsLong(trace)); - return Py_BuildValue("k", need); + return SPPY::Py_BuildValue("k", need); } /* VERIFIED */ -PyObject* Python_TRACE_Size(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_Size(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O", &trace); - return Py_BuildValue("k", TRACE_Size(*(TRACE*)PyInt_AsLong(trace))); + return SPPY::Py_BuildValue("k", TRACE_Size(*(TRACE*)PyInt_AsLong(trace))); } /* NEEDS TESTING IN RTN CLASS*/ -PyObject* Python_TRACE_Rtn(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_Rtn(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); RTN *rtn = (RTN*) malloc(sizeof(RTN)); *rtn = TRACE_Rtn(*(TRACE*)PyInt_AsLong(trace)); - return Py_BuildValue("k", rtn); + return SPPY::Py_BuildValue("k", rtn); } /* VERIFIED */ -PyObject* Python_TRACE_NumBbl(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_NumBbl(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("k", TRACE_NumBbl(*(TRACE*)PyInt_AsLong(trace))); + return SPPY::Py_BuildValue("k", TRACE_NumBbl(*(TRACE*)PyInt_AsLong(trace))); } /* VERIFIED */ -PyObject* Python_TRACE_NumIns(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_NumIns(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("k", TRACE_NumIns(*(TRACE*)PyInt_AsLong(trace))); + return SPPY::Py_BuildValue("k", TRACE_NumIns(*(TRACE*)PyInt_AsLong(trace))); } /* VERIFIED */ -PyObject* Python_TRACE_StubSize(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_StubSize(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("k", TRACE_StubSize(*(TRACE*)PyInt_AsLong(trace))); + return SPPY::Py_BuildValue("k", TRACE_StubSize(*(TRACE*)PyInt_AsLong(trace))); } /* NVERIFIED */ -PyObject* Python_TRACE_HasFallThrough(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_HasFallThrough(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("k", TRACE_HasFallThrough(*(TRACE*)PyInt_AsLong(trace))); + return SPPY::Py_BuildValue("k", TRACE_HasFallThrough(*(TRACE*)PyInt_AsLong(trace))); } /* Need to figure these 3 out */ -PyObject* Python_TRACE_InsertIfCall(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_InsertIfCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_TRACE_InsertThenCall(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_TRACE_InsertThenCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("O", Py_True); //Py_BuildValue("k", TRACE_Address((TRACE)PyInt_AsLong(trace)))); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); //SPPY::Py_BuildValue("k", TRACE_Address((TRACE)PyInt_AsLong(trace)))); } -PyObject* Python_TRACE_InsertCall(PyObject* self, PyObject* args){ - PyObject* trace; +SPPY::PyObject* Python_TRACE_InsertCall(SPPY::PyObject* self, SPPY::PyObject* args){ + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("O", Py_True); //Py_BuildValue("k", TRACE_Address((TRACE)PyInt_AsLong(trace)))); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); //SPPY::Py_BuildValue("k", TRACE_Address((TRACE)PyInt_AsLong(trace)))); } /************ BBL STUFF ******************/ /* VERIFIED */ -PyObject* Python_BBL_MoveAllAttributes(PyObject* self, PyObject* args) { - PyObject* bbl_src, * bbl_dest; +SPPY::PyObject* Python_BBL_MoveAllAttributes(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* bbl_src, * bbl_dest; PyArg_ParseTuple(args, "k|k", &bbl_src, &bbl_dest); BBL src = *(BBL *) bbl_src; BBL dest = *(BBL *) bbl_dest; BBL_MoveAllAttributes(src, dest); - return Py_BuildValue("O", Py_None); + return SPPY::Py_BuildValue("O", (&SPPY::_Py_NoneStruct)); } /* VERIFIED */ -PyObject* Python_BBL_NumIns(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_NumIns(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "k",&trace); - return Py_BuildValue("k", BBL_NumIns(*(BBL*)trace)); + return SPPY::Py_BuildValue("k", BBL_NumIns(*(BBL*)trace)); } /* VERIFIED */ -PyObject* Python_BBL_HasFallThrough(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_HasFallThrough(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "k",&trace); - return Py_BuildValue("k", BBL_HasFallThrough(*(BBL*)trace)); + return SPPY::Py_BuildValue("k", BBL_HasFallThrough(*(BBL*)trace)); } /*NEED TO IMPLEMENT INS FIRST */ -PyObject* Python_BBL_InsHead(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_InsHead(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O", &trace); INS *need = (INS*) malloc(sizeof(INS)); *need = BBL_InsHead(*(BBL*) PyInt_AsLong(trace)); - return Py_BuildValue("k", need); + return SPPY::Py_BuildValue("k", need); } /*NEED TO IMPLEMENT INS FIRST */ -PyObject* Python_BBL_InsTail(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_InsTail(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } /* VERIFIED*/ -PyObject* Python_BBL_Next(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_Next(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); BBL *need = (BBL*) malloc(sizeof(BBL)); *need = BBL_Next(*(BBL*) PyInt_AsLong(trace)); - return Py_BuildValue("k", need); + return SPPY::Py_BuildValue("k", need); } /* VERFIED */ -PyObject* Python_BBL_Prev(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_Prev(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); BBL* prev = (BBL*) malloc(sizeof(BBL)); *prev = BBL_Prev(*(BBL*) PyInt_AsLong(trace)); - return Py_BuildValue("k", prev); + return SPPY::Py_BuildValue("k", prev); } /* VERIFIED */ -PyObject* Python_BBL_Valid(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_Valid(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "k",&trace); - return Py_BuildValue("k", BBL_Valid(*(BBL*)trace)); + return SPPY::Py_BuildValue("k", BBL_Valid(*(BBL*)trace)); } /* VERIFIED */ -PyObject* Python_BBL_Original(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_Original(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "k",&trace); - return Py_BuildValue("k", BBL_Original(*(BBL*)trace)); + return SPPY::Py_BuildValue("k", BBL_Original(*(BBL*)trace)); } /* VERIFIED */ -PyObject* Python_BBL_Address(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_Address(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "k",&trace); - return Py_BuildValue("k", BBL_Address(*(BBL*)trace)); + return SPPY::Py_BuildValue("k", BBL_Address(*(BBL*)trace)); } /* VERIFIED */ -PyObject* Python_BBL_Size(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_Size(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "k",&trace); - return Py_BuildValue("k", BBL_Size(*(BBL*)trace)); + return SPPY::Py_BuildValue("k", BBL_Size(*(BBL*)trace)); } /* NOT IMPLEMENTED */ -PyObject* Python_BBL_InsertCall(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_InsertCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_BBL_InsertIfCall(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_InsertIfCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } -PyObject* Python_BBL_InsertThenCall(PyObject* self, PyObject* args) { - PyObject* trace; +SPPY::PyObject* Python_BBL_InsertThenCall(SPPY::PyObject* self, SPPY::PyObject* args) { + SPPY::PyObject* trace; PyArg_ParseTuple(args, "O",&trace); - return Py_BuildValue("O", Py_True); + return SPPY::Py_BuildValue("O", ((SPPY::PyObject *) &SPPY::_Py_TrueStruct)); } diff --git a/TRACE.h b/TRACE.h index af96e82..a0cbc9e 100644 --- a/TRACE.h +++ b/TRACE.h @@ -2,35 +2,35 @@ #define E_H /* TRACE STUFF */ -PyObject* Python_TRACE_Address(PyObject* self, PyObject* args); -PyObject* Python_TRACE_BblHead(PyObject* self, PyObject* args); -PyObject* Python_TRACE_Original(PyObject* self, PyObject* args); -PyObject* Python_TRACE_InsertCall(PyObject* self, PyObject* args); -PyObject* Python_TRACE_InsertIfCall(PyObject* self, PyObject* args); -PyObject* Python_TRACE_InsertThenCall(PyObject* self, PyObject* args); -PyObject* Python_TRACE_BblTail(PyObject* self, PyObject* args); -PyObject* Python_TRACE_Size(PyObject* self, PyObject* args); -PyObject* Python_TRACE_Rtn(PyObject* self, PyObject* args); -PyObject* Python_TRACE_HasFallThrough(PyObject* self, PyObject* args); -PyObject* Python_TRACE_NumBbl(PyObject* self, PyObject* args); -PyObject* Python_TRACE_NumIns(PyObject* self, PyObject* args); -PyObject* Python_TRACE_StubSize(PyObject* self, PyObject* args); +SPPY::PyObject* Python_TRACE_Address(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_BblHead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_Original(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_InsertCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_InsertIfCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_InsertThenCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_BblTail(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_Size(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_Rtn(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_HasFallThrough(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_NumBbl(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_NumIns(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_StubSize(SPPY::PyObject* self, SPPY::PyObject* args); /* BBL STUFF */ -PyObject* Python_BBL_MoveAllAttributes(PyObject* self, PyObject* args); -PyObject* Python_BBL_NumIns(PyObject* self, PyObject* args); -PyObject* Python_BBL_InsHead(PyObject* self, PyObject* args); -PyObject* Python_BBL_InsTail(PyObject* self, PyObject* args); -PyObject* Python_BBL_Next(PyObject* self, PyObject* args); -PyObject* Python_BBL_Prev(PyObject* self, PyObject* args); -PyObject* Python_BBL_Valid(PyObject* self, PyObject* args); -PyObject* Python_BBL_Original(PyObject* self, PyObject* args); -PyObject* Python_BBL_Address(PyObject* self, PyObject* args); -PyObject* Python_BBL_Size(PyObject* self, PyObject* args); -PyObject* Python_BBL_InsertCall(PyObject* self, PyObject* args); -PyObject* Python_BBL_InsertIfCall(PyObject* self, PyObject* args); -PyObject* Python_BBL_InsertThenCall(PyObject* self, PyObject* args); -PyObject* Python_BBL_HasFallThrough(PyObject* self, PyObject* args); +SPPY::PyObject* Python_BBL_MoveAllAttributes(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_NumIns(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_InsHead(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_InsTail(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_Next(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_Prev(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_Valid(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_Original(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_Address(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_Size(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_InsertCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_InsertIfCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_InsertThenCall(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_BBL_HasFallThrough(SPPY::PyObject* self, SPPY::PyObject* args); #endif \ No newline at end of file diff --git a/python_pin.h b/python_pin.h index 6db6ad4..75eced5 100644 --- a/python_pin.h +++ b/python_pin.h @@ -1,36 +1,36 @@ #ifndef B_H #define B_H -PyObject* module; -PyObject** hooks_syscall_entry = NULL; -PyObject** hooks_syscall_exit = NULL; -PyObject** hooks_instrument_function = NULL; -PyObject** hooks_img_load = NULL; -PyObject** hooks_img_unload = NULL; -PyObject** hooks_trace_instrument = NULL; -PyObject** hooks_instruction = NULL; -PyObject** fini_functions = NULL; +SPPY::PyObject* module; +SPPY::PyObject** hooks_syscall_entry = NULL; +SPPY::PyObject** hooks_syscall_exit = NULL; +SPPY::PyObject** hooks_instrument_function = NULL; +SPPY::PyObject** hooks_img_load = NULL; +SPPY::PyObject** hooks_img_unload = NULL; +SPPY::PyObject** hooks_trace_instrument = NULL; +SPPY::PyObject** hooks_instruction = NULL; +SPPY::PyObject** fini_functions = NULL; void initialize_pin_module(); -void add_hook(PyObject*** hooks, PyObject* new_hook); +void add_hook(SPPY::PyObject*** hooks, SPPY::PyObject* new_hook); void SyscallEntry(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v); void SyscallExit(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID* v); -PyObject* Python_PIN_AddSyscallExitFunction(PyObject* self, PyObject* args); -PyObject* Python_PIN_AddSyscallEntryFunction(PyObject* self, PyObject* args); -PyObject* Python_TRACE_AddInstrumentFunction(PyObject* self, PyObject* args); +SPPY::PyObject* Python_PIN_AddSyscallExitFunction(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_PIN_AddSyscallEntryFunction(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_TRACE_AddInstrumentFunction(SPPY::PyObject* self, SPPY::PyObject* args); void Fini(INT32, VOID*); -PyObject* Python_AddFiniFunction(PyObject* self, PyObject* args); -PyObject* Python_INS_AddInstrumentFunction(PyObject* self, PyObject* args); +SPPY::PyObject* Python_AddFiniFunction(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* Python_INS_AddInstrumentFunction(SPPY::PyObject* self, SPPY::PyObject* args); void InstrumentFunction(RTN rtn, VOID *v); -PyObject* Python_RTN_AddInstrumentFunction(PyObject* self, PyObject* args); -PyObject* get_pointer(PyObject* self, PyObject* args); -PyObject* set_pointer(PyObject* self, PyObject* args); +SPPY::PyObject* Python_RTN_AddInstrumentFunction(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* get_pointer(SPPY::PyObject* self, SPPY::PyObject* args); +SPPY::PyObject* set_pointer(SPPY::PyObject* self, SPPY::PyObject* args); typedef struct rtn_hook { - PyObject* function; + SPPY::PyObject* function; int arguments; } rtn_hook; @@ -39,8 +39,10 @@ void ImageUnload(IMG img, VOID *v); void Trace(TRACE trace, VOID *v); void Ins_Hook(INS ins, VOID *v); +///static (_Py_NoneStruct) methods2[]; -static PyMethodDef methods[] = { +static SPPY::PyMethodDef methods[] = { +//static (SPPY::_Py_NoneStruct) methods[] = { {"AddFiniFunction", Python_AddFiniFunction, METH_VARARGS, From 47fff38b5956a5b979606603900c83ad6892807a Mon Sep 17 00:00:00 2001 From: Kosmonit Date: Fri, 20 Feb 2015 12:20:32 +0300 Subject: [PATCH 2/2] Remark on Windows --- README.md | 44 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 0eda483..8d1abba 100644 --- a/README.md +++ b/README.md @@ -29,5 +29,45 @@ To run a specific python script, for example the strace script: 2. Need to work on compiling for Mac and Windows. Code should be portable but makefile may need to be updated. ==================================================== -# REMARK -=================================================== \ No newline at end of file +# REMARK on Windows +==================================================== +I compiled the project Python_Pin on Windows under MS Visual Studio 2005 but I found errors at compile time. + +Files pin.h and python.h should be different namespace. + +I placed python.h in namespace SPPY: + +`namespace SPPY` + +`{` + +`#include ` + +`}` + +This helped + +This code don't work on Windows: + +`// FILE* tool = fopen(filename, "r");` + +`// if (tool == NULL) {` + +`// perror("fopen");` + +`// exit(1);` + +`// }` + +`//` + +`// SPPY::PyRun_SimpleFile(tool, filename);` + +`// fclose(tool);` + +And replace on this code: + + SPPY::PyObject* PyFileObject = SPPY::PyFile_FromString((char *)filename, "r"); + + SPPY::PyRun_SimpleFile(SPPY::PyFile_AsFile(PyFileObject), filename); +