diff options
Diffstat (limited to 'src/miasm/jitter/arch/JitCore_ppc32.c')
| -rw-r--r-- | src/miasm/jitter/arch/JitCore_ppc32.c | 297 |
1 files changed, 297 insertions, 0 deletions
diff --git a/src/miasm/jitter/arch/JitCore_ppc32.c b/src/miasm/jitter/arch/JitCore_ppc32.c new file mode 100644 index 00000000..086b140f --- /dev/null +++ b/src/miasm/jitter/arch/JitCore_ppc32.c @@ -0,0 +1,297 @@ +#include <Python.h> +#include "structmember.h" +#include <stdint.h> +#include <inttypes.h> +#include "../compat_py23.h" +#include "../queue.h" +#include "../vm_mngr.h" +#include "../bn.h" +#include "../vm_mngr_py.h" +#include "../JitCore.h" +#include "JitCore_ppc32.h" + +reg_dict gpreg_dict[] = { +#define JITCORE_PPC_REG_EXPAND(_name, _size) \ + { .name = #_name, .offset = offsetof(struct vm_cpu, _name), .size = _size }, +#include "JitCore_ppc32_regs.h" +#undef JITCORE_PPC_REG_EXPAND +}; + +PyObject* cpu_get_gpreg(JitCpu* self) +{ + PyObject *dict = PyDict_New(); + PyObject *o; + +#define JITCORE_PPC_REG_EXPAND(_name, _size) \ + get_reg(_name); +#include "JitCore_ppc32_regs.h" +#undef JITCORE_PPC_REG_EXPAND + + return dict; +} + + + +PyObject * +cpu_set_gpreg(JitCpu *self, PyObject *args) { + PyObject *dict; + PyObject *d_key, *d_value = NULL; + Py_ssize_t pos = 0; + const char *d_key_name; + uint32_t val; + unsigned int i; + + if (!PyArg_ParseTuple(args, "O", &dict)) + return NULL; + if(!PyDict_Check(dict)) + RAISE(PyExc_TypeError, "arg must be dict"); + + while(PyDict_Next(dict, &pos, &d_key, &d_value)) { + int found = 0; + PyGetStr(d_key_name, d_key); + PyGetInt_uint32_t(d_value, val); + + for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){ + if (strcmp(d_key_name, gpreg_dict[i].name)) + continue; + *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val; + found = 1; + break; + } + + if (found) + continue; + fprintf(stderr, "unknown key: %s\n", d_key_name); + RAISE(PyExc_ValueError, "unknown reg"); + } + + Py_INCREF(Py_None); + return Py_None; +} + + +PyObject * +cpu_init_regs(JitCpu *self) { + memset(self->cpu, 0, sizeof(struct vm_cpu)); + + Py_INCREF(Py_None); + return Py_None; +} + +static void +dump_gpreg(const char *name, uint32_t val, int *n) { + printf("%6s %.8" PRIX32"%c", name, val, (*n + 1) % 4 == 0? '\n':' '); + *n = (*n + 1) % 4; +} + +void +dump_gpregs(struct vm_cpu *vmcpu) { + int reg_num = 0; + +#define JITCORE_PPC_REG_EXPAND(_name, _size) \ + dump_gpreg(#_name, vmcpu->_name, ®_num); +#include "JitCore_ppc32_regs.h" +#undef JITCORE_PPC_REG_EXPAND + + if ((reg_num % 4) != 0) + putchar('\n'); +} + + +PyObject * +cpu_dump_gpregs(JitCpu *self, PyObject *args) { + + dump_gpregs(self->cpu); + + Py_INCREF(Py_None); + return Py_None; +} + +PyObject * +cpu_dump_gpregs_with_attrib(JitCpu* self, PyObject* args) +{ + return cpu_dump_gpregs(self, args); +} + +PyObject * +cpu_set_exception(JitCpu *self, PyObject *args) { + PyObject *item1; + uint64_t exception_flags; + + if (!PyArg_ParseTuple(args, "O", &item1)) + return NULL; + + PyGetInt_uint64_t(item1, exception_flags); + + ((struct vm_cpu *)self->cpu)->exception_flags = exception_flags; + + Py_INCREF(Py_None); + return Py_None; +} + +PyObject * +cpu_get_exception(JitCpu *self, PyObject *args) { + return PyLong_FromUnsignedLongLong(((struct vm_cpu *)self->cpu)->exception_flags); +} + +static PyObject * +cpu_get_spr_access(JitCpu *self, PyObject *args) { + return PyLong_FromUnsignedLongLong(((struct vm_cpu *) self->cpu)->spr_access); +} + +void MEM_WRITE_08(JitCpu* jitcpu, uint64_t addr, uint8_t src) +{ + vm_MEM_WRITE_08(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src); +} + +void MEM_WRITE_16(JitCpu* jitcpu, uint64_t addr, uint16_t src) +{ + vm_MEM_WRITE_16(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src); +} + +void MEM_WRITE_32(JitCpu* jitcpu, uint64_t addr, uint32_t src) +{ + vm_MEM_WRITE_32(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src); +} + +void MEM_WRITE_64(JitCpu* jitcpu, uint64_t addr, uint64_t src) +{ + vm_MEM_WRITE_64(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src); +} + + + +static PyMemberDef JitCpu_members[] = { + {NULL} /* Sentinel */ +}; + +static PyMethodDef JitCpu_methods[] = { + {"init_regs", (PyCFunction)cpu_init_regs, METH_NOARGS, "X"}, + {"dump_gpregs", (PyCFunction)cpu_dump_gpregs, METH_NOARGS, "X"}, + {"dump_gpregs_with_attrib", (PyCFunction)cpu_dump_gpregs_with_attrib, METH_VARARGS, "X"}, + {"get_gpreg", (PyCFunction)cpu_get_gpreg, METH_NOARGS, "X"}, + {"set_gpreg", (PyCFunction)cpu_set_gpreg, METH_VARARGS, "X"}, + {"get_exception", (PyCFunction)cpu_get_exception, METH_VARARGS, "X"}, + {"set_exception", (PyCFunction)cpu_set_exception, METH_VARARGS, "X"}, + {"get_spr_access", (PyCFunction)cpu_get_spr_access, METH_VARARGS, "X"}, + {NULL} /* Sentinel */ +}; + +static int +JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds) { + self->cpu = malloc(sizeof(struct vm_cpu)); + if (self->cpu == NULL) { + fprintf(stderr, "cannot alloc struct vm_cpu\n"); + exit(1); + } + return 0; +} + + +#define JITCORE_PPC_REG_EXPAND(_name, _size) \ +getset_reg_u32(_name); +#include "JitCore_ppc32_regs.h" +#undef JITCORE_PPC_REG_EXPAND + +PyObject * +get_gpreg_offset_all(void) { + PyObject *dict = PyDict_New(); + PyObject *o; + +#define JITCORE_PPC_REG_EXPAND(_name, _size) \ + get_reg_off(_name); +#include "JitCore_ppc32_regs.h" +#undef JITCORE_PPC_REG_EXPAND + + return dict; +} + +static PyGetSetDef JitCpu_getseters[] = { + {"vmmngr", + (getter)JitCpu_get_vmmngr, (setter)JitCpu_set_vmmngr, + "vmmngr", + NULL}, + + {"jitter", + (getter)JitCpu_get_jitter, (setter)JitCpu_set_jitter, + "jitter", + NULL}, + +#define JITCORE_PPC_REG_EXPAND(_name, _size) \ + { #_name, (getter) JitCpu_get_ ## _name , \ + (setter) JitCpu_set_ ## _name , #_name , NULL}, +#include "JitCore_ppc32_regs.h" +#undef JITCORE_PPC_REG_EXPAND + + {NULL} /* Sentinel */ +}; + + +static PyTypeObject JitCpuType = { + PyVarObject_HEAD_INIT(NULL, 0) + "JitCore_ppc.JitCpu", /*tp_name*/ + sizeof(JitCpu), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)JitCpu_dealloc,/*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "JitCpu objects", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + JitCpu_methods, /* tp_methods */ + JitCpu_members, /* tp_members */ + JitCpu_getseters, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)JitCpu_init, /* tp_init */ + 0, /* tp_alloc */ + JitCpu_new, /* tp_new */ +}; + + + +static PyMethodDef JitCore_ppc32_Methods[] = { + {"get_gpreg_offset_all", (PyCFunction)get_gpreg_offset_all, METH_NOARGS}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + + + +MOD_INIT(JitCore_ppc32) +{ + PyObject *module = NULL; + + MOD_DEF(module, "JitCore_ppc32", "JitCore_ppc32 module", JitCore_ppc32_Methods); + + if (module == NULL) + RET_MODULE; + + if (PyType_Ready(&JitCpuType) < 0) + RET_MODULE; + + Py_INCREF(&JitCpuType); + if (PyModule_AddObject(module, "JitCpu", (PyObject *)&JitCpuType) < 0) + RET_MODULE; + + RET_MODULE; +} |