Miasm2
 All Classes Namespaces Files Functions Variables Typedefs Properties Macros
JitCore_arm.c
Go to the documentation of this file.
1 #include <Python.h>
2 #include "../JitCore.h"
3 #include "structmember.h"
4 #include <stdint.h>
5 #include <inttypes.h>
6 #include "../queue.h"
7 #include "../vm_mngr.h"
8 #include "../vm_mngr_py.h"
9 #include "JitCore_arm.h"
10 
11 
12 
13 reg_dict gpreg_dict[] = { {.name = "R0", .offset = offsetof(vm_cpu_t, R0)},
14  {.name = "R1", .offset = offsetof(vm_cpu_t, R1)},
15  {.name = "R2", .offset = offsetof(vm_cpu_t, R2)},
16  {.name = "R3", .offset = offsetof(vm_cpu_t, R3)},
17  {.name = "R4", .offset = offsetof(vm_cpu_t, R4)},
18  {.name = "R5", .offset = offsetof(vm_cpu_t, R5)},
19  {.name = "R6", .offset = offsetof(vm_cpu_t, R6)},
20  {.name = "R7", .offset = offsetof(vm_cpu_t, R7)},
21  {.name = "R8", .offset = offsetof(vm_cpu_t, R8)},
22  {.name = "R9", .offset = offsetof(vm_cpu_t, R9)},
23  {.name = "R10", .offset = offsetof(vm_cpu_t, R10)},
24  {.name = "R11", .offset = offsetof(vm_cpu_t, R11)},
25  {.name = "R12", .offset = offsetof(vm_cpu_t, R12)},
26  {.name = "SP", .offset = offsetof(vm_cpu_t, SP)},
27  {.name = "LR", .offset = offsetof(vm_cpu_t, LR)},
28  {.name = "PC", .offset = offsetof(vm_cpu_t, PC)},
29 
30  {.name = "zf", .offset = offsetof(vm_cpu_t, zf)},
31  {.name = "nf", .offset = offsetof(vm_cpu_t, nf)},
32  {.name = "of", .offset = offsetof(vm_cpu_t, of)},
33  {.name = "cf", .offset = offsetof(vm_cpu_t, cf)},
34 };
35 
36 /************************** JitCpu object **************************/
37 
38 
39 
40 
41 PyObject* cpu_get_gpreg(JitCpu* self)
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 }
70 
71 
72 
73 PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
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 }
108 
109 
110 PyObject * cpu_init_regs(JitCpu* self)
111 {
112  memset(self->cpu, 0, sizeof(vm_cpu_t));
113 
114  Py_INCREF(Py_None);
115  return Py_None;
116 }
117 
118 void dump_gpregs(vm_cpu_t* vmcpu)
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 }
131 
132 
133 PyObject * cpu_dump_gpregs(JitCpu* self, PyObject* args)
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 }
142 
143 
144 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
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 }
158 
159 PyObject* cpu_get_exception(JitCpu* self, PyObject* args)
160 {
161  return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)self->cpu)->exception_flags));
162 }
163 
164 
165 
166 
167 
168 void check_automod(JitCpu* jitcpu, uint64_t addr, uint64_t size)
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 }
178 
179 void MEM_WRITE_08(JitCpu* jitcpu, uint64_t addr, uint8_t src)
180 {
181  vm_MEM_WRITE_08(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
182  check_automod(jitcpu, addr, 8);
183 }
184 
185 void MEM_WRITE_16(JitCpu* jitcpu, uint64_t addr, uint16_t src)
186 {
187  vm_MEM_WRITE_16(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
188  check_automod(jitcpu, addr, 16);
189 }
190 
191 void MEM_WRITE_32(JitCpu* jitcpu, uint64_t addr, uint32_t src)
192 {
193  vm_MEM_WRITE_32(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
194  check_automod(jitcpu, addr, 32);
195 }
196 
197 void MEM_WRITE_64(JitCpu* jitcpu, uint64_t addr, uint64_t src)
198 {
199  vm_MEM_WRITE_64(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
200  check_automod(jitcpu, addr, 64);
201 }
202 
203 
204 
205 
206 
207 
208 PyObject* vm_set_mem(JitCpu *self, PyObject* args)
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 }
238 
239 static PyMemberDef JitCpu_members[] = {
240  {NULL} /* Sentinel */
241 };
242 
243 static PyMethodDef JitCpu_methods[] = {
244  {"init_regs", (PyCFunction)cpu_init_regs, METH_NOARGS,
245  "X"},
246  {"dump_gpregs", (PyCFunction)cpu_dump_gpregs, METH_NOARGS,
247  "X"},
248  {"get_gpreg", (PyCFunction)cpu_get_gpreg, METH_NOARGS,
249  "X"},
250  {"set_gpreg", (PyCFunction)cpu_set_gpreg, METH_VARARGS,
251  "X"},
252  {"get_exception", (PyCFunction)cpu_get_exception, METH_VARARGS,
253  "X"},
254  {"set_exception", (PyCFunction)cpu_set_exception, METH_VARARGS,
255  "X"},
256  {"set_mem", (PyCFunction)vm_set_mem, METH_VARARGS,
257  "X"},
258  {"get_mem", (PyCFunction)vm_get_mem, METH_VARARGS,
259  "X"},
260  {NULL} /* Sentinel */
261 };
262 
263 static int
264 JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
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 }
273 
290 
295 
296 
297 PyObject* get_gpreg_offset_all(void)
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 }
441 
442 
443 static PyGetSetDef JitCpu_getseters[] = {
444  {"vmmngr",
445  (getter)JitCpu_get_vmmngr, (setter)JitCpu_set_vmmngr,
446  "vmmngr",
447  NULL},
448 
449  {"jitter",
450  (getter)JitCpu_get_jitter, (setter)JitCpu_set_jitter,
451  "jitter",
452  NULL},
453 
454 
455 
456  {"R0" , (getter)JitCpu_get_R0 , (setter)JitCpu_set_R0 , "R0" , NULL},
457  {"R1" , (getter)JitCpu_get_R1 , (setter)JitCpu_set_R1 , "R1" , NULL},
458  {"R2" , (getter)JitCpu_get_R2 , (setter)JitCpu_set_R2 , "R2" , NULL},
459  {"R3" , (getter)JitCpu_get_R3 , (setter)JitCpu_set_R3 , "R3" , NULL},
460  {"R4" , (getter)JitCpu_get_R4 , (setter)JitCpu_set_R4 , "R4" , NULL},
461  {"R5" , (getter)JitCpu_get_R5 , (setter)JitCpu_set_R5 , "R5" , NULL},
462  {"R6" , (getter)JitCpu_get_R6 , (setter)JitCpu_set_R6 , "R6" , NULL},
463  {"R7" , (getter)JitCpu_get_R7 , (setter)JitCpu_set_R7 , "R7" , NULL},
464  {"R8" , (getter)JitCpu_get_R8 , (setter)JitCpu_set_R8 , "R8" , NULL},
465  {"R9" , (getter)JitCpu_get_R9 , (setter)JitCpu_set_R9 , "R9" , NULL},
466  {"R10", (getter)JitCpu_get_R10, (setter)JitCpu_set_R10, "R10", NULL},
467  {"R11", (getter)JitCpu_get_R11, (setter)JitCpu_set_R11, "R11", NULL},
468  {"R12", (getter)JitCpu_get_R12, (setter)JitCpu_set_R12, "R12", NULL},
469  {"SP" , (getter)JitCpu_get_SP , (setter)JitCpu_set_SP , "SP" , NULL},
470  {"LR" , (getter)JitCpu_get_LR , (setter)JitCpu_set_LR , "LR" , NULL},
471  {"PC" , (getter)JitCpu_get_PC , (setter)JitCpu_set_PC , "PC" , NULL},
472 
473  {"zf", (getter)JitCpu_get_zf, (setter)JitCpu_set_zf, "zf", NULL},
474  {"nf", (getter)JitCpu_get_nf, (setter)JitCpu_set_nf, "nf", NULL},
475  {"of", (getter)JitCpu_get_of, (setter)JitCpu_set_of, "of", NULL},
476  {"cf", (getter)JitCpu_get_cf, (setter)JitCpu_set_cf, "cf", NULL},
477 
478  {NULL} /* Sentinel */
479 };
480 
481 
482 static PyTypeObject JitCpuType = {
483  PyObject_HEAD_INIT(NULL)
484  0, /*ob_size*/
485  "JitCore_arm.JitCpu", /*tp_name*/
486  sizeof(JitCpu), /*tp_basicsize*/
487  0, /*tp_itemsize*/
488  (destructor)JitCpu_dealloc,/*tp_dealloc*/
489  0, /*tp_print*/
490  0, /*tp_getattr*/
491  0, /*tp_setattr*/
492  0, /*tp_compare*/
493  0, /*tp_repr*/
494  0, /*tp_as_number*/
495  0, /*tp_as_sequence*/
496  0, /*tp_as_mapping*/
497  0, /*tp_hash */
498  0, /*tp_call*/
499  0, /*tp_str*/
500  0, /*tp_getattro*/
501  0, /*tp_setattro*/
502  0, /*tp_as_buffer*/
503  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
504  "JitCpu objects", /* tp_doc */
505  0, /* tp_traverse */
506  0, /* tp_clear */
507  0, /* tp_richcompare */
508  0, /* tp_weaklistoffset */
509  0, /* tp_iter */
510  0, /* tp_iternext */
511  JitCpu_methods, /* tp_methods */
512  JitCpu_members, /* tp_members */
513  JitCpu_getseters, /* tp_getset */
514  0, /* tp_base */
515  0, /* tp_dict */
516  0, /* tp_descr_get */
517  0, /* tp_descr_set */
518  0, /* tp_dictoffset */
519  (initproc)JitCpu_init, /* tp_init */
520  0, /* tp_alloc */
521  JitCpu_new, /* tp_new */
522 };
523 
524 
525 
526 static PyMethodDef JitCore_arm_Methods[] = {
527 
528  /*
529 
530  */
531  {"get_gpreg_offset_all", (PyCFunction)get_gpreg_offset_all, METH_NOARGS},
532  {NULL, NULL, 0, NULL} /* Sentinel */
533 
534 };
535 
536 static PyObject *JitCore_arm_Error;
537 
538 PyMODINIT_FUNC
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 }
558 
uint32_t R11
Definition: JitCore_arm.h:18
uint32_t R6
Definition: JitCore_arm.h:13
static PyMethodDef JitCore_arm_Methods[]
Definition: JitCore_arm.c:526
#define EXCEPT_CODE_AUTOMOD
Definition: vm_mngr.h:130
static PyMethodDef JitCpu_methods[]
Definition: JitCore_arm.c:243
uint32_t R8
Definition: JitCore_arm.h:15
uint32_t cf
uint64_t PC
static PyTypeObject JitCpuType
Definition: JitCore_arm.c:482
uint32_t R10
Definition: JitCore_arm.h:17
PyObject * JitCpu_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Definition: JitCore.c:17
void MEM_WRITE_16(JitCpu *jitcpu, uint64_t addr, uint16_t src)
Definition: JitCore_arm.c:185
#define RAISE(errtype, msg)
Definition: JitCore.h:4
uint64_t LR
#define PyGetInt(item, value)
Definition: JitCore.h:8
string name
Definition: ir2C.py:22
void MEM_WRITE_64(JitCpu *jitcpu, uint64_t addr, uint64_t src)
Definition: JitCore_arm.c:197
void dump_gpregs(vm_cpu_t *vmcpu)
Definition: JitCore_arm.c:118
uint32_t R1
Definition: JitCore_arm.h:8
PyObject * vm_get_mem(JitCpu *self, PyObject *args)
static int JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
Definition: JitCore_arm.c:264
PyObject * jitter
Definition: JitCore.h:96
static PyGetSetDef JitCpu_getseters[]
Definition: JitCore_arm.c:443
int vm_write_mem(vm_mngr_t *vm_mngr, uint64_t addr, char *buffer, uint64_t size)
Definition: vm_mngr.c:518
size_t offset
Definition: JitCore.h:103
uint32_t R2
Definition: JitCore_arm.h:9
PyObject * cpu_init_regs(JitCpu *self)
Definition: JitCore_arm.c:110
uint32_t nf
uint32_t R5
Definition: JitCore_arm.h:12
void vm_MEM_WRITE_64(vm_mngr_t *vm_mngr, uint64_t addr, uint64_t src)
Definition: vm_mngr.c:454
void MEM_WRITE_32(JitCpu *jitcpu, uint64_t addr, uint32_t src)
Definition: JitCore_arm.c:191
PyObject * JitCpu_set_vmmngr(JitCpu *self, PyObject *value, void *closure)
Definition: JitCore.c:35
PyObject * JitCpu_get_vmmngr(JitCpu *self, void *closure)
Definition: JitCore.c:25
void vm_MEM_WRITE_16(vm_mngr_t *vm_mngr, uint64_t addr, unsigned short src)
Definition: vm_mngr.c:444
uint32_t of
static PyMemberDef JitCpu_members[]
Definition: JitCore_arm.c:239
PyObject * JitCpu_set_jitter(JitCpu *self, PyObject *value, void *closure)
Definition: JitCore.c:51
#define get_reg(reg)
Definition: JitCore.h:74
uint32_t R12
Definition: JitCore_arm.h:19
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
static PyObject * JitCore_arm_Error
Definition: JitCore_arm.c:536
PyObject * cpu_dump_gpregs(JitCpu *self, PyObject *args)
Definition: JitCore_arm.c:133
void vm_MEM_WRITE_08(vm_mngr_t *vm_mngr, uint64_t addr, unsigned char src)
Definition: vm_mngr.c:438
PyMODINIT_FUNC initJitCore_arm(void)
Definition: JitCore_arm.c:539
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
Definition: JitCore_arm.c:168
uint32_t R3
Definition: JitCore_arm.h:10
PyObject * cpu_get_gpreg(JitCpu *self)
Definition: JitCore_arm.c:41
PyObject * get_gpreg_offset_all(void)
Definition: JitCore_arm.c:297
void MEM_WRITE_08(JitCpu *jitcpu, uint64_t addr, uint8_t src)
Definition: JitCore_arm.c:179
getset_reg_u32(R0)
uint32_t R4
Definition: JitCore_arm.h:11
uint32_t R9
Definition: JitCore_arm.h:16
char * name
Definition: JitCore.h:102
uint32_t R7
Definition: JitCore_arm.h:14
void JitCpu_dealloc(JitCpu *self)
Definition: JitCore.c:11
Definition: JitCore.h:93
reg_dict gpreg_dict[]
Definition: JitCore_arm.c:13
uint64_t SP
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
#define get_reg_off(reg)
Definition: JitCore.h:81
tuple exception_flags
Definition: regs.py:7
uint32_t zf
void vm_MEM_WRITE_32(vm_mngr_t *vm_mngr, uint64_t addr, unsigned int src)
Definition: vm_mngr.c:449
PyObject * JitCpu_get_jitter(JitCpu *self, void *closure)
Definition: JitCore.c:41
uint32_t R0
Definition: JitCore_arm.h:7