Merge pull request #116 from JonathonReinhart/use-void-ptrs

change mem read/write APIs to use void*

include/unicorn/unicorn.h

@@ -313,7 +313,7 @@ uc_err uc_reg_read(uc_engine *uc, int regid, void *value);
  for detailed error).
 */
 UNICORN_EXPORT
-uc_err uc_mem_write(uc_engine *uc, uint64_t address, const uint8_t *bytes, size_t size);
+uc_err uc_mem_write(uc_engine *uc, uint64_t address, const void *bytes, size_t size);
 
 /*
  Read a range of bytes in memory.
@@ -329,7 +329,7 @@ uc_err uc_mem_write(uc_engine *uc, uint64_t address, const uint8_t *bytes, size_
  for detailed error).
 */
 UNICORN_EXPORT
-uc_err uc_mem_read(uc_engine *uc, uint64_t address, uint8_t *bytes, size_t size);
+uc_err uc_mem_read(uc_engine *uc, uint64_t address, void *bytes, size_t size);
 
 /*
  Emulate machine code in a specific duration of time.

regress/mem_exec.c

@@ -183,14 +183,14 @@ int main(int argc, char **argv, char **envp)
     }
 
     // fill in sections that shouldn't get touched
-    if (uc_mem_write(uc, 0x1ff000, (uint8_t*)buf1, 4096)) {
+    if (uc_mem_write(uc, 0x1ff000, buf1, sizeof(buf1))) {
         printf("not ok %d - Failed to write random buffer 1 to memory, quit!\n", log_num++);
         return 3;
     } else {
         printf("ok %d - Random buffer 1 written to memory\n", log_num++);
     }
 
-    if (uc_mem_write(uc, 0x301000, (uint8_t*)buf2, 4096)) {
+    if (uc_mem_write(uc, 0x301000, buf2, sizeof(buf2))) {
         printf("not ok %d - Failed to write random buffer 2 to memory, quit!\n", log_num++);
         return 4;
     } else {
@@ -248,7 +248,7 @@ int main(int argc, char **argv, char **envp)
 
     //make sure that random blocks didn't get nuked
     // fill in sections that shouldn't get touched
-    if (uc_mem_read(uc, 0x1ff000, (uint8_t*)readbuf, 4096)) {
+    if (uc_mem_read(uc, 0x1ff000, readbuf, sizeof(readbuf))) {
         printf("not ok %d - Failed to read random buffer 1 from memory\n", log_num++);
     } else {
         printf("ok %d - Random buffer 1 read from memory\n", log_num++);
@@ -259,7 +259,7 @@ int main(int argc, char **argv, char **envp)
         }
     }
 
-    if (uc_mem_read(uc, 0x301000, (uint8_t*)readbuf, 4096)) {
+    if (uc_mem_read(uc, 0x301000, readbuf, sizeof(readbuf))) {
         printf("not ok %d - Failed to read random buffer 2 from memory\n", log_num++);
     } else {
         printf("ok %d - Random buffer 2 read from memory\n", log_num++);

regress/mem_protect.c

@@ -88,7 +88,7 @@ static void hook_code(uc_engine *uc, uint64_t addr, uint32_t size, void *user_da
     switch (opcode) {
         case 0x90:  //nop
             printf("# Handling NOP\n");
-            if (uc_mem_read(uc, 0x200000 + test_num * 0x100000, (uint8_t*)&testval, sizeof(testval)) != UC_ERR_OK) {
+            if (uc_mem_read(uc, 0x200000 + test_num * 0x100000, &testval, sizeof(testval)) != UC_ERR_OK) {
                 printf("not ok %d - uc_mem_read fail for address: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
             } else {
                 printf("ok %d - good uc_mem_read for address: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
@@ -143,7 +143,7 @@ static bool hook_mem_invalid(uc_engine *uc, uc_mem_type type,
         case UC_MEM_WRITE_PROT:
             printf("# write to non-writeable memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "\n", addr, size, value);
 
-            if (uc_mem_read(uc, addr, (uint8_t*)&testval, sizeof(testval)) != UC_ERR_OK) {
+            if (uc_mem_read(uc, addr, &testval, sizeof(testval)) != UC_ERR_OK) {
                 printf("not ok %d - uc_mem_read fail for address: 0x%" PRIx64 "\n", log_num++, addr);
             } else {
                 printf("ok %d - uc_mem_read success after mem_protect at test %d\n", log_num++, test_num - 1);
@@ -191,14 +191,14 @@ int main(int argc, char **argv, char **envp)
     uc_mem_map(uc, 0x3ff000, 0x3000, UC_PROT_READ | UC_PROT_WRITE);
 
     // fill in sections that shouldn't get touched
-    if (uc_mem_write(uc, 0x3ff000, (uint8_t*)buf1, 4096)) {
+    if (uc_mem_write(uc, 0x3ff000, buf1, sizeof(buf1))) {
         printf("not ok %d - Failed to write random buffer 1 to memory, quit!\n", log_num++);
         return 2;
     } else {
         printf("ok %d - Random buffer 1 written to memory\n", log_num++);
     }
 
-    if (uc_mem_write(uc, 0x401000, (uint8_t*)buf2, 4096)) {
+    if (uc_mem_write(uc, 0x401000, buf2, sizeof(buf2))) {
         printf("not ok %d - Failed to write random buffer 2 to memory, quit!\n", log_num++);
         return 3;
     } else {
@@ -251,7 +251,7 @@ int main(int argc, char **argv, char **envp)
     testval = 0x42424242;
     for (addr = 0x200000; addr <= 0x400000; addr += 0x100000) {
         uint32_t val;
-        if (uc_mem_read(uc, addr, (uint8_t*)&val, sizeof(val)) != UC_ERR_OK) {
+        if (uc_mem_read(uc, addr, &val, sizeof(val)) != UC_ERR_OK) {
             printf("not ok %d - Failed uc_mem_read for address 0x%x\n", log_num++, addr);
         } else {
             printf("ok %d - Good uc_mem_read from 0x%x\n", log_num++, addr);
@@ -270,7 +270,7 @@ int main(int argc, char **argv, char **envp)
 
     //make sure that random blocks didn't get nuked
     // fill in sections that shouldn't get touched
-    if (uc_mem_read(uc, 0x3ff000, (uint8_t*)readbuf, 4096)) {
+    if (uc_mem_read(uc, 0x3ff000, readbuf, sizeof(readbuf))) {
         printf("not ok %d - Failed to read random buffer 1 from memory\n", log_num++);
     } else {
         printf("ok %d - Random buffer 1 read from memory\n", log_num++);
@@ -281,7 +281,7 @@ int main(int argc, char **argv, char **envp)
         }
     }
 
-    if (uc_mem_read(uc, 0x401000, (uint8_t*)readbuf, 4096)) {
+    if (uc_mem_read(uc, 0x401000, readbuf, sizeof(readbuf))) {
         printf("not ok %d - Failed to read random buffer 2 from memory\n", log_num++);
     } else {
         printf("ok %d - Random buffer 2 read from memory\n", log_num++);

regress/mem_unmap.c

@@ -83,7 +83,7 @@ static void hook_code(uc_engine *uc, uint64_t addr, uint32_t size, void *user_da
     switch (opcode) {
         case 0x90:  //nop
             printf("# Handling NOP\n");
-            if (uc_mem_read(uc, 0x200000 + test_num * 0x100000, (uint8_t*)&testval, sizeof(testval)) != UC_ERR_OK) {
+            if (uc_mem_read(uc, 0x200000 + test_num * 0x100000, &testval, sizeof(testval)) != UC_ERR_OK) {
                 printf("not ok %d - uc_mem_read fail for address: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
             } else {
                 printf("ok %d - good uc_mem_read for address: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
@@ -138,7 +138,7 @@ static bool hook_mem_invalid(uc_engine *uc, uc_mem_type type,
         case UC_MEM_WRITE:
             printf("# write to invalid memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "\n", addr, size, value);
 
-            if (uc_mem_read(uc, addr, (uint8_t*)&testval, sizeof(testval)) != UC_ERR_OK) {
+            if (uc_mem_read(uc, addr, &testval, sizeof(testval)) != UC_ERR_OK) {
                 printf("ok %d - uc_mem_read fail for address: 0x%" PRIx64 "\n", log_num++, addr);
             } else {
                 printf("not ok %d - uc_mem_read success after unmap at test %d\n", log_num++, test_num - 1);
@@ -186,14 +186,14 @@ int main(int argc, char **argv, char **envp)
     uc_mem_map(uc, 0x3ff000, 0x3000, UC_PROT_READ | UC_PROT_WRITE);
 
     // fill in sections that shouldn't get touched
-    if (uc_mem_write(uc, 0x3ff000, (uint8_t*)buf1, 4096)) {
+    if (uc_mem_write(uc, 0x3ff000, buf1, sizeof(buf1))) {
         printf("not ok %d - Failed to write random buffer 1 to memory, quit!\n", log_num++);
         return 2;
     } else {
         printf("ok %d - Random buffer 1 written to memory\n", log_num++);
     }
 
-    if (uc_mem_write(uc, 0x401000, (uint8_t*)buf2, 4096)) {
+    if (uc_mem_write(uc, 0x401000, buf2, sizeof(buf1))) {
         printf("not ok %d - Failed to write random buffer 2 to memory, quit!\n", log_num++);
         return 3;
     } else {
@@ -246,7 +246,7 @@ int main(int argc, char **argv, char **envp)
     testval = 0x42424242;
     for (addr = 0x200000; addr <= 0x400000; addr += 0x100000) {
         uint32_t val;
-        if (uc_mem_read(uc, addr, (uint8_t*)&val, sizeof(val)) != UC_ERR_OK) {
+        if (uc_mem_read(uc, addr, &val, sizeof(val)) != UC_ERR_OK) {
             printf("not ok %d - Failed uc_mem_read for address 0x%x\n", log_num++, addr);
         } else {
             printf("ok %d - Good uc_mem_read from 0x%x\n", log_num++, addr);
@@ -261,7 +261,7 @@ int main(int argc, char **argv, char **envp)
 
     //make sure that random blocks didn't get nuked
     // fill in sections that shouldn't get touched
-    if (uc_mem_read(uc, 0x3ff000, (uint8_t*)readbuf, 4096)) {
+    if (uc_mem_read(uc, 0x3ff000, readbuf, sizeof(readbuf))) {
         printf("not ok %d - Failed to read random buffer 1 from memory\n", log_num++);
     } else {
         printf("ok %d - Random buffer 1 read from memory\n", log_num++);
@@ -272,7 +272,7 @@ int main(int argc, char **argv, char **envp)
         }
     }
 
-    if (uc_mem_read(uc, 0x401000, (uint8_t*)readbuf, 4096)) {
+    if (uc_mem_read(uc, 0x401000, readbuf, sizeof(readbuf))) {
         printf("not ok %d - Failed to read random buffer 2 from memory\n", log_num++);
     } else {
         printf("ok %d - Random buffer 2 read from memory\n", log_num++);

regress/rep_movsb.c

@@ -112,7 +112,7 @@ int main(int argc, char **argv, char **envp)
    uc_mem_map(uc, 0x200000, 0x2000, UC_PROT_READ | UC_PROT_WRITE);
 
    // fill in the data that we want to copy
-   if (uc_mem_write(uc, 0x200000, (uint8_t*)buf1, 20)) {
+   if (uc_mem_write(uc, 0x200000, buf1, 20)) {
       printf("not ok %d - Failed to write read buffer to memory, quit!\n", log_num++);
       return 2;
    }
@@ -160,7 +160,7 @@ int main(int argc, char **argv, char **envp)
 
    //make sure that data got copied
    // fill in sections that shouldn't get touched
-   if (uc_mem_read(uc, 0x201000, (uint8_t*)readbuf, 20)) {
+   if (uc_mem_read(uc, 0x201000, readbuf, 20)) {
       printf("not ok %d - Failed to read random buffer 1 from memory\n", log_num++);
    }
    else {

regress/timeout_segfault.c

@@ -59,7 +59,7 @@ static void test_arm(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)ARM_CODE, sizeof(ARM_CODE) - 1);
+    uc_mem_write(uc, ADDRESS, ARM_CODE, sizeof(ARM_CODE) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_ARM_REG_R0, &r0);
@@ -112,7 +112,7 @@ static void test_thumb(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)THUMB_CODE, sizeof(THUMB_CODE) - 1);
+    uc_mem_write(uc, ADDRESS, THUMB_CODE, sizeof(THUMB_CODE) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_ARM_REG_SP, &sp);

samples/sample_arm.c

@@ -50,7 +50,7 @@ static void test_arm(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)ARM_CODE, sizeof(ARM_CODE) - 1);
+    uc_mem_write(uc, ADDRESS, ARM_CODE, sizeof(ARM_CODE) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_ARM_REG_R0, &r0);
@@ -103,7 +103,7 @@ static void test_thumb(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)THUMB_CODE, sizeof(THUMB_CODE) - 1);
+    uc_mem_write(uc, ADDRESS, THUMB_CODE, sizeof(THUMB_CODE) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_ARM_REG_SP, &sp);

samples/sample_arm64.c

@@ -48,7 +48,7 @@ static void test_arm64(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)ARM_CODE, sizeof(ARM_CODE) - 1);
+    uc_mem_write(uc, ADDRESS, ARM_CODE, sizeof(ARM_CODE) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_ARM64_REG_X11, &x11);

samples/sample_m68k.c

@@ -63,7 +63,7 @@ static void test_m68k(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)M68K_CODE, sizeof(M68K_CODE) - 1);
+    uc_mem_write(uc, ADDRESS, M68K_CODE, sizeof(M68K_CODE) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_M68K_REG_D0, &d0);

samples/sample_mips.c

@@ -47,7 +47,7 @@ static void test_mips_eb(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)MIPS_CODE_EB, sizeof(MIPS_CODE_EB) - 1);
+    uc_mem_write(uc, ADDRESS, MIPS_CODE_EB, sizeof(MIPS_CODE_EB) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_MIPS_REG_1, &r1);
@@ -97,7 +97,7 @@ static void test_mips_el(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)MIPS_CODE_EL, sizeof(MIPS_CODE_EL) - 1);
+    uc_mem_write(uc, ADDRESS, MIPS_CODE_EL, sizeof(MIPS_CODE_EL) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_MIPS_REG_1, &r1);

samples/sample_sparc.c

@@ -49,7 +49,7 @@ static void test_sparc(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    uc_mem_write(uc, ADDRESS, (uint8_t *)SPARC_CODE, sizeof(SPARC_CODE) - 1);
+    uc_mem_write(uc, ADDRESS, SPARC_CODE, sizeof(SPARC_CODE) - 1);
 
     // initialize machine registers
     uc_reg_write(uc, UC_SPARC_REG_G1, &g1);

samples/sample_x86.c

@@ -189,7 +189,7 @@ static void test_i386(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE32, sizeof(X86_CODE32) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE32, sizeof(X86_CODE32) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }
@@ -220,7 +220,7 @@ static void test_i386(void)
     printf(">>> EDX = 0x%x\n", r_edx);
 
     // read from memory
-    if (!uc_mem_read(uc, ADDRESS, (uint8_t *)&tmp, 4))
+    if (!uc_mem_read(uc, ADDRESS, &tmp, sizeof(tmp)))
         printf(">>> Read 4 bytes from [0x%x] = 0x%x\n", ADDRESS, tmp);
     else
         printf(">>> Failed to read 4 bytes from [0x%x]\n", ADDRESS);
@@ -248,7 +248,7 @@ static void test_i386_jump(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE32_JUMP,
+    if (uc_mem_write(uc, ADDRESS, X86_CODE32_JUMP,
           sizeof(X86_CODE32_JUMP) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
@@ -295,7 +295,7 @@ static void test_i386_loop(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE32_LOOP, sizeof(X86_CODE32_LOOP) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE32_LOOP, sizeof(X86_CODE32_LOOP) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }
@@ -347,7 +347,7 @@ static void test_i386_invalid_mem_read(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE32_MEM_READ, sizeof(X86_CODE32_MEM_READ) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE32_MEM_READ, sizeof(X86_CODE32_MEM_READ) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }
@@ -405,7 +405,7 @@ static void test_i386_invalid_mem_write(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE32_MEM_WRITE, sizeof(X86_CODE32_MEM_WRITE) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE32_MEM_WRITE, sizeof(X86_CODE32_MEM_WRITE) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }
@@ -439,12 +439,12 @@ static void test_i386_invalid_mem_write(void)
     printf(">>> EDX = 0x%x\n", r_edx);
 
     // read from memory
-    if (!uc_mem_read(uc, 0xaaaaaaaa, (uint8_t *)&tmp, 4))
+    if (!uc_mem_read(uc, 0xaaaaaaaa, &tmp, sizeof(tmp)))
         printf(">>> Read 4 bytes from [0x%x] = 0x%x\n", 0xaaaaaaaa, tmp);
     else
         printf(">>> Failed to read 4 bytes from [0x%x]\n", 0xffffffaa);
 
-    if (!uc_mem_read(uc, 0xffffffaa, (uint8_t *)&tmp, 4))
+    if (!uc_mem_read(uc, 0xffffffaa, &tmp, sizeof(tmp)))
         printf(">>> Read 4 bytes from [0x%x] = 0x%x\n", 0xffffffaa, tmp);
     else
         printf(">>> Failed to read 4 bytes from [0x%x]\n", 0xffffffaa);
@@ -476,7 +476,7 @@ static void test_i386_jump_invalid(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE32_JMP_INVALID, sizeof(X86_CODE32_JMP_INVALID) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE32_JMP_INVALID, sizeof(X86_CODE32_JMP_INVALID) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }
@@ -532,7 +532,7 @@ static void test_i386_inout(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE32_INOUT, sizeof(X86_CODE32_INOUT) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE32_INOUT, sizeof(X86_CODE32_INOUT) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }
@@ -607,7 +607,7 @@ static void test_x86_64(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE64, sizeof(X86_CODE64) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE64, sizeof(X86_CODE64) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }
@@ -708,7 +708,7 @@ static void test_x86_64_syscall(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE64_SYSCALL, sizeof(X86_CODE64_SYSCALL) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE64_SYSCALL, sizeof(X86_CODE64_SYSCALL) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }
@@ -760,7 +760,7 @@ static void test_x86_16(void)
     uc_mem_map(uc, 0, 8 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, 0, (uint8_t *)X86_CODE16, sizeof(X86_CODE64) - 1)) {
+    if (uc_mem_write(uc, 0, X86_CODE16, sizeof(X86_CODE64) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }

samples/shellcode.c

@@ -23,7 +23,7 @@
 static void hook_code(uc_engine *uc, uint64_t address, uint32_t size, void *user_data)
 {
     int r_eip;
-    char tmp[16];
+    uint8_t tmp[16];
 
     printf("Tracing instruction at 0x%"PRIx64 ", instruction size = 0x%x\n", address, size);
 
@@ -31,10 +31,10 @@ static void hook_code(uc_engine *uc, uint64_t address, uint32_t size, void *user
     printf("*** EIP = %x ***: ", r_eip);
 
     size = MIN(sizeof(tmp), size);
-    if (!uc_mem_read(uc, address, (uint8_t *)tmp, size)) {
+    if (!uc_mem_read(uc, address, tmp, size)) {
         int i;
         for (i=0; i<size; i++) {
-            printf("%x ", ((uint8_t*)tmp)[i]);
+            printf("%x ", tmp[i]);
         }
         printf("\n");
     }
@@ -106,7 +106,7 @@ static void test_i386(void)
     uc_mem_map(uc, ADDRESS, 2 * 1024 * 1024, UC_PROT_ALL);
 
     // write machine code to be emulated to memory
-    if (uc_mem_write(uc, ADDRESS, (uint8_t *)X86_CODE32_SELF, sizeof(X86_CODE32_SELF) - 1)) {
+    if (uc_mem_write(uc, ADDRESS, X86_CODE32_SELF, sizeof(X86_CODE32_SELF) - 1)) {
         printf("Failed to write emulation code to memory, quit!\n");
         return;
     }

uc.c

@@ -331,8 +331,10 @@ static bool check_mem_area(uc_engine *uc, uint64_t address, size_t size)
 
 
 UNICORN_EXPORT
-uc_err uc_mem_read(uc_engine *uc, uint64_t address, uint8_t *bytes, size_t size)
+uc_err uc_mem_read(uc_engine *uc, uint64_t address, void *_bytes, size_t size)
 {
+    uint8_t *bytes = _bytes;
+
     if (!check_mem_area(uc, address, size))
         return UC_ERR_MEM_READ;
 
@@ -359,8 +361,10 @@ uc_err uc_mem_read(uc_engine *uc, uint64_t address, uint8_t *bytes, size_t size)
 }
 
 UNICORN_EXPORT
-uc_err uc_mem_write(uc_engine *uc, uint64_t address, const uint8_t *bytes, size_t size)
+uc_err uc_mem_write(uc_engine *uc, uint64_t address, const void *_bytes, size_t size)
 {
+    const uint8_t *bytes = _bytes;
+
     if (!check_mem_area(uc, address, size))
         return UC_ERR_MEM_WRITE;