Miasm2
 All Classes Namespaces Files Functions Variables Typedefs Properties Macros
JitCore_msp430.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_msp430.h"
10 
11 
12 reg_dict gpreg_dict[] = { {.name = "PC", .offset = offsetof(vm_cpu_t, PC)},
13  {.name = "SP", .offset = offsetof(vm_cpu_t, SP)},
14  //{.name = "SR", .offset = offsetof(vm_cpu_t, SR)},
15  {.name = "R3", .offset = offsetof(vm_cpu_t, R3)},
16  {.name = "R4", .offset = offsetof(vm_cpu_t, R4)},
17  {.name = "R5", .offset = offsetof(vm_cpu_t, R5)},
18  {.name = "R6", .offset = offsetof(vm_cpu_t, R6)},
19  {.name = "R7", .offset = offsetof(vm_cpu_t, R7)},
20  {.name = "R8", .offset = offsetof(vm_cpu_t, R8)},
21  {.name = "R9", .offset = offsetof(vm_cpu_t, R9)},
22  {.name = "R10", .offset = offsetof(vm_cpu_t, R10)},
23  {.name = "R11", .offset = offsetof(vm_cpu_t, R11)},
24  {.name = "R12", .offset = offsetof(vm_cpu_t, R12)},
25  {.name = "R13", .offset = offsetof(vm_cpu_t, R13)},
26  {.name = "R14", .offset = offsetof(vm_cpu_t, R14)},
27  {.name = "R15", .offset = offsetof(vm_cpu_t, R15)},
28 
29  {.name = "zf", .offset = offsetof(vm_cpu_t, zf)},
30  {.name = "nf", .offset = offsetof(vm_cpu_t, nf)},
31  {.name = "of", .offset = offsetof(vm_cpu_t, of)},
32  {.name = "cf", .offset = offsetof(vm_cpu_t, cf)},
33 
34  {.name = "cpuoff", .offset = offsetof(vm_cpu_t, zf)},
35  {.name = "gie", .offset = offsetof(vm_cpu_t, zf)},
36  {.name = "osc", .offset = offsetof(vm_cpu_t, zf)},
37  {.name = "scg0", .offset = offsetof(vm_cpu_t, zf)},
38  {.name = "scg1", .offset = offsetof(vm_cpu_t, zf)},
39  {.name = "res", .offset = offsetof(vm_cpu_t, zf)},
40 
41 };
42 
43 /************************** JitCpu object **************************/
44 
45 
46 
47 PyObject* cpu_get_gpreg(JitCpu* self)
48 {
49  PyObject *dict = PyDict_New();
50  PyObject *o;
51 
52  get_reg(PC);
53  get_reg(SP);
54  //get_reg(SR);
55  get_reg(R3);
56  get_reg(R4);
57  get_reg(R5);
58  get_reg(R6);
59  get_reg(R7);
60  get_reg(R8);
61  get_reg(R9);
62  get_reg(R10);
63  get_reg(R11);
64  get_reg(R12);
65  get_reg(R13);
66  get_reg(R14);
67  get_reg(R15);
68 
69  get_reg(zf);
70  get_reg(nf);
71  get_reg(of);
72  get_reg(cf);
73 
74  get_reg(cpuoff);
75  get_reg(gie);
76  get_reg(osc);
77  get_reg(scg0);
78  get_reg(scg1);
79  get_reg(res);
80 
81 
82  return dict;
83 }
84 
85 
86 PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
87 {
88  PyObject* dict;
89  PyObject *d_key, *d_value = NULL;
90  Py_ssize_t pos = 0;
91  uint64_t val;
92  unsigned int i, found;
93 
94  if (!PyArg_ParseTuple(args, "O", &dict))
95  return NULL;
96  if(!PyDict_Check(dict))
97  RAISE(PyExc_TypeError, "arg must be dict");
98  while(PyDict_Next(dict, &pos, &d_key, &d_value)){
99  if(!PyString_Check(d_key))
100  RAISE(PyExc_TypeError, "key must be str");
101 
102  PyGetInt(d_value, val);
103 
104  found = 0;
105  for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
106  if (strcmp(PyString_AsString(d_key), gpreg_dict[i].name))
107  continue;
108  *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
109  found = 1;
110  break;
111  }
112 
113  if (found)
114  continue;
115  fprintf(stderr, "unkown key: %s\n", PyString_AsString(d_key));
116  RAISE(PyExc_ValueError, "unkown reg");
117  }
118  Py_INCREF(Py_None);
119  return Py_None;
120 }
121 
122 
123 
124 
125 PyObject * cpu_init_regs(JitCpu* self)
126 {
127  memset(self->cpu, 0, sizeof(vm_cpu_t));
128 
129  Py_INCREF(Py_None);
130  return Py_None;
131 
132 }
133 
134 void dump_gpregs(vm_cpu_t* vmcpu)
135 {
136 
137  printf("PC %.4"PRIX32" SP %.4"PRIX32" R3 %.4"PRIX32" ",
138  vmcpu->PC, vmcpu->SP, vmcpu->R3);
139  printf("R4 %.4"PRIX32" R5 %.4"PRIX32" R6 %.4"PRIX32" R7 %.4"PRIX32"\n",
140  vmcpu->R4, vmcpu->R5, vmcpu->R6, vmcpu->R7);
141  printf("R8 %.4"PRIX32" R9 %.4"PRIX32" R10 %.4"PRIX32" R11 %.4"PRIX32" ",
142  vmcpu->R8, vmcpu->R9, vmcpu->R10, vmcpu->R11);
143  printf("R12 %.4"PRIX32" R13 %.4"PRIX32" R14 %.4"PRIX32" R15 %.4"PRIX32"\n",
144  vmcpu->R12, vmcpu->R13, vmcpu->R14, vmcpu->R15);
145  printf("zf %.4"PRIX32" nf %.4"PRIX32" of %.4"PRIX32" cf %.4"PRIX32"\n",
146  vmcpu->zf, vmcpu->nf, vmcpu->of, vmcpu->cf);
147 }
148 
149 
150 PyObject * cpu_dump_gpregs(JitCpu* self, PyObject* args)
151 {
152  vm_cpu_t* vmcpu;
153 
154  vmcpu = self->cpu;
155  dump_gpregs(vmcpu);
156  Py_INCREF(Py_None);
157  return Py_None;
158 }
159 
160 
161 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
162 {
163  PyObject *item1;
164  uint64_t i;
165 
166  if (!PyArg_ParseTuple(args, "O", &item1))
167  return NULL;
168 
169  PyGetInt(item1, i);
170 
171  ((vm_cpu_t*)self->cpu)->exception_flags = i;
172  Py_INCREF(Py_None);
173  return Py_None;
174 }
175 
176 PyObject* cpu_get_exception(JitCpu* self, PyObject* args)
177 {
178  return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)self->cpu)->exception_flags));
179 }
180 
181 
182 
183 
184 
185 void check_automod(JitCpu* jitcpu, uint64_t addr, uint64_t size)
186 {
187  PyObject *result;
188 
189  if (!(((VmMngr*)jitcpu->pyvm)->vm_mngr.exception_flags & EXCEPT_CODE_AUTOMOD))
190  return;
191  result = PyObject_CallMethod(jitcpu->jitter, "automod_cb", "LL", addr, size);
192  Py_DECREF(result);
193 
194 }
195 
196 void MEM_WRITE_08(JitCpu* jitcpu, uint64_t addr, uint8_t src)
197 {
198  vm_MEM_WRITE_08(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
199  check_automod(jitcpu, addr, 8);
200 }
201 
202 void MEM_WRITE_16(JitCpu* jitcpu, uint64_t addr, uint16_t src)
203 {
204  vm_MEM_WRITE_16(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
205  check_automod(jitcpu, addr, 16);
206 }
207 
208 void MEM_WRITE_32(JitCpu* jitcpu, uint64_t addr, uint32_t src)
209 {
210  vm_MEM_WRITE_32(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
211  check_automod(jitcpu, addr, 32);
212 }
213 
214 void MEM_WRITE_64(JitCpu* jitcpu, uint64_t addr, uint64_t src)
215 {
216  vm_MEM_WRITE_64(&((VmMngr*)jitcpu->pyvm)->vm_mngr, addr, src);
217  check_automod(jitcpu, addr, 64);
218 }
219 
220 
221 PyObject* vm_set_mem(JitCpu *self, PyObject* args)
222 {
223  PyObject *py_addr;
224  PyObject *py_buffer;
225  Py_ssize_t py_length;
226 
227  char * buffer;
228  uint64_t size;
229  uint64_t addr;
230  int ret = 0x1337;
231 
232  if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
233  return NULL;
234 
235  PyGetInt(py_addr, addr);
236 
237  if(!PyString_Check(py_buffer))
238  RAISE(PyExc_TypeError,"arg must be str");
239 
240  size = PyString_Size(py_buffer);
241  PyString_AsStringAndSize(py_buffer, &buffer, &py_length);
242 
243  ret = vm_write_mem(&(((VmMngr*)self->pyvm)->vm_mngr), addr, buffer, size);
244  if (ret < 0)
245  RAISE(PyExc_TypeError,"arg must be str");
246  check_automod(self, addr, size*8);
247 
248  Py_INCREF(Py_None);
249  return Py_None;
250 }
251 
252 static PyMemberDef JitCpu_members[] = {
253  {NULL} /* Sentinel */
254 };
255 
256 static PyMethodDef JitCpu_methods[] = {
257  {"init_regs", (PyCFunction)cpu_init_regs, METH_NOARGS,
258  "X"},
259  {"dump_gpregs", (PyCFunction)cpu_dump_gpregs, METH_NOARGS,
260  "X"},
261  {"get_gpreg", (PyCFunction)cpu_get_gpreg, METH_NOARGS,
262  "X"},
263  {"set_gpreg", (PyCFunction)cpu_set_gpreg, METH_VARARGS,
264  "X"},
265  {"get_exception", (PyCFunction)cpu_get_exception, METH_VARARGS,
266  "X"},
267  {"set_exception", (PyCFunction)cpu_set_exception, METH_VARARGS,
268  "X"},
269  {"set_mem", (PyCFunction)vm_set_mem, METH_VARARGS,
270  "X"},
271  {"get_mem", (PyCFunction)vm_get_mem, METH_VARARGS,
272  "X"},
273  {NULL} /* Sentinel */
274 };
275 
276 static int
277 JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
278 {
279  self->cpu = malloc(sizeof(vm_cpu_t));
280  if (self->cpu == NULL) {
281  fprintf(stderr, "cannot alloc vm_cpu_t\n");
282  exit(0);
283  }
284  return 0;
285 }
286 
287 getset_reg_u16(PC);
288 getset_reg_u16(SP);
289 getset_reg_u16(R3);
290 getset_reg_u16(R4);
291 getset_reg_u16(R5);
292 getset_reg_u16(R6);
293 getset_reg_u16(R7);
294 getset_reg_u16(R8);
295 getset_reg_u16(R9);
296 getset_reg_u16(R10);
297 getset_reg_u16(R11);
298 getset_reg_u16(R12);
299 getset_reg_u16(R13);
300 getset_reg_u16(R14);
301 getset_reg_u16(R15);
302 getset_reg_u16(zf);
303 getset_reg_u16(nf);
304 getset_reg_u16(of);
305 getset_reg_u16(cf);
306 getset_reg_u16(cpuoff);
307 getset_reg_u16(gie);
308 getset_reg_u16(osc);
309 getset_reg_u16(scg0);
310 getset_reg_u16(scg1);
311 getset_reg_u16(res);
312 
313 
314 
315 PyObject* get_gpreg_offset_all(void)
316 {
317  PyObject *dict = PyDict_New();
318  PyObject *o;
319  get_reg_off(exception_flags);
320  get_reg_off(exception_flags_new);
321  get_reg_off(PC);
322  get_reg_off(SP);
323  get_reg_off(R3);
324  get_reg_off(R4);
325  get_reg_off(R5);
326  get_reg_off(R6);
327  get_reg_off(R7);
328  get_reg_off(R8);
329  get_reg_off(R9);
330  get_reg_off(R10);
331  get_reg_off(R11);
332  get_reg_off(R12);
333  get_reg_off(R13);
334  get_reg_off(R14);
335  get_reg_off(R15);
336  get_reg_off(PC_new);
337  get_reg_off(SP_new);
338  get_reg_off(SR_new);
339  get_reg_off(R3_new);
340  get_reg_off(R4_new);
341  get_reg_off(R5_new);
342  get_reg_off(R6_new);
343  get_reg_off(R7_new);
344  get_reg_off(R8_new);
345  get_reg_off(R9_new);
346  get_reg_off(R10_new);
347  get_reg_off(R11_new);
348  get_reg_off(R12_new);
349  get_reg_off(R13_new);
350  get_reg_off(R14_new);
351  get_reg_off(R15_new);
352  get_reg_off(zf);
353  get_reg_off(nf);
354  get_reg_off(of);
355  get_reg_off(cf);
356  get_reg_off(cpuoff);
357  get_reg_off(gie);
358  get_reg_off(osc);
359  get_reg_off(scg0);
360  get_reg_off(scg1);
361  get_reg_off(res);
362  get_reg_off(zf_new);
363  get_reg_off(nf_new);
364  get_reg_off(of_new);
365  get_reg_off(cf_new);
366  get_reg_off(cpuoff_new);
367  get_reg_off(gie_new);
368  get_reg_off(osc_new);
369  get_reg_off(scg0_new);
370  get_reg_off(scg1_new);
371  get_reg_off(res_new);
372  get_reg_off(pfmem08_0);
373  get_reg_off(pfmem08_1);
374  get_reg_off(pfmem08_2);
375  get_reg_off(pfmem08_3);
376  get_reg_off(pfmem08_4);
377  get_reg_off(pfmem08_5);
378  get_reg_off(pfmem08_6);
379  get_reg_off(pfmem08_7);
380  get_reg_off(pfmem08_8);
381  get_reg_off(pfmem08_9);
382  get_reg_off(pfmem08_10);
383  get_reg_off(pfmem08_11);
384  get_reg_off(pfmem08_12);
385  get_reg_off(pfmem08_13);
386  get_reg_off(pfmem08_14);
387  get_reg_off(pfmem08_15);
388  get_reg_off(pfmem08_16);
389  get_reg_off(pfmem08_17);
390  get_reg_off(pfmem08_18);
391  get_reg_off(pfmem08_19);
392  get_reg_off(pfmem16_0);
393  get_reg_off(pfmem16_1);
394  get_reg_off(pfmem16_2);
395  get_reg_off(pfmem16_3);
396  get_reg_off(pfmem16_4);
397  get_reg_off(pfmem16_5);
398  get_reg_off(pfmem16_6);
399  get_reg_off(pfmem16_7);
400  get_reg_off(pfmem16_8);
401  get_reg_off(pfmem16_9);
402  get_reg_off(pfmem16_10);
403  get_reg_off(pfmem16_11);
404  get_reg_off(pfmem16_12);
405  get_reg_off(pfmem16_13);
406  get_reg_off(pfmem16_14);
407  get_reg_off(pfmem16_15);
408  get_reg_off(pfmem16_16);
409  get_reg_off(pfmem16_17);
410  get_reg_off(pfmem16_18);
411  get_reg_off(pfmem16_19);
412  get_reg_off(pfmem32_0);
413  get_reg_off(pfmem32_1);
414  get_reg_off(pfmem32_2);
415  get_reg_off(pfmem32_3);
416  get_reg_off(pfmem32_4);
417  get_reg_off(pfmem32_5);
418  get_reg_off(pfmem32_6);
419  get_reg_off(pfmem32_7);
420  get_reg_off(pfmem32_8);
421  get_reg_off(pfmem32_9);
422  get_reg_off(pfmem32_10);
423  get_reg_off(pfmem32_11);
424  get_reg_off(pfmem32_12);
425  get_reg_off(pfmem32_13);
426  get_reg_off(pfmem32_14);
427  get_reg_off(pfmem32_15);
428  get_reg_off(pfmem32_16);
429  get_reg_off(pfmem32_17);
430  get_reg_off(pfmem32_18);
431  get_reg_off(pfmem32_19);
432  get_reg_off(pfmem64_0);
433  get_reg_off(pfmem64_1);
434  get_reg_off(pfmem64_2);
435  get_reg_off(pfmem64_3);
436  get_reg_off(pfmem64_4);
437  get_reg_off(pfmem64_5);
438  get_reg_off(pfmem64_6);
439  get_reg_off(pfmem64_7);
440  get_reg_off(pfmem64_8);
441  get_reg_off(pfmem64_9);
442  get_reg_off(pfmem64_10);
443  get_reg_off(pfmem64_11);
444  get_reg_off(pfmem64_12);
445  get_reg_off(pfmem64_13);
446  get_reg_off(pfmem64_14);
447  get_reg_off(pfmem64_15);
448  get_reg_off(pfmem64_16);
449  get_reg_off(pfmem64_17);
450  get_reg_off(pfmem64_18);
451  get_reg_off(pfmem64_19);
452  return dict;
453 }
454 
455 
456 
457 
458 static PyGetSetDef JitCpu_getseters[] = {
459  {"vmmngr",
460  (getter)JitCpu_get_vmmngr, (setter)JitCpu_set_vmmngr,
461  "vmmngr",
462  NULL},
463 
464  {"jitter",
465  (getter)JitCpu_get_jitter, (setter)JitCpu_set_jitter,
466  "jitter",
467  NULL},
468 
469 
470  {"PC" , (getter)JitCpu_get_PC , (setter)JitCpu_set_PC , "PC" , NULL},
471  {"SP" , (getter)JitCpu_get_SP , (setter)JitCpu_set_SP , "SP" , NULL},
472  {"R3" , (getter)JitCpu_get_R3 , (setter)JitCpu_set_R3 , "R3" , NULL},
473  {"R4" , (getter)JitCpu_get_R4 , (setter)JitCpu_set_R4 , "R4" , NULL},
474  {"R5" , (getter)JitCpu_get_R5 , (setter)JitCpu_set_R5 , "R5" , NULL},
475  {"R6" , (getter)JitCpu_get_R6 , (setter)JitCpu_set_R6 , "R6" , NULL},
476  {"R7" , (getter)JitCpu_get_R7 , (setter)JitCpu_set_R7 , "R7" , NULL},
477  {"R8" , (getter)JitCpu_get_R8 , (setter)JitCpu_set_R8 , "R8" , NULL},
478  {"R9" , (getter)JitCpu_get_R9 , (setter)JitCpu_set_R9 , "R9" , NULL},
479  {"R10" , (getter)JitCpu_get_R10 , (setter)JitCpu_set_R10 , "R10" , NULL},
480  {"R11" , (getter)JitCpu_get_R11 , (setter)JitCpu_set_R11 , "R11" , NULL},
481  {"R12" , (getter)JitCpu_get_R12 , (setter)JitCpu_set_R12 , "R12" , NULL},
482  {"R13" , (getter)JitCpu_get_R13 , (setter)JitCpu_set_R13 , "R13" , NULL},
483  {"R14" , (getter)JitCpu_get_R14 , (setter)JitCpu_set_R14 , "R14" , NULL},
484  {"R15" , (getter)JitCpu_get_R15 , (setter)JitCpu_set_R15 , "R15" , NULL},
485  {"zf" , (getter)JitCpu_get_zf , (setter)JitCpu_set_zf , "zf" , NULL},
486  {"nf" , (getter)JitCpu_get_nf , (setter)JitCpu_set_nf , "nf" , NULL},
487  {"of" , (getter)JitCpu_get_of , (setter)JitCpu_set_of , "of" , NULL},
488  {"cf" , (getter)JitCpu_get_cf , (setter)JitCpu_set_cf , "cf" , NULL},
489  {"cpuoff" , (getter)JitCpu_get_cpuoff , (setter)JitCpu_set_cpuoff , "cpuoff" , NULL},
490  {"gie" , (getter)JitCpu_get_gie , (setter)JitCpu_set_gie , "gie" , NULL},
491  {"osc" , (getter)JitCpu_get_osc , (setter)JitCpu_set_osc , "osc" , NULL},
492  {"scg0" , (getter)JitCpu_get_scg0 , (setter)JitCpu_set_scg0 , "scg0" , NULL},
493  {"scg1" , (getter)JitCpu_get_scg1 , (setter)JitCpu_set_scg1 , "scg1" , NULL},
494  {"res" , (getter)JitCpu_get_res , (setter)JitCpu_set_res , "res" , NULL},
495 
496  {NULL} /* Sentinel */
497 };
498 
499 
500 
501 static PyTypeObject JitCpuType = {
502  PyObject_HEAD_INIT(NULL)
503  0, /*ob_size*/
504  "JitCore_msp430.JitCpu", /*tp_name*/
505  sizeof(JitCpu), /*tp_basicsize*/
506  0, /*tp_itemsize*/
507  (destructor)JitCpu_dealloc,/*tp_dealloc*/
508  0, /*tp_print*/
509  0, /*tp_getattr*/
510  0, /*tp_setattr*/
511  0, /*tp_compare*/
512  0, /*tp_repr*/
513  0, /*tp_as_number*/
514  0, /*tp_as_sequence*/
515  0, /*tp_as_mapping*/
516  0, /*tp_hash */
517  0, /*tp_call*/
518  0, /*tp_str*/
519  0, /*tp_getattro*/
520  0, /*tp_setattro*/
521  0, /*tp_as_buffer*/
522  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
523  "JitCpu objects", /* tp_doc */
524  0, /* tp_traverse */
525  0, /* tp_clear */
526  0, /* tp_richcompare */
527  0, /* tp_weaklistoffset */
528  0, /* tp_iter */
529  0, /* tp_iternext */
530  JitCpu_methods, /* tp_methods */
531  JitCpu_members, /* tp_members */
532  JitCpu_getseters, /* tp_getset */
533  0, /* tp_base */
534  0, /* tp_dict */
535  0, /* tp_descr_get */
536  0, /* tp_descr_set */
537  0, /* tp_dictoffset */
538  (initproc)JitCpu_init, /* tp_init */
539  0, /* tp_alloc */
540  JitCpu_new, /* tp_new */
541 };
542 
543 
544 
545 static PyMethodDef JitCore_msp430_Methods[] = {
546 
547  /*
548 
549  */
550  {"get_gpreg_offset_all", (PyCFunction)get_gpreg_offset_all, METH_NOARGS},
551  {NULL, NULL, 0, NULL} /* Sentinel */
552 
553 };
554 
555 static PyObject *JitCore_msp430_Error;
556 
557 PyMODINIT_FUNC
558 initJitCore_msp430(void)
559 {
560  PyObject *m;
561 
562  if (PyType_Ready(&JitCpuType) < 0)
563  return;
564 
565  m = Py_InitModule("JitCore_msp430", JitCore_msp430_Methods);
566  if (m == NULL)
567  return;
568 
569  JitCore_msp430_Error = PyErr_NewException("JitCore_msp430.error", NULL, NULL);
570  Py_INCREF(JitCore_msp430_Error);
571  PyModule_AddObject(m, "error", JitCore_msp430_Error);
572 
573  Py_INCREF(&JitCpuType);
574  PyModule_AddObject(m, "JitCpu", (PyObject *)&JitCpuType);
575 
576 }
577 
cpu_set_gpreg
PyObject * cpu_set_gpreg(JitCpu *self, PyObject *args)
Definition: JitCore_msp430.c:86
MEM_WRITE_16
void MEM_WRITE_16(JitCpu *jitcpu, uint64_t addr, uint16_t src)
Definition: JitCore_msp430.c:202
vm_cpu_t::R11
uint32_t R11
Definition: JitCore_arm.h:18
vm_cpu_t::R6
uint32_t R6
Definition: JitCore_arm.h:13
JitCore_msp430.h
vm_cpu_t::R15
uint32_t R15
Definition: JitCore_msp430.h:21
EXCEPT_CODE_AUTOMOD
#define EXCEPT_CODE_AUTOMOD
Definition: vm_mngr.h:130
check_automod
void check_automod(JitCpu *jitcpu, uint64_t addr, uint64_t size)
Definition: JitCore_msp430.c:185
cpu_get_exception
PyObject * cpu_get_exception(JitCpu *self, PyObject *args)
Definition: JitCore_msp430.c:176
cpu_init_regs
PyObject * cpu_init_regs(JitCpu *self)
Definition: JitCore_msp430.c:125
vm_cpu_t::R14
uint32_t R14
Definition: JitCore_msp430.h:20
vm_cpu_t::R8
uint32_t R8
Definition: JitCore_arm.h:15
vm_cpu_t::cf
uint32_t cf
Definition: JitCore_aarch64.h:83
vm_cpu_t::PC
uint64_t PC
Definition: JitCore_aarch64.h:41
vm_cpu_t::R10
uint32_t R10
Definition: JitCore_arm.h:17
JitCpu_new
PyObject * JitCpu_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Definition: JitCore.c:17
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
JitCpu_methods
static PyMethodDef JitCpu_methods[]
Definition: JitCore_msp430.c:256
JitCpuType
static PyTypeObject JitCpuType
Definition: JitCore_msp430.c:501
miasm2.ir.ir2C.name
string name
Definition: ir2C.py:22
vm_get_mem
PyObject * vm_get_mem(JitCpu *self, PyObject *args)
JitCpu::jitter
PyObject * jitter
Definition: JitCore.h:96
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::R13
uint32_t R13
Definition: JitCore_msp430.h:19
_reg_dict::offset
size_t offset
Definition: JitCore.h:103
MEM_WRITE_32
void MEM_WRITE_32(JitCpu *jitcpu, uint64_t addr, uint32_t src)
Definition: JitCore_msp430.c:208
cpu_set_exception
PyObject * cpu_set_exception(JitCpu *self, PyObject *args)
Definition: JitCore_msp430.c:161
vm_cpu_t::nf
uint32_t nf
Definition: JitCore_aarch64.h:81
vm_cpu_t::R5
uint32_t R5
Definition: JitCore_arm.h:12
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
JitCore_msp430_Methods
static PyMethodDef JitCore_msp430_Methods[]
Definition: JitCore_msp430.c:545
JitCpu_set_vmmngr
PyObject * JitCpu_set_vmmngr(JitCpu *self, PyObject *value, void *closure)
Definition: JitCore.c:35
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
get_gpreg_offset_all
PyObject * get_gpreg_offset_all(void)
Definition: JitCore_msp430.c:315
get_reg
#define get_reg(reg)
Definition: JitCore.h:74
vm_cpu_t::R12
uint32_t R12
Definition: JitCore_arm.h:19
JitCpu::pyvm
PyObject_HEAD PyObject * pyvm
Definition: JitCore.h:95
dump_gpregs
void dump_gpregs(vm_cpu_t *vmcpu)
Definition: JitCore_msp430.c:134
vm_set_mem
PyObject * vm_set_mem(JitCpu *self, PyObject *args)
Definition: JitCore_msp430.c:221
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
MEM_WRITE_08
void MEM_WRITE_08(JitCpu *jitcpu, uint64_t addr, uint8_t src)
Definition: JitCore_msp430.c:196
getset_reg_u16
getset_reg_u16(PC)
cpu_dump_gpregs
PyObject * cpu_dump_gpregs(JitCpu *self, PyObject *args)
Definition: JitCore_msp430.c:150
vm_cpu_t::R3
uint32_t R3
Definition: JitCore_arm.h:10
gpreg_dict
reg_dict gpreg_dict[]
Definition: JitCore_msp430.c:12
vm_cpu_t::R4
uint32_t R4
Definition: JitCore_arm.h:11
JitCpu_getseters
static PyGetSetDef JitCpu_getseters[]
Definition: JitCore_msp430.c:458
MEM_WRITE_64
void MEM_WRITE_64(JitCpu *jitcpu, uint64_t addr, uint64_t src)
Definition: JitCore_msp430.c:214
vm_cpu_t::R9
uint32_t R9
Definition: JitCore_arm.h:16
_reg_dict::name
char * name
Definition: JitCore.h:102
JitCore_msp430_Error
static PyObject * JitCore_msp430_Error
Definition: JitCore_msp430.c:555
vm_cpu_t::R7
uint32_t R7
Definition: JitCore_arm.h:14
JitCpu_dealloc
void JitCpu_dealloc(JitCpu *self)
Definition: JitCore.c:11
JitCpu
Definition: JitCore.h:93
cpu_get_gpreg
PyObject * cpu_get_gpreg(JitCpu *self)
Definition: JitCore_msp430.c:47
vm_cpu_t::SP
uint64_t SP
Definition: JitCore_aarch64.h:39
initJitCore_msp430
PyMODINIT_FUNC initJitCore_msp430(void)
Definition: JitCore_msp430.c:558
JitCpu_init
static int JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
Definition: JitCore_msp430.c:277
get_reg_off
#define get_reg_off(reg)
Definition: JitCore.h:81
JitCpu_members
static PyMemberDef JitCpu_members[]
Definition: JitCore_msp430.c:252
miasm2.arch.aarch64.regs.exception_flags
tuple exception_flags
Definition: regs.py:7
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