Miasm2
 All Classes Namespaces Files Functions Variables Typedefs Properties Macros
JitCore_x86.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_x86.h"
10 
11 
12 
13 reg_dict gpreg_dict[] = { {.name = "RAX", .offset = offsetof(vm_cpu_t, RAX)},
14  {.name = "RBX", .offset = offsetof(vm_cpu_t, RBX)},
15  {.name = "RCX", .offset = offsetof(vm_cpu_t, RCX)},
16  {.name = "RDX", .offset = offsetof(vm_cpu_t, RDX)},
17  {.name = "RSI", .offset = offsetof(vm_cpu_t, RSI)},
18  {.name = "RDI", .offset = offsetof(vm_cpu_t, RDI)},
19  {.name = "RSP", .offset = offsetof(vm_cpu_t, RSP)},
20  {.name = "RBP", .offset = offsetof(vm_cpu_t, RBP)},
21 
22  {.name = "R8", .offset = offsetof(vm_cpu_t, R8)},
23  {.name = "R9", .offset = offsetof(vm_cpu_t, R9)},
24  {.name = "R10", .offset = offsetof(vm_cpu_t, R10)},
25  {.name = "R11", .offset = offsetof(vm_cpu_t, R11)},
26  {.name = "R12", .offset = offsetof(vm_cpu_t, R12)},
27  {.name = "R13", .offset = offsetof(vm_cpu_t, R13)},
28  {.name = "R14", .offset = offsetof(vm_cpu_t, R14)},
29  {.name = "R15", .offset = offsetof(vm_cpu_t, R15)},
30 
31  {.name = "RIP", .offset = offsetof(vm_cpu_t, RIP)},
32 
33  {.name = "zf", .offset = offsetof(vm_cpu_t, zf)},
34  {.name = "nf", .offset = offsetof(vm_cpu_t, nf)},
35  {.name = "pf", .offset = offsetof(vm_cpu_t, pf)},
36  {.name = "of", .offset = offsetof(vm_cpu_t, of)},
37  {.name = "cf", .offset = offsetof(vm_cpu_t, cf)},
38  {.name = "af", .offset = offsetof(vm_cpu_t, af)},
39  {.name = "df", .offset = offsetof(vm_cpu_t, df)},
40 
41  {.name = "ES", .offset = offsetof(vm_cpu_t, ES)},
42  {.name = "CS", .offset = offsetof(vm_cpu_t, CS)},
43  {.name = "SS", .offset = offsetof(vm_cpu_t, SS)},
44  {.name = "DS", .offset = offsetof(vm_cpu_t, DS)},
45  {.name = "FS", .offset = offsetof(vm_cpu_t, FS)},
46  {.name = "GS", .offset = offsetof(vm_cpu_t, GS)},
47 
48 };
49 
50 
51 
52 /************************** JitCpu object **************************/
53 
54 
55 
56 
57 
58 PyObject* cpu_get_gpreg(JitCpu* self)
59 {
60  PyObject *dict = PyDict_New();
61  PyObject *o;
62 
63  get_reg(RAX);
64  get_reg(RBX);
65  get_reg(RCX);
66  get_reg(RDX);
67  get_reg(RSI);
68  get_reg(RDI);
69  get_reg(RSP);
70  get_reg(RBP);
71 
72  get_reg(R8);
73  get_reg(R9);
74  get_reg(R10);
75  get_reg(R11);
76  get_reg(R12);
77  get_reg(R13);
78  get_reg(R14);
79  get_reg(R15);
80 
81  get_reg(RIP);
82 
83  get_reg(zf);
84  get_reg(nf);
85  get_reg(pf);
86  get_reg(of);
87  get_reg(cf);
88  get_reg(af);
89  get_reg(df);
90 
91 
92  get_reg(ES);
93  get_reg(CS);
94  get_reg(SS);
95  get_reg(DS);
96  get_reg(FS);
97  get_reg(GS);
98 
99  return dict;
100 }
101 
102 
103 
104 
105 
106 PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
107 {
108  PyObject* dict;
109  PyObject *d_key, *d_value = NULL;
110  Py_ssize_t pos = 0;
111  uint64_t val;
112  unsigned int i, found;
113 
114  if (!PyArg_ParseTuple(args, "O", &dict))
115  return NULL;
116  if(!PyDict_Check(dict))
117  RAISE(PyExc_TypeError, "arg must be dict");
118  while(PyDict_Next(dict, &pos, &d_key, &d_value)){
119  if(!PyString_Check(d_key))
120  RAISE(PyExc_TypeError, "key must be str");
121 
122  PyGetInt(d_value, val);
123 
124  found = 0;
125  for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
126  if (strcmp(PyString_AsString(d_key), gpreg_dict[i].name))
127  continue;
128  *((uint64_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
129  found = 1;
130  break;
131  }
132 
133  if (found)
134  continue;
135  fprintf(stderr, "unkown key: %s\n", PyString_AsString(d_key));
136  RAISE(PyExc_ValueError, "unkown reg");
137  }
138  Py_INCREF(Py_None);
139  return Py_None;
140 }
141 
142 PyObject * cpu_init_regs(JitCpu* self)
143 {
144  memset(self->cpu, 0, sizeof(vm_cpu_t));
145 
146  ((vm_cpu_t*)self->cpu)->tsc1 = 0x22222222;
147  ((vm_cpu_t*)self->cpu)->tsc2 = 0x11111111;
148  ((vm_cpu_t*)self->cpu)->i_f = 1;
149 
150  Py_INCREF(Py_None);
151  return Py_None;
152 
153 }
154 
155 void dump_gpregs(vm_cpu_t* vmcpu)
156 {
157 
158  printf("RAX %.16"PRIX64" RBX %.16"PRIX64" RCX %.16"PRIX64" RDX %.16"PRIX64"\n",
159  vmcpu->RAX, vmcpu->RBX, vmcpu->RCX, vmcpu->RDX);
160  printf("RSI %.16"PRIX64" RDI %.16"PRIX64" RSP %.16"PRIX64" RBP %.16"PRIX64"\n",
161  vmcpu->RSI, vmcpu->RDI, vmcpu->RSP, vmcpu->RBP);
162  printf("zf %.16"PRIX64" nf %.16"PRIX64" of %.16"PRIX64" cf %.16"PRIX64"\n",
163  vmcpu->zf, vmcpu->nf, vmcpu->of, vmcpu->cf);
164  printf("RIP %.16"PRIX64"\n",
165  vmcpu->RIP);
166 
167 }
168 
169 PyObject * cpu_dump_gpregs(JitCpu* self, PyObject* args)
170 {
171  vm_cpu_t* vmcpu;
172 
173  vmcpu = self->cpu;
174  dump_gpregs(vmcpu);
175  Py_INCREF(Py_None);
176  return Py_None;
177 }
178 
179 
180 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
181 {
182  PyObject *item1;
183  uint64_t i;
184 
185  if (!PyArg_ParseTuple(args, "O", &item1))
186  return NULL;
187 
188  PyGetInt(item1, i);
189 
190  ((vm_cpu_t*)self->cpu)->exception_flags = i;
191  Py_INCREF(Py_None);
192  return Py_None;
193 }
194 
195 PyObject* cpu_get_exception(JitCpu* self, PyObject* args)
196 {
197  return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)self->cpu)->exception_flags));
198 }
199 
200 
201 
202 
203 
204 PyObject* cpu_set_segm_base(JitCpu* self, PyObject* args)
205 {
206  PyObject *item1, *item2;
207  uint64_t segm_num, segm_base;
208 
209  if (!PyArg_ParseTuple(args, "OO", &item1, &item2))
210  return NULL;
211 
212  PyGetInt(item1, segm_num);
213  PyGetInt(item2, segm_base);
214  ((vm_cpu_t*)self->cpu)->segm_base[segm_num] = segm_base;
215 
216  Py_INCREF(Py_None);
217  return Py_None;
218 }
219 
220 PyObject* cpu_get_segm_base(JitCpu* self, PyObject* args)
221 {
222  PyObject *item1;
223  uint64_t segm_num;
224  PyObject* v;
225 
226  if (!PyArg_ParseTuple(args, "O", &item1))
227  return NULL;
228  PyGetInt(item1, segm_num);
229  v = PyInt_FromLong((long)(((vm_cpu_t*)self->cpu)->segm_base[segm_num]));
230  return v;
231 }
232 
233 uint64_t segm2addr(JitCpu* jitcpu, uint64_t segm, uint64_t addr)
234 {
235  return addr + ((vm_cpu_t*)jitcpu->cpu)->segm_base[segm];
236 }
237 
238 
239 UDIV(16)
240 UDIV(32)
241 UDIV(64)
242 
243 UMOD(16)
244 UMOD(32)
245 UMOD(64)
246 
247 
248 IDIV(16)
249 IDIV(32)
250 IDIV(64)
251 
252 IMOD(16)
253 IMOD(32)
254 IMOD(64)
255 
256 
257 
258 
259 void check_automod(JitCpu* jitcpu, uint64_t addr, uint64_t size)
260 {
261  PyObject *result;
262 
263  if (!(((VmMngr*)jitcpu->pyvm)->vm_mngr.exception_flags & EXCEPT_CODE_AUTOMOD))
264  return;
265  result = PyObject_CallMethod(jitcpu->jitter, "automod_cb", "LL", addr, size);
266  Py_DECREF(result);
267 
268 }
269 
270 void MEM_WRITE_08(JitCpu* jitcpu, uint64_t addr, uint8_t src)
271 {
272  vm_MEM_WRITE_08(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
273  check_automod(jitcpu, addr, 8);
274 }
275 
276 void MEM_WRITE_16(JitCpu* jitcpu, uint64_t addr, uint16_t src)
277 {
278  vm_MEM_WRITE_16(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
279  check_automod(jitcpu, addr, 16);
280 }
281 
282 void MEM_WRITE_32(JitCpu* jitcpu, uint64_t addr, uint32_t src)
283 {
284  vm_MEM_WRITE_32(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
285  check_automod(jitcpu, addr, 32);
286 }
287 
288 void MEM_WRITE_64(JitCpu* jitcpu, uint64_t addr, uint64_t src)
289 {
290  vm_MEM_WRITE_64(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
291  check_automod(jitcpu, addr, 64);
292 }
293 
294 
295 
296 PyObject* vm_set_mem(JitCpu *self, PyObject* args)
297 {
298  PyObject *py_addr;
299  PyObject *py_buffer;
300  Py_ssize_t py_length;
301 
302  char * buffer;
303  uint64_t size;
304  uint64_t addr;
305  int ret = 0x1337;
306 
307  if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
308  return NULL;
309 
310  PyGetInt(py_addr, addr);
311 
312  if(!PyString_Check(py_buffer))
313  RAISE(PyExc_TypeError,"arg must be str");
314 
315  size = PyString_Size(py_buffer);
316  PyString_AsStringAndSize(py_buffer, &buffer, &py_length);
317 
318  ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, size);
319  if (ret < 0)
320  RAISE(PyExc_TypeError,"arg must be str");
321  check_automod(self, addr, size*8);
322 
323  Py_INCREF(Py_None);
324  return Py_None;
325 }
326 
327 static PyMemberDef JitCpu_members[] = {
328  {NULL} /* Sentinel */
329 };
330 
331 static PyMethodDef JitCpu_methods[] = {
332  {"init_regs", (PyCFunction)cpu_init_regs, METH_NOARGS,
333  "X"},
334  {"dump_gpregs", (PyCFunction)cpu_dump_gpregs, METH_NOARGS,
335  "X"},
336  {"get_gpreg", (PyCFunction)cpu_get_gpreg, METH_NOARGS,
337  "X"},
338  {"set_gpreg", (PyCFunction)cpu_set_gpreg, METH_VARARGS,
339  "X"},
340  {"get_segm_base", (PyCFunction)cpu_get_segm_base, METH_VARARGS,
341  "X"},
342  {"set_segm_base", (PyCFunction)cpu_set_segm_base, METH_VARARGS,
343  "X"},
344  {"get_exception", (PyCFunction)cpu_get_exception, METH_VARARGS,
345  "X"},
346  {"set_exception", (PyCFunction)cpu_set_exception, METH_VARARGS,
347  "X"},
348  {"set_mem", (PyCFunction)vm_set_mem, METH_VARARGS,
349  "X"},
350  {"get_mem", (PyCFunction)vm_get_mem, METH_VARARGS,
351  "X"},
352  {NULL} /* Sentinel */
353 };
354 
355 static int
356 JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
357 {
358  self->cpu = malloc(sizeof(vm_cpu_t));
359  if (self->cpu == NULL) {
360  fprintf(stderr, "cannot alloc vm_cpu_t\n");
361  exit(0);
362  }
363  return 0;
364 }
365 
366 
367 #define getset_reg_E_u32(regname) \
368  static PyObject *JitCpu_get_E ## regname (JitCpu *self, void *closure) \
369  { \
370  return PyLong_FromUnsignedLongLong((uint32_t)(((vm_cpu_t*)(self->cpu))->R ## regname & 0xFFFFFFFF )); \
371  } \
372  static int JitCpu_set_E ## regname (JitCpu *self, PyObject *value, void *closure) \
373  { \
374  uint64_t val; \
375  PyGetInt_ret0(value, val); \
376  val &= 0xFFFFFFFF; \
377  val |= ((vm_cpu_t*)(self->cpu))->R ##regname & 0xFFFFFFFF00000000ULL; \
378  ((vm_cpu_t*)(self->cpu))->R ## regname = val; \
379  return 0; \
380  }
381 
382 
383 
384 #define getset_reg_R_u16(regname) \
385  static PyObject *JitCpu_get_ ## regname (JitCpu *self, void *closure) \
386  { \
387  return PyLong_FromUnsignedLongLong((uint16_t)(((vm_cpu_t*)(self->cpu))->R ## regname & 0xFFFF )); \
388  } \
389  static int JitCpu_set_ ## regname (JitCpu *self, PyObject *value, void *closure) \
390  { \
391  uint64_t val; \
392  PyGetInt_ret0(value, val); \
393  val &= 0xFFFF; \
394  val |= ((vm_cpu_t*)(self->cpu))->R ##regname & 0xFFFFFFFFFFFF0000ULL; \
395  ((vm_cpu_t*)(self->cpu))->R ## regname = val; \
396  return 0; \
397  }
398 
399 
400 getset_reg_u64(RAX);
401 getset_reg_u64(RBX);
402 getset_reg_u64(RCX);
403 getset_reg_u64(RDX);
404 getset_reg_u64(RSI);
405 getset_reg_u64(RDI);
406 getset_reg_u64(RSP);
407 getset_reg_u64(RBP);
408 
409 getset_reg_u64(R8);
410 getset_reg_u64(R9);
411 getset_reg_u64(R10);
412 getset_reg_u64(R11);
413 getset_reg_u64(R12);
414 getset_reg_u64(R13);
415 getset_reg_u64(R14);
416 getset_reg_u64(R15);
417 
418 getset_reg_u64(RIP);
419 
420 getset_reg_u64(zf);
421 getset_reg_u64(nf);
422 getset_reg_u64(pf);
423 getset_reg_u64(of);
424 getset_reg_u64(cf);
425 getset_reg_u64(af);
426 getset_reg_u64(df);
427 
428 
429 getset_reg_u64(ES);
430 getset_reg_u64(CS);
431 getset_reg_u64(SS);
432 getset_reg_u64(DS);
433 getset_reg_u64(FS);
434 getset_reg_u64(GS);
435 
436 
437 getset_reg_E_u32(AX);
438 getset_reg_E_u32(BX);
439 getset_reg_E_u32(CX);
440 getset_reg_E_u32(DX);
441 getset_reg_E_u32(SI);
442 getset_reg_E_u32(DI);
443 getset_reg_E_u32(SP);
444 getset_reg_E_u32(BP);
445 getset_reg_E_u32(IP);
446 
447 getset_reg_R_u16(AX);
448 getset_reg_R_u16(BX);
449 getset_reg_R_u16(CX);
450 getset_reg_R_u16(DX);
451 getset_reg_R_u16(SI);
452 getset_reg_R_u16(DI);
453 getset_reg_R_u16(SP);
454 getset_reg_R_u16(BP);
455 
456 getset_reg_R_u16(IP);
457 
458 
459 PyObject* get_gpreg_offset_all(void)
460 {
461  PyObject *dict = PyDict_New();
462  PyObject *o;
463 
464  get_reg_off(exception_flags);
465  get_reg_off(exception_flags_new);
466 
467  get_reg_off(RAX);
468  get_reg_off(RBX);
469  get_reg_off(RCX);
470  get_reg_off(RDX);
471  get_reg_off(RSI);
472  get_reg_off(RDI);
473  get_reg_off(RSP);
474  get_reg_off(RBP);
475  get_reg_off(R8);
476  get_reg_off(R9);
477  get_reg_off(R10);
478  get_reg_off(R11);
479  get_reg_off(R12);
480  get_reg_off(R13);
481  get_reg_off(R14);
482  get_reg_off(R15);
483  get_reg_off(RIP);
484  get_reg_off(RAX_new);
485  get_reg_off(RBX_new);
486  get_reg_off(RCX_new);
487  get_reg_off(RDX_new);
488  get_reg_off(RSI_new);
489  get_reg_off(RDI_new);
490  get_reg_off(RSP_new);
491  get_reg_off(RBP_new);
492  get_reg_off(R8_new);
493  get_reg_off(R9_new);
494  get_reg_off(R10_new);
495  get_reg_off(R11_new);
496  get_reg_off(R12_new);
497  get_reg_off(R13_new);
498  get_reg_off(R14_new);
499  get_reg_off(R15_new);
500  get_reg_off(RIP_new);
501  get_reg_off(zf);
502  get_reg_off(nf);
503  get_reg_off(pf);
504  get_reg_off(of);
505  get_reg_off(cf);
506  get_reg_off(af);
507  get_reg_off(df);
508  get_reg_off(zf_new);
509  get_reg_off(nf_new);
510  get_reg_off(pf_new);
511  get_reg_off(of_new);
512  get_reg_off(cf_new);
513  get_reg_off(af_new);
514  get_reg_off(df_new);
515  get_reg_off(tf);
516  get_reg_off(i_f);
517  get_reg_off(iopl_f);
518  get_reg_off(nt);
519  get_reg_off(rf);
520  get_reg_off(vm);
521  get_reg_off(ac);
522  get_reg_off(vif);
523  get_reg_off(vip);
524  get_reg_off(i_d);
525  get_reg_off(tf_new);
526  get_reg_off(i_f_new);
527  get_reg_off(iopl_f_new);
528  get_reg_off(nt_new);
529  get_reg_off(rf_new);
530  get_reg_off(vm_new);
531  get_reg_off(ac_new);
532  get_reg_off(vif_new);
533  get_reg_off(vip_new);
534  get_reg_off(i_d_new);
535  get_reg_off(my_tick);
536  get_reg_off(cond);
537 
538  get_reg_off(float_st0);
539  get_reg_off(float_st1);
540  get_reg_off(float_st2);
541  get_reg_off(float_st3);
542  get_reg_off(float_st4);
543  get_reg_off(float_st5);
544  get_reg_off(float_st6);
545  get_reg_off(float_st7);
546  get_reg_off(float_st0_new);
547  get_reg_off(float_st1_new);
548  get_reg_off(float_st2_new);
549  get_reg_off(float_st3_new);
550  get_reg_off(float_st4_new);
551  get_reg_off(float_st5_new);
552  get_reg_off(float_st6_new);
553  get_reg_off(float_st7_new);
554 
555  get_reg_off(ES);
556  get_reg_off(CS);
557  get_reg_off(SS);
558  get_reg_off(DS);
559  get_reg_off(FS);
560  get_reg_off(GS);
561  get_reg_off(ES_new);
562  get_reg_off(CS_new);
563  get_reg_off(SS_new);
564  get_reg_off(DS_new);
565  get_reg_off(FS_new);
566  get_reg_off(GS_new);
567 
568  get_reg_off(pfmem08_0);
569  get_reg_off(pfmem08_1);
570  get_reg_off(pfmem08_2);
571  get_reg_off(pfmem08_3);
572  get_reg_off(pfmem08_4);
573  get_reg_off(pfmem08_5);
574  get_reg_off(pfmem08_6);
575  get_reg_off(pfmem08_7);
576  get_reg_off(pfmem08_8);
577  get_reg_off(pfmem08_9);
578  get_reg_off(pfmem08_10);
579  get_reg_off(pfmem08_11);
580  get_reg_off(pfmem08_12);
581  get_reg_off(pfmem08_13);
582  get_reg_off(pfmem08_14);
583  get_reg_off(pfmem08_15);
584  get_reg_off(pfmem08_16);
585  get_reg_off(pfmem08_17);
586  get_reg_off(pfmem08_18);
587  get_reg_off(pfmem08_19);
588  get_reg_off(pfmem16_0);
589  get_reg_off(pfmem16_1);
590  get_reg_off(pfmem16_2);
591  get_reg_off(pfmem16_3);
592  get_reg_off(pfmem16_4);
593  get_reg_off(pfmem16_5);
594  get_reg_off(pfmem16_6);
595  get_reg_off(pfmem16_7);
596  get_reg_off(pfmem16_8);
597  get_reg_off(pfmem16_9);
598  get_reg_off(pfmem16_10);
599  get_reg_off(pfmem16_11);
600  get_reg_off(pfmem16_12);
601  get_reg_off(pfmem16_13);
602  get_reg_off(pfmem16_14);
603  get_reg_off(pfmem16_15);
604  get_reg_off(pfmem16_16);
605  get_reg_off(pfmem16_17);
606  get_reg_off(pfmem16_18);
607  get_reg_off(pfmem16_19);
608  get_reg_off(pfmem32_0);
609  get_reg_off(pfmem32_1);
610  get_reg_off(pfmem32_2);
611  get_reg_off(pfmem32_3);
612  get_reg_off(pfmem32_4);
613  get_reg_off(pfmem32_5);
614  get_reg_off(pfmem32_6);
615  get_reg_off(pfmem32_7);
616  get_reg_off(pfmem32_8);
617  get_reg_off(pfmem32_9);
618  get_reg_off(pfmem32_10);
619  get_reg_off(pfmem32_11);
620  get_reg_off(pfmem32_12);
621  get_reg_off(pfmem32_13);
622  get_reg_off(pfmem32_14);
623  get_reg_off(pfmem32_15);
624  get_reg_off(pfmem32_16);
625  get_reg_off(pfmem32_17);
626  get_reg_off(pfmem32_18);
627  get_reg_off(pfmem32_19);
628  get_reg_off(pfmem64_0);
629  get_reg_off(pfmem64_1);
630  get_reg_off(pfmem64_2);
631  get_reg_off(pfmem64_3);
632  get_reg_off(pfmem64_4);
633  get_reg_off(pfmem64_5);
634  get_reg_off(pfmem64_6);
635  get_reg_off(pfmem64_7);
636  get_reg_off(pfmem64_8);
637  get_reg_off(pfmem64_9);
638  get_reg_off(pfmem64_10);
639  get_reg_off(pfmem64_11);
640  get_reg_off(pfmem64_12);
641  get_reg_off(pfmem64_13);
642  get_reg_off(pfmem64_14);
643  get_reg_off(pfmem64_15);
644  get_reg_off(pfmem64_16);
645  get_reg_off(pfmem64_17);
646  get_reg_off(pfmem64_18);
647  get_reg_off(pfmem64_19);
648 
649  get_reg_off(MM0);
650  get_reg_off(MM1);
651  get_reg_off(MM2);
652  get_reg_off(MM3);
653  get_reg_off(MM4);
654  get_reg_off(MM5);
655  get_reg_off(MM6);
656  get_reg_off(MM7);
657  get_reg_off(MM0_new);
658  get_reg_off(MM1_new);
659  get_reg_off(MM2_new);
660  get_reg_off(MM3_new);
661  get_reg_off(MM4_new);
662  get_reg_off(MM5_new);
663  get_reg_off(MM6_new);
664  get_reg_off(MM7_new);
665  return dict;
666 }
667 
668 
669 static PyGetSetDef JitCpu_getseters[] = {
670  {"vmmngr",
671  (getter)JitCpu_get_vmmngr, (setter)JitCpu_set_vmmngr,
672  "vmmngr",
673  NULL},
674 
675  {"jitter",
676  (getter)JitCpu_get_jitter, (setter)JitCpu_set_jitter,
677  "jitter",
678  NULL},
679 
680 
681  {"RAX", (getter)JitCpu_get_RAX, (setter)JitCpu_set_RAX, "RAX", NULL},
682  {"RBX", (getter)JitCpu_get_RBX, (setter)JitCpu_set_RBX, "RBX", NULL},
683  {"RCX", (getter)JitCpu_get_RCX, (setter)JitCpu_set_RCX, "RCX", NULL},
684  {"RDX", (getter)JitCpu_get_RDX, (setter)JitCpu_set_RDX, "RDX", NULL},
685  {"RSI", (getter)JitCpu_get_RSI, (setter)JitCpu_set_RSI, "RSI", NULL},
686  {"RDI", (getter)JitCpu_get_RDI, (setter)JitCpu_set_RDI, "RDI", NULL},
687  {"RSP", (getter)JitCpu_get_RSP, (setter)JitCpu_set_RSP, "RSP", NULL},
688  {"RBP", (getter)JitCpu_get_RBP, (setter)JitCpu_set_RBP, "RBP", NULL},
689  {"R8", (getter)JitCpu_get_R8, (setter)JitCpu_set_R8, "R8", NULL},
690  {"R9", (getter)JitCpu_get_R9, (setter)JitCpu_set_R9, "R9", NULL},
691  {"R10", (getter)JitCpu_get_R10, (setter)JitCpu_set_R10, "R10", NULL},
692  {"R11", (getter)JitCpu_get_R11, (setter)JitCpu_set_R11, "R11", NULL},
693  {"R12", (getter)JitCpu_get_R12, (setter)JitCpu_set_R12, "R12", NULL},
694  {"R13", (getter)JitCpu_get_R13, (setter)JitCpu_set_R13, "R13", NULL},
695  {"R14", (getter)JitCpu_get_R14, (setter)JitCpu_set_R14, "R14", NULL},
696  {"R15", (getter)JitCpu_get_R15, (setter)JitCpu_set_R15, "R15", NULL},
697  {"RIP", (getter)JitCpu_get_RIP, (setter)JitCpu_set_RIP, "RIP", NULL},
698  {"zf", (getter)JitCpu_get_zf, (setter)JitCpu_set_zf, "zf", NULL},
699  {"nf", (getter)JitCpu_get_nf, (setter)JitCpu_set_nf, "nf", NULL},
700  {"pf", (getter)JitCpu_get_pf, (setter)JitCpu_set_pf, "pf", NULL},
701  {"of", (getter)JitCpu_get_of, (setter)JitCpu_set_of, "of", NULL},
702  {"cf", (getter)JitCpu_get_cf, (setter)JitCpu_set_cf, "cf", NULL},
703  {"af", (getter)JitCpu_get_af, (setter)JitCpu_set_af, "af", NULL},
704  {"df", (getter)JitCpu_get_df, (setter)JitCpu_set_df, "df", NULL},
705  {"ES", (getter)JitCpu_get_ES, (setter)JitCpu_set_ES, "ES", NULL},
706  {"CS", (getter)JitCpu_get_CS, (setter)JitCpu_set_CS, "CS", NULL},
707  {"SS", (getter)JitCpu_get_SS, (setter)JitCpu_set_SS, "SS", NULL},
708  {"DS", (getter)JitCpu_get_DS, (setter)JitCpu_set_DS, "DS", NULL},
709  {"FS", (getter)JitCpu_get_FS, (setter)JitCpu_set_FS, "FS", NULL},
710  {"GS", (getter)JitCpu_get_GS, (setter)JitCpu_set_GS, "GS", NULL},
711 
712  {"EAX", (getter)JitCpu_get_EAX, (setter)JitCpu_set_EAX, "EAX", NULL},
713  {"EBX", (getter)JitCpu_get_EBX, (setter)JitCpu_set_EBX, "EBX", NULL},
714  {"ECX", (getter)JitCpu_get_ECX, (setter)JitCpu_set_ECX, "ECX", NULL},
715  {"EDX", (getter)JitCpu_get_EDX, (setter)JitCpu_set_EDX, "EDX", NULL},
716  {"ESI", (getter)JitCpu_get_ESI, (setter)JitCpu_set_ESI, "ESI", NULL},
717  {"EDI", (getter)JitCpu_get_EDI, (setter)JitCpu_set_EDI, "EDI", NULL},
718  {"ESP", (getter)JitCpu_get_ESP, (setter)JitCpu_set_ESP, "ESP", NULL},
719  {"EBP", (getter)JitCpu_get_EBP, (setter)JitCpu_set_EBP, "EBP", NULL},
720  {"EIP", (getter)JitCpu_get_EIP, (setter)JitCpu_set_EIP, "EIP", NULL},
721 
722  {"AX", (getter)JitCpu_get_AX, (setter)JitCpu_set_AX, "AX", NULL},
723  {"BX", (getter)JitCpu_get_BX, (setter)JitCpu_set_BX, "BX", NULL},
724  {"CX", (getter)JitCpu_get_CX, (setter)JitCpu_set_CX, "CX", NULL},
725  {"DX", (getter)JitCpu_get_DX, (setter)JitCpu_set_DX, "DX", NULL},
726  {"SI", (getter)JitCpu_get_SI, (setter)JitCpu_set_SI, "SI", NULL},
727  {"DI", (getter)JitCpu_get_DI, (setter)JitCpu_set_DI, "DI", NULL},
728  {"SP", (getter)JitCpu_get_SP, (setter)JitCpu_set_SP, "SP", NULL},
729  {"BP", (getter)JitCpu_get_BP, (setter)JitCpu_set_BP, "BP", NULL},
730 
731  {"IP", (getter)JitCpu_get_IP, (setter)JitCpu_set_IP, "IP", NULL},
732 
733 
734  {NULL} /* Sentinel */
735 };
736 
737 
738 static PyTypeObject JitCpuType = {
739  PyObject_HEAD_INIT(NULL)
740  0, /*ob_size*/
741  "JitCore_x86.JitCpu", /*tp_name*/
742  sizeof(JitCpu), /*tp_basicsize*/
743  0, /*tp_itemsize*/
744  (destructor)JitCpu_dealloc,/*tp_dealloc*/
745  0, /*tp_print*/
746  0, /*tp_getattr*/
747  0, /*tp_setattr*/
748  0, /*tp_compare*/
749  0, /*tp_repr*/
750  0, /*tp_as_number*/
751  0, /*tp_as_sequence*/
752  0, /*tp_as_mapping*/
753  0, /*tp_hash */
754  0, /*tp_call*/
755  0, /*tp_str*/
756  0, /*tp_getattro*/
757  0, /*tp_setattro*/
758  0, /*tp_as_buffer*/
759  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
760  "JitCpu objects", /* tp_doc */
761  0, /* tp_traverse */
762  0, /* tp_clear */
763  0, /* tp_richcompare */
764  0, /* tp_weaklistoffset */
765  0, /* tp_iter */
766  0, /* tp_iternext */
767  JitCpu_methods, /* tp_methods */
768  JitCpu_members, /* tp_members */
769  JitCpu_getseters, /* tp_getset */
770  0, /* tp_base */
771  0, /* tp_dict */
772  0, /* tp_descr_get */
773  0, /* tp_descr_set */
774  0, /* tp_dictoffset */
775  (initproc)JitCpu_init, /* tp_init */
776  0, /* tp_alloc */
777  JitCpu_new, /* tp_new */
778 };
779 
780 
781 
782 static PyMethodDef JitCore_x86_Methods[] = {
783 
784  /*
785 
786  */
787  {"get_gpreg_offset_all", (PyCFunction)get_gpreg_offset_all, METH_NOARGS},
788  {NULL, NULL, 0, NULL} /* Sentinel */
789 
790 };
791 
792 static PyObject *JitCore_x86_Error;
793 
794 PyMODINIT_FUNC
795 initJitCore_x86(void)
796 {
797  PyObject *m;
798 
799  if (PyType_Ready(&JitCpuType) < 0)
800  return;
801 
802  m = Py_InitModule("JitCore_x86", JitCore_x86_Methods);
803  if (m == NULL)
804  return;
805 
806  JitCore_x86_Error = PyErr_NewException("JitCore_x86.error", NULL, NULL);
807  Py_INCREF(JitCore_x86_Error);
808  PyModule_AddObject(m, "error", JitCore_x86_Error);
809 
810  Py_INCREF(&JitCpuType);
811  PyModule_AddObject(m, "JitCpu", (PyObject *)&JitCpuType);
812 
813 }
814 
815 
816 
817 
818 
819 
820 
821 
822 
823 
824 
825 
826 
827 
828 
829 
830 
831 
832 
833 
834 
835 
cpu_set_segm_base
PyObject * cpu_set_segm_base(JitCpu *self, PyObject *args)
Definition: JitCore_x86.c:204
UDIV
#define UDIV(sizeA)
Definition: vm_mngr.h:213
IMOD
#define IMOD(sizeA)
Definition: vm_mngr.h:252
EXCEPT_CODE_AUTOMOD
#define EXCEPT_CODE_AUTOMOD
Definition: vm_mngr.h:130
UMOD
#define UMOD(sizeA)
Definition: vm_mngr.h:226
MEM_WRITE_32
void MEM_WRITE_32(JitCpu *jitcpu, uint64_t addr, uint32_t src)
Definition: JitCore_x86.c:282
JitCpu_init
static int JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
Definition: JitCore_x86.c:356
vm_cpu_t::RSI
uint64_t RSI
Definition: JitCore_x86.h:12
cpu_init_regs
PyObject * cpu_init_regs(JitCpu *self)
Definition: JitCore_x86.c:142
vm_cpu_t::cf
uint32_t cf
Definition: JitCore_aarch64.h:83
vm_cpu_t::RAX
uint64_t RAX
Definition: JitCore_x86.h:8
dump_gpregs
void dump_gpregs(vm_cpu_t *vmcpu)
Definition: JitCore_x86.c:155
JitCpu_methods
static PyMethodDef JitCpu_methods[]
Definition: JitCore_x86.c:331
JitCpu_new
PyObject * JitCpu_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Definition: JitCore.c:17
JitCore_x86_Error
static PyObject * JitCore_x86_Error
Definition: JitCore_x86.c:792
cpu_get_segm_base
PyObject * cpu_get_segm_base(JitCpu *self, PyObject *args)
Definition: JitCore_x86.c:220
RAISE
#define RAISE(errtype, msg)
Definition: JitCore.h:4
PyGetInt
#define PyGetInt(item, value)
Definition: JitCore.h:8
vm_cpu_t
Definition: JitCore_aarch64.h:2
cpu_get_exception
PyObject * cpu_get_exception(JitCpu *self, PyObject *args)
Definition: JitCore_x86.c:195
getset_reg_u64
getset_reg_u64(RAX)
miasm2.ir.ir2C.name
string name
Definition: ir2C.py:22
vm_get_mem
PyObject * vm_get_mem(JitCpu *self, PyObject *args)
JitCpu_getseters
static PyGetSetDef JitCpu_getseters[]
Definition: JitCore_x86.c:669
vm_cpu_t::RSP
uint64_t RSP
Definition: JitCore_x86.h:14
MEM_WRITE_16
void MEM_WRITE_16(JitCpu *jitcpu, uint64_t addr, uint16_t src)
Definition: JitCore_x86.c:276
cpu_set_gpreg
PyObject * cpu_set_gpreg(JitCpu *self, PyObject *args)
Definition: JitCore_x86.c:106
vm_write_mem
int vm_write_mem(vm_mngr_t *vm_mngr, uint64_t addr, char *buffer, uint64_t size)
Definition: vm_mngr.c:518
vm_cpu_t::RCX
uint64_t RCX
Definition: JitCore_x86.h:10
_reg_dict::offset
size_t offset
Definition: JitCore.h:103
JitCpu_members
static PyMemberDef JitCpu_members[]
Definition: JitCore_x86.c:327
vm_cpu_t::nf
uint32_t nf
Definition: JitCore_aarch64.h:81
cpu_get_gpreg
PyObject * cpu_get_gpreg(JitCpu *self)
Definition: JitCore_x86.c:58
vm_MEM_WRITE_64
void vm_MEM_WRITE_64(vm_mngr_t *vm_mngr, uint64_t addr, uint64_t src)
Definition: vm_mngr.c:454
cpu_dump_gpregs
PyObject * cpu_dump_gpregs(JitCpu *self, PyObject *args)
Definition: JitCore_x86.c:169
JitCpu_set_vmmngr
PyObject * JitCpu_set_vmmngr(JitCpu *self, PyObject *value, void *closure)
Definition: JitCore.c:35
getset_reg_R_u16
#define getset_reg_R_u16(regname)
Definition: JitCore_x86.c:384
JitCpu_get_vmmngr
PyObject * JitCpu_get_vmmngr(JitCpu *self, void *closure)
Definition: JitCore.c:25
vm_MEM_WRITE_16
void vm_MEM_WRITE_16(vm_mngr_t *vm_mngr, uint64_t addr, unsigned short src)
Definition: vm_mngr.c:444
vm_cpu_t::of
uint32_t of
Definition: JitCore_aarch64.h:82
JitCpu_set_jitter
PyObject * JitCpu_set_jitter(JitCpu *self, PyObject *value, void *closure)
Definition: JitCore.c:51
vm_cpu_t::RDX
uint64_t RDX
Definition: JitCore_x86.h:11
vm_cpu_t::RIP
uint64_t RIP
Definition: JitCore_x86.h:25
get_reg
#define get_reg(reg)
Definition: JitCore.h:74
JitCpu::pyvm
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
MEM_WRITE_64
void MEM_WRITE_64(JitCpu *jitcpu, uint64_t addr, uint64_t src)
Definition: JitCore_x86.c:288
getset_reg_E_u32
#define getset_reg_E_u32(regname)
Definition: JitCore_x86.c:367
JitCore_x86.h
gpreg_dict
reg_dict gpreg_dict[]
Definition: JitCore_x86.c:13
vm_MEM_WRITE_08
void vm_MEM_WRITE_08(vm_mngr_t *vm_mngr, uint64_t addr, unsigned char src)
Definition: vm_mngr.c:438
_reg_dict
Definition: JitCore.h:101
check_automod
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
Definition: JitCore_x86.c:259
JitCpu::cpu
void * cpu
Definition: JitCore.h:97
MEM_WRITE_08
void MEM_WRITE_08(JitCpu *jitcpu, uint64_t addr, uint8_t src)
Definition: JitCore_x86.c:270
get_gpreg_offset_all
PyObject * get_gpreg_offset_all(void)
Definition: JitCore_x86.c:459
_reg_dict::name
char * name
Definition: JitCore.h:102
IDIV
#define IDIV(sizeA)
Definition: vm_mngr.h:239
vm_cpu_t::RDI
uint64_t RDI
Definition: JitCore_x86.h:13
cpu_set_exception
PyObject * cpu_set_exception(JitCpu *self, PyObject *args)
Definition: JitCore_x86.c:180
segm2addr
uint64_t segm2addr(JitCpu *jitcpu, uint64_t segm, uint64_t addr)
Definition: JitCore_x86.c:233
JitCpu_dealloc
void JitCpu_dealloc(JitCpu *self)
Definition: JitCore.c:11
JitCpu
Definition: JitCore.h:93
JitCore_x86_Methods
static PyMethodDef JitCore_x86_Methods[]
Definition: JitCore_x86.c:782
get_reg_off
#define get_reg_off(reg)
Definition: JitCore.h:81
initJitCore_x86
PyMODINIT_FUNC initJitCore_x86(void)
Definition: JitCore_x86.c:795
JitCpuType
static PyTypeObject JitCpuType
Definition: JitCore_x86.c:738
vm_cpu_t::RBX
uint64_t RBX
Definition: JitCore_x86.h:9
miasm2.arch.aarch64.regs.exception_flags
tuple exception_flags
Definition: regs.py:7
vm_cpu_t::RBP
uint64_t RBP
Definition: JitCore_x86.h:15
vm_set_mem
PyObject * vm_set_mem(JitCpu *self, PyObject *args)
Definition: JitCore_x86.c:296
vm_cpu_t::zf
uint32_t zf
Definition: JitCore_aarch64.h:80
vm_MEM_WRITE_32
void vm_MEM_WRITE_32(vm_mngr_t *vm_mngr, uint64_t addr, unsigned int src)
Definition: vm_mngr.c:449
JitCpu_get_jitter
PyObject * JitCpu_get_jitter(JitCpu *self, void *closure)
Definition: JitCore.c:41
Generated by   doxygen 1.8.8