Miasm2
 All Classes Namespaces Files Functions Variables Typedefs Properties Macros
JitCore_aarch64.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_aarch64.h"
10 
11 
12 
14  {.name = "X0", .offset = offsetof(vm_cpu_t, X0)},
15  {.name = "X1", .offset = offsetof(vm_cpu_t, X1)},
16  {.name = "X2", .offset = offsetof(vm_cpu_t, X2)},
17  {.name = "X3", .offset = offsetof(vm_cpu_t, X3)},
18  {.name = "X4", .offset = offsetof(vm_cpu_t, X4)},
19  {.name = "X5", .offset = offsetof(vm_cpu_t, X5)},
20  {.name = "X6", .offset = offsetof(vm_cpu_t, X6)},
21  {.name = "X7", .offset = offsetof(vm_cpu_t, X7)},
22  {.name = "X8", .offset = offsetof(vm_cpu_t, X8)},
23  {.name = "X9", .offset = offsetof(vm_cpu_t, X9)},
24  {.name = "X10", .offset = offsetof(vm_cpu_t, X10)},
25  {.name = "X11", .offset = offsetof(vm_cpu_t, X11)},
26  {.name = "X12", .offset = offsetof(vm_cpu_t, X12)},
27  {.name = "X13", .offset = offsetof(vm_cpu_t, X13)},
28  {.name = "X14", .offset = offsetof(vm_cpu_t, X14)},
29  {.name = "X15", .offset = offsetof(vm_cpu_t, X15)},
30  {.name = "X16", .offset = offsetof(vm_cpu_t, X16)},
31  {.name = "X17", .offset = offsetof(vm_cpu_t, X17)},
32  {.name = "X18", .offset = offsetof(vm_cpu_t, X18)},
33  {.name = "X19", .offset = offsetof(vm_cpu_t, X19)},
34  {.name = "X20", .offset = offsetof(vm_cpu_t, X20)},
35  {.name = "X21", .offset = offsetof(vm_cpu_t, X21)},
36  {.name = "X22", .offset = offsetof(vm_cpu_t, X22)},
37  {.name = "X23", .offset = offsetof(vm_cpu_t, X23)},
38  {.name = "X24", .offset = offsetof(vm_cpu_t, X24)},
39  {.name = "X25", .offset = offsetof(vm_cpu_t, X25)},
40  {.name = "X26", .offset = offsetof(vm_cpu_t, X26)},
41  {.name = "X27", .offset = offsetof(vm_cpu_t, X27)},
42  {.name = "X28", .offset = offsetof(vm_cpu_t, X28)},
43  {.name = "X29", .offset = offsetof(vm_cpu_t, X29)},
44  {.name = "LR", .offset = offsetof(vm_cpu_t, LR)},
45 
46  {.name = "SP", .offset = offsetof(vm_cpu_t, SP)},
47  {.name = "PC", .offset = offsetof(vm_cpu_t, PC)},
48 
49  {.name = "zf", .offset = offsetof(vm_cpu_t, zf)},
50  {.name = "nf", .offset = offsetof(vm_cpu_t, nf)},
51  {.name = "of", .offset = offsetof(vm_cpu_t, of)},
52  {.name = "cf", .offset = offsetof(vm_cpu_t, cf)},
53 };
54 
55 /************************** JitCpu object **************************/
56 
57 
58 
59 
60 PyObject* cpu_get_gpreg(JitCpu* self)
61 {
62  PyObject *dict = PyDict_New();
63  PyObject *o;
64 
65  get_reg(X0);
66  get_reg(X1);
67  get_reg(X2);
68  get_reg(X3);
69  get_reg(X4);
70  get_reg(X5);
71  get_reg(X6);
72  get_reg(X7);
73  get_reg(X8);
74  get_reg(X9);
75  get_reg(X10);
76  get_reg(X11);
77  get_reg(X12);
78  get_reg(X13);
79  get_reg(X14);
80  get_reg(X15);
81  get_reg(X16);
82  get_reg(X17);
83  get_reg(X18);
84  get_reg(X19);
85  get_reg(X20);
86  get_reg(X21);
87  get_reg(X22);
88  get_reg(X23);
89  get_reg(X24);
90  get_reg(X25);
91  get_reg(X26);
92  get_reg(X27);
93  get_reg(X28);
94  get_reg(X29);
95  get_reg(LR);
96  get_reg(SP);
97  get_reg(PC);
98 
99  get_reg(zf);
100  get_reg(nf);
101  get_reg(of);
102  get_reg(cf);
103 
104  return dict;
105 }
106 
107 
108 
109 PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
110 {
111  PyObject* dict;
112  PyObject *d_key, *d_value = NULL;
113  Py_ssize_t pos = 0;
114  uint64_t val;
115  unsigned int i, found;
116 
117  if (!PyArg_ParseTuple(args, "O", &dict))
118  return NULL;
119  if(!PyDict_Check(dict))
120  RAISE(PyExc_TypeError, "arg must be dict");
121  while(PyDict_Next(dict, &pos, &d_key, &d_value)){
122  if(!PyString_Check(d_key))
123  RAISE(PyExc_TypeError, "key must be str");
124 
125  PyGetInt(d_value, val);
126 
127  found = 0;
128  for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
129  if (strcmp(PyString_AsString(d_key), gpreg_dict[i].name))
130  continue;
131  *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
132  found = 1;
133  break;
134  }
135 
136  if (found)
137  continue;
138  fprintf(stderr, "unkown key: %s\n", PyString_AsString(d_key));
139  RAISE(PyExc_ValueError, "unkown reg");
140  }
141  Py_INCREF(Py_None);
142  return Py_None;
143 }
144 
145 
146 PyObject * cpu_init_regs(JitCpu* self)
147 {
148  memset(self->cpu, 0, sizeof(vm_cpu_t));
149 
150  Py_INCREF(Py_None);
151  return Py_None;
152 }
153 
154 void dump_gpregs(vm_cpu_t* vmcpu)
155 {
156  printf("X0 %.16"PRIX64" X1 %.16"PRIX64" X2 %.16"PRIX64" X3 %.16"PRIX64" "\
157  "X4 %.16"PRIX64" X5 %.16"PRIX64" X6 %.16"PRIX64" X7 %.16"PRIX64"\n",
158  vmcpu->X0, vmcpu->X1, vmcpu->X2, vmcpu->X3, vmcpu->X4, vmcpu->X5, vmcpu->X6, vmcpu->X7);
159  printf("X8 %.16"PRIX64" X9 %.16"PRIX64" X10 %.16"PRIX64" X11 %.16"PRIX64" "\
160  "X12 %.16"PRIX64" X13 %.16"PRIX64" X14 %.16"PRIX64" X15 %.16"PRIX64"\n",
161  vmcpu->X8, vmcpu->X9, vmcpu->X10, vmcpu->X11,
162  vmcpu->X12, vmcpu->X13, vmcpu->X14, vmcpu->X15);
163  printf("X16 %.16"PRIX64" X17 %.16"PRIX64" X18 %.16"PRIX64" X19 %.16"PRIX64" "\
164  "X20 %.16"PRIX64" X21 %.16"PRIX64" X22 %.16"PRIX64" X23 %.16"PRIX64"\n",
165  vmcpu->X16, vmcpu->X17, vmcpu->X18, vmcpu->X19,
166  vmcpu->X20, vmcpu->X21, vmcpu->X22, vmcpu->X23);
167  printf("X24 %.16"PRIX64" X25 %.16"PRIX64" X26 %.16"PRIX64" X27 %.16"PRIX64" "\
168  "X28 %.16"PRIX64" X29 %.16"PRIX64" LR %.16"PRIX64"\n",
169  vmcpu->X24, vmcpu->X25, vmcpu->X26, vmcpu->X27,
170  vmcpu->X28, vmcpu->X29, vmcpu->LR);
171 
172 
173  printf("SP %.16"PRIX64" PC %.16"PRIX64" "\
174  "zf %.16"PRIX32" nf %.16"PRIX32" of %.16"PRIX32" cf %.16"PRIX32"\n",
175  vmcpu->SP, vmcpu->PC,
176  vmcpu->zf, vmcpu->nf, vmcpu->of, vmcpu->cf);
177 }
178 
179 
180 PyObject * cpu_dump_gpregs(JitCpu* self, PyObject* args)
181 {
182  vm_cpu_t* vmcpu;
183 
184  vmcpu = self->cpu;
185  dump_gpregs(vmcpu);
186  Py_INCREF(Py_None);
187  return Py_None;
188 }
189 
190 
191 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
192 {
193  PyObject *item1;
194  uint64_t i;
195 
196  if (!PyArg_ParseTuple(args, "O", &item1))
197  return NULL;
198 
199  PyGetInt(item1, i);
200 
201  ((vm_cpu_t*)self->cpu)->exception_flags = i;
202  Py_INCREF(Py_None);
203  return Py_None;
204 }
205 
206 PyObject* cpu_get_exception(JitCpu* self, PyObject* args)
207 {
208  return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)self->cpu)->exception_flags));
209 }
210 
211 
212 
213 
214 
215 void check_automod(JitCpu* jitcpu, uint64_t addr, uint64_t size)
216 {
217  PyObject *result;
218 
219  if (!(((VmMngr*)jitcpu->pyvm)->vm_mngr.exception_flags & EXCEPT_CODE_AUTOMOD))
220  return;
221  result = PyObject_CallMethod(jitcpu->jitter, "automod_cb", "LL", addr, size);
222  Py_DECREF(result);
223 
224 }
225 
226 void MEM_WRITE_08(JitCpu* jitcpu, uint64_t addr, uint8_t src)
227 {
228  vm_MEM_WRITE_08(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
229  check_automod(jitcpu, addr, 8);
230 }
231 
232 void MEM_WRITE_16(JitCpu* jitcpu, uint64_t addr, uint16_t src)
233 {
234  vm_MEM_WRITE_16(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
235  check_automod(jitcpu, addr, 16);
236 }
237 
238 void MEM_WRITE_32(JitCpu* jitcpu, uint64_t addr, uint32_t src)
239 {
240  vm_MEM_WRITE_32(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
241  check_automod(jitcpu, addr, 32);
242 }
243 
244 void MEM_WRITE_64(JitCpu* jitcpu, uint64_t addr, uint64_t src)
245 {
246  vm_MEM_WRITE_64(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
247  check_automod(jitcpu, addr, 64);
248 }
249 
250 
251 
252 
253 
254 
255 PyObject* vm_set_mem(JitCpu *self, PyObject* args)
256 {
257  PyObject *py_addr;
258  PyObject *py_buffer;
259  Py_ssize_t py_length;
260 
261  char * buffer;
262  uint64_t size;
263  uint64_t addr;
264  int ret = 0x1337;
265 
266  if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
267  return NULL;
268 
269  PyGetInt(py_addr, addr);
270 
271  if(!PyString_Check(py_buffer))
272  RAISE(PyExc_TypeError,"arg must be str");
273 
274  size = PyString_Size(py_buffer);
275  PyString_AsStringAndSize(py_buffer, &buffer, &py_length);
276 
277  ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, size);
278  if (ret < 0)
279  RAISE(PyExc_TypeError,"arg must be str");
280  check_automod(self, addr, size*8);
281 
282  Py_INCREF(Py_None);
283  return Py_None;
284 }
285 
286 
287 UDIV(16)
288 UDIV(32)
289 UDIV(64)
290 
291 UMOD(16)
292 UMOD(32)
293 UMOD(64)
294 
295 
296 IDIV(16)
297 IDIV(32)
298 IDIV(64)
299 
300 IMOD(16)
301 IMOD(32)
302 IMOD(64)
303 
304 
305 static PyMemberDef JitCpu_members[] = {
306  {NULL} /* Sentinel */
307 };
308 
309 static PyMethodDef JitCpu_methods[] = {
310  {"init_regs", (PyCFunction)cpu_init_regs, METH_NOARGS,
311  "X"},
312  {"dump_gpregs", (PyCFunction)cpu_dump_gpregs, METH_NOARGS,
313  "X"},
314  {"get_gpreg", (PyCFunction)cpu_get_gpreg, METH_NOARGS,
315  "X"},
316  {"set_gpreg", (PyCFunction)cpu_set_gpreg, METH_VARARGS,
317  "X"},
318  {"get_exception", (PyCFunction)cpu_get_exception, METH_VARARGS,
319  "X"},
320  {"set_exception", (PyCFunction)cpu_set_exception, METH_VARARGS,
321  "X"},
322  {"set_mem", (PyCFunction)vm_set_mem, METH_VARARGS,
323  "X"},
324  {"get_mem", (PyCFunction)vm_get_mem, METH_VARARGS,
325  "X"},
326  {NULL} /* Sentinel */
327 };
328 
329 static int
330 JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
331 {
332  self->cpu = malloc(sizeof(vm_cpu_t));
333  if (self->cpu == NULL) {
334  fprintf(stderr, "cannot alloc vm_cpu_t\n");
335  exit(0);
336  }
337  return 0;
338 }
339 
340 
341 
342 getset_reg_u64(X0);
343 getset_reg_u64(X1);
344 getset_reg_u64(X2);
345 getset_reg_u64(X3);
346 getset_reg_u64(X4);
347 getset_reg_u64(X5);
348 getset_reg_u64(X6);
349 getset_reg_u64(X7);
350 getset_reg_u64(X8);
351 getset_reg_u64(X9);
352 getset_reg_u64(X10);
353 getset_reg_u64(X11);
354 getset_reg_u64(X12);
355 getset_reg_u64(X13);
356 getset_reg_u64(X14);
357 getset_reg_u64(X15);
358 getset_reg_u64(X16);
359 getset_reg_u64(X17);
360 getset_reg_u64(X18);
361 getset_reg_u64(X19);
362 getset_reg_u64(X20);
363 getset_reg_u64(X21);
364 getset_reg_u64(X22);
365 getset_reg_u64(X23);
366 getset_reg_u64(X24);
367 getset_reg_u64(X25);
368 getset_reg_u64(X26);
369 getset_reg_u64(X27);
370 getset_reg_u64(X28);
371 getset_reg_u64(X29);
375 
380 
381 
382 
383 PyObject* get_gpreg_offset_all(void)
384 {
385  PyObject *dict = PyDict_New();
386  PyObject *o;
387 
389  get_reg_off(exception_flags_new);
390 
391  get_reg_off(X0);
392  get_reg_off(X1);
393  get_reg_off(X2);
394  get_reg_off(X3);
395  get_reg_off(X4);
396  get_reg_off(X5);
397  get_reg_off(X6);
398  get_reg_off(X7);
399  get_reg_off(X8);
400  get_reg_off(X9);
401  get_reg_off(X10);
402  get_reg_off(X11);
403  get_reg_off(X12);
404  get_reg_off(X13);
405  get_reg_off(X14);
406  get_reg_off(X15);
407  get_reg_off(X16);
408  get_reg_off(X17);
409  get_reg_off(X18);
410  get_reg_off(X19);
411  get_reg_off(X20);
412  get_reg_off(X21);
413  get_reg_off(X22);
414  get_reg_off(X23);
415  get_reg_off(X24);
416  get_reg_off(X25);
417  get_reg_off(X26);
418  get_reg_off(X27);
419  get_reg_off(X28);
420  get_reg_off(X29);
421  get_reg_off(LR);
422  get_reg_off(SP);
423  get_reg_off(PC);
424 
425 
426  get_reg_off(X0_new);
427  get_reg_off(X1_new);
428  get_reg_off(X2_new);
429  get_reg_off(X3_new);
430  get_reg_off(X4_new);
431  get_reg_off(X5_new);
432  get_reg_off(X6_new);
433  get_reg_off(X7_new);
434  get_reg_off(X8_new);
435  get_reg_off(X9_new);
436  get_reg_off(X10_new);
437  get_reg_off(X11_new);
438  get_reg_off(X12_new);
439  get_reg_off(X13_new);
440  get_reg_off(X14_new);
441  get_reg_off(X15_new);
442  get_reg_off(X16_new);
443  get_reg_off(X17_new);
444  get_reg_off(X18_new);
445  get_reg_off(X19_new);
446  get_reg_off(X20_new);
447  get_reg_off(X21_new);
448  get_reg_off(X22_new);
449  get_reg_off(X23_new);
450  get_reg_off(X24_new);
451  get_reg_off(X25_new);
452  get_reg_off(X26_new);
453  get_reg_off(X27_new);
454  get_reg_off(X28_new);
455  get_reg_off(X29_new);
456  get_reg_off(LR_new);
457  get_reg_off(SP_new);
458  get_reg_off(PC_new);
459 
460 
461 
462  /* eflag */
463  get_reg_off(zf);
464  get_reg_off(nf);
465  get_reg_off(of);
466  get_reg_off(cf);
467 
468  get_reg_off(zf_new);
469  get_reg_off(nf_new);
470  get_reg_off(of_new);
471  get_reg_off(cf_new);
472 
473 
474  get_reg_off(pfmem08_0);
475  get_reg_off(pfmem08_1);
476  get_reg_off(pfmem08_2);
477  get_reg_off(pfmem08_3);
478  get_reg_off(pfmem08_4);
479  get_reg_off(pfmem08_5);
480  get_reg_off(pfmem08_6);
481  get_reg_off(pfmem08_7);
482  get_reg_off(pfmem08_8);
483  get_reg_off(pfmem08_9);
484  get_reg_off(pfmem08_10);
485  get_reg_off(pfmem08_11);
486  get_reg_off(pfmem08_12);
487  get_reg_off(pfmem08_13);
488  get_reg_off(pfmem08_14);
489  get_reg_off(pfmem08_15);
490  get_reg_off(pfmem08_16);
491  get_reg_off(pfmem08_17);
492  get_reg_off(pfmem08_18);
493  get_reg_off(pfmem08_19);
494 
495 
496  get_reg_off(pfmem16_0);
497  get_reg_off(pfmem16_1);
498  get_reg_off(pfmem16_2);
499  get_reg_off(pfmem16_3);
500  get_reg_off(pfmem16_4);
501  get_reg_off(pfmem16_5);
502  get_reg_off(pfmem16_6);
503  get_reg_off(pfmem16_7);
504  get_reg_off(pfmem16_8);
505  get_reg_off(pfmem16_9);
506  get_reg_off(pfmem16_10);
507  get_reg_off(pfmem16_11);
508  get_reg_off(pfmem16_12);
509  get_reg_off(pfmem16_13);
510  get_reg_off(pfmem16_14);
511  get_reg_off(pfmem16_15);
512  get_reg_off(pfmem16_16);
513  get_reg_off(pfmem16_17);
514  get_reg_off(pfmem16_18);
515  get_reg_off(pfmem16_19);
516 
517 
518  get_reg_off(pfmem32_0);
519  get_reg_off(pfmem32_1);
520  get_reg_off(pfmem32_2);
521  get_reg_off(pfmem32_3);
522  get_reg_off(pfmem32_4);
523  get_reg_off(pfmem32_5);
524  get_reg_off(pfmem32_6);
525  get_reg_off(pfmem32_7);
526  get_reg_off(pfmem32_8);
527  get_reg_off(pfmem32_9);
528  get_reg_off(pfmem32_10);
529  get_reg_off(pfmem32_11);
530  get_reg_off(pfmem32_12);
531  get_reg_off(pfmem32_13);
532  get_reg_off(pfmem32_14);
533  get_reg_off(pfmem32_15);
534  get_reg_off(pfmem32_16);
535  get_reg_off(pfmem32_17);
536  get_reg_off(pfmem32_18);
537  get_reg_off(pfmem32_19);
538 
539 
540  get_reg_off(pfmem64_0);
541  get_reg_off(pfmem64_1);
542  get_reg_off(pfmem64_2);
543  get_reg_off(pfmem64_3);
544  get_reg_off(pfmem64_4);
545  get_reg_off(pfmem64_5);
546  get_reg_off(pfmem64_6);
547  get_reg_off(pfmem64_7);
548  get_reg_off(pfmem64_8);
549  get_reg_off(pfmem64_9);
550  get_reg_off(pfmem64_10);
551  get_reg_off(pfmem64_11);
552  get_reg_off(pfmem64_12);
553  get_reg_off(pfmem64_13);
554  get_reg_off(pfmem64_14);
555  get_reg_off(pfmem64_15);
556  get_reg_off(pfmem64_16);
557  get_reg_off(pfmem64_17);
558  get_reg_off(pfmem64_18);
559  get_reg_off(pfmem64_19);
560 
561  return dict;
562 }
563 
564 
565 static PyGetSetDef JitCpu_getseters[] = {
566  {"vmmngr",
567  (getter)JitCpu_get_vmmngr, (setter)JitCpu_set_vmmngr,
568  "vmmngr",
569  NULL},
570 
571  {"jitter",
572  (getter)JitCpu_get_jitter, (setter)JitCpu_set_jitter,
573  "jitter",
574  NULL},
575 
576 
577 
578  {"X0" , (getter)JitCpu_get_X0 , (setter)JitCpu_set_X0 , "X0" , NULL},
579  {"X1" , (getter)JitCpu_get_X1 , (setter)JitCpu_set_X1 , "X1" , NULL},
580  {"X2" , (getter)JitCpu_get_X2 , (setter)JitCpu_set_X2 , "X2" , NULL},
581  {"X3" , (getter)JitCpu_get_X3 , (setter)JitCpu_set_X3 , "X3" , NULL},
582  {"X4" , (getter)JitCpu_get_X4 , (setter)JitCpu_set_X4 , "X4" , NULL},
583  {"X5" , (getter)JitCpu_get_X5 , (setter)JitCpu_set_X5 , "X5" , NULL},
584  {"X6" , (getter)JitCpu_get_X6 , (setter)JitCpu_set_X6 , "X6" , NULL},
585  {"X7" , (getter)JitCpu_get_X7 , (setter)JitCpu_set_X7 , "X7" , NULL},
586  {"X8" , (getter)JitCpu_get_X8 , (setter)JitCpu_set_X8 , "X8" , NULL},
587  {"X9" , (getter)JitCpu_get_X9 , (setter)JitCpu_set_X9 , "X9" , NULL},
588 
589  {"X10" , (getter)JitCpu_get_X10 , (setter)JitCpu_set_X10 , "X10" , NULL},
590  {"X11" , (getter)JitCpu_get_X11 , (setter)JitCpu_set_X11 , "X11" , NULL},
591  {"X12" , (getter)JitCpu_get_X12 , (setter)JitCpu_set_X12 , "X12" , NULL},
592  {"X13" , (getter)JitCpu_get_X13 , (setter)JitCpu_set_X13 , "X13" , NULL},
593  {"X14" , (getter)JitCpu_get_X14 , (setter)JitCpu_set_X14 , "X14" , NULL},
594  {"X15" , (getter)JitCpu_get_X15 , (setter)JitCpu_set_X15 , "X15" , NULL},
595  {"X16" , (getter)JitCpu_get_X16 , (setter)JitCpu_set_X16 , "X16" , NULL},
596  {"X17" , (getter)JitCpu_get_X17 , (setter)JitCpu_set_X17 , "X17" , NULL},
597  {"X18" , (getter)JitCpu_get_X18 , (setter)JitCpu_set_X18 , "X18" , NULL},
598  {"X19" , (getter)JitCpu_get_X19 , (setter)JitCpu_set_X19 , "X19" , NULL},
599 
600  {"X20" , (getter)JitCpu_get_X20 , (setter)JitCpu_set_X20 , "X20" , NULL},
601  {"X21" , (getter)JitCpu_get_X21 , (setter)JitCpu_set_X21 , "X21" , NULL},
602  {"X22" , (getter)JitCpu_get_X22 , (setter)JitCpu_set_X22 , "X22" , NULL},
603  {"X23" , (getter)JitCpu_get_X23 , (setter)JitCpu_set_X23 , "X23" , NULL},
604  {"X24" , (getter)JitCpu_get_X24 , (setter)JitCpu_set_X24 , "X24" , NULL},
605  {"X25" , (getter)JitCpu_get_X25 , (setter)JitCpu_set_X25 , "X25" , NULL},
606  {"X26" , (getter)JitCpu_get_X26 , (setter)JitCpu_set_X26 , "X26" , NULL},
607  {"X27" , (getter)JitCpu_get_X27 , (setter)JitCpu_set_X27 , "X27" , NULL},
608  {"X28" , (getter)JitCpu_get_X28 , (setter)JitCpu_set_X28 , "X28" , NULL},
609  {"X29" , (getter)JitCpu_get_X29 , (setter)JitCpu_set_X29 , "X29" , NULL},
610 
611  {"LR" , (getter)JitCpu_get_LR , (setter)JitCpu_set_LR , "LR" , NULL},
612 
613 
614 
615  {"SP" , (getter)JitCpu_get_SP , (setter)JitCpu_set_SP , "SP" , NULL},
616  {"PC" , (getter)JitCpu_get_PC , (setter)JitCpu_set_PC , "PC" , NULL},
617 
618  {"zf", (getter)JitCpu_get_zf, (setter)JitCpu_set_zf, "zf", NULL},
619  {"nf", (getter)JitCpu_get_nf, (setter)JitCpu_set_nf, "nf", NULL},
620  {"of", (getter)JitCpu_get_of, (setter)JitCpu_set_of, "of", NULL},
621  {"cf", (getter)JitCpu_get_cf, (setter)JitCpu_set_cf, "cf", NULL},
622 
623  {NULL} /* Sentinel */
624 };
625 
626 
627 static PyTypeObject JitCpuType = {
628  PyObject_HEAD_INIT(NULL)
629  0, /*ob_size*/
630  "JitCore_aarch64.JitCpu", /*tp_name*/
631  sizeof(JitCpu), /*tp_basicsize*/
632  0, /*tp_itemsize*/
633  (destructor)JitCpu_dealloc,/*tp_dealloc*/
634  0, /*tp_print*/
635  0, /*tp_getattr*/
636  0, /*tp_setattr*/
637  0, /*tp_compare*/
638  0, /*tp_repr*/
639  0, /*tp_as_number*/
640  0, /*tp_as_sequence*/
641  0, /*tp_as_mapping*/
642  0, /*tp_hash */
643  0, /*tp_call*/
644  0, /*tp_str*/
645  0, /*tp_getattro*/
646  0, /*tp_setattro*/
647  0, /*tp_as_buffer*/
648  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
649  "JitCpu objects", /* tp_doc */
650  0, /* tp_traverse */
651  0, /* tp_clear */
652  0, /* tp_richcompare */
653  0, /* tp_weaklistoffset */
654  0, /* tp_iter */
655  0, /* tp_iternext */
656  JitCpu_methods, /* tp_methods */
657  JitCpu_members, /* tp_members */
658  JitCpu_getseters, /* tp_getset */
659  0, /* tp_base */
660  0, /* tp_dict */
661  0, /* tp_descr_get */
662  0, /* tp_descr_set */
663  0, /* tp_dictoffset */
664  (initproc)JitCpu_init, /* tp_init */
665  0, /* tp_alloc */
666  JitCpu_new, /* tp_new */
667 };
668 
669 
670 
671 static PyMethodDef JitCore_aarch64_Methods[] = {
672  {"get_gpreg_offset_all", (PyCFunction)get_gpreg_offset_all, METH_NOARGS},
673  {NULL, NULL, 0, NULL} /* Sentinel */
674 
675 };
676 
677 static PyObject *JitCore_aarch64_Error;
678 
679 PyMODINIT_FUNC
681 {
682  PyObject *m;
683 
684  if (PyType_Ready(&JitCpuType) < 0)
685  return;
686 
687  m = Py_InitModule("JitCore_aarch64", JitCore_aarch64_Methods);
688  if (m == NULL)
689  return;
690 
691  JitCore_aarch64_Error = PyErr_NewException("JitCore_aarch64.error", NULL, NULL);
692  Py_INCREF(JitCore_aarch64_Error);
693  PyModule_AddObject(m, "error", JitCore_aarch64_Error);
694 
695  Py_INCREF(&JitCpuType);
696  PyModule_AddObject(m, "JitCpu", (PyObject *)&JitCpuType);
697 
698 }
699 
uint64_t X24
uint64_t X12
uint64_t X9
uint64_t X5
#define UDIV(sizeA)
Definition: vm_mngr.h:213
#define IMOD(sizeA)
Definition: vm_mngr.h:252
#define EXCEPT_CODE_AUTOMOD
Definition: vm_mngr.h:130
#define UMOD(sizeA)
Definition: vm_mngr.h:226
uint64_t X8
uint64_t X1
void MEM_WRITE_16(JitCpu *jitcpu, uint64_t addr, uint16_t src)
uint32_t cf
uint64_t PC
PyObject * vm_set_mem(JitCpu *self, PyObject *args)
static int JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
PyObject * JitCpu_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Definition: JitCore.c:17
#define RAISE(errtype, msg)
Definition: JitCore.h:4
uint64_t LR
#define PyGetInt(item, value)
Definition: JitCore.h:8
getset_reg_u32(zf)
string name
Definition: ir2C.py:22
static PyGetSetDef JitCpu_getseters[]
getset_reg_u64(X0)
PyObject * vm_get_mem(JitCpu *self, PyObject *args)
PyObject * jitter
Definition: JitCore.h:96
uint64_t X17
int vm_write_mem(vm_mngr_t *vm_mngr, uint64_t addr, char *buffer, uint64_t size)
Definition: vm_mngr.c:518
PyObject * cpu_set_exception(JitCpu *self, PyObject *args)
size_t offset
Definition: JitCore.h:103
static PyTypeObject JitCpuType
PyMODINIT_FUNC initJitCore_aarch64(void)
uint32_t nf
uint64_t X11
void vm_MEM_WRITE_64(vm_mngr_t *vm_mngr, uint64_t addr, uint64_t src)
Definition: vm_mngr.c:454
uint64_t X14
PyObject * JitCpu_set_vmmngr(JitCpu *self, PyObject *value, void *closure)
Definition: JitCore.c:35
static PyObject * JitCore_aarch64_Error
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
PyObject * JitCpu_set_jitter(JitCpu *self, PyObject *value, void *closure)
Definition: JitCore.c:51
#define get_reg(reg)
Definition: JitCore.h:74
uint64_t X16
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
PyObject * cpu_init_regs(JitCpu *self)
uint64_t X23
uint64_t X13
PyObject * cpu_get_gpreg(JitCpu *self)
uint64_t X4
reg_dict gpreg_dict[]
uint64_t X0
PyObject * cpu_get_exception(JitCpu *self, PyObject *args)
void MEM_WRITE_32(JitCpu *jitcpu, uint64_t addr, uint32_t src)
static PyMemberDef JitCpu_members[]
uint64_t X25
void vm_MEM_WRITE_08(vm_mngr_t *vm_mngr, uint64_t addr, unsigned char src)
Definition: vm_mngr.c:438
void MEM_WRITE_64(JitCpu *jitcpu, uint64_t addr, uint64_t src)
uint64_t X20
void dump_gpregs(vm_cpu_t *vmcpu)
uint64_t X15
PyObject * cpu_set_gpreg(JitCpu *self, PyObject *args)
PyObject * cpu_dump_gpregs(JitCpu *self, PyObject *args)
uint64_t X29
char * name
Definition: JitCore.h:102
#define IDIV(sizeA)
Definition: vm_mngr.h:239
static PyMethodDef JitCpu_methods[]
uint64_t X2
void MEM_WRITE_08(JitCpu *jitcpu, uint64_t addr, uint8_t src)
void JitCpu_dealloc(JitCpu *self)
Definition: JitCore.c:11
Definition: JitCore.h:93
uint64_t X22
uint64_t SP
uint64_t X3
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
uint64_t X19
uint64_t X7
static PyMethodDef JitCore_aarch64_Methods[]
uint64_t X28
uint64_t X21
#define get_reg_off(reg)
Definition: JitCore.h:81
uint64_t X6
uint64_t X18
uint64_t X27
uint64_t X10
PyObject * get_gpreg_offset_all(void)
tuple exception_flags
Definition: regs.py:7
uint32_t zf
uint64_t X26
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