about summary refs log tree commit diff stats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--miasm/jitter/JitCore.c4
-rw-r--r--miasm/jitter/JitCore.h30
-rw-r--r--miasm/jitter/arch/JitCore_aarch64.c28
-rw-r--r--miasm/jitter/arch/JitCore_arm.c20
-rw-r--r--miasm/jitter/arch/JitCore_mep.c14
-rw-r--r--miasm/jitter/arch/JitCore_mips32.c14
-rw-r--r--miasm/jitter/arch/JitCore_msp430.c14
-rw-r--r--miasm/jitter/arch/JitCore_ppc32.c14
-rw-r--r--miasm/jitter/arch/JitCore_x86.c54
-rw-r--r--miasm/jitter/compat_py23.h31
-rw-r--r--miasm/jitter/vm_mngr_py.c115
11 files changed, 171 insertions, 167 deletions
diff --git a/miasm/jitter/JitCore.c b/miasm/jitter/JitCore.c
index 0c36c15f..012a53c4 100644
--- a/miasm/jitter/JitCore.c
+++ b/miasm/jitter/JitCore.c
@@ -244,8 +244,8 @@ PyObject* vm_get_mem(JitCpu *self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_len))
 	       return NULL;
 
-       PyGetInt(py_addr, addr);
-       PyGetInt(py_len, size);
+       PyGetInt_uint64_t(py_addr, addr);
+       PyGetInt_uint64_t(py_len, size);
 
 
        if (size > SSIZE_MAX) {
diff --git a/miasm/jitter/JitCore.h b/miasm/jitter/JitCore.h
index a492086a..92572fa3 100644
--- a/miasm/jitter/JitCore.h
+++ b/miasm/jitter/JitCore.h
@@ -170,26 +170,26 @@
 #define getset_reg_u64(regname)						\
 	static PyObject *JitCpu_get_ ## regname  (JitCpu *self, void *closure) \
 	{								\
-		return PyLong_FromUnsignedLongLong((uint64_t)(((vm_cpu_t*)(self->cpu))->  regname  )); \
+		return PyLong_FromUnsignedLongLong((((vm_cpu_t*)(self->cpu))->  regname  )); \
 	}								\
 	static int JitCpu_set_ ## regname  (JitCpu *self, PyObject *value, void *closure) \
 	{								\
 		uint64_t val;						\
-		PyGetInt_retneg(value, val);				\
-		((vm_cpu_t*)(self->cpu))->  regname   = val;		\
+		PyGetInt_uint64_t_retneg(value, val);			\
+		((vm_cpu_t*)(self->cpu))->  regname = val;		\
 		return 0;						\
 	}
 
 #define getset_reg_u32(regname)						\
 	static PyObject *JitCpu_get_ ## regname  (JitCpu *self, void *closure) \
 	{								\
-		return PyLong_FromUnsignedLongLong((uint32_t)(((vm_cpu_t*)(self->cpu))->  regname  )); \
+		return PyLong_FromUnsignedLongLong((((vm_cpu_t*)(self->cpu))->  regname  )); \
 	}								\
 	static int JitCpu_set_ ## regname  (JitCpu *self, PyObject *value, void *closure) \
 	{								\
-		uint64_t val;						\
-		PyGetInt_retneg(value, val);				\
-		((vm_cpu_t*)(self->cpu))->  regname = (uint32_t)val;	\
+		uint32_t val;						\
+		PyGetInt_uint32_t_retneg(value, val);			\
+		((vm_cpu_t*)(self->cpu))->  regname = val;		\
 		return 0;						\
 	}
 
@@ -197,13 +197,13 @@
 #define getset_reg_u16(regname)						\
 	static PyObject *JitCpu_get_ ## regname  (JitCpu *self, void *closure) \
 	{								\
-		return PyLong_FromUnsignedLongLong((uint16_t)(((vm_cpu_t*)(self->cpu))-> regname  )); \
+		return PyLong_FromUnsignedLongLong((((vm_cpu_t*)(self->cpu))-> regname  )); \
 	}								\
 	static int JitCpu_set_ ## regname  (JitCpu *self, PyObject *value, void *closure) \
 	{								\
-		uint64_t val;						\
-		PyGetInt_retneg(value, val);				\
-		((vm_cpu_t*)(self->cpu))->  regname   = (uint16_t)val;	\
+		uint16_t val;						\
+		PyGetInt_uint16_t_retneg(value, val);			\
+		((vm_cpu_t*)(self->cpu))->  regname = val;		\
 		return 0;						\
 	}
 
@@ -211,13 +211,13 @@
 #define getset_reg_u8(regname)						\
 	static PyObject *JitCpu_get_ ## regname  (JitCpu *self, void *closure) \
 	{								\
-		return PyLong_FromUnsignedLongLong((uint8_t)(((vm_cpu_t*)(self->cpu))-> regname  )); \
+		return PyLong_FromUnsignedLongLong((((vm_cpu_t*)(self->cpu))-> regname  )); \
 	}								\
 	static int JitCpu_set_ ## regname  (JitCpu *self, PyObject *value, void *closure) \
 	{								\
-		uint64_t val;						\
-		PyGetInt_retneg(value, val);				\
-		((vm_cpu_t*)(self->cpu))->  regname   = (uint8_t)val;	\
+		uint8_t val;						\
+		PyGetInt_uint8_t_retneg(value, val);			\
+		((vm_cpu_t*)(self->cpu))->  regname = val;		\
 		return 0;						\
 	}
 
diff --git a/miasm/jitter/arch/JitCore_aarch64.c b/miasm/jitter/arch/JitCore_aarch64.c
index 7b860257..9878a4ff 100644
--- a/miasm/jitter/arch/JitCore_aarch64.c
+++ b/miasm/jitter/arch/JitCore_aarch64.c
@@ -119,7 +119,8 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
     PyObject *d_key, *d_value = NULL;
     Py_ssize_t pos = 0;
     char* d_key_name;
-    uint64_t val;
+    uint32_t val32;
+    uint64_t val64;
     unsigned int i, found;
 
     if (!PyArg_ParseTuple(args, "O", &dict))
@@ -128,15 +129,24 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
 	    RAISE(PyExc_TypeError, "arg must be dict");
     while(PyDict_Next(dict, &pos, &d_key, &d_value)){
 	    PyGetStr(d_key_name, d_key);
-	    PyGetInt(d_value, val);
-
 	    found = 0;
 	    for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
 		    if (strcmp(d_key_name, gpreg_dict[i].name))
 			    continue;
-		    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint32_t)val;
 		    found = 1;
-		    break;
+		    switch (gpreg_dict[i].size) {
+			    default:
+				    RAISE(PyExc_TypeError, "Unsupported size");
+				    break;
+			    case 32:
+				    PyGetInt_uint32_t(d_value, val32);
+				    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val32;
+				    break;
+			    case 64:
+				    PyGetInt_uint64_t(d_value, val64);
+				    *((uint64_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val64;
+				    break;
+		    }
 	    }
 
 	    if (found)
@@ -203,14 +213,14 @@ PyObject * cpu_dump_gpregs_with_attrib(JitCpu* self, PyObject* args)
 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
 {
 	PyObject *item1;
-	uint64_t i;
+	uint32_t exception_flags;
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, i);
+	PyGetInt_uint32_t(item1, exception_flags);
 
-	((vm_cpu_t*)self->cpu)->exception_flags = (uint32_t)i;
+	((vm_cpu_t*)self->cpu)->exception_flags = exception_flags;
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -274,7 +284,7 @@ PyObject* vm_set_mem(JitCpu *self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        if(!PyBytes_Check(py_buffer))
 	       RAISE(PyExc_TypeError,"arg must be bytes");
diff --git a/miasm/jitter/arch/JitCore_arm.c b/miasm/jitter/arch/JitCore_arm.c
index 3d8cb784..25595274 100644
--- a/miasm/jitter/arch/JitCore_arm.c
+++ b/miasm/jitter/arch/JitCore_arm.c
@@ -93,7 +93,7 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
     PyObject *d_key, *d_value = NULL;
     Py_ssize_t pos = 0;
     char* d_key_name;
-    uint64_t val;
+    uint32_t val;
     unsigned int i, found;
 
     if (!PyArg_ParseTuple(args, "O", &dict))
@@ -102,13 +102,13 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
 	    RAISE(PyExc_TypeError, "arg must be dict");
     while(PyDict_Next(dict, &pos, &d_key, &d_value)){
 	    PyGetStr(d_key_name, d_key);
-	    PyGetInt(d_value, val);
+	    PyGetInt_uint32_t(d_value, val);
 
 	    found = 0;
 	    for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
 		    if (strcmp(d_key_name, gpreg_dict[i].name))
 			    continue;
-		    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint32_t)val;
+		    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
 		    found = 1;
 		    break;
 	    }
@@ -167,14 +167,14 @@ PyObject * cpu_dump_gpregs_with_attrib(JitCpu* self, PyObject* args)
 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
 {
 	PyObject *item1;
-	uint64_t i;
+	uint32_t exception_flags;
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, i);
+	PyGetInt_uint32_t(item1, exception_flags);
 
-	((vm_cpu_t*)self->cpu)->exception_flags = (uint32_t)i;
+	((vm_cpu_t*)self->cpu)->exception_flags = exception_flags;
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -237,7 +237,7 @@ PyObject* vm_set_mem(JitCpu *self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        if(!PyBytes_Check(py_buffer))
 	       RAISE(PyExc_TypeError,"arg must be bytes");
@@ -257,14 +257,14 @@ PyObject* vm_set_mem(JitCpu *self, PyObject* args)
 PyObject* cpu_set_interrupt_num(JitCpu* self, PyObject* args)
 {
 	PyObject *item1;
-	uint64_t i;
+	uint32_t exception_flags;
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, i);
+	PyGetInt_uint32_t(item1, exception_flags);
 
-	((vm_cpu_t*)self->cpu)->interrupt_num = (uint32_t)i;
+	((vm_cpu_t*)self->cpu)->interrupt_num = exception_flags;
 	Py_INCREF(Py_None);
 	return Py_None;
 }
diff --git a/miasm/jitter/arch/JitCore_mep.c b/miasm/jitter/arch/JitCore_mep.c
index e2ba4c60..969bae27 100644
--- a/miasm/jitter/arch/JitCore_mep.c
+++ b/miasm/jitter/arch/JitCore_mep.c
@@ -150,7 +150,7 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
     PyObject *d_key, *d_value = NULL;
     Py_ssize_t pos = 0;
     char* d_key_name;
-    uint64_t val;
+    uint32_t val;
     unsigned int i, found;
 
     if (!PyArg_ParseTuple(args, "O", &dict))
@@ -159,13 +159,13 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
 	RAISE(PyExc_TypeError, "arg must be dict");
     while(PyDict_Next(dict, &pos, &d_key, &d_value)){
 	PyGetStr(d_key_name, d_key);
-	PyGetInt(d_value, val);
+	PyGetInt_uint32_t(d_value, val);
 
 	found = 0;
 	for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
 	    if (strcmp(d_key_name, gpreg_dict[i].name))
 		continue;
-	    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint32_t)val;
+	    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
 	    found = 1;
 	    break;
 	}
@@ -231,14 +231,14 @@ PyObject * cpu_dump_gpregs_with_attrib(JitCpu* self, PyObject* args)
 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
 {
     PyObject *item1;
-    uint64_t i;
+    uint32_t exception_flags;
 
     if (!PyArg_ParseTuple(args, "O", &item1))
 	return NULL;
 
-    PyGetInt(item1, i);
+    PyGetInt_uint32_t(item1, exception_flags);
 
-    ((vm_cpu_t*)self->cpu)->exception_flags = (uint32_t)i;
+    ((vm_cpu_t*)self->cpu)->exception_flags = exception_flags;
     Py_INCREF(Py_None);
     return Py_None;
 }
@@ -298,7 +298,7 @@ PyObject* vm_set_mem(JitCpu *self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
 	   return NULL;
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        if(!PyBytes_Check(py_buffer))
 	   RAISE(PyExc_TypeError,"arg must be bytes");
diff --git a/miasm/jitter/arch/JitCore_mips32.c b/miasm/jitter/arch/JitCore_mips32.c
index 21fe2e4d..1a8748cf 100644
--- a/miasm/jitter/arch/JitCore_mips32.c
+++ b/miasm/jitter/arch/JitCore_mips32.c
@@ -109,7 +109,7 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
     PyObject *d_key, *d_value = NULL;
     Py_ssize_t pos = 0;
     char* d_key_name;
-    uint64_t val;
+    uint32_t val;
     unsigned int i, found;
 
     if (!PyArg_ParseTuple(args, "O", &dict))
@@ -118,13 +118,13 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
 	    RAISE(PyExc_TypeError, "arg must be dict");
     while(PyDict_Next(dict, &pos, &d_key, &d_value)){
 	    PyGetStr(d_key_name, d_key);
-	    PyGetInt(d_value, val);
+	    PyGetInt_uint32_t(d_value, val);
 
 	    found = 0;
 	    for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
 		    if (strcmp(d_key_name, gpreg_dict[i].name))
 			    continue;
-		    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint32_t)val;
+		    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
 		    found = 1;
 		    break;
 	    }
@@ -189,14 +189,14 @@ PyObject * cpu_dump_gpregs(JitCpu* self, PyObject* args)
 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
 {
 	PyObject *item1;
-	uint64_t i;
+	uint32_t exception_flags;
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, i);
+	PyGetInt_uint32_t(item1, exception_flags);
 
-	((vm_cpu_t*)self->cpu)->exception_flags = (uint32_t)i;
+	((vm_cpu_t*)self->cpu)->exception_flags = exception_flags;
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -262,7 +262,7 @@ PyObject* vm_set_mem(JitCpu *self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        if(!PyBytes_Check(py_buffer))
 	       RAISE(PyExc_TypeError,"arg must be bytes");
diff --git a/miasm/jitter/arch/JitCore_msp430.c b/miasm/jitter/arch/JitCore_msp430.c
index fbeb31cd..5a4cae2f 100644
--- a/miasm/jitter/arch/JitCore_msp430.c
+++ b/miasm/jitter/arch/JitCore_msp430.c
@@ -91,7 +91,7 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
     PyObject *d_key, *d_value = NULL;
     Py_ssize_t pos = 0;
     char* d_key_name;
-    uint64_t val;
+    uint32_t val;
     unsigned int i, found;
 
     if (!PyArg_ParseTuple(args, "O", &dict))
@@ -100,12 +100,12 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
 	    RAISE(PyExc_TypeError, "arg must be dict");
     while(PyDict_Next(dict, &pos, &d_key, &d_value)){
 	    PyGetStr(d_key_name, d_key);
-	    PyGetInt(d_value, val);
+	    PyGetInt_uint32_t(d_value, val);
 	    found = 0;
 	    for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
 		    if (strcmp(d_key_name, gpreg_dict[i].name))
 			    continue;
-		    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint32_t)val;
+		    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
 		    found = 1;
 		    break;
 	    }
@@ -166,14 +166,14 @@ PyObject * cpu_dump_gpregs_with_attrib(JitCpu* self, PyObject* args)
 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
 {
 	PyObject *item1;
-	uint64_t i;
+	uint32_t exception_flags;
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, i);
+	PyGetInt_uint32_t(item1, exception_flags);
 
-	((vm_cpu_t*)self->cpu)->exception_flags = (uint32_t)i;
+	((vm_cpu_t*)self->cpu)->exception_flags = exception_flags;
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -237,7 +237,7 @@ PyObject* vm_set_mem(JitCpu *self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        if(!PyBytes_Check(py_buffer))
 	       RAISE(PyExc_TypeError,"arg must be bytes");
diff --git a/miasm/jitter/arch/JitCore_ppc32.c b/miasm/jitter/arch/JitCore_ppc32.c
index b61cb517..d272d66e 100644
--- a/miasm/jitter/arch/JitCore_ppc32.c
+++ b/miasm/jitter/arch/JitCore_ppc32.c
@@ -38,7 +38,7 @@ cpu_set_gpreg(JitCpu *self, PyObject *args) {
     PyObject *d_key, *d_value = NULL;
     Py_ssize_t pos = 0;
     char* d_key_name;
-    uint64_t val;
+    uint32_t val;
     unsigned int i;
 
     if (!PyArg_ParseTuple(args, "O", &dict))
@@ -49,12 +49,12 @@ cpu_set_gpreg(JitCpu *self, PyObject *args) {
     while(PyDict_Next(dict, &pos, &d_key, &d_value)) {
 	int found = 0;
 	PyGetStr(d_key_name, d_key);
-	PyGetInt(d_value, val);
+	PyGetInt_uint32_t(d_value, val);
 
 	for (i=0; i < sizeof(gpreg_dict)/sizeof(reg_dict); i++){
 	    if (strcmp(d_key_name, gpreg_dict[i].name))
 		continue;
-	    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint32_t)val;
+	    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
 	    found = 1;
 	    break;
 	}
@@ -116,14 +116,14 @@ cpu_dump_gpregs_with_attrib(JitCpu* self, PyObject* args)
 PyObject *
 cpu_set_exception(JitCpu *self, PyObject *args) {
     PyObject *item1;
-    uint64_t i;
+    uint64_t exception_flags;
 
     if (!PyArg_ParseTuple(args, "O", &item1))
 	return NULL;
 
-    PyGetInt(item1, i);
+    PyGetInt_uint64_t(item1, exception_flags);
 
-    ((struct vm_cpu *)self->cpu)->exception_flags = i;
+    ((struct vm_cpu *)self->cpu)->exception_flags = exception_flags;
 
     Py_INCREF(Py_None);
     return Py_None;
@@ -189,7 +189,7 @@ vm_set_mem(JitCpu *self, PyObject *args) {
    if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
        return NULL;
 
-   PyGetInt(py_addr, addr);
+   PyGetInt_uint64_t(py_addr, addr);
 
    if(!PyBytes_Check(py_buffer))
        RAISE(PyExc_TypeError,"arg must be bytes");
diff --git a/miasm/jitter/arch/JitCore_x86.c b/miasm/jitter/arch/JitCore_x86.c
index 11a21427..3225eab5 100644
--- a/miasm/jitter/arch/JitCore_x86.c
+++ b/miasm/jitter/arch/JitCore_x86.c
@@ -169,7 +169,10 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
     PyObject *d_key, *d_value = NULL;
     char* d_key_name;
     Py_ssize_t pos = 0;
-    uint64_t val;
+    uint8_t val08;
+    uint16_t val16;
+    uint32_t val32;
+    uint64_t val64;
     unsigned int i, found;
 
     if (!PyArg_ParseTuple(args, "O", &dict))
@@ -184,21 +187,24 @@ PyObject* cpu_set_gpreg(JitCpu* self, PyObject *args)
 			    continue;
 		    found = 1;
 		    switch (gpreg_dict[i].size) {
+			    default:
+				    RAISE(PyExc_TypeError, "Unsupported size");
+				    break;
 			    case 8:
-				    PyGetInt(d_value, val);
-				    *((uint8_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint8_t)val;
+				    PyGetInt_uint8_t(d_value, val08);
+				    *((uint8_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val08;
 				    break;
 			    case 16:
-				    PyGetInt(d_value, val);
-				    *((uint16_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint16_t)val;
+				    PyGetInt_uint16_t(d_value, val16);
+				    *((uint16_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val16;
 				    break;
 			    case 32:
-				    PyGetInt(d_value, val);
-				    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = (uint32_t)val;
+				    PyGetInt_uint32_t(d_value, val32);
+				    *((uint32_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val32;
 				    break;
 			    case 64:
-				    PyGetInt(d_value, val);
-				    *((uint64_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val;
+				    PyGetInt_uint64_t(d_value, val64);
+				    *((uint64_t*)(((char*)(self->cpu)) + gpreg_dict[i].offset)) = val64;
 				    break;
 			    case 128:
 				    {
@@ -363,7 +369,7 @@ PyObject * cpu_dump_gpregs_with_attrib(JitCpu* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, attrib);
+	PyGetInt_uint64_t(item1, attrib);
 
 	vmcpu = self->cpu;
 	if (attrib == 16 || attrib == 32)
@@ -383,14 +389,14 @@ PyObject * cpu_dump_gpregs_with_attrib(JitCpu* self, PyObject* args)
 PyObject* cpu_set_exception(JitCpu* self, PyObject* args)
 {
 	PyObject *item1;
-	uint64_t i;
+	uint32_t exception_flags;
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, i);
+	PyGetInt_uint32_t(item1, exception_flags);
 
-	((vm_cpu_t*)self->cpu)->exception_flags = (uint32_t)i;
+	((vm_cpu_t*)self->cpu)->exception_flags = exception_flags;
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -403,14 +409,14 @@ PyObject* cpu_get_exception(JitCpu* self, PyObject* args)
 PyObject* cpu_set_interrupt_num(JitCpu* self, PyObject* args)
 {
 	PyObject *item1;
-	uint64_t i;
+	uint32_t exception_flags;
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, i);
+	PyGetInt_uint32_t(item1, exception_flags);
 
-	((vm_cpu_t*)self->cpu)->interrupt_num = (uint32_t)i;
+	((vm_cpu_t*)self->cpu)->interrupt_num = exception_flags;
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -428,8 +434,8 @@ PyObject* cpu_set_segm_base(JitCpu* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "OO", &item1, &item2))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, segm_num);
-	PyGetInt(item2, segm_base);
+	PyGetInt_uint64_t(item1, segm_num);
+	PyGetInt_uint64_t(item2, segm_base);
 	((vm_cpu_t*)self->cpu)->segm_base[segm_num] = segm_base;
 
 	Py_INCREF(Py_None);
@@ -444,7 +450,7 @@ PyObject* cpu_get_segm_base(JitCpu* self, PyObject* args)
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
-	PyGetInt(item1, segm_num);
+	PyGetInt_uint64_t(item1, segm_num);
 	v = PyLong_FromLong((long)(((vm_cpu_t*)self->cpu)->segm_base[segm_num]));
 	return v;
 }
@@ -490,7 +496,7 @@ PyObject* vm_set_mem(JitCpu *self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        if(!PyBytes_Check(py_buffer))
 	       RAISE(PyExc_TypeError,"arg must be bytes");
@@ -559,10 +565,10 @@ JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
 	static int JitCpu_set_E ## regname  (JitCpu *self, PyObject *value, void *closure) \
 	{								\
 		uint64_t val;						\
-		PyGetInt_retneg(value, val);				\
+		PyGetInt_uint64_t_retneg(value, val);			\
 		val &= 0xFFFFFFFF;					\
 		val |= ((vm_cpu_t*)(self->cpu))->R ##regname & 0xFFFFFFFF00000000ULL; \
-		((vm_cpu_t*)(self->cpu))->R ## regname   = val;			\
+		((vm_cpu_t*)(self->cpu))->R ## regname   = val;		\
 		return 0;						\
 	}
 
@@ -576,10 +582,10 @@ JitCpu_init(JitCpu *self, PyObject *args, PyObject *kwds)
 	static int JitCpu_set_ ## regname  (JitCpu *self, PyObject *value, void *closure) \
 	{								\
 		uint64_t val;						\
-		PyGetInt_retneg(value, val);				\
+		PyGetInt_uint64_t_retneg(value, val);			\
 		val &= 0xFFFF;						\
 		val |= ((vm_cpu_t*)(self->cpu))->R ##regname & 0xFFFFFFFFFFFF0000ULL; \
-		((vm_cpu_t*)(self->cpu))->R ## regname   = val;			\
+		((vm_cpu_t*)(self->cpu))->R ## regname   = val;		\
 		return 0;						\
 	}
 
diff --git a/miasm/jitter/compat_py23.h b/miasm/jitter/compat_py23.h
index 1993142e..f1f5f24a 100644
--- a/miasm/jitter/compat_py23.h
+++ b/miasm/jitter/compat_py23.h
@@ -4,18 +4,18 @@
 
 
 #if PY_MAJOR_VERSION >= 3
-#define PyGetInt(item, value)						\
+#define PyGetInt_uint_t(size, item, value)				\
 	if (PyLong_Check(item)){					\
-		value = (uint64_t)PyLong_AsUnsignedLongLong(item);	\
+		value = (uint ## size ## _t)PyLong_AsUnsignedLongLong(item); \
 	}								\
 	else{								\
 		RAISE(PyExc_TypeError,"arg must be int");		\
 	}
 
 
-#define PyGetInt_retneg(item, value)					\
+#define PyGetInt_uint_t_retneg(size, item, value)			\
 	if (PyLong_Check(item)){					\
-		value = (uint64_t)PyLong_AsUnsignedLongLong(item);	\
+		value = (uint ## size ##_t)PyLong_AsUnsignedLongLong(item); \
 	}								\
 	else{								\
 		PyErr_SetString(PyExc_TypeError, "Arg must be int");	\
@@ -30,24 +30,24 @@
 
 
 #else
-#define PyGetInt(item, value)						\
+#define PyGetInt_uint_t(size, item, value)				\
 	if (PyInt_Check(item)){						\
-		value = (uint64_t)PyInt_AsLong(item);			\
+		value = (uint ## size ##_t)PyInt_AsLong(item);		\
 	}								\
 	else if (PyLong_Check(item)){					\
-		value = (uint64_t)PyLong_AsUnsignedLongLong(item);	\
+		value = (uint ## size ##_t)PyLong_AsUnsignedLongLong(item); \
 	}								\
 	else{								\
 		RAISE(PyExc_TypeError,"arg must be int");		\
 	}
 
 
-#define PyGetInt_retneg(item, value)					\
+#define PyGetInt_uint_t_retneg(size, item, value)			\
 	if (PyInt_Check(item)){						\
-		value = (uint64_t)PyLong_AsLong(item);			\
+		value = (uint ## size ##_t)PyLong_AsLong(item);		\
 	}								\
 	else if (PyLong_Check(item)){					\
-		value = (uint64_t)PyLong_AsUnsignedLongLong(item);	\
+		value = (uint ## size ##_t)PyLong_AsUnsignedLongLong(item); \
 	}								\
 	else{								\
 		PyErr_SetString(PyExc_TypeError, "Arg must be int");	\
@@ -63,6 +63,17 @@
 #endif
 
 
+#define PyGetInt_uint8_t(item, value) PyGetInt_uint_t(8, item, value)
+#define PyGetInt_uint16_t(item, value) PyGetInt_uint_t(16, item, value)
+#define PyGetInt_uint32_t(item, value) PyGetInt_uint_t(32, item, value)
+#define PyGetInt_uint64_t(item, value) PyGetInt_uint_t(64, item, value)
+
+#define PyGetInt_uint8_t_retneg(item, value) PyGetInt_uint_t_retneg(8, item, value)
+#define PyGetInt_uint16_t_retneg(item, value) PyGetInt_uint_t_retneg(16, item, value)
+#define PyGetInt_uint32_t_retneg(item, value) PyGetInt_uint_t_retneg(32, item, value)
+#define PyGetInt_uint64_t_retneg(item, value) PyGetInt_uint_t_retneg(64, item, value)
+
+
 
 #if PY_MAJOR_VERSION >= 3
 
diff --git a/miasm/jitter/vm_mngr_py.c b/miasm/jitter/vm_mngr_py.c
index c51719a0..381067a0 100644
--- a/miasm/jitter/vm_mngr_py.c
+++ b/miasm/jitter/vm_mngr_py.c
@@ -91,8 +91,8 @@ PyObject* vm_add_memory_page(VmMngr* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "OOO|O", &addr, &access, &item_str, &name))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(addr, page_addr);
-	PyGetInt(access, page_access);
+	PyGetInt_uint64_t(addr, page_addr);
+	PyGetInt_uint64_t(access, page_access);
 
 	if(!PyBytes_Check(item_str))
 		RAISE(PyExc_TypeError,"arg must be bytes");
@@ -140,8 +140,8 @@ PyObject* vm_set_mem_access(VmMngr* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "OO", &addr, &access))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(addr, page_addr);
-	PyGetInt(access, page_access);
+	PyGetInt_uint64_t(addr, page_addr);
+	PyGetInt_uint64_t(access, page_access);
 
 	mpn = get_memory_page_from_address(&self->vm_mngr, page_addr, 1);
 	if (!mpn){
@@ -169,7 +169,7 @@ PyObject* vm_set_mem(VmMngr* self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_buffer))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        if (!PyBytes_Check(py_buffer))
 	       RAISE(PyExc_TypeError,"arg must be bytes");
@@ -199,7 +199,7 @@ PyObject* vm_get_mem_access(VmMngr* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "O", &py_addr))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(py_addr, page_addr);
+	PyGetInt_uint64_t(py_addr, page_addr);
 
 	mpn = get_memory_page_from_address(&self->vm_mngr, page_addr, 1);
 	if (!mpn){
@@ -225,8 +225,8 @@ PyObject* vm_get_mem(VmMngr* self, PyObject* args)
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_len))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
-       PyGetInt(py_len, size);
+       PyGetInt_uint64_t(py_addr, addr);
+       PyGetInt_uint64_t(py_len, size);
 
        if (size > SIZE_MAX) {
 	       fprintf(stderr, "Size too big\n");
@@ -257,7 +257,7 @@ PyObject* vm_get_u8(VmMngr* self, PyObject* args)
        if (!PyArg_ParseTuple(args, "O", &py_addr))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        ret = vm_read_mem(&self->vm_mngr, addr, &buf_out, 1);
        if (ret < 0) {
@@ -284,7 +284,7 @@ PyObject* vm_get_u16(VmMngr* self, PyObject* args)
        if (!PyArg_ParseTuple(args, "O", &py_addr))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        ret = vm_read_mem(&self->vm_mngr, addr, &buf_out, 2);
        if (ret < 0) {
@@ -311,7 +311,7 @@ PyObject* vm_get_u32(VmMngr* self, PyObject* args)
        if (!PyArg_ParseTuple(args, "O", &py_addr))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        ret = vm_read_mem(&self->vm_mngr, addr, &buf_out, 4);
        if (ret < 0) {
@@ -339,7 +339,7 @@ PyObject* vm_get_u64(VmMngr* self, PyObject* args)
        if (!PyArg_ParseTuple(args, "O", &py_addr))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
+       PyGetInt_uint64_t(py_addr, addr);
 
        ret = vm_read_mem(&self->vm_mngr, addr, &buf_out, 8);
        if (ret < 0) {
@@ -358,24 +358,17 @@ PyObject* vm_set_u8(VmMngr* self, PyObject* args)
 {
        PyObject *py_addr;
        PyObject *py_val;
-       uint64_t value;
+       uint8_t value;
        uint64_t addr;
-       uint8_t final_value;
        int ret;
 
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_val))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
-       PyGetInt(py_val, value);
-
-       if (value > 0xFF) {
-		fprintf(stderr, "Warning: int to big\n");
-       }
-
-       final_value = (uint8_t)value;
+       PyGetInt_uint64_t(py_addr, addr);
+       PyGetInt_uint8_t(py_val, value);
 
-       ret = vm_write_mem(&self->vm_mngr, addr, (char*)&final_value, 1);
+       ret = vm_write_mem(&self->vm_mngr, addr, (char*)&value, 1);
        if (ret < 0)
 	      RAISE(PyExc_TypeError, "Error in set_mem");
 
@@ -390,27 +383,19 @@ PyObject* vm_set_u16(VmMngr* self, PyObject* args)
 {
        PyObject *py_addr;
        PyObject *py_val;
-       uint64_t value;
-       uint16_t value_u16;
+       uint16_t value;
 
        uint64_t addr;
-       uint16_t final_value;
        int ret;
 
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_val))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
-       PyGetInt(py_val, value);
+       PyGetInt_uint64_t(py_addr, addr);
+       PyGetInt_uint16_t(py_val, value);
 
-       if (value > 0xFFFF) {
-		fprintf(stderr, "Warning: int to big\n");
-       }
-
-       value_u16 = (uint16_t) value;
-
-       final_value = set_endian16(&self->vm_mngr, value_u16);
-       ret = vm_write_mem(&self->vm_mngr, addr, (char*)&final_value, 2);
+       value = set_endian16(&self->vm_mngr, value);
+       ret = vm_write_mem(&self->vm_mngr, addr, (char*)&value, 2);
        if (ret < 0)
 	      RAISE(PyExc_TypeError, "Error in set_mem");
 
@@ -425,26 +410,19 @@ PyObject* vm_set_u32(VmMngr* self, PyObject* args)
 {
        PyObject *py_addr;
        PyObject *py_val;
-       uint64_t value;
-       uint32_t value_u32;
+       uint32_t value;
        uint64_t addr;
-       uint32_t final_value;
        int ret;
 
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_val))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
-       PyGetInt(py_val, value);
-
-       if (value > 0xFFFFFFFF) {
-		fprintf(stderr, "Warning: int to big\n");
-       }
+       PyGetInt_uint64_t(py_addr, addr);
+       PyGetInt_uint32_t(py_val, value);
 
-       value_u32 = (uint32_t) value;
-       final_value = set_endian32(&self->vm_mngr, value_u32);
+       value = set_endian32(&self->vm_mngr, value);
 
-       ret = vm_write_mem(&self->vm_mngr, addr, (char*)&final_value, 4);
+       ret = vm_write_mem(&self->vm_mngr, addr, (char*)&value, 4);
        if (ret < 0)
 	      RAISE(PyExc_TypeError, "Error in set_mem");
 
@@ -461,18 +439,17 @@ PyObject* vm_set_u64(VmMngr* self, PyObject* args)
        PyObject *py_val;
        uint64_t value;
        uint64_t addr;
-       uint64_t final_value;
        int ret;
 
        if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_val))
 	       RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-       PyGetInt(py_addr, addr);
-       PyGetInt(py_val, value);
+       PyGetInt_uint64_t(py_addr, addr);
+       PyGetInt_uint64_t(py_val, value);
 
-       final_value = set_endian64(&self->vm_mngr, value);
+       value = set_endian64(&self->vm_mngr, value);
 
-       ret = vm_write_mem(&self->vm_mngr, addr, (char*)&final_value, 8);
+       ret = vm_write_mem(&self->vm_mngr, addr, (char*)&value, 8);
        if (ret < 0)
 	      RAISE(PyExc_TypeError, "Error in set_mem");
 
@@ -500,9 +477,9 @@ PyObject* vm_add_memory_breakpoint(VmMngr* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "OOO", &ad, &size, &access))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(ad, b_ad);
-	PyGetInt(size, b_size);
-	PyGetInt(access, b_access);
+	PyGetInt_uint64_t(ad, b_ad);
+	PyGetInt_uint64_t(size, b_size);
+	PyGetInt_uint64_t(access, b_access);
 
 	add_memory_breakpoint(&self->vm_mngr, b_ad, b_size, (unsigned int)b_access);
 
@@ -528,8 +505,8 @@ PyObject* vm_remove_memory_breakpoint(VmMngr* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "OO", &ad, &access))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(ad, b_ad);
-	PyGetInt(access, b_access);
+	PyGetInt_uint64_t(ad, b_ad);
+	PyGetInt_uint64_t(access, b_access);
 	remove_memory_breakpoint(&self->vm_mngr, b_ad, (unsigned int)b_access);
 
 	Py_INCREF(Py_None);
@@ -540,14 +517,14 @@ PyObject* vm_remove_memory_breakpoint(VmMngr* self, PyObject* args)
 PyObject* vm_set_exception(VmMngr* self, PyObject* args)
 {
 	PyObject *item1;
-	uint64_t i;
+	uint64_t exception_flags;
 
 	if (!PyArg_ParseTuple(args, "O", &item1))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, i);
+	PyGetInt_uint64_t(item1, exception_flags);
 
-	self->vm_mngr.exception_flags = i;
+	self->vm_mngr.exception_flags = exception_flags;
 	Py_INCREF(Py_None);
 	return Py_None;
 }
@@ -608,8 +585,8 @@ PyObject* py_add_mem_read(VmMngr* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_size))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(py_addr, addr);
-	PyGetInt(py_size, size);
+	PyGetInt_uint64_t(py_addr, addr);
+	PyGetInt_uint64_t(py_size, size);
 	add_mem_read(&self->vm_mngr, addr, size);
 	Py_INCREF(Py_None);
 	return Py_None;
@@ -626,8 +603,8 @@ PyObject* py_add_mem_write(VmMngr* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "OO", &py_addr, &py_size))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(py_addr, addr);
-	PyGetInt(py_size, size);
+	PyGetInt_uint64_t(py_addr, addr);
+	PyGetInt_uint64_t(py_size, size);
 	add_mem_write(&self->vm_mngr, addr, size);
 	Py_INCREF(Py_None);
 	return Py_None;
@@ -732,8 +709,8 @@ PyObject* vm_add_code_bloc(VmMngr *self, PyObject *args)
 	if (!PyArg_ParseTuple(args, "OO", &item1, &item2))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(item1, ad_start);
-	PyGetInt(item2, ad_stop);
+	PyGetInt_uint64_t(item1, ad_start);
+	PyGetInt_uint64_t(item2, ad_stop);
 
 	cbp = create_code_bloc_node(ad_start, ad_stop);
 	cbp->ad_start = ad_start;
@@ -766,8 +743,8 @@ PyObject* vm_is_mapped(VmMngr* self, PyObject* args)
 	if (!PyArg_ParseTuple(args, "OO", &ad, &size))
 		RAISE(PyExc_TypeError,"Cannot parse arguments");
 
-	PyGetInt(ad, b_ad);
-	PyGetInt(size, b_size);
+	PyGetInt_uint64_t(ad, b_ad);
+	PyGetInt_uint64_t(size, b_size);
 	ret = is_mapped(&self->vm_mngr, b_ad, b_size);
 	return PyLong_FromUnsignedLongLong((uint64_t)ret);
 }