Miasm2
 All Classes Namespaces Files Functions Variables Typedefs Properties Macros
Functions | Variables
JitCore_arm.c File Reference
#include <Python.h>
#include "../JitCore.h"
#include "structmember.h"
#include <stdint.h>
#include <inttypes.h>
#include "../queue.h"
#include "../vm_mngr.h"
#include "../vm_mngr_py.h"
#include "JitCore_arm.h"
+ Include dependency graph for JitCore_arm.c:

Go to the source code of this file.

Functions

PyObject * cpu_get_gpreg (JitCpu *self)
 
PyObject * cpu_set_gpreg (JitCpu *self, PyObject *args)
 
PyObject * cpu_init_regs (JitCpu *self)
 
void dump_gpregs (vm_cpu_t *vmcpu)
 
PyObject * cpu_dump_gpregs (JitCpu *self, PyObject *args)
 
PyObject * cpu_set_exception (JitCpu *self, PyObject *args)
 
PyObject * cpu_get_exception (JitCpu *self, PyObject *args)
 
void check_automod (JitCpu *jitcpu, uint64_t addr, uint64_t size)
 
void MEM_WRITE_08 (JitCpu *jitcpu, uint64_t addr, uint8_t src)
 
void MEM_WRITE_16 (JitCpu *jitcpu, uint64_t addr, uint16_t src)
 
void MEM_WRITE_32 (JitCpu *jitcpu, uint64_t addr, uint32_t src)
 
void MEM_WRITE_64 (JitCpu *jitcpu, uint64_t addr, uint64_t src)
 
PyObject * vm_set_mem (JitCpu *self, PyObject *args)
 
static int JitCpu_init (JitCpu *self, PyObject *args, PyObject *kwds)
 
 getset_reg_u32 (R0)
 
 getset_reg_u32 (R1)
 
 getset_reg_u32 (R2)
 
 getset_reg_u32 (R3)
 
 getset_reg_u32 (R4)
 
 getset_reg_u32 (R5)
 
 getset_reg_u32 (R6)
 
 getset_reg_u32 (R7)
 
 getset_reg_u32 (R8)
 
 getset_reg_u32 (R9)
 
 getset_reg_u32 (R10)
 
 getset_reg_u32 (R11)
 
 getset_reg_u32 (R12)
 
 getset_reg_u32 (SP)
 
 getset_reg_u32 (LR)
 
 getset_reg_u32 (PC)
 
 getset_reg_u32 (zf)
 
 getset_reg_u32 (nf)
 
 getset_reg_u32 (of)
 
 getset_reg_u32 (cf)
 
PyObject * get_gpreg_offset_all (void)
 
PyMODINIT_FUNC initJitCore_arm (void)
 

Variables

reg_dict gpreg_dict []
 
static PyMemberDef JitCpu_members []
 
static PyMethodDef JitCpu_methods []
 
static PyGetSetDef JitCpu_getseters []
 
static PyTypeObject JitCpuType
 
static PyMethodDef JitCore_arm_Methods []
 
static PyObject * JitCore_arm_Error
 

Function Documentation

void check_automod ( JitCpu jitcpu,
uint64_t  addr,
uint64_t  size 
)

Definition at line 168 of file JitCore_arm.c.

169 {
170  PyObject *result;
171 
172  if (!(((VmMngr*)jitcpu->pyvm)->vm_mngr.exception_flags & EXCEPT_CODE_AUTOMOD))
173  return;
174  result = PyObject_CallMethod(jitcpu->jitter, "automod_cb", "LL", addr, size);
175  Py_DECREF(result);
176 
177 }
#define EXCEPT_CODE_AUTOMOD
Definition: vm_mngr.h:130
PyObject * jitter
Definition: JitCore.h:96
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95

+ Here is the caller graph for this function:

PyObject* cpu_dump_gpregs ( JitCpu self,
PyObject *  args 
)

Definition at line 133 of file JitCore_arm.c.

134 {
135  vm_cpu_t* vmcpu;
136 
137  vmcpu = self->cpu;
138  dump_gpregs(vmcpu);
139  Py_INCREF(Py_None);
140  return Py_None;
141 }
void dump_gpregs(vm_cpu_t *vmcpu)
Definition: JitCore_arm.c:118

+ Here is the call graph for this function:

PyObject* cpu_get_exception ( JitCpu self,
PyObject *  args 
)

Definition at line 159 of file JitCore_arm.c.

160 {
161  return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)self->cpu)->exception_flags));
162 }
void * cpu
Definition: JitCore.h:97
PyObject* cpu_get_gpreg ( JitCpu self)

Definition at line 41 of file JitCore_arm.c.

42 {
43  PyObject *dict = PyDict_New();
44  PyObject *o;
45 
46  get_reg(R0);
47  get_reg(R1);
48  get_reg(R2);
49  get_reg(R3);
50  get_reg(R4);
51  get_reg(R5);
52  get_reg(R6);
53  get_reg(R7);
54  get_reg(R8);
55  get_reg(R9);
56  get_reg(R10);
57  get_reg(R11);
58  get_reg(R12);
59  get_reg(SP);
60  get_reg(LR);
61  get_reg(PC);
62 
63  get_reg(zf);
64  get_reg(nf);
65  get_reg(of);
66  get_reg(cf);
67 
68  return dict;
69 }
#define get_reg(reg)
Definition: JitCore.h:74
PyObject* cpu_init_regs ( JitCpu self)

Definition at line 110 of file JitCore_arm.c.

111 {
112  memset(self->cpu, 0, sizeof(vm_cpu_t));
113 
114  Py_INCREF(Py_None);
115  return Py_None;
116 }
void * cpu
Definition: JitCore.h:97
PyObject* cpu_set_exception ( JitCpu self,
PyObject *  args 
)

Definition at line 144 of file JitCore_arm.c.

145 {
146  PyObject *item1;
147  uint64_t i;
148 
149  if (!PyArg_ParseTuple(args, "O", &item1))
150  return NULL;
151 
152  PyGetInt(item1, i);
153 
154  ((vm_cpu_t*)self->cpu)->exception_flags = i;
155  Py_INCREF(Py_None);
156  return Py_None;
157 }
#define PyGetInt(item, value)
Definition: JitCore.h:8
void * cpu
Definition: JitCore.h:97
PyObject* cpu_set_gpreg ( JitCpu self,
PyObject *  args 
)

Definition at line 73 of file JitCore_arm.c.

74 {
75  PyObject* dict;
76  PyObject *d_key, *d_value = NULL;
77  Py_ssize_t pos = 0;
78  uint64_t val;
79  unsigned int i, found;
80 
81  if (!PyArg_ParseTuple(args, "O", &dict))
82  return NULL;
83  if(!PyDict_Check(dict))
84  RAISE(PyExc_TypeError, "arg must be dict");
85  while(PyDict_Next(dict, &pos, &d_key, &d_value)){
86  if(!PyString_Check(d_key))
87  RAISE(PyExc_TypeError, "key must be str");
88 
89  PyGetInt(d_value, val);
90 
91  found = 0;
92  for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
93  if (strcmp(PyString_AsString(d_key), gpreg_dict[i].name))
94  continue;
95  *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
96  found = 1;
97  break;
98  }
99 
100  if (found)
101  continue;
102  fprintf(stderr, "unkown key: %s\n", PyString_AsString(d_key));
103  RAISE(PyExc_ValueError, "unkown reg");
104  }
105  Py_INCREF(Py_None);
106  return Py_None;
107 }
#define RAISE(errtype, msg)
Definition: JitCore.h:4
#define PyGetInt(item, value)
Definition: JitCore.h:8
string name
Definition: ir2C.py:22
size_t offset
Definition: JitCore.h:103
reg_dict gpreg_dict[]
Definition: JitCore_arm.c:13
void dump_gpregs ( vm_cpu_t vmcpu)

Definition at line 118 of file JitCore_arm.c.

119 {
120  printf("R0 %.16"PRIX32" R1 %.16"PRIX32" R2 %.16"PRIX32" R3 %.16"PRIX32"\n",
121  vmcpu->R0, vmcpu->R1, vmcpu->R2, vmcpu->R3);
122  printf("R4 %.16"PRIX32" R5 %.16"PRIX32" R6 %.16"PRIX32" R7 %.16"PRIX32"\n",
123  vmcpu->R4, vmcpu->R5, vmcpu->R6, vmcpu->R7);
124  printf("R8 %.16"PRIX32" R9 %.16"PRIX32" R10 %.16"PRIX32" R11 %.16"PRIX32"\n",
125  vmcpu->R8, vmcpu->R9, vmcpu->R10, vmcpu->R11);
126  printf("R12 %.16"PRIX32" SP %.16"PRIX32" LR %.16"PRIX32" PC %.16"PRIX32"\n",
127  vmcpu->R12, vmcpu->SP, vmcpu->LR, vmcpu->PC);
128  printf("zf %.16"PRIX32" nf %.16"PRIX32" of %.16"PRIX32" cf %.16"PRIX32"\n",
129  vmcpu->zf, vmcpu->nf, vmcpu->of, vmcpu->cf);
130 }
uint32_t R11
Definition: JitCore_arm.h:18
uint32_t R6
Definition: JitCore_arm.h:13
uint32_t R8
Definition: JitCore_arm.h:15
uint32_t cf
uint64_t PC
uint32_t R10
Definition: JitCore_arm.h:17
uint64_t LR
uint32_t R1
Definition: JitCore_arm.h:8
uint32_t R2
Definition: JitCore_arm.h:9
uint32_t nf
uint32_t R5
Definition: JitCore_arm.h:12
uint32_t of
uint32_t R12
Definition: JitCore_arm.h:19
uint32_t R3
Definition: JitCore_arm.h:10
uint32_t R4
Definition: JitCore_arm.h:11
uint32_t R9
Definition: JitCore_arm.h:16
uint32_t R7
Definition: JitCore_arm.h:14
uint64_t SP
uint32_t zf
uint32_t R0
Definition: JitCore_arm.h:7

+ Here is the caller graph for this function:

PyObject* get_gpreg_offset_all ( void  )

Definition at line 297 of file JitCore_arm.c.

298 {
299  PyObject *dict = PyDict_New();
300  PyObject *o;
301 
303  get_reg_off(exception_flags_new);
304 
305 
306  get_reg_off(R0);
307  get_reg_off(R1);
308  get_reg_off(R2);
309  get_reg_off(R3);
310  get_reg_off(R4);
311  get_reg_off(R5);
312  get_reg_off(R6);
313  get_reg_off(R7);
314  get_reg_off(R8);
315  get_reg_off(R9);
316  get_reg_off(R10);
317  get_reg_off(R11);
318  get_reg_off(R12);
319  get_reg_off(SP);
320  get_reg_off(LR);
321  get_reg_off(PC);
322 
323  get_reg_off(R0_new);
324  get_reg_off(R1_new);
325  get_reg_off(R2_new);
326  get_reg_off(R3_new);
327  get_reg_off(R4_new);
328  get_reg_off(R5_new);
329  get_reg_off(R6_new);
330  get_reg_off(R7_new);
331  get_reg_off(R8_new);
332  get_reg_off(R9_new);
333  get_reg_off(R10_new);
334  get_reg_off(R11_new);
335  get_reg_off(R12_new);
336  get_reg_off(SP_new);
337  get_reg_off(LR_new);
338  get_reg_off(PC_new);
339 
340  /* eflag */
341  get_reg_off(zf);
342  get_reg_off(nf);
343  get_reg_off(of);
344  get_reg_off(cf);
345 
346  get_reg_off(zf_new);
347  get_reg_off(nf_new);
348  get_reg_off(of_new);
349  get_reg_off(cf_new);
350 
351 
352  get_reg_off(pfmem08_0);
353  get_reg_off(pfmem08_1);
354  get_reg_off(pfmem08_2);
355  get_reg_off(pfmem08_3);
356  get_reg_off(pfmem08_4);
357  get_reg_off(pfmem08_5);
358  get_reg_off(pfmem08_6);
359  get_reg_off(pfmem08_7);
360  get_reg_off(pfmem08_8);
361  get_reg_off(pfmem08_9);
362  get_reg_off(pfmem08_10);
363  get_reg_off(pfmem08_11);
364  get_reg_off(pfmem08_12);
365  get_reg_off(pfmem08_13);
366  get_reg_off(pfmem08_14);
367  get_reg_off(pfmem08_15);
368  get_reg_off(pfmem08_16);
369  get_reg_off(pfmem08_17);
370  get_reg_off(pfmem08_18);
371  get_reg_off(pfmem08_19);
372 
373 
374  get_reg_off(pfmem16_0);
375  get_reg_off(pfmem16_1);
376  get_reg_off(pfmem16_2);
377  get_reg_off(pfmem16_3);
378  get_reg_off(pfmem16_4);
379  get_reg_off(pfmem16_5);
380  get_reg_off(pfmem16_6);
381  get_reg_off(pfmem16_7);
382  get_reg_off(pfmem16_8);
383  get_reg_off(pfmem16_9);
384  get_reg_off(pfmem16_10);
385  get_reg_off(pfmem16_11);
386  get_reg_off(pfmem16_12);
387  get_reg_off(pfmem16_13);
388  get_reg_off(pfmem16_14);
389  get_reg_off(pfmem16_15);
390  get_reg_off(pfmem16_16);
391  get_reg_off(pfmem16_17);
392  get_reg_off(pfmem16_18);
393  get_reg_off(pfmem16_19);
394 
395 
396  get_reg_off(pfmem32_0);
397  get_reg_off(pfmem32_1);
398  get_reg_off(pfmem32_2);
399  get_reg_off(pfmem32_3);
400  get_reg_off(pfmem32_4);
401  get_reg_off(pfmem32_5);
402  get_reg_off(pfmem32_6);
403  get_reg_off(pfmem32_7);
404  get_reg_off(pfmem32_8);
405  get_reg_off(pfmem32_9);
406  get_reg_off(pfmem32_10);
407  get_reg_off(pfmem32_11);
408  get_reg_off(pfmem32_12);
409  get_reg_off(pfmem32_13);
410  get_reg_off(pfmem32_14);
411  get_reg_off(pfmem32_15);
412  get_reg_off(pfmem32_16);
413  get_reg_off(pfmem32_17);
414  get_reg_off(pfmem32_18);
415  get_reg_off(pfmem32_19);
416 
417 
418  get_reg_off(pfmem64_0);
419  get_reg_off(pfmem64_1);
420  get_reg_off(pfmem64_2);
421  get_reg_off(pfmem64_3);
422  get_reg_off(pfmem64_4);
423  get_reg_off(pfmem64_5);
424  get_reg_off(pfmem64_6);
425  get_reg_off(pfmem64_7);
426  get_reg_off(pfmem64_8);
427  get_reg_off(pfmem64_9);
428  get_reg_off(pfmem64_10);
429  get_reg_off(pfmem64_11);
430  get_reg_off(pfmem64_12);
431  get_reg_off(pfmem64_13);
432  get_reg_off(pfmem64_14);
433  get_reg_off(pfmem64_15);
434  get_reg_off(pfmem64_16);
435  get_reg_off(pfmem64_17);
436  get_reg_off(pfmem64_18);
437  get_reg_off(pfmem64_19);
438 
439  return dict;
440 }
#define get_reg_off(reg)
Definition: JitCore.h:81
tuple exception_flags
Definition: regs.py:7
getset_reg_u32 ( R0  )
getset_reg_u32 ( R1  )
getset_reg_u32 ( R2  )
getset_reg_u32 ( R3  )
getset_reg_u32 ( R4  )
getset_reg_u32 ( R5  )
getset_reg_u32 ( R6  )
getset_reg_u32 ( R7  )
getset_reg_u32 ( R8  )
getset_reg_u32 ( R9  )
getset_reg_u32 ( R10  )
getset_reg_u32 ( R11  )
getset_reg_u32 ( R12  )
getset_reg_u32 ( SP  )
getset_reg_u32 ( LR  )
getset_reg_u32 ( PC  )
getset_reg_u32 ( zf  )
getset_reg_u32 ( nf  )
getset_reg_u32 ( of  )
getset_reg_u32 ( cf  )
PyMODINIT_FUNC initJitCore_arm ( void  )

Definition at line 539 of file JitCore_arm.c.

540 {
541  PyObject *m;
542 
543  if (PyType_Ready(&JitCpuType) < 0)
544  return;
545 
546  m = Py_InitModule("JitCore_arm", JitCore_arm_Methods);
547  if (m == NULL)
548  return;
549 
550  JitCore_arm_Error = PyErr_NewException("JitCore_arm.error", NULL, NULL);
551  Py_INCREF(JitCore_arm_Error);
552  PyModule_AddObject(m, "error", JitCore_arm_Error);
553 
554  Py_INCREF(&JitCpuType);
555  PyModule_AddObject(m, "JitCpu", (PyObject *)&JitCpuType);
556 
557 }
static PyMethodDef JitCore_arm_Methods[]
Definition: JitCore_arm.c:526
static PyTypeObject JitCpuType
Definition: JitCore_arm.c:482
static PyObject * JitCore_arm_Error
Definition: JitCore_arm.c:536
static int JitCpu_init ( JitCpu self,
PyObject *  args,
PyObject *  kwds 
)
static

Definition at line 264 of file JitCore_arm.c.

265 {
266  self->cpu = malloc(sizeof(vm_cpu_t));
267  if (self->cpu == NULL) {
268  fprintf(stderr, "cannot alloc vm_cpu_t\n");
269  exit(0);
270  }
271  return 0;
272 }
void * cpu
Definition: JitCore.h:97
void MEM_WRITE_08 ( JitCpu jitcpu,
uint64_t  addr,
uint8_t  src 
)

Definition at line 179 of file JitCore_arm.c.

180 {
181  vm_MEM_WRITE_08(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
182  check_automod(jitcpu, addr, 8);
183 }
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
void vm_MEM_WRITE_08(vm_mngr_t *vm_mngr, uint64_t addr, unsigned char src)
Definition: vm_mngr.c:438
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
Definition: JitCore_arm.c:168

+ Here is the call graph for this function:

void MEM_WRITE_16 ( JitCpu jitcpu,
uint64_t  addr,
uint16_t  src 
)

Definition at line 185 of file JitCore_arm.c.

186 {
187  vm_MEM_WRITE_16(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
188  check_automod(jitcpu, addr, 16);
189 }
void vm_MEM_WRITE_16(vm_mngr_t *vm_mngr, uint64_t addr, unsigned short src)
Definition: vm_mngr.c:444
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
Definition: JitCore_arm.c:168

+ Here is the call graph for this function:

void MEM_WRITE_32 ( JitCpu jitcpu,
uint64_t  addr,
uint32_t  src 
)

Definition at line 191 of file JitCore_arm.c.

192 {
193  vm_MEM_WRITE_32(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
194  check_automod(jitcpu, addr, 32);
195 }
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
Definition: JitCore_arm.c:168
void vm_MEM_WRITE_32(vm_mngr_t *vm_mngr, uint64_t addr, unsigned int src)
Definition: vm_mngr.c:449

+ Here is the call graph for this function:

void MEM_WRITE_64 ( JitCpu jitcpu,
uint64_t  addr,
uint64_t  src 
)

Definition at line 197 of file JitCore_arm.c.

198 {
199  vm_MEM_WRITE_64(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
200  check_automod(jitcpu, addr, 64);
201 }
void vm_MEM_WRITE_64(vm_mngr_t *vm_mngr, uint64_t addr, uint64_t src)
Definition: vm_mngr.c:454
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
Definition: JitCore_arm.c:168

+ Here is the call graph for this function:

PyObject* vm_set_mem ( JitCpu self,
PyObject *  args 
)

Definition at line 208 of file JitCore_arm.c.

209 {
210  PyObject *py_addr;
211  PyObject *py_buffer;
212  Py_ssize_t py_length;
213 
214  char * buffer;
215  uint64_t size;
216  uint64_t addr;
217  int ret = 0x1337;
218 
219  if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
220  return NULL;
221 
222  PyGetInt(py_addr, addr);
223 
224  if(!PyString_Check(py_buffer))
225  RAISE(PyExc_TypeError,"arg must be str");
226 
227  size = PyString_Size(py_buffer);
228  PyString_AsStringAndSize(py_buffer, &buffer, &py_length);
229 
230  ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, size);
231  if (ret < 0)
232  RAISE(PyExc_TypeError,"arg must be str");
233  check_automod(self, addr, size*8);
234 
235  Py_INCREF(Py_None);
236  return Py_None;
237 }
#define RAISE(errtype, msg)
Definition: JitCore.h:4
#define PyGetInt(item, value)
Definition: JitCore.h:8
int vm_write_mem(vm_mngr_t *vm_mngr, uint64_t addr, char *buffer, uint64_t size)
Definition: vm_mngr.c:518
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
Definition: JitCore_arm.c:168

+ Here is the call graph for this function:

Variable Documentation

reg_dict gpreg_dict[]
Initial value:
= { {.name = "R0", .offset = offsetof(vm_cpu_t, R0)},
{.name = "R1", .offset = offsetof(vm_cpu_t, R1)},
{.name = "R2", .offset = offsetof(vm_cpu_t, R2)},
{.name = "R3", .offset = offsetof(vm_cpu_t, R3)},
{.name = "R4", .offset = offsetof(vm_cpu_t, R4)},
{.name = "R5", .offset = offsetof(vm_cpu_t, R5)},
{.name = "R6", .offset = offsetof(vm_cpu_t, R6)},
{.name = "R7", .offset = offsetof(vm_cpu_t, R7)},
{.name = "R8", .offset = offsetof(vm_cpu_t, R8)},
{.name = "R9", .offset = offsetof(vm_cpu_t, R9)},
{.name = "R10", .offset = offsetof(vm_cpu_t, R10)},
{.name = "R11", .offset = offsetof(vm_cpu_t, R11)},
{.name = "R12", .offset = offsetof(vm_cpu_t, R12)},
{.name = "SP", .offset = offsetof(vm_cpu_t, SP)},
{.name = "LR", .offset = offsetof(vm_cpu_t, LR)},
{.name = "PC", .offset = offsetof(vm_cpu_t, PC)},
{.name = "zf", .offset = offsetof(vm_cpu_t, zf)},
{.name = "nf", .offset = offsetof(vm_cpu_t, nf)},
{.name = "of", .offset = offsetof(vm_cpu_t, of)},
{.name = "cf", .offset = offsetof(vm_cpu_t, cf)},
}

Definition at line 13 of file JitCore_arm.c.

PyObject* JitCore_arm_Error
static

Definition at line 536 of file JitCore_arm.c.

PyMethodDef JitCore_arm_Methods[]
static
Initial value:
= {
{"get_gpreg_offset_all", (PyCFunction)get_gpreg_offset_all, METH_NOARGS},
{NULL, NULL, 0, NULL}
}
PyObject * get_gpreg_offset_all(void)
Definition: JitCore_arm.c:297

Definition at line 526 of file JitCore_arm.c.

PyGetSetDef JitCpu_getseters[]
static

Definition at line 443 of file JitCore_arm.c.

PyMemberDef JitCpu_members[]
static
Initial value:
= {
{NULL}
}

Definition at line 239 of file JitCore_arm.c.

PyMethodDef JitCpu_methods[]
static
Initial value:
= {
{"init_regs", (PyCFunction)cpu_init_regs, METH_NOARGS,
"X"},
{"dump_gpregs", (PyCFunction)cpu_dump_gpregs, METH_NOARGS,
"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"},
{"set_mem", (PyCFunction)vm_set_mem, METH_VARARGS,
"X"},
{"get_mem", (PyCFunction)vm_get_mem, METH_VARARGS,
"X"},
{NULL}
}
PyObject * vm_get_mem(JitCpu *self, PyObject *args)
PyObject * cpu_init_regs(JitCpu *self)
Definition: JitCore_arm.c:110
PyObject * cpu_dump_gpregs(JitCpu *self, PyObject *args)
Definition: JitCore_arm.c:133
PyObject * cpu_get_gpreg(JitCpu *self)
Definition: JitCore_arm.c:41
PyObject * vm_set_mem(JitCpu *self, PyObject *args)
Definition: JitCore_arm.c:208
PyObject * cpu_set_exception(JitCpu *self, PyObject *args)
Definition: JitCore_arm.c:144
PyObject * cpu_set_gpreg(JitCpu *self, PyObject *args)
Definition: JitCore_arm.c:73
PyObject * cpu_get_exception(JitCpu *self, PyObject *args)
Definition: JitCore_arm.c:159

Definition at line 243 of file JitCore_arm.c.

PyTypeObject JitCpuType
static

Definition at line 482 of file JitCore_arm.c.