Reformat code with format.sh

unicorn-engine · Jun 16, 2023 · d7a806c · d7a806c
1 parent fa1f261
commit d7a806c
Show file tree

Hide file tree

Showing 17 changed files with 216 additions and 166 deletions.
diff --git a/include/uc_priv.h b/include/uc_priv.h
@@ -403,7 +403,7 @@ struct uc_struct {
     uint32_t tcg_buffer_size; // The buffer size we are going to use
 #ifdef WIN32
     PVOID seh_handle;
-    void* seh_closure;
+    void *seh_closure;
 #endif
 };
 

diff --git a/include/unicorn/unicorn.h b/include/unicorn/unicorn.h
@@ -264,13 +264,15 @@ typedef enum uc_mem_type {
 
   @vaddr: virtuall address for lookup
   @rw: the access mode
-  @result: result entry, contains physical address (paddr) and permitted access type (perms) for the entry
+  @result: result entry, contains physical address (paddr) and permitted access
+  type (perms) for the entry
 
   @return: return true if the entry was found. If a callback is present but
   no one returns true a pagefault is generated.
 */
-typedef bool (*uc_cb_tlbevent_t)(uc_engine *uc, uint64_t vaddr, uc_mem_type type,
-                                 uc_tlb_entry *result, void *user_data);
+typedef bool (*uc_cb_tlbevent_t)(uc_engine *uc, uint64_t vaddr,
+                                 uc_mem_type type, uc_tlb_entry *result,
+                                 void *user_data);
 
 // Represent a TranslationBlock.
 typedef struct uc_tb {
@@ -510,11 +512,12 @@ typedef enum uc_query_type {
 
 // unicorn tlb type selection
 typedef enum uc_tlb_type {
-  // The default unicorn virtuall TLB implementation.
+    // The default unicorn virtuall TLB implementation.
     // The tlb implementation of the CPU, best to use for full system emulation.
     UC_TLB_CPU = 0,
     // This tlb defaults to virtuall address == physical address
-    // Also a hook is availible to override the tlb entries (see uc_cb_tlbevent_t).
+    // Also a hook is availible to override the tlb entries (see
+    // uc_cb_tlbevent_t).
     UC_TLB_VIRTUAL
 } uc_tlb_type;
 
@@ -652,7 +655,8 @@ See sample_ctl.c for a detailed example.
     uc_ctl(uc, UC_CTL_READ_WRITE(UC_CTL_TB_REQUEST_CACHE, 2), (address), (tb))
 #define uc_ctl_flush_tb(uc) uc_ctl(uc, UC_CTL_WRITE(UC_CTL_TB_FLUSH, 0))
 #define uc_ctl_flush_tlb(uc) uc_ctl(uc, UC_CTL_WRITE(UC_CTL_TLB_FLUSH, 0))
-#define uc_ctl_tlb_mode(uc, mode) uc_ctl(uc, UC_CTL_WRITE(UC_CTL_TLB_TYPE, 1), (mode))
+#define uc_ctl_tlb_mode(uc, mode)                                              \
+    uc_ctl(uc, UC_CTL_WRITE(UC_CTL_TLB_TYPE, 1), (mode))
 #define uc_ctl_get_tcg_buffer_size(uc, size)                                   \
     uc_ctl(uc, UC_CTL_READ(UC_CTL_TCG_BUFFER_SIZE, 1), (size))
 #define uc_ctl_set_tcg_buffer_size(uc, size)                                   \

diff --git a/msvc/config-host.h b/msvc/config-host.h
@@ -6,4 +6,4 @@
 // #define CONFIG_INT128 1
 #define CONFIG_CMPXCHG128 1
 // #define CONFIG_ATOMIC64 1
-#define CONFIG_PLUGIN 1
+#define CONFIG_PLUGIN 1
diff --git a/qemu/target/i386/unicorn.c b/qemu/target/i386/unicorn.c
@@ -986,7 +986,7 @@ static int reg_write(CPUX86State *env, unsigned int regid, const void *value,
             goto write_cr;
         case UC_X86_REG_CR4:
             cpu_x86_update_cr4(env, *(uint32_t *)value);
-write_cr:
+        write_cr:
             env->cr[regid - UC_X86_REG_CR0] = *(uint32_t *)value;
             break;
         case UC_X86_REG_DR0:
@@ -1169,16 +1169,16 @@ static int reg_write(CPUX86State *env, unsigned int regid, const void *value,
         default:
             break;
         case UC_X86_REG_CR0:
-            cpu_x86_update_cr0(env, *(uint32_t *) value);
+            cpu_x86_update_cr0(env, *(uint32_t *)value);
             goto write_cr64;
         case UC_X86_REG_CR1:
         case UC_X86_REG_CR2:
         case UC_X86_REG_CR3:
-            cpu_x86_update_cr3(env, *(uint32_t *) value);
+            cpu_x86_update_cr3(env, *(uint32_t *)value);
             goto write_cr64;
         case UC_X86_REG_CR4:
-            cpu_x86_update_cr4(env, *(uint32_t *) value);
-write_cr64:
+            cpu_x86_update_cr4(env, *(uint32_t *)value);
+        write_cr64:
             env->cr[regid - UC_X86_REG_CR0] = *(uint64_t *)value;
             break;
         case UC_X86_REG_DR0:

diff --git a/samples/sample_arm64.c b/samples/sample_arm64.c
@@ -10,8 +10,8 @@
 #define ARM64_CODE                                                             \
     "\xab\x05\x00\xb8\xaf\x05\x40\x38" // str w11, [x13], #0; ldrb w15, [x13],
                                        // #0
-//#define ARM64_CODE_EB "\xb8\x00\x05\xab\x38\x40\x05\xaf" // str w11, [x13];
-// ldrb w15, [x13]
+// #define ARM64_CODE_EB "\xb8\x00\x05\xab\x38\x40\x05\xaf" // str w11, [x13];
+//  ldrb w15, [x13]
 #define ARM64_CODE_EB ARM64_CODE
 
 // mrs        x2, tpidrro_el0

diff --git a/samples/sample_mmu.c b/samples/sample_mmu.c
@@ -18,25 +18,30 @@
  * mov rax, 60
  * syscall
  */
-char code[] = "\xB8\x39\x00\x00\x00\x0F\x05\x48\x85\xC0\x74\x0F\xB8\x3C\x00\x00\x00\x48\x89\x04\x25\x00\x40\x00\x00\x0F\x05\xB9\x2A\x00\x00\x00\x48\x89\x0C\x25\x00\x40\x00\x00\xB8\x3C\x00\x00\x00\x0F\x05";
+char code[] = "\xB8\x39\x00\x00\x00\x0F\x05\x48\x85\xC0\x74\x0F\xB8\x3C\x00\x00"
+              "\x00\x48\x89\x04\x25\x00\x40\x00\x00\x0F\x05\xB9\x2A\x00\x00\x00"
+              "\x48\x89\x0C\x25\x00\x40\x00\x00\xB8\x3C\x00\x00\x00\x0F\x05";
 
-static void mmu_write_callback(uc_engine *uc, uc_mem_type type, uint64_t address, int size, int64_t value, void *user_data)
+static void mmu_write_callback(uc_engine *uc, uc_mem_type type,
+                               uint64_t address, int size, int64_t value,
+                               void *user_data)
 {
     printf("write at 0x%lx: 0x%lx\n", address, value);
 }
 
-static void x86_mmu_prepare_tlb(uc_engine *uc, uint64_t vaddr, uint64_t tlb_base)
+static void x86_mmu_prepare_tlb(uc_engine *uc, uint64_t vaddr,
+                                uint64_t tlb_base)
 {
     uc_err err;
     uint64_t cr0;
     uint64_t cr4;
     uc_x86_msr msr = {.rid = 0xC0000080, .value = 0};
-    uint64_t pml4o = ((vaddr & 0x00ff8000000000) >> 39)*8;
-    uint64_t pdpo  = ((vaddr & 0x00007fc0000000) >> 30)*8;
-    uint64_t pdo   = ((vaddr & 0x0000003fe00000) >> 21)*8;
+    uint64_t pml4o = ((vaddr & 0x00ff8000000000) >> 39) * 8;
+    uint64_t pdpo = ((vaddr & 0x00007fc0000000) >> 30) * 8;
+    uint64_t pdo = ((vaddr & 0x0000003fe00000) >> 21) * 8;
     uint64_t pml4e = (tlb_base + 0x1000) | 1 | (1 << 2);
-    uint64_t pdpe  = (tlb_base + 0x2000) | 1 | (1 << 2);
-    uint64_t pde   = (tlb_base + 0x3000) | 1 | (1 << 2);
+    uint64_t pdpe = (tlb_base + 0x2000) | 1 | (1 << 2);
+    uint64_t pde = (tlb_base + 0x3000) | 1 | (1 << 2);
     err = uc_mem_write(uc, tlb_base + pml4o, &pml4e, sizeof(pml4o));
     if (err) {
         printf("failed to write pml4e\n");
@@ -73,10 +78,10 @@ static void x86_mmu_prepare_tlb(uc_engine *uc, uint64_t vaddr, uint64_t tlb_base
         exit(1);
     }
 
-    cr0 |= 1;                   //enable protected mode
-    cr0 |= 1l << 31;            //enable paging
-    cr4 |= 1l << 5;             //enable physical address extension
-    msr.value |= 1l << 8;       //enable long mode
+    cr0 |= 1;             // enable protected mode
+    cr0 |= 1l << 31;      // enable paging
+    cr4 |= 1l << 5;       // enable physical address extension
+    msr.value |= 1l << 8; // enable long mode
 
     err = uc_reg_write(uc, UC_X86_REG_CR0, &cr0);
     if (err) {
@@ -95,10 +100,11 @@ static void x86_mmu_prepare_tlb(uc_engine *uc, uint64_t vaddr, uint64_t tlb_base
     }
 }
 
-static void x86_mmu_pt_set(uc_engine *uc, uint64_t vaddr, uint64_t paddr, uint64_t tlb_base)
+static void x86_mmu_pt_set(uc_engine *uc, uint64_t vaddr, uint64_t paddr,
+                           uint64_t tlb_base)
 {
-    uint64_t pto   = ((vaddr & 0x000000001ff000) >> 12)*8;
-    uint32_t pte   = (paddr) | 1 | (1 << 2);
+    uint64_t pto = ((vaddr & 0x000000001ff000) >> 12) * 8;
+    uint32_t pte = (paddr) | 1 | (1 << 2);
     uc_mem_write(uc, tlb_base + 0x3000 + pto, &pte, sizeof(pte));
 }
 
@@ -162,20 +168,23 @@ void cpu_tlb(void)
         exit(1);
     }
 
-    err = uc_hook_add(uc, &h1, UC_HOOK_INSN, &x86_mmu_syscall_callback, &parrent_done, 1, 0, UC_X86_INS_SYSCALL);
+    err = uc_hook_add(uc, &h1, UC_HOOK_INSN, &x86_mmu_syscall_callback,
+                      &parrent_done, 1, 0, UC_X86_INS_SYSCALL);
     if (err) {
         printf("Failed on uc_hook_add() with error returned: %u\n", err);
         exit(1);
     }
 
-    // Memory hooks are called after the mmu translation, so hook the physicall addresses
-    err = uc_hook_add(uc, &h2, UC_HOOK_MEM_WRITE, &mmu_write_callback, NULL, 0x1000, 0x3000);
+    // Memory hooks are called after the mmu translation, so hook the physicall
+    // addresses
+    err = uc_hook_add(uc, &h2, UC_HOOK_MEM_WRITE, &mmu_write_callback, NULL,
+                      0x1000, 0x3000);
     if (err) {
         printf("Faled on uc_hook_add() with error returned: %u\n", err);
     }
 
     printf("map code\n");
-    err = uc_mem_map(uc, 0x0, 0x1000, UC_PROT_ALL); //Code
+    err = uc_mem_map(uc, 0x0, 0x1000, UC_PROT_ALL); // Code
     if (err) {
         printf("Failed on uc_mem_map() with error return: %u\n", err);
         exit(1);
@@ -186,25 +195,24 @@ void cpu_tlb(void)
         exit(1);
     }
     printf("map parrent memory\n");
-    err = uc_mem_map(uc, 0x1000, 0x1000, UC_PROT_ALL); //Parrent
+    err = uc_mem_map(uc, 0x1000, 0x1000, UC_PROT_ALL); // Parrent
     if (err) {
         printf("Failed on uc_mem_map() with error return: %u\n", err);
         exit(1);
     }
     printf("map child memory\n");
-    err = uc_mem_map(uc, 0x2000, 0x1000, UC_PROT_ALL); //Child
+    err = uc_mem_map(uc, 0x2000, 0x1000, UC_PROT_ALL); // Child
     if (err) {
         printf("failed to map child memory\n");
         exit(1);
     }
     printf("map tlb memory\n");
-    err = uc_mem_map(uc, tlb_base, 0x4000, UC_PROT_ALL); //TLB
+    err = uc_mem_map(uc, tlb_base, 0x4000, UC_PROT_ALL); // TLB
     if (err) {
         printf("failed to map memory for tlb\n");
         exit(1);
     }
 
-
     printf("set up the tlb\n");
     x86_mmu_prepare_tlb(uc, 0x0, tlb_base);
     x86_mmu_pt_set(uc, 0x2000, 0x0, tlb_base);
@@ -277,7 +285,8 @@ void cpu_tlb(void)
     uc_close(uc);
 }
 
-static bool virtual_tlb_callback(uc_engine *uc, uint64_t addr, uc_mem_type type, uc_tlb_entry *result, void *user_data)
+static bool virtual_tlb_callback(uc_engine *uc, uint64_t addr, uc_mem_type type,
+                                 uc_tlb_entry *result, void *user_data)
 {
     bool *parrent_done = user_data;
     printf("tlb lookup for address: 0x%lX\n", addr);
@@ -324,20 +333,23 @@ void virtual_tlb(void)
         exit(1);
     }
 
-    err = uc_hook_add(uc, &h1, UC_HOOK_INSN, &x86_mmu_syscall_callback, &parrent_done, 1, 0, UC_X86_INS_SYSCALL);
+    err = uc_hook_add(uc, &h1, UC_HOOK_INSN, &x86_mmu_syscall_callback,
+                      &parrent_done, 1, 0, UC_X86_INS_SYSCALL);
     if (err) {
         printf("Failed on uc_hook_add() with error returned: %u\n", err);
         exit(1);
     }
 
-    // Memory hooks are called after the mmu translation, so hook the physicall addresses
-    err = uc_hook_add(uc, &h2, UC_HOOK_MEM_WRITE, &mmu_write_callback, NULL, 0x1000, 0x3000);
+    // Memory hooks are called after the mmu translation, so hook the physicall
+    // addresses
+    err = uc_hook_add(uc, &h2, UC_HOOK_MEM_WRITE, &mmu_write_callback, NULL,
+                      0x1000, 0x3000);
     if (err) {
         printf("Faled on uc_hook_add() with error returned: %u\n", err);
     }
 
     printf("map code\n");
-    err = uc_mem_map(uc, 0x0, 0x1000, UC_PROT_ALL); //Code
+    err = uc_mem_map(uc, 0x0, 0x1000, UC_PROT_ALL); // Code
     if (err) {
         printf("Failed on uc_mem_map() with error return: %u\n", err);
         exit(1);
@@ -348,19 +360,20 @@ void virtual_tlb(void)
         exit(1);
     }
     printf("map parrent memory\n");
-    err = uc_mem_map(uc, 0x1000, 0x1000, UC_PROT_ALL); //Parrent
+    err = uc_mem_map(uc, 0x1000, 0x1000, UC_PROT_ALL); // Parrent
     if (err) {
         printf("Failed on uc_mem_map() with error return: %u\n", err);
         exit(1);
     }
     printf("map child memory\n");
-    err = uc_mem_map(uc, 0x2000, 0x1000, UC_PROT_ALL); //Child
+    err = uc_mem_map(uc, 0x2000, 0x1000, UC_PROT_ALL); // Child
     if (err) {
         printf("failed to map child memory\n");
         exit(1);
     }
 
-    err = uc_hook_add(uc, &h3, UC_HOOK_TLB_FILL, virtual_tlb_callback, &parrent_done, 1, 0);
+    err = uc_hook_add(uc, &h3, UC_HOOK_TLB_FILL, virtual_tlb_callback,
+                      &parrent_done, 1, 0);
 
     printf("run the parrent\n");
     err = uc_emu_start(uc, 0x2000, 0x0, 0, 0);

diff --git a/samples/sample_riscv.c b/samples/sample_riscv.c
@@ -11,7 +11,7 @@
  0  13 05 10 00  addi	a0, zero, 1
  4  93 85 05 02  addi	a1, a1, 0x20
 #endif
-//#define RISCV_CODE "\x13\x05\x10\x00\x93\x85\x05\x02\x93\x85\x05\x02"
+// #define RISCV_CODE "\x13\x05\x10\x00\x93\x85\x05\x02\x93\x85\x05\x02"
 #define RISCV_CODE "\x13\x05\x10\x00\x93\x85\x05\x02"
 
 // memory address where emulation starts

diff --git a/samples/sample_sparc.c b/samples/sample_sparc.c
@@ -8,7 +8,7 @@
 
 // code to be emulated
 #define SPARC_CODE "\x86\x00\x40\x02" // add %g1, %g2, %g3;
-//#define SPARC_CODE "\xbb\x70\x00\x00" // illegal code
+// #define SPARC_CODE "\xbb\x70\x00\x00" // illegal code
 
 // memory address where emulation starts
 #define ADDRESS 0x10000

diff --git a/samples/sample_x86.c b/samples/sample_x86.c
@@ -13,7 +13,7 @@
     "\xeb\x02\x90\x90\x90\x90\x90\x90" // jmp 4; nop; nop; nop; nop; nop; nop
 // #define X86_CODE32_SELF
 // "\xeb\x1c\x5a\x89\xd6\x8b\x02\x66\x3d\xca\x7d\x75\x06\x66\x05\x03\x03\x89\x02\xfe\xc2\x3d\x41\x41\x41\x41\x75\xe9\xff\xe6\xe8\xdf\xff\xff\xff\x31\xd2\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xca\x7d\x41\x41\x41\x41"
-//#define X86_CODE32 "\x51\x51\x51\x51" // PUSH ecx;
+// #define X86_CODE32 "\x51\x51\x51\x51" // PUSH ecx;
 #define X86_CODE32_LOOP "\x41\x4a\xeb\xfe" // INC ecx; DEC edx; JMP self-loop
 #define X86_CODE32_MEM_WRITE                                                   \
     "\x89\x0D\xAA\xAA\xAA\xAA\x41\x4a" // mov [0xaaaaaaaa], ecx; INC ecx; DEC
@@ -30,7 +30,7 @@
                                    // AL; INC ebx
 #define X86_CODE32_INC "\x40"      // INC eax
 
-//#define X86_CODE64 "\x41\xBC\x3B\xB0\x28\x2A \x49\x0F\xC9 \x90
+// #define X86_CODE64 "\x41\xBC\x3B\xB0\x28\x2A \x49\x0F\xC9 \x90
 //\x4D\x0F\xAD\xCF\x49\x87\xFD\x90\x48\x81\xD2\x8A\xCE\x77\x35\x48\xF7\xD9" //
 //<== still crash #define X86_CODE64
 //"\x41\xBC\x3B\xB0\x28\x2A\x49\x0F\xC9\x90\x4D\x0F\xAD\xCF\x49\x87\xFD\x90\x48\x81\xD2\x8A\xCE\x77\x35\x48\xF7\xD9"

diff --git a/tests/unit/acutest.h b/tests/unit/acutest.h
@@ -270,7 +270,8 @@
 #include <string.h>
 #include <setjmp.h>
 
-#if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__) || defined(__HAIKU__)
+#if defined(unix) || defined(__unix__) || defined(__unix) ||                   \
+    defined(__APPLE__) || defined(__HAIKU__)
 #define ACUTEST_UNIX_ 1
 #include <errno.h>
 #include <libgen.h>