style: align pointer "*" to the right

1 files changed, 165 insertions, 165 deletions

diff --git a/yjit_asm.c b/yjit_asm.c
index 001856395f..4b7205e14a 100644
--- a/yjit_asm.c
+++ b/yjit_asm.c
@@ -128,7 +128,7 @@ x86opnd_t const_ptr_opnd(const void *ptr)
 }
 
 // Align the current write position to a multiple of bytes
-static uint8_t* align_ptr(uint8_t* ptr, uint32_t multiple)
+static uint8_t *align_ptr(uint8_t *ptr, uint32_t multiple)
 {
     // Compute the pointer modulo the given alignment boundary
     uint32_t rem = ((uint32_t)(uintptr_t)ptr) % multiple;
@@ -144,16 +144,16 @@ static uint8_t* align_ptr(uint8_t* ptr, uint32_t multiple)
 }
 
 // Allocate a block of executable memory
-uint8_t* alloc_exec_mem(uint32_t mem_size)
+uint8_t *alloc_exec_mem(uint32_t mem_size)
 {
 #ifndef _WIN32
-    uint8_t* mem_block;
+    uint8_t *mem_block;
 
     // On Linux
     #if defined(MAP_FIXED_NOREPLACE) && defined(_SC_PAGESIZE)
         // Align the requested address to page size
         uint32_t page_size = (uint32_t)sysconf(_SC_PAGESIZE);
-        uint8_t* req_addr = align_ptr((uint8_t*)&alloc_exec_mem, page_size);
+        uint8_t *req_addr = align_ptr((uint8_t*)&alloc_exec_mem, page_size);
 
         while (req_addr < (uint8_t*)&alloc_exec_mem + INT32_MAX)
         {
@@ -223,16 +223,16 @@ uint8_t* alloc_exec_mem(uint32_t mem_size)
 code_page_t *freelist = NULL;
 
 // Allocate a single code page from a pool of free pages
-code_page_t* alloc_code_page()
+code_page_t *alloc_code_page()
 {
     // If the free list is empty
     if (!freelist) {
         // Allocate many pages at once
-        uint8_t* code_chunk = alloc_exec_mem(PAGES_PER_ALLOC * CODE_PAGE_SIZE);
+        uint8_t *code_chunk = alloc_exec_mem(PAGES_PER_ALLOC * CODE_PAGE_SIZE);
 
         // Do this in reverse order so we allocate our pages in order
         for (int i = PAGES_PER_ALLOC - 1; i >= 0; --i) {
-            code_page_t* code_page = malloc(sizeof(code_page_t));
+            code_page_t *code_page = malloc(sizeof(code_page_t));
             code_page->mem_block = code_chunk + i * CODE_PAGE_SIZE;
             assert ((intptr_t)code_page->mem_block % CODE_PAGE_SIZE == 0);
             code_page->page_size = CODE_PAGE_SIZE;
@@ -241,21 +241,21 @@ code_page_t* alloc_code_page()
         }
     }
 
-    code_page_t* free_page = freelist;
+    code_page_t *free_page = freelist;
     freelist = freelist->_next;
 
     return free_page;
 }
 
 // Put a code page back into the allocation pool
-void free_code_page(code_page_t* code_page)
+void free_code_page(code_page_t *code_page)
 {
     code_page->_next = freelist;
     freelist = code_page;
 }
 
 // Initialize a code block object
-void cb_init(codeblock_t* cb, uint8_t* mem_block, uint32_t mem_size)
+void cb_init(codeblock_t *cb, uint8_t *mem_block, uint32_t mem_size)
 {
     assert (mem_block);
     cb->mem_block = mem_block;
@@ -266,11 +266,11 @@ void cb_init(codeblock_t* cb, uint8_t* mem_block, uint32_t mem_size)
 }
 
 // Align the current write position to a multiple of bytes
-void cb_align_pos(codeblock_t* cb, uint32_t multiple)
+void cb_align_pos(codeblock_t *cb, uint32_t multiple)
 {
     // Compute the pointer modulo the given alignment boundary
-    uint8_t* ptr = &cb->mem_block[cb->write_pos];
-    uint8_t* aligned_ptr = align_ptr(ptr, multiple);
+    uint8_t *ptr = &cb->mem_block[cb->write_pos];
+    uint8_t *aligned_ptr = align_ptr(ptr, multiple);
 
     // Pad the pointer by the necessary amount to align it
     ptrdiff_t pad = aligned_ptr - ptr;
@@ -278,14 +278,14 @@ void cb_align_pos(codeblock_t* cb, uint32_t multiple)
 }
 
 // Set the current write position
-void cb_set_pos(codeblock_t* cb, uint32_t pos)
+void cb_set_pos(codeblock_t *cb, uint32_t pos)
 {
     assert (pos < cb->mem_size);
     cb->write_pos = pos;
 }
 
 // Set the current write position from a pointer
-void cb_set_write_ptr(codeblock_t* cb, uint8_t* code_ptr)
+void cb_set_write_ptr(codeblock_t *cb, uint8_t *code_ptr)
 {
     intptr_t pos = code_ptr - cb->mem_block;
     assert (pos < cb->mem_size);
@@ -293,20 +293,20 @@ void cb_set_write_ptr(codeblock_t* cb, uint8_t* code_ptr)
 }
 
 // Get a direct pointer into the executable memory block
-uint8_t* cb_get_ptr(codeblock_t* cb, uint32_t index)
+uint8_t *cb_get_ptr(codeblock_t *cb, uint32_t index)
 {
     assert (index < cb->mem_size);
     return &cb->mem_block[index];
 }
 
 // Get a direct pointer to the current write position
-uint8_t* cb_get_write_ptr(codeblock_t* cb)
+uint8_t *cb_get_write_ptr(codeblock_t *cb)
 {
     return cb_get_ptr(cb, cb->write_pos);
 }
 
 // Write a byte at the current position
-void cb_write_byte(codeblock_t* cb, uint8_t byte)
+void cb_write_byte(codeblock_t *cb, uint8_t byte)
 {
     assert (cb->mem_block);
     assert (cb->write_pos + 1 <= cb->mem_size);
@@ -314,7 +314,7 @@ void cb_write_byte(codeblock_t* cb, uint8_t byte)
 }
 
 // Write multiple bytes starting from the current position
-void cb_write_bytes(codeblock_t* cb, uint32_t num_bytes, ...)
+void cb_write_bytes(codeblock_t *cb, uint32_t num_bytes, ...)
 {
     va_list va;
     va_start(va, num_bytes);
@@ -329,7 +329,7 @@ void cb_write_bytes(codeblock_t* cb, uint32_t num_bytes, ...)
 }
 
 // Write a signed integer over a given number of bits at the current position
-void cb_write_int(codeblock_t* cb, uint64_t val, uint32_t num_bits)
+void cb_write_int(codeblock_t *cb, uint64_t val, uint32_t num_bits)
 {
     assert (num_bits > 0);
     assert (num_bits % 8 == 0);
@@ -378,7 +378,7 @@ void cb_write_int(codeblock_t* cb, uint64_t val, uint32_t num_bits)
 }
 
 // Allocate a new label with a given name
-uint32_t cb_new_label(codeblock_t* cb, const char* name)
+uint32_t cb_new_label(codeblock_t *cb, const char *name)
 {
     //if (hasASM)
     //    writeString(to!string(label) ~ ":");
@@ -396,14 +396,14 @@ uint32_t cb_new_label(codeblock_t* cb, const char* name)
 }
 
 // Write a label at the current address
-void cb_write_label(codeblock_t* cb, uint32_t label_idx)
+void cb_write_label(codeblock_t *cb, uint32_t label_idx)
 {
     assert (label_idx < MAX_LABELS);
     cb->label_addrs[label_idx] = cb->write_pos;
 }
 
 // Add a label reference at the current write position
-void cb_label_ref(codeblock_t* cb, uint32_t label_idx)
+void cb_label_ref(codeblock_t *cb, uint32_t label_idx)
 {
     assert (label_idx < MAX_LABELS);
     assert (cb->num_refs < MAX_LABEL_REFS);
@@ -414,7 +414,7 @@ void cb_label_ref(codeblock_t* cb, uint32_t label_idx)
 }
 
 // Link internal label references
-void cb_link_labels(codeblock_t* cb)
+void cb_link_labels(codeblock_t *cb)
 {
     uint32_t orig_pos = cb->write_pos;
 
@@ -516,7 +516,7 @@ uint32_t disp_size(x86opnd_t opnd)
 
 // Write the REX byte
 static void cb_write_rex(
-    codeblock_t* cb,
+    codeblock_t *cb,
     bool w_flag,
     uint8_t reg_no,
     uint8_t idx_reg_no,
@@ -539,7 +539,7 @@ static void cb_write_rex(
 }
 
 // Write an opcode byte with an embedded register operand
-static void cb_write_opcode(codeblock_t* cb, uint8_t opcode, x86opnd_t reg)
+static void cb_write_opcode(codeblock_t *cb, uint8_t opcode, x86opnd_t reg)
 {
     // Write the reg field into the opcode byte
     uint8_t op_byte = opcode | (reg.as.reg.reg_no & 7);
@@ -548,7 +548,7 @@ static void cb_write_opcode(codeblock_t* cb, uint8_t opcode, x86opnd_t reg)
 
 // Encode an RM instruction
 void cb_write_rm(
-    codeblock_t* cb,
+    codeblock_t *cb,
     bool szPref,
     bool rexW,
     x86opnd_t r_opnd,
@@ -709,8 +709,8 @@ void cb_write_rm(
 
 // Encode a mul-like single-operand RM instruction
 void write_rm_unary(
-    codeblock_t* cb,
-    const char* mnem,
+    codeblock_t *cb,
+    const char *mnem,
     uint8_t opMemReg8,
     uint8_t opMemRegPref,
     uint8_t opExt,
@@ -738,8 +738,8 @@ void write_rm_unary(
 
 // Encode an add-like RM instruction with multiple possible encodings
 void cb_write_rm_multi(
-    codeblock_t* cb,
-    const char* mnem,
+    codeblock_t *cb,
+    const char *mnem,
     uint8_t opMemReg8,
     uint8_t opMemRegPref,
     uint8_t opRegMem8,
@@ -837,8 +837,8 @@ void cb_write_rm_multi(
 
 // Encode a single-operand shift instruction
 void cb_write_shift(
-    codeblock_t* cb,
-    const char* mnem,
+    codeblock_t *cb,
+    const char *mnem,
     uint8_t opMemOnePref,
     uint8_t opMemClPref,
     uint8_t opMemImmPref,
@@ -887,7 +887,7 @@ void cb_write_shift(
 
 // Encode a relative jump to a label (direct or conditional)
 // Note: this always encodes a 32-bit offset
-void cb_write_jcc(codeblock_t* cb, const char* mnem, uint8_t op0, uint8_t op1, uint32_t label_idx)
+void cb_write_jcc(codeblock_t *cb, const char *mnem, uint8_t op0, uint8_t op1, uint32_t label_idx)
 {
     //cb.writeASM(mnem, label);
 
@@ -904,7 +904,7 @@ void cb_write_jcc(codeblock_t* cb, const char* mnem, uint8_t op0, uint8_t op1, u
 }
 
 // Encode a relative jump to a pointer at a 32-bit offset (direct or conditional)
-void cb_write_jcc_ptr(codeblock_t* cb, const char* mnem, uint8_t op0, uint8_t op1, uint8_t* dst_ptr)
+void cb_write_jcc_ptr(codeblock_t *cb, const char *mnem, uint8_t op0, uint8_t op1, uint8_t *dst_ptr)
 {
     //cb.writeASM(mnem, label);
 
@@ -914,7 +914,7 @@ void cb_write_jcc_ptr(codeblock_t* cb, const char* mnem, uint8_t op0, uint8_t op
     cb_write_byte(cb, op1);
 
     // Pointer to the end of this jump instruction
-    uint8_t* end_ptr = &cb->mem_block[cb->write_pos] + 4;
+    uint8_t *end_ptr = &cb->mem_block[cb->write_pos] + 4;
 
     // Compute the jump offset
     int64_t rel64 = (int64_t)(dst_ptr - end_ptr);
@@ -925,7 +925,7 @@ void cb_write_jcc_ptr(codeblock_t* cb, const char* mnem, uint8_t op0, uint8_t op
 }
 
 // Encode a conditional move instruction
-void cb_write_cmov(codeblock_t* cb, const char* mnem, uint8_t opcode1, x86opnd_t dst, x86opnd_t src)
+void cb_write_cmov(codeblock_t *cb, const char *mnem, uint8_t opcode1, x86opnd_t dst, x86opnd_t src)
 {
     //cb.writeASM(mnem, dst, src);
 
@@ -940,7 +940,7 @@ void cb_write_cmov(codeblock_t* cb, const char* mnem, uint8_t opcode1, x86opnd_t
 }
 
 // add - Integer addition
-void add(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void add(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_rm_multi(
         cb,
@@ -959,7 +959,7 @@ void add(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 /// and - Bitwise AND
-void and(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void and(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_rm_multi(
         cb,
@@ -978,7 +978,7 @@ void and(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 // call - Call to a pointer with a 32-bit displacement offset
-void call_rel32(codeblock_t* cb, int32_t rel32)
+void call_rel32(codeblock_t *cb, int32_t rel32)
 {
     //cb.writeASM("call", rel32);
 
@@ -990,12 +990,12 @@ void call_rel32(codeblock_t* cb, int32_t rel32)
 }
 
 // call - Call a pointer, encode with a 32-bit offset if possible
-void call_ptr(codeblock_t* cb, x86opnd_t scratch_reg, uint8_t* dst_ptr)
+void call_ptr(codeblock_t *cb, x86opnd_t scratch_reg, uint8_t *dst_ptr)
 {
     assert (scratch_reg.type == OPND_REG);
 
     // Pointer to the end of this call instruction
-    uint8_t* end_ptr = &cb->mem_block[cb->write_pos] + 5;
+    uint8_t *end_ptr = &cb->mem_block[cb->write_pos] + 5;
 
     // Compute the jump offset
     int64_t rel64 = (int64_t)(dst_ptr - end_ptr);
@@ -1013,7 +1013,7 @@ void call_ptr(codeblock_t* cb, x86opnd_t scratch_reg, uint8_t* dst_ptr)
 }
 
 /// call - Call to label with 32-bit offset
-void call_label(codeblock_t* cb, uint32_t label_idx)
+void call_label(codeblock_t *cb, uint32_t label_idx)
 {
     //cb.writeASM("call", label);
 
@@ -1028,46 +1028,46 @@ void call_label(codeblock_t* cb, uint32_t label_idx)
 }
 
 /// call - Indirect call with an R/M operand
-void call(codeblock_t* cb, x86opnd_t opnd)
+void call(codeblock_t *cb, x86opnd_t opnd)
 {
     //cb.writeASM("call", opnd);
     cb_write_rm(cb, false, false, NO_OPND, opnd, 2, 1, 0xFF);
 }
 
 /// cmovcc - Conditional move
-void cmova(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmova", 0x47, dst, src); }
-void cmovae(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovae", 0x43, dst, src); }
-void cmovb(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovb", 0x42, dst, src); }
-void cmovbe(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovbe", 0x46, dst, src); }
-void cmovc(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovc", 0x42, dst, src); }
-void cmove(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmove", 0x44, dst, src); }
-void cmovg(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovg", 0x4F, dst, src); }
-void cmovge(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovge", 0x4D, dst, src); }
-void cmovl(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovl", 0x4C, dst, src); }
-void cmovle(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovle", 0x4E, dst, src); }
-void cmovna(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovna", 0x46, dst, src); }
-void cmovnae(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnae", 0x42, dst, src); }
-void cmovnb(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnb", 0x43, dst, src); }
-void cmovnbe(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnbe", 0x47, dst, src); }
-void cmovnc(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnc", 0x43, dst, src); }
-void cmovne(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovne", 0x45, dst, src); }
-void cmovng(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovng", 0x4E, dst, src); }
-void cmovnge(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnge", 0x4C, dst, src); }
-void cmovnl(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnl" , 0x4D, dst, src); }
-void cmovnle(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnle", 0x4F, dst, src); }
-void cmovno(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovno", 0x41, dst, src); }
-void cmovnp(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnp", 0x4B, dst, src); }
-void cmovns(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovns", 0x49, dst, src); }
-void cmovnz(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnz", 0x45, dst, src); }
-void cmovo(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovo", 0x40, dst, src); }
-void cmovp(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovp", 0x4A, dst, src); }
-void cmovpe(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovpe", 0x4A, dst, src); }
-void cmovpo(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovpo", 0x4B, dst, src); }
-void cmovs(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovs", 0x48, dst, src); }
-void cmovz(codeblock_t* cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovz", 0x44, dst, src); }
+void cmova(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmova", 0x47, dst, src); }
+void cmovae(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovae", 0x43, dst, src); }
+void cmovb(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovb", 0x42, dst, src); }
+void cmovbe(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovbe", 0x46, dst, src); }
+void cmovc(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovc", 0x42, dst, src); }
+void cmove(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmove", 0x44, dst, src); }
+void cmovg(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovg", 0x4F, dst, src); }
+void cmovge(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovge", 0x4D, dst, src); }
+void cmovl(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovl", 0x4C, dst, src); }
+void cmovle(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovle", 0x4E, dst, src); }
+void cmovna(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovna", 0x46, dst, src); }
+void cmovnae(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnae", 0x42, dst, src); }
+void cmovnb(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnb", 0x43, dst, src); }
+void cmovnbe(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnbe", 0x47, dst, src); }
+void cmovnc(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnc", 0x43, dst, src); }
+void cmovne(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovne", 0x45, dst, src); }
+void cmovng(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovng", 0x4E, dst, src); }
+void cmovnge(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnge", 0x4C, dst, src); }
+void cmovnl(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnl" , 0x4D, dst, src); }
+void cmovnle(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnle", 0x4F, dst, src); }
+void cmovno(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovno", 0x41, dst, src); }
+void cmovnp(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnp", 0x4B, dst, src); }
+void cmovns(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovns", 0x49, dst, src); }
+void cmovnz(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovnz", 0x45, dst, src); }
+void cmovo(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovo", 0x40, dst, src); }
+void cmovp(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovp", 0x4A, dst, src); }
+void cmovpe(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovpe", 0x4A, dst, src); }
+void cmovpo(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovpo", 0x4B, dst, src); }
+void cmovs(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovs", 0x48, dst, src); }
+void cmovz(codeblock_t *cb, x86opnd_t dst, x86opnd_t src) { cb_write_cmov(cb, "cmovz", 0x44, dst, src); }
 
 /// cmp - Compare and set flags
-void cmp(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void cmp(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_rm_multi(
         cb,
@@ -1086,21 +1086,21 @@ void cmp(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 /// cdq - Convert doubleword to quadword
-void cdq(codeblock_t* cb)
+void cdq(codeblock_t *cb)
 {
     //cb.writeASM("cdq");
     cb_write_byte(cb, 0x99);
 }
 
 /// cqo - Convert quadword to octaword
-void cqo(codeblock_t* cb)
+void cqo(codeblock_t *cb)
 {
     //cb.writeASM("cqo");
     cb_write_bytes(cb, 2, 0x48, 0x99);
 }
 
 /// Interrupt 3 - trap to debugger
-void int3(codeblock_t* cb)
+void int3(codeblock_t *cb)
 {
     //cb.writeASM("INT 3");
     cb_write_byte(cb, 0xCC);
@@ -1205,80 +1205,80 @@ void imul(CodeBlock cb, X86Opnd opnd0, X86Opnd opnd1, X86Opnd opnd2)
 */
 
 /// jcc - relative jumps to a label
-void ja_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "ja"  , 0x0F, 0x87, label_idx); }
-void jae_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jae" , 0x0F, 0x83, label_idx); }
-void jb_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jb"  , 0x0F, 0x82, label_idx); }
-void jbe_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jbe" , 0x0F, 0x86, label_idx); }
-void jc_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jc"  , 0x0F, 0x82, label_idx); }
-void je_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "je"  , 0x0F, 0x84, label_idx); }
-void jg_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jg"  , 0x0F, 0x8F, label_idx); }
-void jge_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jge" , 0x0F, 0x8D, label_idx); }
-void jl_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jl"  , 0x0F, 0x8C, label_idx); }
-void jle_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jle" , 0x0F, 0x8E, label_idx); }
-void jna_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jna" , 0x0F, 0x86, label_idx); }
-void jnae_label(codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnae", 0x0F, 0x82, label_idx); }
-void jnb_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnb" , 0x0F, 0x83, label_idx); }
-void jnbe_label(codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnbe", 0x0F, 0x87, label_idx); }
-void jnc_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnc" , 0x0F, 0x83, label_idx); }
-void jne_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jne" , 0x0F, 0x85, label_idx); }
-void jng_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jng" , 0x0F, 0x8E, label_idx); }
-void jnge_label(codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnge", 0x0F, 0x8C, label_idx); }
-void jnl_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnl" , 0x0F, 0x8D, label_idx); }
-void jnle_label(codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnle", 0x0F, 0x8F, label_idx); }
-void jno_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jno" , 0x0F, 0x81, label_idx); }
-void jnp_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnp" , 0x0F, 0x8b, label_idx); }
-void jns_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jns" , 0x0F, 0x89, label_idx); }
-void jnz_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jnz" , 0x0F, 0x85, label_idx); }
-void jo_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jo"  , 0x0F, 0x80, label_idx); }
-void jp_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jp"  , 0x0F, 0x8A, label_idx); }
-void jpe_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jpe" , 0x0F, 0x8A, label_idx); }
-void jpo_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jpo" , 0x0F, 0x8B, label_idx); }
-void js_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "js"  , 0x0F, 0x88, label_idx); }
-void jz_label  (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jz"  , 0x0F, 0x84, label_idx); }
-void jmp_label (codeblock_t* cb, uint32_t label_idx) { cb_write_jcc(cb, "jmp" , 0xFF, 0xE9, label_idx); }
+void ja_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "ja"  , 0x0F, 0x87, label_idx); }
+void jae_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jae" , 0x0F, 0x83, label_idx); }
+void jb_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jb"  , 0x0F, 0x82, label_idx); }
+void jbe_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jbe" , 0x0F, 0x86, label_idx); }
+void jc_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jc"  , 0x0F, 0x82, label_idx); }
+void je_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "je"  , 0x0F, 0x84, label_idx); }
+void jg_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jg"  , 0x0F, 0x8F, label_idx); }
+void jge_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jge" , 0x0F, 0x8D, label_idx); }
+void jl_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jl"  , 0x0F, 0x8C, label_idx); }
+void jle_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jle" , 0x0F, 0x8E, label_idx); }
+void jna_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jna" , 0x0F, 0x86, label_idx); }
+void jnae_label(codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnae", 0x0F, 0x82, label_idx); }
+void jnb_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnb" , 0x0F, 0x83, label_idx); }
+void jnbe_label(codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnbe", 0x0F, 0x87, label_idx); }
+void jnc_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnc" , 0x0F, 0x83, label_idx); }
+void jne_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jne" , 0x0F, 0x85, label_idx); }
+void jng_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jng" , 0x0F, 0x8E, label_idx); }
+void jnge_label(codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnge", 0x0F, 0x8C, label_idx); }
+void jnl_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnl" , 0x0F, 0x8D, label_idx); }
+void jnle_label(codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnle", 0x0F, 0x8F, label_idx); }
+void jno_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jno" , 0x0F, 0x81, label_idx); }
+void jnp_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnp" , 0x0F, 0x8b, label_idx); }
+void jns_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jns" , 0x0F, 0x89, label_idx); }
+void jnz_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jnz" , 0x0F, 0x85, label_idx); }
+void jo_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jo"  , 0x0F, 0x80, label_idx); }
+void jp_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jp"  , 0x0F, 0x8A, label_idx); }
+void jpe_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jpe" , 0x0F, 0x8A, label_idx); }
+void jpo_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jpo" , 0x0F, 0x8B, label_idx); }
+void js_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "js"  , 0x0F, 0x88, label_idx); }
+void jz_label  (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jz"  , 0x0F, 0x84, label_idx); }
+void jmp_label (codeblock_t *cb, uint32_t label_idx) { cb_write_jcc(cb, "jmp" , 0xFF, 0xE9, label_idx); }
 
 /// jcc - relative jumps to a pointer (32-bit offset)
-void ja_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "ja"  , 0x0F, 0x87, ptr); }
-void jae_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jae" , 0x0F, 0x83, ptr); }
-void jb_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jb"  , 0x0F, 0x82, ptr); }
-void jbe_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jbe" , 0x0F, 0x86, ptr); }
-void jc_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jc"  , 0x0F, 0x82, ptr); }
-void je_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "je"  , 0x0F, 0x84, ptr); }
-void jg_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jg"  , 0x0F, 0x8F, ptr); }
-void jge_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jge" , 0x0F, 0x8D, ptr); }
-void jl_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jl"  , 0x0F, 0x8C, ptr); }
-void jle_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jle" , 0x0F, 0x8E, ptr); }
-void jna_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jna" , 0x0F, 0x86, ptr); }
-void jnae_ptr(codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnae", 0x0F, 0x82, ptr); }
-void jnb_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnb" , 0x0F, 0x83, ptr); }
-void jnbe_ptr(codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnbe", 0x0F, 0x87, ptr); }
-void jnc_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnc" , 0x0F, 0x83, ptr); }
-void jne_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jne" , 0x0F, 0x85, ptr); }
-void jng_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jng" , 0x0F, 0x8E, ptr); }
-void jnge_ptr(codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnge", 0x0F, 0x8C, ptr); }
-void jnl_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnl" , 0x0F, 0x8D, ptr); }
-void jnle_ptr(codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnle", 0x0F, 0x8F, ptr); }
-void jno_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jno" , 0x0F, 0x81, ptr); }
-void jnp_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnp" , 0x0F, 0x8b, ptr); }
-void jns_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jns" , 0x0F, 0x89, ptr); }
-void jnz_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jnz" , 0x0F, 0x85, ptr); }
-void jo_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jo"  , 0x0F, 0x80, ptr); }
-void jp_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jp"  , 0x0F, 0x8A, ptr); }
-void jpe_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jpe" , 0x0F, 0x8A, ptr); }
-void jpo_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jpo" , 0x0F, 0x8B, ptr); }
-void js_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "js"  , 0x0F, 0x88, ptr); }
-void jz_ptr  (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jz"  , 0x0F, 0x84, ptr); }
-void jmp_ptr (codeblock_t* cb, uint8_t* ptr) { cb_write_jcc_ptr(cb, "jmp" , 0xFF, 0xE9, ptr); }
+void ja_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "ja"  , 0x0F, 0x87, ptr); }
+void jae_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jae" , 0x0F, 0x83, ptr); }
+void jb_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jb"  , 0x0F, 0x82, ptr); }
+void jbe_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jbe" , 0x0F, 0x86, ptr); }
+void jc_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jc"  , 0x0F, 0x82, ptr); }
+void je_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "je"  , 0x0F, 0x84, ptr); }
+void jg_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jg"  , 0x0F, 0x8F, ptr); }
+void jge_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jge" , 0x0F, 0x8D, ptr); }
+void jl_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jl"  , 0x0F, 0x8C, ptr); }
+void jle_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jle" , 0x0F, 0x8E, ptr); }
+void jna_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jna" , 0x0F, 0x86, ptr); }
+void jnae_ptr(codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnae", 0x0F, 0x82, ptr); }
+void jnb_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnb" , 0x0F, 0x83, ptr); }
+void jnbe_ptr(codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnbe", 0x0F, 0x87, ptr); }
+void jnc_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnc" , 0x0F, 0x83, ptr); }
+void jne_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jne" , 0x0F, 0x85, ptr); }
+void jng_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jng" , 0x0F, 0x8E, ptr); }
+void jnge_ptr(codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnge", 0x0F, 0x8C, ptr); }
+void jnl_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnl" , 0x0F, 0x8D, ptr); }
+void jnle_ptr(codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnle", 0x0F, 0x8F, ptr); }
+void jno_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jno" , 0x0F, 0x81, ptr); }
+void jnp_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnp" , 0x0F, 0x8b, ptr); }
+void jns_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jns" , 0x0F, 0x89, ptr); }
+void jnz_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jnz" , 0x0F, 0x85, ptr); }
+void jo_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jo"  , 0x0F, 0x80, ptr); }
+void jp_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jp"  , 0x0F, 0x8A, ptr); }
+void jpe_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jpe" , 0x0F, 0x8A, ptr); }
+void jpo_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jpo" , 0x0F, 0x8B, ptr); }
+void js_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "js"  , 0x0F, 0x88, ptr); }
+void jz_ptr  (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jz"  , 0x0F, 0x84, ptr); }
+void jmp_ptr (codeblock_t *cb, uint8_t *ptr) { cb_write_jcc_ptr(cb, "jmp" , 0xFF, 0xE9, ptr); }
 
 /// jmp - Indirect jump near to an R/M operand
-void jmp_rm(codeblock_t* cb, x86opnd_t opnd)
+void jmp_rm(codeblock_t *cb, x86opnd_t opnd)
 {
     //cb.writeASM("jmp", opnd);
     cb_write_rm(cb, false, false, NO_OPND, opnd, 4, 1, 0xFF);
 }
 
 // jmp - Jump with relative 32-bit offset
-void jmp32(codeblock_t* cb, int32_t offset)
+void jmp32(codeblock_t *cb, int32_t offset)
 {
     //cb.writeASM("jmp", ((offset > 0)? "+":"-") ~ to!string(offset));
     cb_write_byte(cb, 0xE9);
@@ -1286,7 +1286,7 @@ void jmp32(codeblock_t* cb, int32_t offset)
 }
 
 /// lea - Load Effective Address
-void lea(codeblock_t* cb, x86opnd_t dst, x86opnd_t src)
+void lea(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
 {
     //cb.writeASM("lea", dst, src);
     assert (dst.num_bits == 64);
@@ -1294,7 +1294,7 @@ void lea(codeblock_t* cb, x86opnd_t dst, x86opnd_t src)
 }
 
 /// mov - Data move operation
-void mov(codeblock_t* cb, x86opnd_t dst, x86opnd_t src)
+void mov(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
 {
     // R/M + Imm
     if (src.type == OPND_IMM)
@@ -1357,7 +1357,7 @@ void mov(codeblock_t* cb, x86opnd_t dst, x86opnd_t src)
 }
 
 /// movsx - Move with sign extension (signed integers)
-void movsx(codeblock_t* cb, x86opnd_t dst, x86opnd_t src)
+void movsx(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
 {
     assert (dst.type == OPND_REG);
     assert (src.type == OPND_REG || src.type == OPND_MEM);
@@ -1385,7 +1385,7 @@ void movsx(codeblock_t* cb, x86opnd_t dst, x86opnd_t src)
 
 /*
 /// movzx - Move with zero extension (unsigned values)
-void movzx(codeblock_t* cb, x86opnd_t dst, x86opnd_t src)
+void movzx(codeblock_t *cb, x86opnd_t dst, x86opnd_t src)
 {
     cb.writeASM("movzx", dst, src);
 
@@ -1424,7 +1424,7 @@ void movzx(codeblock_t* cb, x86opnd_t dst, x86opnd_t src)
 */
 
 // neg - Integer negation (multiplication by -1)
-void neg(codeblock_t* cb, x86opnd_t opnd)
+void neg(codeblock_t *cb, x86opnd_t opnd)
 {
     write_rm_unary(
         cb,
@@ -1437,7 +1437,7 @@ void neg(codeblock_t* cb, x86opnd_t opnd)
 }
 
 // nop - Noop, one or multiple bytes long
-void nop(codeblock_t* cb, uint32_t length)
+void nop(codeblock_t *cb, uint32_t length)
 {
     switch (length)
     {
@@ -1504,7 +1504,7 @@ void nop(codeblock_t* cb, uint32_t length)
 }
 
 // not - Bitwise NOT
-void not(codeblock_t* cb, x86opnd_t opnd)
+void not(codeblock_t *cb, x86opnd_t opnd)
 {
     write_rm_unary(
         cb,
@@ -1517,7 +1517,7 @@ void not(codeblock_t* cb, x86opnd_t opnd)
 }
 
 /// or - Bitwise OR
-void or(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void or(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_rm_multi(
         cb,
@@ -1536,7 +1536,7 @@ void or(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 /// pop - Pop a register off the stack
-void pop(codeblock_t* cb, x86opnd_t opnd)
+void pop(codeblock_t *cb, x86opnd_t opnd)
 {
     assert (opnd.num_bits == 64);
 
@@ -1554,7 +1554,7 @@ void pop(codeblock_t* cb, x86opnd_t opnd)
 }
 
 /// popfq - Pop the flags register (64-bit)
-void popfq(codeblock_t* cb)
+void popfq(codeblock_t *cb)
 {
     //cb.writeASM("popfq");
 
@@ -1563,7 +1563,7 @@ void popfq(codeblock_t* cb)
 }
 
 /// push - Push an operand on the stack
-void push(codeblock_t* cb, x86opnd_t opnd)
+void push(codeblock_t *cb, x86opnd_t opnd)
 {
     assert (opnd.num_bits == 64);
 
@@ -1581,21 +1581,21 @@ void push(codeblock_t* cb, x86opnd_t opnd)
 }
 
 /// pushfq - Push the flags register (64-bit)
-void pushfq(codeblock_t* cb)
+void pushfq(codeblock_t *cb)
 {
     //cb.writeASM("pushfq");
     cb_write_byte(cb, 0x9C);
 }
 
 /// ret - Return from call, popping only the return address
-void ret(codeblock_t* cb)
+void ret(codeblock_t *cb)
 {
     //cb.writeASM("ret");
     cb_write_byte(cb, 0xC3);
 }
 
 // sal - Shift arithmetic left
-void sal(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void sal(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_shift(
         cb,
@@ -1610,7 +1610,7 @@ void sal(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 /// sar - Shift arithmetic right (signed)
-void sar(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void sar(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_shift(
         cb,
@@ -1624,7 +1624,7 @@ void sar(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
     );
 }
 // shl - Shift logical left
-void shl(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void shl(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_shift(
         cb,
@@ -1639,7 +1639,7 @@ void shl(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 /// shr - Shift logical right (unsigned)
-void shr(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void shr(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_shift(
         cb,
@@ -1654,7 +1654,7 @@ void shr(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 /// sub - Integer subtraction
-void sub(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void sub(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_rm_multi(
         cb,
@@ -1673,7 +1673,7 @@ void sub(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 /// test - Logical Compare
-void test(codeblock_t* cb, x86opnd_t rm_opnd, x86opnd_t test_opnd)
+void test(codeblock_t *cb, x86opnd_t rm_opnd, x86opnd_t test_opnd)
 {
     assert (rm_opnd.type == OPND_REG || rm_opnd.type == OPND_MEM);
     assert (test_opnd.type == OPND_REG || test_opnd.type == OPND_IMM);
@@ -1728,13 +1728,13 @@ void test(codeblock_t* cb, x86opnd_t rm_opnd, x86opnd_t test_opnd)
 }
 
 /// Undefined opcode
-void ud2(codeblock_t* cb)
+void ud2(codeblock_t *cb)
 {
     cb_write_bytes(cb, 2, 0x0F, 0x0B);
 }
 
 /// xchg - Exchange Register/Memory with Register
-void xchg(codeblock_t* cb, x86opnd_t rm_opnd, x86opnd_t r_opnd)
+void xchg(codeblock_t *cb, x86opnd_t rm_opnd, x86opnd_t r_opnd)
 {
     assert (rm_opnd.num_bits == 64);
     assert (r_opnd.num_bits == 64);
@@ -1757,7 +1757,7 @@ void xchg(codeblock_t* cb, x86opnd_t rm_opnd, x86opnd_t r_opnd)
 }
 
 /// xor - Exclusive bitwise OR
-void xor(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
+void xor(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1)
 {
     cb_write_rm_multi(
         cb,
@@ -1776,7 +1776,7 @@ void xor(codeblock_t* cb, x86opnd_t opnd0, x86opnd_t opnd1)
 }
 
 // LOCK - lock prefix for atomic shared memory operations
-void cb_write_lock_prefix(codeblock_t* cb)
+void cb_write_lock_prefix(codeblock_t *cb)
 {
     cb_write_byte(cb, 0xF0);
 }