enable separate compilation

Makefile

@@ -142,7 +142,7 @@ build/v86.wasm: src/native/*.c src/native/*.h src/native/codegen/*.c src/native/
 	# -Wno-extra-semi
 	# EMCC_DEBUG=1  EMCC_WASM_BACKEND=1
 	# -fno-inline
-	emcc src/native/all.c src/native/codegen/codegen.c src/native/call-indirect.ll \
+	emcc src/native/*.c src/native/profiler/profiler.c src/native/codegen/codegen.c src/native/call-indirect.ll \
 	    -Isrc/native/ -Isrc/native/profiler/ \
 	    -Wall -Wpedantic -Wextra \
 	    -DDEBUG=false \
@@ -161,7 +161,7 @@ build/v86.wasm: src/native/*.c src/native/*.h src/native/codegen/*.c src/native/
 
 build/v86-debug.wasm: src/native/*.c src/native/*.h src/native/codegen/*.c src/native/codegen/*.h src/native/profiler/*
 	mkdir -p build
-	emcc src/native/all.c src/native/codegen/codegen.c src/native/call-indirect.ll \
+	emcc src/native/*.c src/native/profiler/profiler.c src/native/codegen/codegen.c src/native/call-indirect.ll \
 	    -Isrc/native/ -Isrc/native/profiler/ \
 	    -Wall -Wpedantic -Wextra \
 	    -Wno-bitwise-op-parentheses -Wno-gnu-binary-literal \

src/native/all.c

@@ -1,22 +0,0 @@
-#include <stdint.h>
-#include <math.h>
-#include <stdbool.h>
-
-extern void call_interrupt_vector(int32_t interrupt_nr, bool is_software_int, bool has_error_code, int32_t error_code);
-extern void throw_cpu_exception(void);
-extern double_t math_pow(double_t, double_t);
-
-#include "const.h"
-#include "global_pointers.h"
-#include "log.c"
-#include "cpu.c"
-#include "profiler.c"
-#include "memory.c"
-#include "modrm.c"
-#include "misc_instr.c"
-#include "arith.c"
-#include "fpu.c"
-#include "instructions.c"
-#include "instructions_0f.c"
-#include "string.c"
-#include "sse_instr.c"

src/native/arith.c

@@ -3,10 +3,15 @@
 #include <assert.h>
 #include <stdbool.h>
 
-#include <stdio.h>
-
 #include "const.h"
 #include "global_pointers.h"
+#include "cpu.h"
+#include "misc_instr.h"
+#include "memory.h"
+#include "log.h"
+#include "arith.h"
+
+extern int32_t int_log2(int32_t);
 
 int32_t add(int32_t dest_operand, int32_t source_operand, int32_t op_size)
 {
@@ -1132,8 +1137,6 @@ int32_t shld32(int32_t dest_operand, int32_t source_operand, int32_t count)
     return *last_result;
 }
 
-int32_t int_log2(int32_t);
-
 void bt_reg(int32_t bit_base, int32_t bit_offset)
 {
     *flags = (*flags & ~1) | (bit_base >> bit_offset & 1);

src/native/arith.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <stdint.h>
+
+int32_t add(int32_t dest_operand, int32_t source_operand, int32_t op_size);
+int32_t adc(int32_t dest_operand, int32_t source_operand, int32_t op_size);
+int32_t sub(int32_t dest_operand, int32_t source_operand, int32_t op_size);
+int32_t sbb(int32_t dest_operand, int32_t source_operand, int32_t op_size);
+int32_t add8(int32_t x, int32_t y);
+int32_t add16(int32_t x, int32_t y);
+int32_t add32(int32_t x, int32_t y);
+int32_t sub8(int32_t x, int32_t y);
+int32_t sub16(int32_t x, int32_t y);
+int32_t sub32(int32_t x, int32_t y);
+int32_t adc8(int32_t x, int32_t y);
+int32_t adc16(int32_t x, int32_t y);
+int32_t adc32(int32_t x, int32_t y);
+int32_t sbb8(int32_t x, int32_t y);
+int32_t sbb16(int32_t x, int32_t y);
+int32_t sbb32(int32_t x, int32_t y);
+void cmp8(int32_t x, int32_t y);
+void cmp16(int32_t x, int32_t y);
+void cmp32(int32_t x, int32_t y);
+int32_t inc(int32_t dest_operand, int32_t op_size);
+int32_t dec(int32_t dest_operand, int32_t op_size);
+int32_t inc8(int32_t x);
+int32_t inc16(int32_t x);
+int32_t inc32(int32_t x);
+int32_t dec8(int32_t x);
+int32_t dec16(int32_t x);
+int32_t dec32(int32_t x);
+int32_t neg(int32_t dest_operand, int32_t op_size);
+int32_t neg8(int32_t x);
+int32_t neg16(int32_t x);
+int32_t neg32(int32_t x);
+void mul8(int32_t source_operand);
+void imul8(int32_t source_operand);
+void mul16(uint32_t source_operand);
+void imul16(int32_t source_operand);
+int32_t imul_reg16(int32_t operand1, int32_t operand2);
+void mul32(int32_t source_operand);
+void imul32(int32_t source_operand);
+int32_t imul_reg32(int32_t operand1, int32_t operand2);
+int32_t xadd8(int32_t source_operand, int32_t reg);
+int32_t xadd16(int32_t source_operand, int32_t reg);
+int32_t xadd32(int32_t source_operand, int32_t reg);
+void bcd_daa(void);
+void bcd_das(void);
+void bcd_aad(int32_t imm8);
+void bcd_aaa(void);
+void bcd_aas(void);
+int32_t and(int32_t dest_operand, int32_t source_operand, int32_t op_size);
+int32_t or(int32_t dest_operand, int32_t source_operand, int32_t op_size);
+int32_t xor(int32_t dest_operand, int32_t source_operand, int32_t op_size);
+int32_t and8(int32_t x, int32_t y);
+int32_t and16(int32_t x, int32_t y);
+int32_t and32(int32_t x, int32_t y);
+void test8(int32_t x, int32_t y);
+void test16(int32_t x, int32_t y);
+void test32(int32_t x, int32_t y);
+int32_t or8(int32_t x, int32_t y);
+int32_t or16(int32_t x, int32_t y);
+int32_t or32(int32_t x, int32_t y);
+int32_t xor8(int32_t x, int32_t y);
+int32_t xor16(int32_t x, int32_t y);
+int32_t xor32(int32_t x, int32_t y);
+int32_t rol8(int32_t dest_operand, int32_t count);
+int32_t rol16(int32_t dest_operand, int32_t count);
+int32_t rol32(int32_t dest_operand, int32_t count);
+int32_t rcl8(int32_t dest_operand, int32_t count);
+int32_t rcl16(int32_t dest_operand, int32_t count);
+int32_t rcl32(int32_t dest_operand, int32_t count);
+int32_t ror8(int32_t dest_operand, int32_t count);
+int32_t ror16(int32_t dest_operand, int32_t count);
+int32_t ror32(int32_t dest_operand, int32_t count);
+int32_t rcr8(int32_t dest_operand, int32_t count);
+int32_t rcr16(int32_t dest_operand, int32_t count);
+int32_t rcr32(int32_t dest_operand, int32_t count);
+void div8(uint32_t source_operand);
+void idiv8(int32_t source_operand);
+void div16(uint32_t source_operand);
+void idiv16(int32_t source_operand);
+void div32(uint32_t source_operand);
+void idiv32(int32_t source_operand);
+int32_t shl8(int32_t dest_operand, int32_t count);
+int32_t shl16(int32_t dest_operand, int32_t count);
+int32_t shl32(int32_t dest_operand, int32_t count);
+int32_t shr8(int32_t dest_operand, int32_t count);
+int32_t shr16(int32_t dest_operand, int32_t count);
+int32_t shr32(int32_t dest_operand, int32_t count);
+int32_t sar8(int32_t dest_operand, int32_t count);
+int32_t sar16(int32_t dest_operand, int32_t count);
+int32_t sar32(int32_t dest_operand, int32_t count);
+int32_t shrd16(int32_t dest_operand, int32_t source_operand, int32_t count);
+int32_t shrd32(int32_t dest_operand, int32_t source_operand, int32_t count);
+int32_t shld16(int32_t dest_operand, int32_t source_operand, int32_t count);
+int32_t shld32(int32_t dest_operand, int32_t source_operand, int32_t count);
+void bt_reg(int32_t bit_base, int32_t bit_offset);
+int32_t btc_reg(int32_t bit_base, int32_t bit_offset);
+int32_t bts_reg(int32_t bit_base, int32_t bit_offset);
+int32_t btr_reg(int32_t bit_base, int32_t bit_offset);
+void bt_mem(int32_t virt_addr, int32_t bit_offset);
+void btc_mem(int32_t virt_addr, int32_t bit_offset);
+void btr_mem(int32_t virt_addr, int32_t bit_offset);
+void bts_mem(int32_t virt_addr, int32_t bit_offset);
+int32_t bsf16(int32_t old, int32_t bit_base);
+int32_t bsf32(int32_t old, int32_t bit_base);
+int32_t bsr16(int32_t old, int32_t bit_base);
+int32_t bsr32(int32_t old, int32_t bit_base);
+int32_t popcnt(int32_t v);
+uint32_t saturate_sw_to_ub(uint32_t v);
+int32_t saturate_sw_to_sb(int32_t v);
+uint32_t saturate_sd_to_sw(uint32_t v);
+uint32_t saturate_sd_to_sb(uint32_t v);
+int32_t saturate_sd_to_ub(int32_t v);
+uint32_t saturate_ud_to_ub(uint32_t v);
+int32_t saturate_uw(uint32_t v);

src/native/codegen/codegen.c

@@ -9,6 +9,7 @@
 #include "util.h"
 #include "wasm_util.h"
 #include "module_init.h"
+#include "global_pointers.h"
 
 static Buffer op = { .start = (uint8_t* const) 2048, .ptr = (uint8_t*) 2048, .len = 1024 };
 static Buffer cs = { .start = (uint8_t* const) 3072, .ptr = (uint8_t*) 3072, .len = 1024 };
@@ -23,16 +24,6 @@ extern int32_t read_imm16();
 extern int32_t read_imm32s();
 extern int32_t get_fn_index(char* fn, uint8_t fn_len, uint8_t type_index);
 
-extern uint8_t* const prefixes;
-extern int32_t* const instruction_pointer;
-extern uint32_t* const timestamp_counter;
-extern int32_t* const previous_ip;
-extern uint8_t* const reg8;
-extern uint16_t* const reg16;
-extern int8_t* const reg8s;
-extern int16_t* const reg16s;
-extern int32_t* const reg32s;
-
 static uint8_t* op_ptr_reset_location;
 static uint32_t import_table_size_reset_value;
 static uint32_t initial_import_count;

src/native/cpu.c

@@ -8,48 +8,26 @@
 #include "global_pointers.h"
 #include "profiler.h"
 #include "codegen/codegen.h"
+#include "log.h"
+#include "instructions.h"
+#include "memory.h"
+#include "shared.h"
+#include "modrm.h"
+#include "misc_instr.h"
+#include "cpu.h"
 
 // like memcpy, but only efficient for large (approximately 10k) sizes
 // See memcpy in https://github.com/kripken/emscripten/blob/master/src/library.js
-void* memcpy_large(void* dest, const void* src, size_t n);
-
-void writable_or_pagefault(int32_t, int32_t);
-int32_t translate_address_read(int32_t);
-int32_t translate_address_write(int32_t);
-int32_t read8(uint32_t);
-int32_t read16(uint32_t);
-int32_t read32s(uint32_t);
-int64_t read64s(uint32_t);
-int32_t read_aligned16(uint32_t addr);
-int32_t virt_boundary_read16(int32_t, int32_t);
-int32_t virt_boundary_read32s(int32_t, int32_t);
-void write8(uint32_t, int32_t);
-void write16(uint32_t, int32_t);
-void write32(uint32_t, int32_t);
-void write64(uint32_t, int64_t);
-void virt_boundary_write16(int32_t, int32_t, int32_t);
-void virt_boundary_write32(int32_t, int32_t, int32_t);
-
-bool cpu_exception_hook(int32_t);
-
-bool in_mapped_range(uint32_t);
-
-void trigger_gp(int32_t);
-void trigger_ud();
-void trigger_nm();
-
-int32_t safe_read8(int32_t);
-int32_t safe_read16(int32_t);
-int32_t safe_read32s(int32_t);
-
-void safe_write8(int32_t, int32_t);
-void safe_write16(int32_t, int32_t);
-void safe_write32(int32_t, int32_t);
-
-void fxsave(uint32_t);
-void fxrstor(uint32_t);
-
-int32_t do_page_translation(int32_t, bool, bool);
+extern void* memcpy_large(void* dest, const void* src, size_t n);
+extern void codegen_finalize(int32_t, int32_t, int32_t, int32_t);
+extern void codegen_finalize(int32_t, int32_t, int32_t, int32_t);
+extern int32_t do_page_translation(int32_t, bool, bool);
+extern bool cpu_exception_hook(int32_t);
+
+struct code_cache jit_cache_arr[WASM_TABLE_SIZE] = {{0, {0}, 0, 0, 0}};
+uint32_t jit_jump = 0;
+int32_t hot_code_addresses[HASH_PRIME] = {0};
+uint32_t group_dirtiness[1 + (0xffffffff >> DIRTY_ARR_SHIFT)] = {0};
 
 void after_jump()
 {
@@ -71,18 +49,6 @@ void branch_not_taken()
     after_jump();
 }
 
-
-int32_t getcf(void);
-int32_t getpf(void);
-int32_t getaf(void);
-int32_t getzf(void);
-int32_t getsf(void);
-int32_t getof(void);
-
-
-double_t microtick();
-
-
 int32_t get_eflags()
 {
     return (*flags & ~FLAGS_ALL) | !!getcf() | !!getpf() << 2 | !!getaf() << 4 |
@@ -229,11 +195,7 @@ int32_t get_seg_prefix_ds(int32_t offset) { return get_seg_prefix(DS) + offset;
 int32_t get_seg_prefix_ss(int32_t offset) { return get_seg_prefix(SS) + offset; }
 int32_t get_seg_prefix_cs(int32_t offset) { return get_seg_prefix(CS) + offset; }
 
-void run_instruction(int32_t);
-static int32_t resolve_modrm16(int32_t);
-static int32_t resolve_modrm32(int32_t);
-
-static int32_t modrm_resolve(int32_t modrm_byte)
+int32_t modrm_resolve(int32_t modrm_byte)
 {
     if(is_asize_32())
     {
@@ -250,10 +212,6 @@ uint32_t jit_hot_hash(uint32_t addr)
     return addr % HASH_PRIME;
 }
 
-static void jit_instruction(int32_t);
-void codegen_finalize(int32_t, int32_t, int32_t, int32_t);
-void codegen_call_cache(int32_t);
-
 void generate_instruction(int32_t opcode)
 {
     gen_set_previous_eip();
@@ -441,12 +399,12 @@ void cycle_internal()
 #endif
 }
 
-static void run_prefix_instruction()
+void run_prefix_instruction()
 {
     run_instruction(read_imm8() | is_osize_32() << 8);
 }
 
-static void jit_prefix_instruction()
+void jit_prefix_instruction()
 {
     //dbg_log("jit_prefix_instruction is32=%d", is_osize_32());
     jit_instruction(read_imm8() | is_osize_32() << 8);
@@ -737,42 +695,42 @@ void safe_write128(int32_t addr, union reg128 value)
     }
 }
 
-static int32_t get_reg8_index(int32_t index) { return index << 2 & 0xC | index >> 2 & 1; }
+int32_t get_reg8_index(int32_t index) { return index << 2 & 0xC | index >> 2 & 1; }
 
-static int32_t read_reg8(int32_t index)
+int32_t read_reg8(int32_t index)
 {
     return reg8[get_reg8_index(index)];
 }
 
-static void write_reg8(int32_t index, int32_t value)
+void write_reg8(int32_t index, int32_t value)
 {
     reg8[get_reg8_index(index)] = value;
 }
 
-static int32_t get_reg16_index(int32_t index) { return index << 1; }
+int32_t get_reg16_index(int32_t index) { return index << 1; }
 
-static int32_t read_reg16(int32_t index)
+int32_t read_reg16(int32_t index)
 {
     return reg16[get_reg16_index(index)];
 }
 
-static void write_reg16(int32_t index, int32_t value)
+void write_reg16(int32_t index, int32_t value)
 {
     reg16[get_reg16_index(index)] = value;
 }
 
 
-static int32_t read_reg32(int32_t index)
+int32_t read_reg32(int32_t index)
 {
     return reg32s[index];
 }
 
-static void write_reg32(int32_t index, int32_t value)
+void write_reg32(int32_t index, int32_t value)
 {
     reg32s[index] = value;
 }
 
-static void write_reg_osize(int32_t index, int32_t value)
+void write_reg_osize(int32_t index, int32_t value)
 {
     assert(index >= 0 && index < 8);
 

src/native/cpu.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "shared.h"
+
+void after_jump(void);
+void diverged(void);
+void branch_taken(void);
+void branch_not_taken(void);
+int32_t get_eflags(void);
+int32_t translate_address_read(int32_t address);
+int32_t translate_address_write(int32_t address);
+int32_t read_imm8(void);
+int32_t read_imm8s(void);
+int32_t read_imm16(void);
+int32_t read_imm32s(void);
+bool is_osize_32(void);
+bool is_asize_32(void);
+int32_t get_seg(int32_t segment);
+int32_t get_seg_prefix(int32_t default_segment);
+int32_t get_seg_prefix_ds(int32_t offset);
+int32_t get_seg_prefix_ss(int32_t offset);
+int32_t get_seg_prefix_cs(int32_t offset);
+int32_t modrm_resolve(int32_t modrm_byte);
+uint32_t jit_hot_hash(uint32_t addr);
+void generate_instruction(int32_t opcode);
+void cycle_internal(void);
+void run_prefix_instruction(void);
+void jit_prefix_instruction(void);
+void clear_prefixes(void);
+void segment_prefix_op(int32_t seg);
+void segment_prefix_op_jit(int32_t seg);
+void do_many_cycles_unsafe(void);
+void raise_exception(int32_t interrupt_nr);
+void raise_exception_with_code(int32_t interrupt_nr, int32_t error_code);
+void trigger_de(void);
+void trigger_ud(void);
+void trigger_nm(void);
+void trigger_gp(int32_t code);
+int32_t virt_boundary_read16(int32_t low, int32_t high);
+int32_t virt_boundary_read32s(int32_t low, int32_t high);
+void virt_boundary_write16(int32_t low, int32_t high, int32_t value);
+void virt_boundary_write32(int32_t low, int32_t high, int32_t value);
+int32_t safe_read8(int32_t addr);
+int32_t safe_read16(int32_t addr);
+int32_t safe_read32s(int32_t addr);
+union reg64 safe_read64s(int32_t addr);
+union reg128 safe_read128s(int32_t addr);
+void safe_write8(int32_t addr, int32_t value);
+void safe_write16(int32_t addr, int32_t value);
+void safe_write32(int32_t addr, int32_t value);
+void safe_write64(int32_t addr, int64_t value);
+void safe_write128(int32_t addr, union reg128 value);
+int32_t get_reg8_index(int32_t index);
+int32_t read_reg8(int32_t index);
+void write_reg8(int32_t index, int32_t value);
+int32_t get_reg16_index(int32_t index);
+int32_t read_reg16(int32_t index);
+void write_reg16(int32_t index, int32_t value);
+int32_t read_reg32(int32_t index);
+void write_reg32(int32_t index, int32_t value);
+void write_reg_osize(int32_t index, int32_t value);
+int32_t read_mmx32s(int32_t r);
+union reg64 read_mmx64s(int32_t r);
+void write_mmx64(int32_t r, int32_t low, int32_t high);
+void write_mmx_reg64(int32_t r, union reg64 data);
+union reg64 read_xmm64s(int32_t r);
+union reg128 read_xmm128s(int32_t r);
+void write_xmm64(int32_t r, union reg64 data);
+void write_xmm128(int32_t r, int32_t i0, int32_t i1, int32_t i2, int32_t i3);
+void write_xmm_reg128(int32_t r, union reg128 data);
+void clear_tlb(void);
+void task_switch_test_mmx(void);
+int32_t read_moffs(void);
+int32_t get_real_eip(void);
+int32_t get_stack_reg(void);
+void set_stack_reg(int32_t value);
+int32_t get_reg_asize(int32_t reg);
+void set_ecx_asize(int32_t value);
+void add_reg_asize(int32_t reg, int32_t value);
+int32_t decr_ecx_asize(void);
+uint64_t read_tsc(void);

src/native/fpu.c

@@ -1,12 +1,12 @@
 #include <stdint.h>
 #include <math.h>
-#include <assert.h>
 #include <stdbool.h>
 
-#include <stdio.h>
-
 #include "const.h"
 #include "global_pointers.h"
+#include "cpu.h"
+#include "log.h"
+#include "fpu.h"
 
 void fpu_set_tag_word(int32_t tag_word)
 {

src/native/fpu.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <stdint.h>
+#include <math.h>
+
+void fpu_set_tag_word(int32_t tag_word);
+void fpu_fcomi(double_t y);
+int32_t fpu_load_status_word(void);
+void fpu_set_status_word(int32_t sw);
+void fpu_store_m80(uint32_t addr, double_t n);
+double_t fpu_load_m80(uint32_t addr);

src/native/global_pointers.h

@@ -1,102 +1,100 @@
-#ifndef _GLOBAL_POINTERS_H
-#define _GLOBAL_POINTERS_H
+#pragma once
 
 #include <stdint.h>
 #include <stdbool.h>
 #include <math.h>
+
 #include "const.h"
 #include "shared.h"
 
-uint8_t* const reg8 = (uint8_t* const) 4;
-uint16_t* const reg16 = (uint16_t* const) 4;
-int8_t* const reg8s = (int8_t* const) 4;
-int16_t* const reg16s = (int16_t* const) 4;
-int32_t* const reg32s = (int32_t* const) 4;
-
-int32_t* const last_op1 = (int32_t* const) 512;
-int32_t* const last_op2 = (int32_t* const) 516;
-int32_t* const last_op_size = (int32_t* const) 520;
-int32_t* const last_add_result = (int32_t* const) 524;
-int32_t* const last_result = (int32_t* const) 528;
-int32_t* const flags_changed = (int32_t* const) 532;
-int32_t* const flags = (int32_t* const) 536;
+static uint8_t* const reg8 = (uint8_t* const) 4;
+static uint16_t* const reg16 = (uint16_t* const) 4;
+static int8_t* const reg8s = (int8_t* const) 4;
+static int16_t* const reg16s = (int16_t* const) 4;
+static int32_t* const reg32s = (int32_t* const) 4;
+
+static int32_t* const last_op1 = (int32_t* const) 512;
+static int32_t* const last_op2 = (int32_t* const) 516;
+static int32_t* const last_op_size = (int32_t* const) 520;
+static int32_t* const last_add_result = (int32_t* const) 524;
+static int32_t* const last_result = (int32_t* const) 528;
+static int32_t* const flags_changed = (int32_t* const) 532;
+static int32_t* const flags = (int32_t* const) 536;
 // gap 16
 
-bool* const a20_enabled = (bool* const) 552;
-int32_t* const instruction_pointer = (int32_t* const) 556;
-int32_t* const previous_ip = (int32_t* const) 560;
-
-int32_t* const idtr_size = (int32_t* const) 564;
-int32_t* const idtr_offset = (int32_t* const) 568;
-int32_t* const gdtr_size = (int32_t* const) 572;
-int32_t* const gdtr_offset = (int32_t* const) 576;
-int32_t* const cr = (int32_t* const) 580; // length 32
-
-uint8_t* const cpl = (uint8_t* const) 612;
-int32_t* const page_size_extensions = (int32_t* const) 616;
-int32_t* const last_virt_eip = (int32_t* const) 620;
-int32_t* const eip_phys = (int32_t* const) 624;
-int32_t* const last_virt_esp = (int32_t* const) 628;
-int32_t* const esp_phys = (int32_t* const) 632;
-int32_t* const sysenter_cs = (int32_t* const) 636;
-int32_t* const sysenter_esp = (int32_t* const) 640;
-int32_t* const sysenter_eip = (int32_t* const) 644;
-uint8_t* const prefixes = (uint8_t* const) 648;
-int32_t* const tsc_offset = (int32_t* const) 652;
-int32_t* const phys_addr = (int32_t* const) 656;
-int32_t* const phys_addr_high = (int32_t* const) 660;
-uint32_t* const timestamp_counter = (uint32_t* const) 664;
-
-uint16_t* const sreg = (uint16_t* const) 668;
-int32_t* const dreg = (int32_t* const) 684; // length 32
-int32_t* const fw_value = (int32_t* const) 720;
-bool* const segment_is_null = (bool* const) 724; // length 8
-int32_t* const segment_offsets = (int32_t* const) 736; // length 32
-uint32_t* const segment_limits = (uint32_t* const) 768; // length 32
-
-bool* const protected_mode = (bool* const) 800;
-bool* const is_32 = (bool* const) 804;
-bool* const stack_size_32 = (bool* const) 808;
-uint32_t* const memory_size = (uint32_t* const) 812;
-int32_t* const fpu_stack_empty = (int32_t* const) 816;
-
-bool* const paging = (bool* const) 820;
-
-int32_t* const mxcsr = (int32_t* const) 824;
-
-union reg128* const reg_xmm = (union reg128* const) 828; // length 128
-
-uint8_t* const codegen_buffers = (uint8_t* const) 2048; // length 2048
-
-uint8_t* const tlb_info = (uint8_t* const) 4096; // length 0x100000
-uint8_t* const tlb_info_global = (uint8_t* const) (4096 + 0x100000); // length 0x100000
-int32_t* const tlb_data = (int32_t* const) (4096 + 0x100000 + 0x100000); // length 0x100000*4
-
-uint8_t* const mem8 = (uint8_t* const) (4096 + 0x100000 * 6);
-uint16_t* const mem16 = (uint16_t* const) (4096 + 0x100000 * 6);
-int32_t* const mem32s = (int32_t* const) (4096 + 0x100000 * 6);
-
-float_t* const fpu_float32 = (float_t* const) 956;
-uint8_t* const fpu_float32_byte = (uint8_t* const) 956;
-int32_t* const fpu_float32_int = (int32_t* const) 956;
-
-double_t* const fpu_float64 = (double_t* const) 960;
-uint8_t* const fpu_float64_byte = (uint8_t* const) 960;
-int32_t* const fpu_float64_int = (int32_t* const) 960;
-
-uint32_t* const fpu_stack_ptr = (uint32_t* const) 1032;
-int32_t* const fpu_control_word = (int32_t* const) 1036;
-int32_t* const fpu_status_word = (int32_t* const) 1040;
-int32_t* const fpu_opcode = (int32_t* const) 1044;
-int32_t* const fpu_ip = (int32_t* const) 1048;
-int32_t* const fpu_ip_selector = (int32_t* const) 1052;
-int32_t* const fpu_dp = (int32_t* const) 1056;
-int32_t* const fpu_dp_selector = (int32_t* const) 1060;
-
-double_t* const fpu_st = (double_t* const) 968;
-uint8_t* const fpu_st8 = (uint8_t* const) 968;
-int32_t* const fpu_st32 = (int32_t* const) 968;
-
-union reg64* const reg_mmx = (union reg64* const) 1064; // length 64
-
-#endif
+static bool* const a20_enabled = (bool* const) 552;
+static int32_t* const instruction_pointer = (int32_t* const) 556;
+static int32_t* const previous_ip = (int32_t* const) 560;
+
+static int32_t* const idtr_size = (int32_t* const) 564;
+static int32_t* const idtr_offset = (int32_t* const) 568;
+static int32_t* const gdtr_size = (int32_t* const) 572;
+static int32_t* const gdtr_offset = (int32_t* const) 576;
+static int32_t* const cr = (int32_t* const) 580; // length 32
+
+static uint8_t* const cpl = (uint8_t* const) 612;
+static int32_t* const page_size_extensions = (int32_t* const) 616;
+static int32_t* const last_virt_eip = (int32_t* const) 620;
+static int32_t* const eip_phys = (int32_t* const) 624;
+static int32_t* const last_virt_esp = (int32_t* const) 628;
+static int32_t* const esp_phys = (int32_t* const) 632;
+static int32_t* const sysenter_cs = (int32_t* const) 636;
+static int32_t* const sysenter_esp = (int32_t* const) 640;
+static int32_t* const sysenter_eip = (int32_t* const) 644;
+static uint8_t* const prefixes = (uint8_t* const) 648;
+static int32_t* const tsc_offset = (int32_t* const) 652;
+static int32_t* const phys_addr = (int32_t* const) 656;
+static int32_t* const phys_addr_high = (int32_t* const) 660;
+static uint32_t* const timestamp_counter = (uint32_t* const) 664;
+
+static uint16_t* const sreg = (uint16_t* const) 668;
+static int32_t* const dreg = (int32_t* const) 684; // length 32
+static int32_t* const fw_value = (int32_t* const) 720;
+static bool* const segment_is_null = (bool* const) 724; // length 8
+static int32_t* const segment_offsets = (int32_t* const) 736; // length 32
+static uint32_t* const segment_limits = (uint32_t* const) 768; // length 32
+
+static bool* const protected_mode = (bool* const) 800;
+static bool* const is_32 = (bool* const) 804;
+static bool* const stack_size_32 = (bool* const) 808;
+static uint32_t* const memory_size = (uint32_t* const) 812;
+static int32_t* const fpu_stack_empty = (int32_t* const) 816;
+
+static bool* const paging = (bool* const) 820;
+
+static int32_t* const mxcsr = (int32_t* const) 824;
+
+static union reg128* const reg_xmm = (union reg128* const) 828; // length 128
+
+static uint8_t* const codegen_buffers = (uint8_t* const) 2048; // length 2048
+
+static uint8_t* const tlb_info = (uint8_t* const) 4096; // length 0x100000
+static uint8_t* const tlb_info_global = (uint8_t* const) (4096 + 0x100000); // length 0x100000
+static int32_t* const tlb_data = (int32_t* const) (4096 + 0x100000 + 0x100000); // length 0x100000*4
+
+static uint8_t* const mem8 = (uint8_t* const) (4096 + 0x100000 * 6);
+static uint16_t* const mem16 = (uint16_t* const) (4096 + 0x100000 * 6);
+static int32_t* const mem32s = (int32_t* const) (4096 + 0x100000 * 6);
+
+static float_t* const fpu_float32 = (float_t* const) 956;
+static uint8_t* const fpu_float32_byte = (uint8_t* const) 956;
+static int32_t* const fpu_float32_int = (int32_t* const) 956;
+
+static double_t* const fpu_float64 = (double_t* const) 960;
+static uint8_t* const fpu_float64_byte = (uint8_t* const) 960;
+static int32_t* const fpu_float64_int = (int32_t* const) 960;
+
+static uint32_t* const fpu_stack_ptr = (uint32_t* const) 1032;
+static int32_t* const fpu_control_word = (int32_t* const) 1036;
+static int32_t* const fpu_status_word = (int32_t* const) 1040;
+static int32_t* const fpu_opcode = (int32_t* const) 1044;
+static int32_t* const fpu_ip = (int32_t* const) 1048;
+static int32_t* const fpu_ip_selector = (int32_t* const) 1052;
+static int32_t* const fpu_dp = (int32_t* const) 1056;
+static int32_t* const fpu_dp_selector = (int32_t* const) 1060;
+
+static double_t* const fpu_st = (double_t* const) 968;
+static uint8_t* const fpu_st8 = (uint8_t* const) 968;
+static int32_t* const fpu_st32 = (int32_t* const) 968;
+
+static union reg64* const reg_mmx = (union reg64* const) 1064; // length 64

src/native/instructions.c

@@ -3,304 +3,69 @@
 #include <assert.h>
 #include <stdbool.h>
 
-#include <stdio.h>
-
 #include "const.h"
 #include "global_pointers.h"
+#include "log.h"
+#include "arith.h"
+#include "cpu.h"
+#include "shared.h"
+#include "misc_instr.h"
+#include "string.h"
+#include "memory.h"
 #include "codegen/codegen.h"
+#include "instructions_0f.h"
+#include "instructions.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 
-int32_t translate_address_write(int32_t);
-int32_t resolve_modrm(int32_t);
-
-
-#define SAFE_READ_WRITE8(addr, fun) \
-    int32_t phys_addr = translate_address_write(addr); \
-    int32_t ___ = read8(phys_addr); \
-    write8(phys_addr, fun);
-
-#define SAFE_READ_WRITE16(addr, fun) \
-    int32_t phys_addr = translate_address_write(addr); \
-    if((phys_addr & 0xFFF) == 0xFFF) \
-    { \
-        int32_t phys_addr_high = translate_address_write(addr + 1); \
-        int32_t ___ = virt_boundary_read16(phys_addr, phys_addr_high); \
-        virt_boundary_write16(phys_addr, phys_addr_high, fun); \
-    } \
-    else \
-    { \
-        int32_t ___ = read16(phys_addr); \
-        write16(phys_addr, fun); \
-    }
-
-#define SAFE_READ_WRITE32(addr, fun) \
-    int32_t phys_addr = translate_address_write(addr); \
-    if((phys_addr & 0xFFF) >= 0xFFD) \
-    { \
-        int32_t phys_addr_high = translate_address_write(addr + 3 & ~3) | (addr + 3) & 3; \
-        int32_t ___ = virt_boundary_read32s(phys_addr, phys_addr_high); \
-        virt_boundary_write32(phys_addr, phys_addr_high, fun); \
-    } \
-    else \
-    { \
-        int32_t ___ = read32s(phys_addr); \
-        write32(phys_addr, fun); \
-    }
-
-// XXX: Remove these declarations when they are implemented in C
-void push16(int32_t);
-void push32(int32_t);
-
-void pusha16(void);
-void pusha32(void);
-void popa16(void);
-void popa32(void);
-int32_t arpl(int32_t, int32_t);
-
-void trigger_ud(void);
-void trigger_nm(void);
-void run_prefix_instruction(void);
-
-int32_t pop16(void);
-int32_t pop32s(void);
-
-int32_t safe_read8(int32_t);
-int32_t safe_read16(int32_t);
-int32_t safe_read32s(int32_t);
-
-void safe_write8(int32_t, int32_t);
-void safe_write16(int32_t, int32_t);
-void safe_write32(int32_t, int32_t);
-
-void push32(int32_t);
-int32_t get_stack_pointer(int32_t);
-void adjust_stack_reg(int32_t);
-void set_stack_reg(int32_t);
-
-int32_t getiopl(void);
-int32_t get_eflags(void);
-int32_t getof(void);
-int32_t getzf(void);
-
-void switch_seg(int32_t, int32_t);
-
-bool vm86_mode(void);
-
-int32_t shl8(int32_t, int32_t);
-int32_t shr8(int32_t, int32_t);
-int32_t sar8(int32_t, int32_t);
-int32_t ror8(int32_t, int32_t);
-int32_t rol8(int32_t, int32_t);
-int32_t rcr8(int32_t, int32_t);
-int32_t rcl8(int32_t, int32_t);
-
-int32_t shl16(int32_t, int32_t);
-int32_t shr16(int32_t, int32_t);
-int32_t sar16(int32_t, int32_t);
-int32_t ror16(int32_t, int32_t);
-int32_t rol16(int32_t, int32_t);
-int32_t rcr16(int32_t, int32_t);
-int32_t rcl16(int32_t, int32_t);
-
-int32_t shl32(int32_t, int32_t);
-int32_t shr32(int32_t, int32_t);
-int32_t sar32(int32_t, int32_t);
-int32_t ror32(int32_t, int32_t);
-int32_t rol32(int32_t, int32_t);
-int32_t rcr32(int32_t, int32_t);
-int32_t rcl32(int32_t, int32_t);
-
-void idiv16(int32_t);
-void div32(uint32_t);
-void idiv32(int32_t);
-
-
-void insb(void);
-void insw(void);
-void insd(void);
-void outsb(void);
-void outsw(void);
-void outsd(void);
-void movsb(void);
-void movsw(void);
-void movsd(void);
-void cmpsb(void);
-void cmpsw(void);
-void cmpsd(void);
-void stosb(void);
-void stosw(void);
-void stosd(void);
-void lodsb(void);
-void lodsw(void);
-void lodsd(void);
-void scasb(void);
-void scasw(void);
-void scasd(void);
-
-void fpu_op_D8_mem(int32_t, int32_t);
-void fpu_op_D8_reg(int32_t);
-void fpu_op_D9_mem(int32_t, int32_t);
-void fpu_op_D9_reg(int32_t);
-void fpu_op_DA_mem(int32_t, int32_t);
-void fpu_op_DA_reg(int32_t);
-void fpu_op_DB_mem(int32_t, int32_t);
-void fpu_op_DB_reg(int32_t);
-void fpu_op_DC_mem(int32_t, int32_t);
-void fpu_op_DC_reg(int32_t);
-void fpu_op_DD_mem(int32_t, int32_t);
-void fpu_op_DD_reg(int32_t);
-void fpu_op_DE_mem(int32_t, int32_t);
-void fpu_op_DE_reg(int32_t);
-void fpu_op_DF_mem(int32_t, int32_t);
-void fpu_op_DF_reg(int32_t);
-
-int32_t test_o(void);
-int32_t test_b(void);
-int32_t test_z(void);
-int32_t test_s(void);
-int32_t test_p(void);
-int32_t test_be(void);
-int32_t test_l(void);
-int32_t test_le(void);
-
-void jmpcc8(bool, int32_t);
-
-void far_jump(int32_t, int32_t, int32_t);
-void far_return(int32_t, int32_t, int32_t);
-
-void iret16();
-void iret32();
-
-void lss16(int32_t, int32_t, int32_t);
-void lss32(int32_t, int32_t, int32_t);
-
-void enter16(int32_t, int32_t);
-void enter32(int32_t, int32_t);
-
-int32_t get_seg(int32_t);
-int32_t get_seg_prefix(int32_t);
-void update_eflags(int32_t);
-void handle_irqs(void);
-int32_t get_real_eip(void);
-void diverged(void);
-
-int32_t xchg8(int32_t, int32_t);
-int32_t xchg16(int32_t, int32_t);
-void xchg16r(int32_t);
-int32_t xchg32(int32_t, int32_t);
-void xchg32r(int32_t);
-
-int32_t loop(int32_t);
-int32_t loope(int32_t);
-int32_t loopne(int32_t);
-
-void bcd_aam(int32_t);
-void task_switch_test(void);
-void jcxz(int32_t);
-void test_privileges_for_io(int32_t, int32_t);
-int32_t io_port_read8(int32_t);
-int32_t io_port_read16(int32_t);
-int32_t io_port_read32(int32_t);
-void jmp_rel16(int32_t);
-void hlt_op(void);
-
-void io_port_write8(int32_t, int32_t);
-void io_port_write16(int32_t, int32_t);
-void io_port_write32(int32_t, int32_t);
-
-int32_t modrm_resolve(int32_t);
-
-void run_instruction0f_16(int32_t);
-void run_instruction0f_32(int32_t);
-
-void jit_instruction0f_16(int32_t);
-void jit_instruction0f_32(int32_t);
-
-void clear_prefixes(void);
-void cycle_internal(void);
-
-void fwait(void);
-
-
-#define DEFINE_MODRM_INSTR1_READ_WRITE_8(name, fun) \
-    void name ## _mem(int32_t addr) { SAFE_READ_WRITE8(addr, fun) } \
-    void name ## _reg(int32_t r1) { int32_t ___ = read_reg8(r1); write_reg8(r1, fun); }
-
-#define DEFINE_MODRM_INSTR1_READ_WRITE_16(name, fun) \
-    void name ## _mem(int32_t addr) { SAFE_READ_WRITE16(addr, fun) } \
-    void name ## _reg(int32_t r1) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
-
-#define DEFINE_MODRM_INSTR1_READ_WRITE_32(name, fun) \
-    void name ## _mem(int32_t addr) { SAFE_READ_WRITE32(addr, fun) } \
-    void name ## _reg(int32_t r1) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
-
-
-#define DEFINE_MODRM_INSTR2_READ_WRITE_8(name, fun) \
-    void name ## _mem(int32_t addr, int32_t imm) { SAFE_READ_WRITE8(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg8(r1); write_reg8(r1, fun); }
-
-#define DEFINE_MODRM_INSTR2_READ_WRITE_16(name, fun) \
-    void name ## _mem(int32_t addr, int32_t imm) { SAFE_READ_WRITE16(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
-
-#define DEFINE_MODRM_INSTR2_READ_WRITE_32(name, fun) \
-    void name ## _mem(int32_t addr, int32_t imm) { SAFE_READ_WRITE32(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
-
-
-#define DEFINE_MODRM_INSTR_READ_WRITE_8(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE8(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg8(r1); write_reg8(r1, fun); }
-
-#define DEFINE_MODRM_INSTR_READ_WRITE_16(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE16(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
-
-#define DEFINE_MODRM_INSTR_READ_WRITE_32(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE32(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
-
-
-#define DEFINE_MODRM_INSTR1_READ8(name, fun) \
-    void name ## _mem(int32_t addr) { int32_t ___ = safe_read8(addr); fun; } \
-    void name ## _reg(int32_t r1) { int32_t ___ = read_reg8(r1); fun; }
-
-#define DEFINE_MODRM_INSTR1_READ16(name, fun) \
-    void name ## _mem(int32_t addr) { int32_t ___ = safe_read16(addr); fun; } \
-    void name ## _reg(int32_t r1) { int32_t ___ = read_reg16(r1); fun; }
-
-#define DEFINE_MODRM_INSTR1_READ32(name, fun) \
-    void name ## _mem(int32_t addr) { int32_t ___ = safe_read32s(addr); fun; } \
-    void name ## _reg(int32_t r1) { int32_t ___ = read_reg32(r1); fun; }
-
-
-#define DEFINE_MODRM_INSTR2_READ8(name, fun) \
-    void name ## _mem(int32_t addr, int32_t imm) { int32_t ___ = safe_read8(addr); fun; } \
-    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg8(r1); fun; }
-
-#define DEFINE_MODRM_INSTR2_READ16(name, fun) \
-    void name ## _mem(int32_t addr, int32_t imm) { int32_t ___ = safe_read16(addr); fun; } \
-    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg16(r1); fun; }
-
-#define DEFINE_MODRM_INSTR2_READ32(name, fun) \
-    void name ## _mem(int32_t addr, int32_t imm) { int32_t ___ = safe_read32s(addr); fun; } \
-    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg32(r1); fun; }
-
-
-#define DEFINE_MODRM_INSTR_READ8(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read8(addr); fun; } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg8(r1); fun; }
-
-#define DEFINE_MODRM_INSTR_READ16(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read16(addr); fun; } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg16(r1); fun; }
-
-#define DEFINE_MODRM_INSTR_READ32(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read32s(addr); fun; } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg32(r1); fun; }
-
+extern void far_jump(int32_t, int32_t, int32_t);
+extern void update_eflags(int32_t);
+extern void iret16(void);
+extern void iret32(void);
+extern void bcd_aam(int32_t);
+extern void task_switch_test(void);
+extern void far_return(int32_t, int32_t, int32_t);
+extern void switch_seg(int32_t, int32_t);
+extern int32_t arpl(int32_t, int32_t);
+extern void popa16(void);
+extern void popa32(void);
+extern int32_t getiopl(void);
+extern bool vm86_mode(void);
+extern void fwait(void);
+extern void fpu_op_D8_mem(int32_t, int32_t);
+extern void fpu_op_D8_reg(int32_t);
+extern void fpu_op_D9_mem(int32_t, int32_t);
+extern void fpu_op_D9_reg(int32_t);
+extern void fpu_op_DA_mem(int32_t, int32_t);
+extern void fpu_op_DA_reg(int32_t);
+extern void fpu_op_DB_mem(int32_t, int32_t);
+extern void fpu_op_DB_reg(int32_t);
+extern void fpu_op_DC_mem(int32_t, int32_t);
+extern void fpu_op_DC_reg(int32_t);
+extern void fpu_op_DD_mem(int32_t, int32_t);
+extern void fpu_op_DD_reg(int32_t);
+extern void fpu_op_DE_mem(int32_t, int32_t);
+extern void fpu_op_DE_reg(int32_t);
+extern void fpu_op_DF_mem(int32_t, int32_t);
+extern void fpu_op_DF_reg(int32_t);
+extern int32_t loop(int32_t);
+extern int32_t loope(int32_t);
+extern int32_t loopne(int32_t);
+extern void enter16(int32_t, int32_t);
+extern void enter32(int32_t, int32_t);
+extern void hlt_op(void);
+extern void test_privileges_for_io(int32_t, int32_t);
+extern void lss16(int32_t, int32_t, int32_t);
+extern void lss32(int32_t, int32_t, int32_t);
+extern int32_t io_port_read8(int32_t);
+extern int32_t io_port_read16(int32_t);
+extern int32_t io_port_read32(int32_t);
+extern void io_port_write8(int32_t, int32_t);
+extern void io_port_write16(int32_t, int32_t);
+extern void io_port_write32(int32_t, int32_t);
+extern void handle_irqs(void);
+extern void jcxz(int32_t);
 
 DEFINE_MODRM_INSTR_READ_WRITE_8(instr_00, add8(___, read_reg8(r)))
 DEFINE_MODRM_INSTR_READ_WRITE_16(instr16_01, add16(___, read_reg16(r)))

src/native/instructions.h

@@ -0,0 +1,913 @@
+#pragma once
+
+#include <stdint.h>
+
+#define SAFE_READ_WRITE8(addr, fun) \
+    int32_t phys_addr = translate_address_write(addr); \
+    int32_t ___ = read8(phys_addr); \
+    write8(phys_addr, fun);
+
+#define SAFE_READ_WRITE16(addr, fun) \
+    int32_t phys_addr = translate_address_write(addr); \
+    if((phys_addr & 0xFFF) == 0xFFF) \
+    { \
+        int32_t phys_addr_high = translate_address_write(addr + 1); \
+        int32_t ___ = virt_boundary_read16(phys_addr, phys_addr_high); \
+        virt_boundary_write16(phys_addr, phys_addr_high, fun); \
+    } \
+    else \
+    { \
+        int32_t ___ = read16(phys_addr); \
+        write16(phys_addr, fun); \
+    }
+
+#define SAFE_READ_WRITE32(addr, fun) \
+    int32_t phys_addr = translate_address_write(addr); \
+    if((phys_addr & 0xFFF) >= 0xFFD) \
+    { \
+        int32_t phys_addr_high = translate_address_write(addr + 3 & ~3) | (addr + 3) & 3; \
+        int32_t ___ = virt_boundary_read32s(phys_addr, phys_addr_high); \
+        virt_boundary_write32(phys_addr, phys_addr_high, fun); \
+    } \
+    else \
+    { \
+        int32_t ___ = read32s(phys_addr); \
+        write32(phys_addr, fun); \
+    }
+
+#define DEFINE_MODRM_INSTR1_READ_WRITE_8(name, fun) \
+    void name ## _mem(int32_t addr) { SAFE_READ_WRITE8(addr, fun) } \
+    void name ## _reg(int32_t r1) { int32_t ___ = read_reg8(r1); write_reg8(r1, fun); }
+
+#define DEFINE_MODRM_INSTR1_READ_WRITE_16(name, fun) \
+    void name ## _mem(int32_t addr) { SAFE_READ_WRITE16(addr, fun) } \
+    void name ## _reg(int32_t r1) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
+
+#define DEFINE_MODRM_INSTR1_READ_WRITE_32(name, fun) \
+    void name ## _mem(int32_t addr) { SAFE_READ_WRITE32(addr, fun) } \
+    void name ## _reg(int32_t r1) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
+
+
+#define DEFINE_MODRM_INSTR2_READ_WRITE_8(name, fun) \
+    void name ## _mem(int32_t addr, int32_t imm) { SAFE_READ_WRITE8(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg8(r1); write_reg8(r1, fun); }
+
+#define DEFINE_MODRM_INSTR2_READ_WRITE_16(name, fun) \
+    void name ## _mem(int32_t addr, int32_t imm) { SAFE_READ_WRITE16(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
+
+#define DEFINE_MODRM_INSTR2_READ_WRITE_32(name, fun) \
+    void name ## _mem(int32_t addr, int32_t imm) { SAFE_READ_WRITE32(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
+
+
+#define DEFINE_MODRM_INSTR_READ_WRITE_8(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE8(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg8(r1); write_reg8(r1, fun); }
+
+#define DEFINE_MODRM_INSTR_READ_WRITE_16(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE16(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
+
+#define DEFINE_MODRM_INSTR_READ_WRITE_32(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE32(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
+
+
+#define DEFINE_MODRM_INSTR1_READ8(name, fun) \
+    void name ## _mem(int32_t addr) { int32_t ___ = safe_read8(addr); fun; } \
+    void name ## _reg(int32_t r1) { int32_t ___ = read_reg8(r1); fun; }
+
+#define DEFINE_MODRM_INSTR1_READ16(name, fun) \
+    void name ## _mem(int32_t addr) { int32_t ___ = safe_read16(addr); fun; } \
+    void name ## _reg(int32_t r1) { int32_t ___ = read_reg16(r1); fun; }
+
+#define DEFINE_MODRM_INSTR1_READ32(name, fun) \
+    void name ## _mem(int32_t addr) { int32_t ___ = safe_read32s(addr); fun; } \
+    void name ## _reg(int32_t r1) { int32_t ___ = read_reg32(r1); fun; }
+
+
+#define DEFINE_MODRM_INSTR2_READ8(name, fun) \
+    void name ## _mem(int32_t addr, int32_t imm) { int32_t ___ = safe_read8(addr); fun; } \
+    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg8(r1); fun; }
+
+#define DEFINE_MODRM_INSTR2_READ16(name, fun) \
+    void name ## _mem(int32_t addr, int32_t imm) { int32_t ___ = safe_read16(addr); fun; } \
+    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg16(r1); fun; }
+
+#define DEFINE_MODRM_INSTR2_READ32(name, fun) \
+    void name ## _mem(int32_t addr, int32_t imm) { int32_t ___ = safe_read32s(addr); fun; } \
+    void name ## _reg(int32_t r1, int32_t imm) { int32_t ___ = read_reg32(r1); fun; }
+
+
+#define DEFINE_MODRM_INSTR_READ8(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read8(addr); fun; } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg8(r1); fun; }
+
+#define DEFINE_MODRM_INSTR_READ16(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read16(addr); fun; } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg16(r1); fun; }
+
+#define DEFINE_MODRM_INSTR_READ32(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read32s(addr); fun; } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg32(r1); fun; }
+
+void instr_00_mem(int32_t addr, int32_t r);
+void instr_00_reg(int32_t r1, int32_t r);
+void instr16_01_mem(int32_t addr, int32_t r);
+void instr16_01_reg(int32_t r1, int32_t r);
+void instr32_01_mem(int32_t addr, int32_t r);
+void instr32_01_reg(int32_t r1, int32_t r);
+void instr_02_mem(int32_t addr, int32_t r);
+void instr_02_reg(int32_t r1, int32_t r);
+void instr16_03_mem(int32_t addr, int32_t r);
+void instr16_03_reg(int32_t r1, int32_t r);
+void instr32_03_mem(int32_t addr, int32_t r);
+void instr32_03_reg(int32_t r1, int32_t r);
+void instr_04(int32_t imm8);
+void instr16_05(int32_t imm16);
+void instr32_05(int32_t imm32);
+void instr16_06(void);
+void instr32_06(void);
+void instr16_07(void);
+void instr32_07(void);
+void instr_08_mem(int32_t addr, int32_t r);
+void instr_08_reg(int32_t r1, int32_t r);
+void instr16_09_mem(int32_t addr, int32_t r);
+void instr16_09_reg(int32_t r1, int32_t r);
+void instr32_09_mem(int32_t addr, int32_t r);
+void instr32_09_reg(int32_t r1, int32_t r);
+void instr_0A_mem(int32_t addr, int32_t r);
+void instr_0A_reg(int32_t r1, int32_t r);
+void instr16_0B_mem(int32_t addr, int32_t r);
+void instr16_0B_reg(int32_t r1, int32_t r);
+void instr32_0B_mem(int32_t addr, int32_t r);
+void instr32_0B_reg(int32_t r1, int32_t r);
+void instr_0C(int32_t imm8);
+void instr16_0D(int32_t imm16);
+void instr32_0D(int32_t imm32);
+void instr16_0E(void);
+void instr32_0E(void);
+void instr16_0F(void);
+void instr32_0F(void);
+void instr16_0F_jit(void);
+void instr32_0F_jit(void);
+void instr_10_mem(int32_t addr, int32_t r);
+void instr_10_reg(int32_t r1, int32_t r);
+void instr16_11_mem(int32_t addr, int32_t r);
+void instr16_11_reg(int32_t r1, int32_t r);
+void instr32_11_mem(int32_t addr, int32_t r);
+void instr32_11_reg(int32_t r1, int32_t r);
+void instr_12_mem(int32_t addr, int32_t r);
+void instr_12_reg(int32_t r1, int32_t r);
+void instr16_13_mem(int32_t addr, int32_t r);
+void instr16_13_reg(int32_t r1, int32_t r);
+void instr32_13_mem(int32_t addr, int32_t r);
+void instr32_13_reg(int32_t r1, int32_t r);
+void instr_14(int32_t imm8);
+void instr16_15(int32_t imm16);
+void instr32_15(int32_t imm32);
+void instr16_16(void);
+void instr32_16(void);
+void instr16_17(void);
+void instr32_17(void);
+void instr_18_mem(int32_t addr, int32_t r);
+void instr_18_reg(int32_t r1, int32_t r);
+void instr16_19_mem(int32_t addr, int32_t r);
+void instr16_19_reg(int32_t r1, int32_t r);
+void instr32_19_mem(int32_t addr, int32_t r);
+void instr32_19_reg(int32_t r1, int32_t r);
+void instr_1A_mem(int32_t addr, int32_t r);
+void instr_1A_reg(int32_t r1, int32_t r);
+void instr16_1B_mem(int32_t addr, int32_t r);
+void instr16_1B_reg(int32_t r1, int32_t r);
+void instr32_1B_mem(int32_t addr, int32_t r);
+void instr32_1B_reg(int32_t r1, int32_t r);
+void instr_1C(int32_t imm8);
+void instr16_1D(int32_t imm16);
+void instr32_1D(int32_t imm32);
+void instr16_1E(void);
+void instr32_1E(void);
+void instr16_1F(void);
+void instr32_1F(void);
+void instr_20_mem(int32_t addr, int32_t r);
+void instr_20_reg(int32_t r1, int32_t r);
+void instr16_21_mem(int32_t addr, int32_t r);
+void instr16_21_reg(int32_t r1, int32_t r);
+void instr32_21_mem(int32_t addr, int32_t r);
+void instr32_21_reg(int32_t r1, int32_t r);
+void instr_22_mem(int32_t addr, int32_t r);
+void instr_22_reg(int32_t r1, int32_t r);
+void instr16_23_mem(int32_t addr, int32_t r);
+void instr16_23_reg(int32_t r1, int32_t r);
+void instr32_23_mem(int32_t addr, int32_t r);
+void instr32_23_reg(int32_t r1, int32_t r);
+void instr_24(int32_t imm8);
+void instr16_25(int32_t imm16);
+void instr32_25(int32_t imm32);
+void instr_26(void);
+void instr_26_jit(void);
+void instr_27(void);
+void instr_28_mem(int32_t addr, int32_t r);
+void instr_28_reg(int32_t r1, int32_t r);
+void instr16_29_mem(int32_t addr, int32_t r);
+void instr16_29_reg(int32_t r1, int32_t r);
+void instr32_29_mem(int32_t addr, int32_t r);
+void instr32_29_reg(int32_t r1, int32_t r);
+void instr_2A_mem(int32_t addr, int32_t r);
+void instr_2A_reg(int32_t r1, int32_t r);
+void instr16_2B_mem(int32_t addr, int32_t r);
+void instr16_2B_reg(int32_t r1, int32_t r);
+void instr32_2B_mem(int32_t addr, int32_t r);
+void instr32_2B_reg(int32_t r1, int32_t r);
+void instr_2C(int32_t imm8);
+void instr16_2D(int32_t imm16);
+void instr32_2D(int32_t imm32);
+void instr_2E(void);
+void instr_2E_jit(void);
+void instr_2F(void);
+void instr_30_mem(int32_t addr, int32_t r);
+void instr_30_reg(int32_t r1, int32_t r);
+void instr16_31_mem(int32_t addr, int32_t r);
+void instr16_31_reg(int32_t r1, int32_t r);
+void instr32_31_mem(int32_t addr, int32_t r);
+void instr32_31_reg(int32_t r1, int32_t r);
+void instr_32_mem(int32_t addr, int32_t r);
+void instr_32_reg(int32_t r1, int32_t r);
+void instr16_33_mem(int32_t addr, int32_t r);
+void instr16_33_reg(int32_t r1, int32_t r);
+void instr32_33_mem(int32_t addr, int32_t r);
+void instr32_33_reg(int32_t r1, int32_t r);
+void instr_34(int32_t imm8);
+void instr16_35(int32_t imm16);
+void instr32_35(int32_t imm32);
+void instr_36(void);
+void instr_36_jit(void);
+void instr_37(void);
+void instr_38_mem(int32_t addr, int32_t r);
+void instr_38_reg(int32_t r1, int32_t r);
+void instr16_39_mem(int32_t addr, int32_t r);
+void instr16_39_reg(int32_t r1, int32_t r);
+void instr32_39_mem(int32_t addr, int32_t r);
+void instr32_39_reg(int32_t r1, int32_t r);
+void instr_3A_mem(int32_t addr, int32_t r);
+void instr_3A_reg(int32_t r1, int32_t r);
+void instr16_3B_mem(int32_t addr, int32_t r);
+void instr16_3B_reg(int32_t r1, int32_t r);
+void instr32_3B_mem(int32_t addr, int32_t r);
+void instr32_3B_reg(int32_t r1, int32_t r);
+void instr_3C(int32_t imm8);
+void instr16_3D(int32_t imm16);
+void instr32_3D(int32_t imm32);
+void instr_3E(void);
+void instr_3E_jit(void);
+void instr_3F(void);
+void instr16_40(void);
+void instr32_40(void);
+void instr16_41(void);
+void instr32_41(void);
+void instr16_42(void);
+void instr32_42(void);
+void instr16_43(void);
+void instr32_43(void);
+void instr16_44(void);
+void instr32_44(void);
+void instr16_45(void);
+void instr32_45(void);
+void instr16_46(void);
+void instr32_46(void);
+void instr16_47(void);
+void instr32_47(void);
+void instr16_48(void);
+void instr32_48(void);
+void instr16_49(void);
+void instr32_49(void);
+void instr16_4A(void);
+void instr32_4A(void);
+void instr16_4B(void);
+void instr32_4B(void);
+void instr16_4C(void);
+void instr32_4C(void);
+void instr16_4D(void);
+void instr32_4D(void);
+void instr16_4E(void);
+void instr32_4E(void);
+void instr16_4F(void);
+void instr32_4F(void);
+void instr16_50(void);
+void instr32_50(void);
+void instr16_51(void);
+void instr32_51(void);
+void instr16_52(void);
+void instr32_52(void);
+void instr16_53(void);
+void instr32_53(void);
+void instr16_54(void);
+void instr32_54(void);
+void instr16_55(void);
+void instr32_55(void);
+void instr16_56(void);
+void instr32_56(void);
+void instr16_57(void);
+void instr32_57(void);
+void instr16_58(void);
+void instr32_58(void);
+void instr16_59(void);
+void instr32_59(void);
+void instr16_5A(void);
+void instr32_5A(void);
+void instr16_5B(void);
+void instr32_5B(void);
+void instr16_5C(void);
+void instr32_5C(void);
+void instr16_5D(void);
+void instr32_5D(void);
+void instr16_5E(void);
+void instr32_5E(void);
+void instr16_5F(void);
+void instr32_5F(void);
+void instr16_60(void);
+void instr32_60(void);
+void instr16_61(void);
+void instr32_61(void);
+void instr_62_reg(int32_t r2, int32_t r);
+void instr_62_mem(int32_t addr, int32_t r);
+void instr_63_mem(int32_t addr, int32_t r);
+void instr_63_reg(int32_t r1, int32_t r);
+void instr_64(void);
+void instr_64_jit(void);
+void instr_65(void);
+void instr_65_jit(void);
+void instr_66(void);
+void instr_66_jit(void);
+void instr_67(void);
+void instr_67_jit(void);
+void instr16_68(int32_t imm16);
+void instr32_68(int32_t imm32);
+void instr16_69_mem(int32_t addr, int32_t r, int32_t imm);
+void instr16_69_reg(int32_t r1, int32_t r, int32_t imm);
+void instr32_69_mem(int32_t addr, int32_t r, int32_t imm);
+void instr32_69_reg(int32_t r1, int32_t r, int32_t imm);
+void instr16_6A(int32_t imm8);
+void instr32_6A(int32_t imm8);
+void instr16_6B_mem(int32_t addr, int32_t r, int32_t imm);
+void instr16_6B_reg(int32_t r1, int32_t r, int32_t imm);
+void instr32_6B_mem(int32_t addr, int32_t r, int32_t imm);
+void instr32_6B_reg(int32_t r1, int32_t r, int32_t imm);
+void instr_6C(void);
+void instr16_6D(void);
+void instr32_6D(void);
+void instr_6E(void);
+void instr16_6F(void);
+void instr32_6F(void);
+void instr_70(int32_t imm8);
+void instr_71(int32_t imm8);
+void instr_72(int32_t imm8);
+void instr_73(int32_t imm8);
+void instr_74(int32_t imm8);
+void instr_75(int32_t imm8);
+void instr_76(int32_t imm8);
+void instr_77(int32_t imm8);
+void instr_78(int32_t imm8);
+void instr_79(int32_t imm8);
+void instr_7A(int32_t imm8);
+void instr_7B(int32_t imm8);
+void instr_7C(int32_t imm8);
+void instr_7D(int32_t imm8);
+void instr_7E(int32_t imm8);
+void instr_7F(int32_t imm8);
+void instr_80_0_mem(int32_t addr, int32_t imm);
+void instr_80_0_reg(int32_t r1, int32_t imm);
+void instr_80_1_mem(int32_t addr, int32_t imm);
+void instr_80_1_reg(int32_t r1, int32_t imm);
+void instr_80_2_mem(int32_t addr, int32_t imm);
+void instr_80_2_reg(int32_t r1, int32_t imm);
+void instr_80_3_mem(int32_t addr, int32_t imm);
+void instr_80_3_reg(int32_t r1, int32_t imm);
+void instr_80_4_mem(int32_t addr, int32_t imm);
+void instr_80_4_reg(int32_t r1, int32_t imm);
+void instr_80_5_mem(int32_t addr, int32_t imm);
+void instr_80_5_reg(int32_t r1, int32_t imm);
+void instr_80_6_mem(int32_t addr, int32_t imm);
+void instr_80_6_reg(int32_t r1, int32_t imm);
+void instr_80_7_reg(int32_t r, int32_t imm);
+void instr_80_7_mem(int32_t addr, int32_t imm);
+void instr16_81_0_mem(int32_t addr, int32_t imm);
+void instr16_81_0_reg(int32_t r1, int32_t imm);
+void instr16_81_1_mem(int32_t addr, int32_t imm);
+void instr16_81_1_reg(int32_t r1, int32_t imm);
+void instr16_81_2_mem(int32_t addr, int32_t imm);
+void instr16_81_2_reg(int32_t r1, int32_t imm);
+void instr16_81_3_mem(int32_t addr, int32_t imm);
+void instr16_81_3_reg(int32_t r1, int32_t imm);
+void instr16_81_4_mem(int32_t addr, int32_t imm);
+void instr16_81_4_reg(int32_t r1, int32_t imm);
+void instr16_81_5_mem(int32_t addr, int32_t imm);
+void instr16_81_5_reg(int32_t r1, int32_t imm);
+void instr16_81_6_mem(int32_t addr, int32_t imm);
+void instr16_81_6_reg(int32_t r1, int32_t imm);
+void instr16_81_7_reg(int32_t r, int32_t imm);
+void instr16_81_7_mem(int32_t addr, int32_t imm);
+void instr32_81_0_mem(int32_t addr, int32_t imm);
+void instr32_81_0_reg(int32_t r1, int32_t imm);
+void instr32_81_1_mem(int32_t addr, int32_t imm);
+void instr32_81_1_reg(int32_t r1, int32_t imm);
+void instr32_81_2_mem(int32_t addr, int32_t imm);
+void instr32_81_2_reg(int32_t r1, int32_t imm);
+void instr32_81_3_mem(int32_t addr, int32_t imm);
+void instr32_81_3_reg(int32_t r1, int32_t imm);
+void instr32_81_4_mem(int32_t addr, int32_t imm);
+void instr32_81_4_reg(int32_t r1, int32_t imm);
+void instr32_81_5_mem(int32_t addr, int32_t imm);
+void instr32_81_5_reg(int32_t r1, int32_t imm);
+void instr32_81_6_mem(int32_t addr, int32_t imm);
+void instr32_81_6_reg(int32_t r1, int32_t imm);
+void instr32_81_7_reg(int32_t r, int32_t imm);
+void instr32_81_7_mem(int32_t addr, int32_t imm);
+void instr_82_0_mem(int32_t addr, int32_t imm);
+void instr_82_0_reg(int32_t r1, int32_t imm);
+void instr_82_1_mem(int32_t addr, int32_t imm);
+void instr_82_1_reg(int32_t r1, int32_t imm);
+void instr_82_2_mem(int32_t addr, int32_t imm);
+void instr_82_2_reg(int32_t r1, int32_t imm);
+void instr_82_3_mem(int32_t addr, int32_t imm);
+void instr_82_3_reg(int32_t r1, int32_t imm);
+void instr_82_4_mem(int32_t addr, int32_t imm);
+void instr_82_4_reg(int32_t r1, int32_t imm);
+void instr_82_5_mem(int32_t addr, int32_t imm);
+void instr_82_5_reg(int32_t r1, int32_t imm);
+void instr_82_6_mem(int32_t addr, int32_t imm);
+void instr_82_6_reg(int32_t r1, int32_t imm);
+void instr_82_7_reg(int32_t r, int32_t imm);
+void instr_82_7_mem(int32_t addr, int32_t imm);
+void instr16_83_0_mem(int32_t addr, int32_t imm);
+void instr16_83_0_reg(int32_t r1, int32_t imm);
+void instr16_83_1_mem(int32_t addr, int32_t imm);
+void instr16_83_1_reg(int32_t r1, int32_t imm);
+void instr16_83_2_mem(int32_t addr, int32_t imm);
+void instr16_83_2_reg(int32_t r1, int32_t imm);
+void instr16_83_3_mem(int32_t addr, int32_t imm);
+void instr16_83_3_reg(int32_t r1, int32_t imm);
+void instr16_83_4_mem(int32_t addr, int32_t imm);
+void instr16_83_4_reg(int32_t r1, int32_t imm);
+void instr16_83_5_mem(int32_t addr, int32_t imm);
+void instr16_83_5_reg(int32_t r1, int32_t imm);
+void instr16_83_6_mem(int32_t addr, int32_t imm);
+void instr16_83_6_reg(int32_t r1, int32_t imm);
+void instr16_83_7_reg(int32_t r, int32_t imm);
+void instr16_83_7_mem(int32_t addr, int32_t imm);
+void instr32_83_0_mem(int32_t addr, int32_t imm);
+void instr32_83_0_reg(int32_t r1, int32_t imm);
+void instr32_83_1_mem(int32_t addr, int32_t imm);
+void instr32_83_1_reg(int32_t r1, int32_t imm);
+void instr32_83_2_mem(int32_t addr, int32_t imm);
+void instr32_83_2_reg(int32_t r1, int32_t imm);
+void instr32_83_3_mem(int32_t addr, int32_t imm);
+void instr32_83_3_reg(int32_t r1, int32_t imm);
+void instr32_83_4_mem(int32_t addr, int32_t imm);
+void instr32_83_4_reg(int32_t r1, int32_t imm);
+void instr32_83_5_mem(int32_t addr, int32_t imm);
+void instr32_83_5_reg(int32_t r1, int32_t imm);
+void instr32_83_6_mem(int32_t addr, int32_t imm);
+void instr32_83_6_reg(int32_t r1, int32_t imm);
+void instr32_83_7_reg(int32_t r, int32_t imm);
+void instr32_83_7_mem(int32_t addr, int32_t imm);
+void instr_84_mem(int32_t addr, int32_t r);
+void instr_84_reg(int32_t r1, int32_t r);
+void instr16_85_mem(int32_t addr, int32_t r);
+void instr16_85_reg(int32_t r1, int32_t r);
+void instr32_85_mem(int32_t addr, int32_t r);
+void instr32_85_reg(int32_t r1, int32_t r);
+void instr_86_mem(int32_t addr, int32_t r);
+void instr_86_reg(int32_t r1, int32_t r);
+void instr16_87_mem(int32_t addr, int32_t r);
+void instr16_87_reg(int32_t r1, int32_t r);
+void instr32_87_mem(int32_t addr, int32_t r);
+void instr32_87_reg(int32_t r1, int32_t r);
+void instr_88_reg(int32_t r2, int32_t r);
+void instr_88_mem(int32_t addr, int32_t r);
+void instr16_89_reg(int32_t r2, int32_t r);
+void instr16_89_mem(int32_t addr, int32_t r);
+void instr32_89_reg(int32_t r2, int32_t r);
+void instr32_89_mem(int32_t addr, int32_t r);
+void instr_8A_mem(int32_t addr, int32_t r);
+void instr_8A_reg(int32_t r1, int32_t r);
+void instr16_8B_mem(int32_t addr, int32_t r);
+void instr16_8B_reg(int32_t r1, int32_t r);
+void instr32_8B_mem(int32_t addr, int32_t r);
+void instr32_8B_reg(int32_t r1, int32_t r);
+void instr_8C_check_sreg(int32_t sreg);
+void instr16_8C_reg(int32_t r, int32_t seg);
+void instr16_8C_mem(int32_t addr, int32_t seg);
+void instr32_8C_reg(int32_t r, int32_t seg);
+void instr32_8C_mem(int32_t addr, int32_t seg);
+void instr16_8D_reg(int32_t r, int32_t r2);
+void instr16_8D_mem_pre(void);
+void instr16_8D_mem(int32_t addr, int32_t mod);
+void instr32_8D_reg(int32_t r, int32_t r2);
+void instr32_8D_mem_pre(void);
+void instr32_8D_mem(int32_t addr, int32_t mod);
+void instr_8E_helper(int32_t data, int32_t mod);
+void instr_8E_mem(int32_t addr, int32_t r);
+void instr_8E_reg(int32_t r1, int32_t r);
+void instr16_8F_0_mem_pre(void);
+void instr16_8F_0_mem(int32_t addr);
+void instr16_8F_0_reg(int32_t r);
+void instr32_8F_0_mem_pre(void);
+void instr32_8F_0_mem(int32_t addr);
+void instr32_8F_0_reg(int32_t r);
+void instr_90(void);
+void instr16_91(void);
+void instr32_91(void);
+void instr16_92(void);
+void instr32_92(void);
+void instr16_93(void);
+void instr32_93(void);
+void instr16_94(void);
+void instr32_94(void);
+void instr16_95(void);
+void instr32_95(void);
+void instr16_96(void);
+void instr32_96(void);
+void instr16_97(void);
+void instr32_97(void);
+void instr16_98(void);
+void instr32_98(void);
+void instr16_99(void);
+void instr32_99(void);
+void instr16_9A(int32_t new_ip, int32_t new_cs);
+void instr32_9A(int32_t new_ip, int32_t new_cs);
+void instr_9B(void);
+void instr16_9C(void);
+void instr32_9C(void);
+void instr16_9D(void);
+void instr32_9D(void);
+void instr_9E(void);
+void instr_9F(void);
+void instr_A0(int32_t moffs);
+void instr16_A1(int32_t moffs);
+void instr32_A1(int32_t moffs);
+void instr_A2(int32_t moffs);
+void instr16_A3(int32_t moffs);
+void instr32_A3(int32_t moffs);
+void instr_A4(void);
+void instr16_A5(void);
+void instr32_A5(void);
+void instr_A6(void);
+void instr16_A7(void);
+void instr32_A7(void);
+void instr_A8(int32_t imm8);
+void instr16_A9(int32_t imm16);
+void instr32_A9(int32_t imm32);
+void instr_AA(void);
+void instr16_AB(void);
+void instr32_AB(void);
+void instr_AC(void);
+void instr16_AD(void);
+void instr32_AD(void);
+void instr_AE(void);
+void instr16_AF(void);
+void instr32_AF(void);
+void instr_B0(int32_t imm8);
+void instr_B1(int32_t imm8);
+void instr_B2(int32_t imm8);
+void instr_B3(int32_t imm8);
+void instr_B4(int32_t imm8);
+void instr_B5(int32_t imm8);
+void instr_B6(int32_t imm8);
+void instr_B7(int32_t imm8);
+void instr16_B8(int32_t imm);
+void instr32_B8(int32_t imm);
+void instr16_B9(int32_t imm);
+void instr32_B9(int32_t imm);
+void instr16_BA(int32_t imm);
+void instr32_BA(int32_t imm);
+void instr16_BB(int32_t imm);
+void instr32_BB(int32_t imm);
+void instr16_BC(int32_t imm);
+void instr32_BC(int32_t imm);
+void instr16_BD(int32_t imm);
+void instr32_BD(int32_t imm);
+void instr16_BE(int32_t imm);
+void instr32_BE(int32_t imm);
+void instr16_BF(int32_t imm);
+void instr32_BF(int32_t imm);
+void instr_C0_0_mem(int32_t addr, int32_t imm);
+void instr_C0_0_reg(int32_t r1, int32_t imm);
+void instr_C0_1_mem(int32_t addr, int32_t imm);
+void instr_C0_1_reg(int32_t r1, int32_t imm);
+void instr_C0_2_mem(int32_t addr, int32_t imm);
+void instr_C0_2_reg(int32_t r1, int32_t imm);
+void instr_C0_3_mem(int32_t addr, int32_t imm);
+void instr_C0_3_reg(int32_t r1, int32_t imm);
+void instr_C0_4_mem(int32_t addr, int32_t imm);
+void instr_C0_4_reg(int32_t r1, int32_t imm);
+void instr_C0_5_mem(int32_t addr, int32_t imm);
+void instr_C0_5_reg(int32_t r1, int32_t imm);
+void instr_C0_6_mem(int32_t addr, int32_t imm);
+void instr_C0_6_reg(int32_t r1, int32_t imm);
+void instr_C0_7_mem(int32_t addr, int32_t imm);
+void instr_C0_7_reg(int32_t r1, int32_t imm);
+void instr16_C1_0_mem(int32_t addr, int32_t imm);
+void instr16_C1_0_reg(int32_t r1, int32_t imm);
+void instr16_C1_1_mem(int32_t addr, int32_t imm);
+void instr16_C1_1_reg(int32_t r1, int32_t imm);
+void instr16_C1_2_mem(int32_t addr, int32_t imm);
+void instr16_C1_2_reg(int32_t r1, int32_t imm);
+void instr16_C1_3_mem(int32_t addr, int32_t imm);
+void instr16_C1_3_reg(int32_t r1, int32_t imm);
+void instr16_C1_4_mem(int32_t addr, int32_t imm);
+void instr16_C1_4_reg(int32_t r1, int32_t imm);
+void instr16_C1_5_mem(int32_t addr, int32_t imm);
+void instr16_C1_5_reg(int32_t r1, int32_t imm);
+void instr16_C1_6_mem(int32_t addr, int32_t imm);
+void instr16_C1_6_reg(int32_t r1, int32_t imm);
+void instr16_C1_7_mem(int32_t addr, int32_t imm);
+void instr16_C1_7_reg(int32_t r1, int32_t imm);
+void instr32_C1_0_mem(int32_t addr, int32_t imm);
+void instr32_C1_0_reg(int32_t r1, int32_t imm);
+void instr32_C1_1_mem(int32_t addr, int32_t imm);
+void instr32_C1_1_reg(int32_t r1, int32_t imm);
+void instr32_C1_2_mem(int32_t addr, int32_t imm);
+void instr32_C1_2_reg(int32_t r1, int32_t imm);
+void instr32_C1_3_mem(int32_t addr, int32_t imm);
+void instr32_C1_3_reg(int32_t r1, int32_t imm);
+void instr32_C1_4_mem(int32_t addr, int32_t imm);
+void instr32_C1_4_reg(int32_t r1, int32_t imm);
+void instr32_C1_5_mem(int32_t addr, int32_t imm);
+void instr32_C1_5_reg(int32_t r1, int32_t imm);
+void instr32_C1_6_mem(int32_t addr, int32_t imm);
+void instr32_C1_6_reg(int32_t r1, int32_t imm);
+void instr32_C1_7_mem(int32_t addr, int32_t imm);
+void instr32_C1_7_reg(int32_t r1, int32_t imm);
+void instr16_C2(int32_t imm16);
+void instr32_C2(int32_t imm16);
+void instr16_C3(void);
+void instr32_C3(void);
+void instr16_C4_reg(int32_t _unused1, int32_t _unused2);
+void instr16_C4_mem(int32_t addr, int32_t r);
+void instr32_C4_reg(int32_t _unused1, int32_t _unused2);
+void instr32_C4_mem(int32_t addr, int32_t r);
+void instr16_C5_reg(int32_t _unused1, int32_t _unused2);
+void instr16_C5_mem(int32_t addr, int32_t r);
+void instr32_C5_reg(int32_t _unused1, int32_t _unused2);
+void instr32_C5_mem(int32_t addr, int32_t r);
+void instr_C6_0_reg(int32_t r, int32_t imm);
+void instr_C6_0_mem(int32_t addr, int32_t imm);
+void instr16_C7_0_reg(int32_t r, int32_t imm);
+void instr16_C7_0_mem(int32_t addr, int32_t imm);
+void instr32_C7_0_reg(int32_t r, int32_t imm);
+void instr32_C7_0_mem(int32_t addr, int32_t imm);
+void instr16_C8(int32_t size, int32_t nesting);
+void instr32_C8(int32_t size, int32_t nesting);
+void instr16_C9(void);
+void instr32_C9(void);
+void instr16_CA(int32_t imm16);
+void instr32_CA(int32_t imm16);
+void instr16_CB(void);
+void instr32_CB(void);
+void instr_CC(void);
+void instr_CD(int32_t imm8);
+void instr_CE(void);
+void instr16_CF(void);
+void instr32_CF(void);
+void instr_D0_0_mem(int32_t addr);
+void instr_D0_0_reg(int32_t r1);
+void instr_D0_1_mem(int32_t addr);
+void instr_D0_1_reg(int32_t r1);
+void instr_D0_2_mem(int32_t addr);
+void instr_D0_2_reg(int32_t r1);
+void instr_D0_3_mem(int32_t addr);
+void instr_D0_3_reg(int32_t r1);
+void instr_D0_4_mem(int32_t addr);
+void instr_D0_4_reg(int32_t r1);
+void instr_D0_5_mem(int32_t addr);
+void instr_D0_5_reg(int32_t r1);
+void instr_D0_6_mem(int32_t addr);
+void instr_D0_6_reg(int32_t r1);
+void instr_D0_7_mem(int32_t addr);
+void instr_D0_7_reg(int32_t r1);
+void instr16_D1_0_mem(int32_t addr);
+void instr16_D1_0_reg(int32_t r1);
+void instr16_D1_1_mem(int32_t addr);
+void instr16_D1_1_reg(int32_t r1);
+void instr16_D1_2_mem(int32_t addr);
+void instr16_D1_2_reg(int32_t r1);
+void instr16_D1_3_mem(int32_t addr);
+void instr16_D1_3_reg(int32_t r1);
+void instr16_D1_4_mem(int32_t addr);
+void instr16_D1_4_reg(int32_t r1);
+void instr16_D1_5_mem(int32_t addr);
+void instr16_D1_5_reg(int32_t r1);
+void instr16_D1_6_mem(int32_t addr);
+void instr16_D1_6_reg(int32_t r1);
+void instr16_D1_7_mem(int32_t addr);
+void instr16_D1_7_reg(int32_t r1);
+void instr32_D1_0_mem(int32_t addr);
+void instr32_D1_0_reg(int32_t r1);
+void instr32_D1_1_mem(int32_t addr);
+void instr32_D1_1_reg(int32_t r1);
+void instr32_D1_2_mem(int32_t addr);
+void instr32_D1_2_reg(int32_t r1);
+void instr32_D1_3_mem(int32_t addr);
+void instr32_D1_3_reg(int32_t r1);
+void instr32_D1_4_mem(int32_t addr);
+void instr32_D1_4_reg(int32_t r1);
+void instr32_D1_5_mem(int32_t addr);
+void instr32_D1_5_reg(int32_t r1);
+void instr32_D1_6_mem(int32_t addr);
+void instr32_D1_6_reg(int32_t r1);
+void instr32_D1_7_mem(int32_t addr);
+void instr32_D1_7_reg(int32_t r1);
+void instr_D2_0_mem(int32_t addr);
+void instr_D2_0_reg(int32_t r1);
+void instr_D2_1_mem(int32_t addr);
+void instr_D2_1_reg(int32_t r1);
+void instr_D2_2_mem(int32_t addr);
+void instr_D2_2_reg(int32_t r1);
+void instr_D2_3_mem(int32_t addr);
+void instr_D2_3_reg(int32_t r1);
+void instr_D2_4_mem(int32_t addr);
+void instr_D2_4_reg(int32_t r1);
+void instr_D2_5_mem(int32_t addr);
+void instr_D2_5_reg(int32_t r1);
+void instr_D2_6_mem(int32_t addr);
+void instr_D2_6_reg(int32_t r1);
+void instr_D2_7_mem(int32_t addr);
+void instr_D2_7_reg(int32_t r1);
+void instr16_D3_0_mem(int32_t addr);
+void instr16_D3_0_reg(int32_t r1);
+void instr16_D3_1_mem(int32_t addr);
+void instr16_D3_1_reg(int32_t r1);
+void instr16_D3_2_mem(int32_t addr);
+void instr16_D3_2_reg(int32_t r1);
+void instr16_D3_3_mem(int32_t addr);
+void instr16_D3_3_reg(int32_t r1);
+void instr16_D3_4_mem(int32_t addr);
+void instr16_D3_4_reg(int32_t r1);
+void instr16_D3_5_mem(int32_t addr);
+void instr16_D3_5_reg(int32_t r1);
+void instr16_D3_6_mem(int32_t addr);
+void instr16_D3_6_reg(int32_t r1);
+void instr16_D3_7_mem(int32_t addr);
+void instr16_D3_7_reg(int32_t r1);
+void instr32_D3_0_mem(int32_t addr);
+void instr32_D3_0_reg(int32_t r1);
+void instr32_D3_1_mem(int32_t addr);
+void instr32_D3_1_reg(int32_t r1);
+void instr32_D3_2_mem(int32_t addr);
+void instr32_D3_2_reg(int32_t r1);
+void instr32_D3_3_mem(int32_t addr);
+void instr32_D3_3_reg(int32_t r1);
+void instr32_D3_4_mem(int32_t addr);
+void instr32_D3_4_reg(int32_t r1);
+void instr32_D3_5_mem(int32_t addr);
+void instr32_D3_5_reg(int32_t r1);
+void instr32_D3_6_mem(int32_t addr);
+void instr32_D3_6_reg(int32_t r1);
+void instr32_D3_7_mem(int32_t addr);
+void instr32_D3_7_reg(int32_t r1);
+void instr_D4(int32_t arg);
+void instr_D5(int32_t arg);
+void instr_D6(void);
+void instr_D7(void);
+void instr_D8_mem(int32_t addr, int32_t r);
+void instr_D8_reg(int32_t r2, int32_t r);
+void instr_D9_mem(int32_t addr, int32_t r);
+void instr_D9_reg(int32_t r2, int32_t r);
+void instr_DA_mem(int32_t addr, int32_t r);
+void instr_DA_reg(int32_t r2, int32_t r);
+void instr_DB_mem(int32_t addr, int32_t r);
+void instr_DB_reg(int32_t r2, int32_t r);
+void instr_DC_mem(int32_t addr, int32_t r);
+void instr_DC_reg(int32_t r2, int32_t r);
+void instr_DD_mem(int32_t addr, int32_t r);
+void instr_DD_reg(int32_t r2, int32_t r);
+void instr_DE_mem(int32_t addr, int32_t r);
+void instr_DE_reg(int32_t r2, int32_t r);
+void instr_DF_mem(int32_t addr, int32_t r);
+void instr_DF_reg(int32_t r2, int32_t r);
+void instr_E0(int32_t off);
+void instr_E1(int32_t off);
+void instr_E2(int32_t off);
+void instr_E3(int32_t off);
+void instr_E4(int32_t port);
+void instr16_E5(int32_t port);
+void instr32_E5(int32_t port);
+void instr_E6(int32_t port);
+void instr16_E7(int32_t port);
+void instr32_E7(int32_t port);
+void instr16_E8(int32_t imm16);
+void instr32_E8(int32_t imm32s);
+void instr16_E9(int32_t imm16);
+void instr32_E9(int32_t imm32s);
+void instr16_EA(int32_t new_ip, int32_t cs);
+void instr32_EA(int32_t new_ip, int32_t cs);
+void instr_EB(int32_t imm8);
+void instr_EC(void);
+void instr16_ED(void);
+void instr32_ED(void);
+void instr_EE(void);
+void instr16_EF(void);
+void instr32_EF(void);
+void instr_F0(void);
+void instr_F0_jit(void);
+void instr_F1(void);
+void instr_F2(void);
+void instr_F2_jit(void);
+void instr_F3(void);
+void instr_F3_jit(void);
+void instr_F4(void);
+void instr_F5(void);
+void instr_F6_0_mem(int32_t addr, int32_t imm);
+void instr_F6_0_reg(int32_t r1, int32_t imm);
+void instr_F6_1_mem(int32_t addr, int32_t imm);
+void instr_F6_1_reg(int32_t r1, int32_t imm);
+void instr_F6_2_mem(int32_t addr);
+void instr_F6_2_reg(int32_t r1);
+void instr_F6_3_mem(int32_t addr);
+void instr_F6_3_reg(int32_t r1);
+void instr_F6_4_mem(int32_t addr);
+void instr_F6_4_reg(int32_t r1);
+void instr_F6_5_mem(int32_t addr);
+void instr_F6_5_reg(int32_t r1);
+void instr_F6_6_mem(int32_t addr);
+void instr_F6_6_reg(int32_t r1);
+void instr_F6_7_mem(int32_t addr);
+void instr_F6_7_reg(int32_t r1);
+void instr16_F7_0_mem(int32_t addr, int32_t imm);
+void instr16_F7_0_reg(int32_t r1, int32_t imm);
+void instr16_F7_1_mem(int32_t addr, int32_t imm);
+void instr16_F7_1_reg(int32_t r1, int32_t imm);
+void instr16_F7_2_mem(int32_t addr);
+void instr16_F7_2_reg(int32_t r1);
+void instr16_F7_3_mem(int32_t addr);
+void instr16_F7_3_reg(int32_t r1);
+void instr16_F7_4_mem(int32_t addr);
+void instr16_F7_4_reg(int32_t r1);
+void instr16_F7_5_mem(int32_t addr);
+void instr16_F7_5_reg(int32_t r1);
+void instr16_F7_6_mem(int32_t addr);
+void instr16_F7_6_reg(int32_t r1);
+void instr16_F7_7_mem(int32_t addr);
+void instr16_F7_7_reg(int32_t r1);
+void instr32_F7_0_mem(int32_t addr, int32_t imm);
+void instr32_F7_0_reg(int32_t r1, int32_t imm);
+void instr32_F7_1_mem(int32_t addr, int32_t imm);
+void instr32_F7_1_reg(int32_t r1, int32_t imm);
+void instr32_F7_2_mem(int32_t addr);
+void instr32_F7_2_reg(int32_t r1);
+void instr32_F7_3_mem(int32_t addr);
+void instr32_F7_3_reg(int32_t r1);
+void instr32_F7_4_mem(int32_t addr);
+void instr32_F7_4_reg(int32_t r1);
+void instr32_F7_5_mem(int32_t addr);
+void instr32_F7_5_reg(int32_t r1);
+void instr32_F7_6_mem(int32_t addr);
+void instr32_F7_6_reg(int32_t r1);
+void instr32_F7_7_mem(int32_t addr);
+void instr32_F7_7_reg(int32_t r1);
+void instr_F8(void);
+void instr_F9(void);
+void instr_FA(void);
+void instr_FB(void);
+void instr_FC(void);
+void instr_FD(void);
+void instr_FE_0_mem(int32_t addr);
+void instr_FE_0_reg(int32_t r1);
+void instr_FE_1_mem(int32_t addr);
+void instr_FE_1_reg(int32_t r1);
+void instr16_FF_0_mem(int32_t addr);
+void instr16_FF_0_reg(int32_t r1);
+void instr16_FF_1_mem(int32_t addr);
+void instr16_FF_1_reg(int32_t r1);
+void instr16_FF_2_helper(int32_t data);
+void instr16_FF_2_mem(int32_t addr);
+void instr16_FF_2_reg(int32_t r1);
+void instr16_FF_3_reg(int32_t r);
+void instr16_FF_3_mem(int32_t addr);
+void instr16_FF_4_helper(int32_t data);
+void instr16_FF_4_mem(int32_t addr);
+void instr16_FF_4_reg(int32_t r1);
+void instr16_FF_5_reg(int32_t r);
+void instr16_FF_5_mem(int32_t addr);
+void instr16_FF_6_mem(int32_t addr);
+void instr16_FF_6_reg(int32_t r1);
+void instr32_FF_0_mem(int32_t addr);
+void instr32_FF_0_reg(int32_t r1);
+void instr32_FF_1_mem(int32_t addr);
+void instr32_FF_1_reg(int32_t r1);
+void instr32_FF_2_helper(int32_t data);
+void instr32_FF_2_mem(int32_t addr);
+void instr32_FF_2_reg(int32_t r1);
+void instr32_FF_3_reg(int32_t r);
+void instr32_FF_3_mem(int32_t addr);
+void instr32_FF_4_helper(int32_t data);
+void instr32_FF_4_mem(int32_t addr);
+void instr32_FF_4_reg(int32_t r1);
+void instr32_FF_5_reg(int32_t r);
+void instr32_FF_5_mem(int32_t addr);
+void instr32_FF_6_mem(int32_t addr);
+void instr32_FF_6_reg(int32_t r1);
+void run_instruction(int32_t opcode);
+void jit_instruction(int32_t opcode);

src/native/instructions_0f.c

@@ -5,122 +5,48 @@
 #include <stdlib.h>
 
 #include "const.h"
+#include "cpu.h"
+#include "log.h"
+#include "misc_instr.h"
+#include "arith.h"
+#include "fpu.h"
 #include "sse_instr.h"
 #include "global_pointers.h"
+#include "memory.h"
+#include "instructions.h"
+#include "instructions_0f.h"
+#include "codegen/codegen.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 
-// XXX: Remove these declarations when they are implemented in C
-void cmovcc16(bool, int32_t, int32_t);
-void cmovcc32(bool, int32_t, int32_t);
-void jmpcc16(bool, int32_t);
-void jmpcc32(bool, int32_t);
-void setcc(bool);
-void cpuid();
-
-void bt_mem(int32_t, int32_t);
-void bt_reg(int32_t, int32_t);
-void bts_mem(int32_t, int32_t);
-int32_t bts_reg(int32_t, int32_t);
-void btc_mem(int32_t, int32_t);
-int32_t btc_reg(int32_t, int32_t);
-void btr_mem(int32_t, int32_t);
-int32_t btr_reg(int32_t, int32_t);
-int32_t bsf16(int32_t, int32_t);
-int32_t bsf32(int32_t, int32_t);
-int32_t bsr16(int32_t, int32_t);
-int32_t bsr32(int32_t, int32_t);
-
-int32_t popcnt(int32_t);
-int32_t bswap(int32_t);
-
-void cpl_changed(void);
-void update_cs_size(int32_t);
-void unimplemented_sse(void);
-
-int32_t shld16(int32_t, int32_t, int32_t);
-int32_t shld32(int32_t, int32_t, int32_t);
-int32_t shrd16(int32_t, int32_t, int32_t);
-int32_t shrd32(int32_t, int32_t, int32_t);
-
-bool has_rand_int(void);
-int32_t get_rand_int(void);
-
-void todo();
-void undefined_instruction();
-
-void clear_tlb();
-void full_clear_tlb();
-
-double_t microtick();
-
-int32_t lsl(int32_t, int32_t);
-int32_t lar(int32_t, int32_t);
-int32_t verw(int32_t);
-int32_t verr(int32_t);
-
-void invlpg(int32_t);
-void load_tr(int32_t);
-void load_ldt(int32_t);
-
-int32_t set_cr0(int32_t);
-void writable_or_pagefault(int32_t, int32_t);
+extern void setcc(bool);
+extern void cpuid();
+extern void cpl_changed(void);
+extern void update_cs_size(int32_t);
+extern void unimplemented_sse(void);
+extern bool has_rand_int(void);
+extern int32_t get_rand_int(void);
+extern void todo();
+extern void undefined_instruction();
+extern void full_clear_tlb();
+extern int32_t lsl(int32_t, int32_t);
+extern int32_t lar(int32_t, int32_t);
+extern int32_t verw(int32_t);
+extern int32_t verr(int32_t);
+extern void invlpg(int32_t);
+extern void load_tr(int32_t);
+extern void load_ldt(int32_t);
+extern int32_t set_cr0(int32_t);
+extern void writable_or_pagefault(int32_t, int32_t);
+extern void switch_seg(int32_t, int32_t);
+extern int32_t bswap(int32_t);
+extern bool vm86_mode(void);
+extern void lss16(int32_t, int32_t, int32_t);
+extern void lss32(int32_t, int32_t, int32_t);
 
 bool* const apic_enabled;
 
-
-void write_reg8(int32_t index, int32_t value);
-int32_t read_reg16(int32_t index);
-void write_reg16(int32_t index, int32_t value);
-int32_t read_reg32(int32_t index);
-void write_reg32(int32_t index, int32_t value);
-
-
-#define DEFINE_MODRM_INSTR_READ16(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read16(addr); fun; } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg16(r1); fun; }
-
-#define DEFINE_MODRM_INSTR_READ32(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read32s(addr); fun; } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg32(r1); fun; }
-
-
-#define DEFINE_MODRM_INSTR_IMM_READ_WRITE_16(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r, int32_t imm) { SAFE_READ_WRITE16(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t r, int32_t imm) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
-
-#define DEFINE_MODRM_INSTR_IMM_READ_WRITE_32(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r, int32_t imm) { SAFE_READ_WRITE32(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t r, int32_t imm) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
-
-
-#define DEFINE_MODRM_INSTR_READ_WRITE_8(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE8(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg8(r1); write_reg8(r1, fun); }
-
-#define DEFINE_MODRM_INSTR_READ_WRITE_16(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE16(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
-
-#define DEFINE_MODRM_INSTR_READ_WRITE_32(name, fun) \
-    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE32(addr, fun) } \
-    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
-
-
-#define DEFINE_SSE_SPLIT(name, mem_fn, reg_fn) \
-    void name ## _reg(int32_t r1, int32_t r2) { name(reg_fn(r1), r2); } \
-    void name ## _mem(int32_t addr, int32_t r) { name(mem_fn(addr), r); } \
-
-#define DEFINE_SSE_SPLIT_IMM(name, mem_fn, reg_fn) \
-    void name ## _reg(int32_t r1, int32_t r2, int32_t imm) { name(reg_fn(r1), r2, imm); } \
-    void name ## _mem(int32_t addr, int32_t r, int32_t imm) { name(mem_fn(addr), r, imm); } \
-
-#define DEFINE_SSE_SPLIT_WRITE(name, mem_fn, reg_fn) \
-    void name ## _reg(int32_t r1, int32_t r2) { reg_fn(r1, name(r2)); } \
-    void name ## _mem(int32_t addr, int32_t r) { mem_fn(addr, name(r)); } \
-
-
 void instr_0F00_0_mem(int32_t addr) {
     // sldt
     if(!protected_mode[0] || vm86_mode()) trigger_ud();

src/native/instructions_0f.h

@@ -0,0 +1,1000 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "shared.h"
+
+#define DEFINE_MODRM_INSTR_READ16(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read16(addr); fun; } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg16(r1); fun; }
+
+#define DEFINE_MODRM_INSTR_READ32(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { int32_t ___ = safe_read32s(addr); fun; } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg32(r1); fun; }
+
+
+#define DEFINE_MODRM_INSTR_IMM_READ_WRITE_16(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r, int32_t imm) { SAFE_READ_WRITE16(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t r, int32_t imm) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
+
+#define DEFINE_MODRM_INSTR_IMM_READ_WRITE_32(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r, int32_t imm) { SAFE_READ_WRITE32(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t r, int32_t imm) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
+
+
+#define DEFINE_MODRM_INSTR_READ_WRITE_8(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE8(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg8(r1); write_reg8(r1, fun); }
+
+#define DEFINE_MODRM_INSTR_READ_WRITE_16(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE16(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg16(r1); write_reg16(r1, fun); }
+
+#define DEFINE_MODRM_INSTR_READ_WRITE_32(name, fun) \
+    void name ## _mem(int32_t addr, int32_t r) { SAFE_READ_WRITE32(addr, fun) } \
+    void name ## _reg(int32_t r1, int32_t r) { int32_t ___ = read_reg32(r1); write_reg32(r1, fun); }
+
+
+#define DEFINE_SSE_SPLIT(name, mem_fn, reg_fn) \
+    void name ## _reg(int32_t r1, int32_t r2) { name(reg_fn(r1), r2); } \
+    void name ## _mem(int32_t addr, int32_t r) { name(mem_fn(addr), r); } \
+
+#define DEFINE_SSE_SPLIT_IMM(name, mem_fn, reg_fn) \
+    void name ## _reg(int32_t r1, int32_t r2, int32_t imm) { name(reg_fn(r1), r2, imm); } \
+    void name ## _mem(int32_t addr, int32_t r, int32_t imm) { name(mem_fn(addr), r, imm); } \
+
+#define DEFINE_SSE_SPLIT_WRITE(name, mem_fn, reg_fn) \
+    void name ## _reg(int32_t r1, int32_t r2) { reg_fn(r1, name(r2)); } \
+    void name ## _mem(int32_t addr, int32_t r) { mem_fn(addr, name(r)); } \
+
+void instr_0F00_0_mem(int32_t addr);
+void instr_0F00_0_reg(int32_t r);
+void instr_0F00_1_mem(int32_t addr);
+void instr_0F00_1_reg(int32_t r);
+void instr_0F00_2_mem(int32_t addr);
+void instr_0F00_2_reg(int32_t r);
+void instr_0F00_3_mem(int32_t addr);
+void instr_0F00_3_reg(int32_t r);
+void instr_0F00_4_mem(int32_t addr);
+void instr_0F00_4_reg(int32_t r);
+void instr_0F00_5_mem(int32_t addr);
+void instr_0F00_5_reg(int32_t r);
+void instr_0F01_0_reg(int32_t r);
+void instr_0F01_0_mem(int32_t addr);
+void instr_0F01_1_reg(int32_t r);
+void instr_0F01_1_mem(int32_t addr);
+void instr_0F01_2_reg(int32_t r);
+void instr_0F01_2_mem(int32_t addr);
+void instr_0F01_3_reg(int32_t r);
+void instr_0F01_3_mem(int32_t addr);
+void instr_0F01_4_reg(int32_t r);
+void instr_0F01_4_mem(int32_t addr);
+void lmsw(int32_t new_cr0);
+void instr_0F01_6_reg(int32_t r);
+void instr_0F01_6_mem(int32_t addr);
+void instr_0F01_7_reg(int32_t r);
+void instr_0F01_7_mem(int32_t addr);
+void instr16_0F02_mem(int32_t addr, int32_t r);
+void instr16_0F02_reg(int32_t r1, int32_t r);
+void instr32_0F02_mem(int32_t addr, int32_t r);
+void instr32_0F02_reg(int32_t r1, int32_t r);
+void instr16_0F03_mem(int32_t addr, int32_t r);
+void instr16_0F03_reg(int32_t r1, int32_t r);
+void instr32_0F03_mem(int32_t addr, int32_t r);
+void instr32_0F03_reg(int32_t r1, int32_t r);
+void instr_0F04(void);
+void instr_0F05(void);
+void instr_0F06(void);
+void instr_0F07(void);
+void instr_0F08(void);
+void instr_0F09(void);
+void instr_0F0A(void);
+void instr_0F0B(void);
+void instr_0F0C(void);
+void instr_0F0D(void);
+void instr_0F0E(void);
+void instr_0F0F(void);
+void instr_0F10(union reg128 source, int32_t r);
+void instr_0F10_reg(int32_t r1, int32_t r2);
+void instr_0F10_mem(int32_t addr, int32_t r);
+void instr_F30F10_reg(int32_t r1, int32_t r2);
+void instr_F30F10_mem(int32_t addr, int32_t r);
+void instr_660F10(union reg128 source, int32_t r);
+void instr_660F10_reg(int32_t r1, int32_t r2);
+void instr_660F10_mem(int32_t addr, int32_t r);
+void instr_F20F10_reg(int32_t r1, int32_t r2);
+void instr_F20F10_mem(int32_t addr, int32_t r);
+void instr_0F11_reg(int32_t r1, int32_t r2);
+void instr_0F11_mem(int32_t addr, int32_t r);
+void instr_F30F11_reg(int32_t rm_dest, int32_t reg_src);
+void instr_F30F11_mem(int32_t addr, int32_t r);
+void instr_660F11_reg(int32_t r1, int32_t r2);
+void instr_660F11_mem(int32_t addr, int32_t r);
+void instr_F20F11_reg(int32_t r1, int32_t r2);
+void instr_F20F11_mem(int32_t addr, int32_t r);
+void instr_0F12_mem(int32_t addr, int32_t r);
+void instr_0F12_reg(int32_t r1, int32_t r2);
+void instr_660F12_reg(int32_t r1, int32_t r);
+void instr_660F12_mem(int32_t addr, int32_t r);
+void instr_F20F12_mem(int32_t addr, int32_t r);
+void instr_F20F12_reg(int32_t r1, int32_t r2);
+void instr_F30F12_mem(int32_t addr, int32_t r);
+void instr_F30F12_reg(int32_t r1, int32_t r2);
+void instr_0F13_mem(int32_t addr, int32_t r);
+void instr_0F13_reg(int32_t r1, int32_t r2);
+void instr_660F13_reg(int32_t r1, int32_t r);
+void instr_660F13_mem(int32_t addr, int32_t r);
+void instr_0F14(union reg64 source, int32_t r);
+void instr_0F14_reg(int32_t r1, int32_t r2);
+void instr_0F14_mem(int32_t addr, int32_t r);
+void instr_660F14(union reg64 source, int32_t r);
+void instr_660F14_reg(int32_t r1, int32_t r2);
+void instr_660F14_mem(int32_t addr, int32_t r);
+void instr_0F15(union reg128 source, int32_t r);
+void instr_0F15_reg(int32_t r1, int32_t r2);
+void instr_0F15_mem(int32_t addr, int32_t r);
+void instr_660F15(union reg128 source, int32_t r);
+void instr_660F15_reg(int32_t r1, int32_t r2);
+void instr_660F15_mem(int32_t addr, int32_t r);
+void instr_0F16_mem(int32_t addr, int32_t r);
+void instr_0F16_reg(int32_t r1, int32_t r2);
+void instr_660F16_mem(int32_t addr, int32_t r);
+void instr_660F16_reg(int32_t r1, int32_t r2);
+void instr_0F17_mem(int32_t addr, int32_t r);
+void instr_0F17_reg(int32_t r1, int32_t r2);
+void instr_660F17_mem(int32_t addr, int32_t r);
+void instr_660F17_reg(int32_t r1, int32_t r2);
+void instr_0F18_reg(int32_t r1, int32_t r2);
+void instr_0F18_mem(int32_t addr, int32_t r);
+void instr_0F19(void);
+void instr_0F1A(void);
+void instr_0F1B(void);
+void instr_0F1C(void);
+void instr_0F1D(void);
+void instr_0F1E(void);
+void instr_0F1F_reg(int32_t r1, int32_t r2);
+void instr_0F1F_mem(int32_t addr, int32_t r);
+void instr_0F20(int32_t r, int32_t creg);
+void instr_0F21(int32_t r, int32_t dreg_index);
+void instr_0F22(int32_t r, int32_t creg);
+void instr_0F23(int32_t r, int32_t dreg_index);
+void instr_0F24(void);
+void instr_0F25(void);
+void instr_0F26(void);
+void instr_0F27(void);
+void instr_0F28(union reg128 source, int32_t r);
+void instr_0F28_reg(int32_t r1, int32_t r2);
+void instr_0F28_mem(int32_t addr, int32_t r);
+void instr_660F28(union reg128 source, int32_t r);
+void instr_660F28_reg(int32_t r1, int32_t r2);
+void instr_660F28_mem(int32_t addr, int32_t r);
+void instr_0F29_mem(int32_t addr, int32_t r);
+void instr_0F29_reg(int32_t r1, int32_t r2);
+void instr_660F29_mem(int32_t addr, int32_t r);
+void instr_660F29_reg(int32_t r1, int32_t r2);
+void instr_0F2A(void);
+void instr_0F2B_reg(int32_t r1, int32_t r2);
+void instr_0F2B_mem(int32_t addr, int32_t r);
+void instr_660F2B_reg(int32_t r1, int32_t r2);
+void instr_660F2B_mem(int32_t addr, int32_t r);
+void instr_0F2C_mem(int32_t addr, int32_t r);
+void instr_0F2C_reg(int32_t r1, int32_t r2);
+void instr_660F2C_mem(int32_t addr, int32_t r);
+void instr_660F2C_reg(int32_t r1, int32_t r2);
+void instr_F20F2C(union reg64 source, int32_t r);
+void instr_F20F2C_reg(int32_t r1, int32_t r2);
+void instr_F20F2C_mem(int32_t addr, int32_t r);
+void instr_F30F2C_mem(int32_t addr, int32_t r);
+void instr_F30F2C_reg(int32_t r1, int32_t r2);
+void instr_0F2D(void);
+void instr_0F2E(void);
+void instr_0F2F(void);
+void instr_0F30(void);
+void instr_0F31(void);
+void instr_0F32(void);
+void instr_0F33(void);
+void instr_0F34(void);
+void instr_0F35(void);
+void instr_0F36(void);
+void instr_0F37(void);
+void instr_0F38(void);
+void instr_0F39(void);
+void instr_0F3A(void);
+void instr_0F3B(void);
+void instr_0F3C(void);
+void instr_0F3D(void);
+void instr_0F3E(void);
+void instr_0F3F(void);
+void instr16_0F40_mem(int32_t addr, int32_t r);
+void instr16_0F40_reg(int32_t r1, int32_t r);
+void instr32_0F40_mem(int32_t addr, int32_t r);
+void instr32_0F40_reg(int32_t r1, int32_t r);
+void instr16_0F41_mem(int32_t addr, int32_t r);
+void instr16_0F41_reg(int32_t r1, int32_t r);
+void instr32_0F41_mem(int32_t addr, int32_t r);
+void instr32_0F41_reg(int32_t r1, int32_t r);
+void instr16_0F42_mem(int32_t addr, int32_t r);
+void instr16_0F42_reg(int32_t r1, int32_t r);
+void instr32_0F42_mem(int32_t addr, int32_t r);
+void instr32_0F42_reg(int32_t r1, int32_t r);
+void instr16_0F43_mem(int32_t addr, int32_t r);
+void instr16_0F43_reg(int32_t r1, int32_t r);
+void instr32_0F43_mem(int32_t addr, int32_t r);
+void instr32_0F43_reg(int32_t r1, int32_t r);
+void instr16_0F44_mem(int32_t addr, int32_t r);
+void instr16_0F44_reg(int32_t r1, int32_t r);
+void instr32_0F44_mem(int32_t addr, int32_t r);
+void instr32_0F44_reg(int32_t r1, int32_t r);
+void instr16_0F45_mem(int32_t addr, int32_t r);
+void instr16_0F45_reg(int32_t r1, int32_t r);
+void instr32_0F45_mem(int32_t addr, int32_t r);
+void instr32_0F45_reg(int32_t r1, int32_t r);
+void instr16_0F46_mem(int32_t addr, int32_t r);
+void instr16_0F46_reg(int32_t r1, int32_t r);
+void instr32_0F46_mem(int32_t addr, int32_t r);
+void instr32_0F46_reg(int32_t r1, int32_t r);
+void instr16_0F47_mem(int32_t addr, int32_t r);
+void instr16_0F47_reg(int32_t r1, int32_t r);
+void instr32_0F47_mem(int32_t addr, int32_t r);
+void instr32_0F47_reg(int32_t r1, int32_t r);
+void instr16_0F48_mem(int32_t addr, int32_t r);
+void instr16_0F48_reg(int32_t r1, int32_t r);
+void instr32_0F48_mem(int32_t addr, int32_t r);
+void instr32_0F48_reg(int32_t r1, int32_t r);
+void instr16_0F49_mem(int32_t addr, int32_t r);
+void instr16_0F49_reg(int32_t r1, int32_t r);
+void instr32_0F49_mem(int32_t addr, int32_t r);
+void instr32_0F49_reg(int32_t r1, int32_t r);
+void instr16_0F4A_mem(int32_t addr, int32_t r);
+void instr16_0F4A_reg(int32_t r1, int32_t r);
+void instr32_0F4A_mem(int32_t addr, int32_t r);
+void instr32_0F4A_reg(int32_t r1, int32_t r);
+void instr16_0F4B_mem(int32_t addr, int32_t r);
+void instr16_0F4B_reg(int32_t r1, int32_t r);
+void instr32_0F4B_mem(int32_t addr, int32_t r);
+void instr32_0F4B_reg(int32_t r1, int32_t r);
+void instr16_0F4C_mem(int32_t addr, int32_t r);
+void instr16_0F4C_reg(int32_t r1, int32_t r);
+void instr32_0F4C_mem(int32_t addr, int32_t r);
+void instr32_0F4C_reg(int32_t r1, int32_t r);
+void instr16_0F4D_mem(int32_t addr, int32_t r);
+void instr16_0F4D_reg(int32_t r1, int32_t r);
+void instr32_0F4D_mem(int32_t addr, int32_t r);
+void instr32_0F4D_reg(int32_t r1, int32_t r);
+void instr16_0F4E_mem(int32_t addr, int32_t r);
+void instr16_0F4E_reg(int32_t r1, int32_t r);
+void instr32_0F4E_mem(int32_t addr, int32_t r);
+void instr32_0F4E_reg(int32_t r1, int32_t r);
+void instr16_0F4F_mem(int32_t addr, int32_t r);
+void instr16_0F4F_reg(int32_t r1, int32_t r);
+void instr32_0F4F_mem(int32_t addr, int32_t r);
+void instr32_0F4F_reg(int32_t r1, int32_t r);
+void instr_0F50_reg(int32_t r1, int32_t r2);
+void instr_0F50_mem(int32_t addr, int32_t r1);
+void instr_660F50_reg(int32_t r1, int32_t r2);
+void instr_660F50_mem(int32_t addr, int32_t r1);
+void instr_0F51(void);
+void instr_0F52(void);
+void instr_0F53(void);
+void instr_0F54(union reg128 source, int32_t r);
+void instr_0F54_reg(int32_t r1, int32_t r2);
+void instr_0F54_mem(int32_t addr, int32_t r);
+void instr_660F54(union reg128 source, int32_t r);
+void instr_660F54_reg(int32_t r1, int32_t r2);
+void instr_660F54_mem(int32_t addr, int32_t r);
+void instr_0F55(union reg128 source, int32_t r);
+void instr_0F55_reg(int32_t r1, int32_t r2);
+void instr_0F55_mem(int32_t addr, int32_t r);
+void instr_660F55(union reg128 source, int32_t r);
+void instr_660F55_reg(int32_t r1, int32_t r2);
+void instr_660F55_mem(int32_t addr, int32_t r);
+void instr_0F56(union reg128 source, int32_t r);
+void instr_0F56_reg(int32_t r1, int32_t r2);
+void instr_0F56_mem(int32_t addr, int32_t r);
+void instr_660F56(union reg128 source, int32_t r);
+void instr_660F56_reg(int32_t r1, int32_t r2);
+void instr_660F56_mem(int32_t addr, int32_t r);
+void instr_0F57(union reg128 source, int32_t r);
+void instr_0F57_reg(int32_t r1, int32_t r2);
+void instr_0F57_mem(int32_t addr, int32_t r);
+void instr_660F57(union reg128 source, int32_t r);
+void instr_660F57_reg(int32_t r1, int32_t r2);
+void instr_660F57_mem(int32_t addr, int32_t r);
+void instr_0F58(void);
+void instr_0F59(void);
+void instr_0F5A(void);
+void instr_0F5B(void);
+void instr_0F5C(void);
+void instr_0F5D(void);
+void instr_0F5E(void);
+void instr_0F5F(void);
+void instr_0F60(int32_t source, int32_t r);
+void instr_0F60_reg(int32_t r1, int32_t r2);
+void instr_0F60_mem(int32_t addr, int32_t r);
+void instr_660F60(union reg64 source, int32_t r);
+void instr_660F60_reg(int32_t r1, int32_t r2);
+void instr_660F60_mem(int32_t addr, int32_t r);
+void instr_0F61(int32_t source, int32_t r);
+void instr_0F61_reg(int32_t r1, int32_t r2);
+void instr_0F61_mem(int32_t addr, int32_t r);
+void instr_660F61(union reg64 source, int32_t r);
+void instr_660F61_reg(int32_t r1, int32_t r2);
+void instr_660F61_mem(int32_t addr, int32_t r);
+void instr_0F62(int32_t source, int32_t r);
+void instr_0F62_reg(int32_t r1, int32_t r2);
+void instr_0F62_mem(int32_t addr, int32_t r);
+void instr_660F62(union reg128 source, int32_t r);
+void instr_660F62_reg(int32_t r1, int32_t r2);
+void instr_660F62_mem(int32_t addr, int32_t r);
+void instr_0F63(union reg64 source, int32_t r);
+void instr_0F63_reg(int32_t r1, int32_t r2);
+void instr_0F63_mem(int32_t addr, int32_t r);
+void instr_660F63(union reg128 source, int32_t r);
+void instr_660F63_reg(int32_t r1, int32_t r2);
+void instr_660F63_mem(int32_t addr, int32_t r);
+void instr_0F64(union reg64 source, int32_t r);
+void instr_0F64_reg(int32_t r1, int32_t r2);
+void instr_0F64_mem(int32_t addr, int32_t r);
+void instr_660F64(union reg128 source, int32_t r);
+void instr_660F64_reg(int32_t r1, int32_t r2);
+void instr_660F64_mem(int32_t addr, int32_t r);
+void instr_0F65(union reg64 source, int32_t r);
+void instr_0F65_reg(int32_t r1, int32_t r2);
+void instr_0F65_mem(int32_t addr, int32_t r);
+void instr_660F65(union reg128 source, int32_t r);
+void instr_660F65_reg(int32_t r1, int32_t r2);
+void instr_660F65_mem(int32_t addr, int32_t r);
+void instr_0F66(union reg64 source, int32_t r);
+void instr_0F66_reg(int32_t r1, int32_t r2);
+void instr_0F66_mem(int32_t addr, int32_t r);
+void instr_660F66(union reg128 source, int32_t r);
+void instr_660F66_reg(int32_t r1, int32_t r2);
+void instr_660F66_mem(int32_t addr, int32_t r);
+void instr_0F67(union reg64 source, int32_t r);
+void instr_0F67_reg(int32_t r1, int32_t r2);
+void instr_0F67_mem(int32_t addr, int32_t r);
+void instr_660F67(union reg128 source, int32_t r);
+void instr_660F67_reg(int32_t r1, int32_t r2);
+void instr_660F67_mem(int32_t addr, int32_t r);
+void instr_0F68(union reg64 source, int32_t r);
+void instr_0F68_reg(int32_t r1, int32_t r2);
+void instr_0F68_mem(int32_t addr, int32_t r);
+void instr_660F68(union reg128 source, int32_t r);
+void instr_660F68_reg(int32_t r1, int32_t r2);
+void instr_660F68_mem(int32_t addr, int32_t r);
+void instr_0F69(union reg64 source, int32_t r);
+void instr_0F69_reg(int32_t r1, int32_t r2);
+void instr_0F69_mem(int32_t addr, int32_t r);
+void instr_660F69(union reg128 source, int32_t r);
+void instr_660F69_reg(int32_t r1, int32_t r2);
+void instr_660F69_mem(int32_t addr, int32_t r);
+void instr_0F6A(union reg64 source, int32_t r);
+void instr_0F6A_reg(int32_t r1, int32_t r2);
+void instr_0F6A_mem(int32_t addr, int32_t r);
+void instr_660F6A(union reg128 source, int32_t r);
+void instr_660F6A_reg(int32_t r1, int32_t r2);
+void instr_660F6A_mem(int32_t addr, int32_t r);
+void instr_0F6B(union reg64 source, int32_t r);
+void instr_0F6B_reg(int32_t r1, int32_t r2);
+void instr_0F6B_mem(int32_t addr, int32_t r);
+void instr_660F6B(union reg128 source, int32_t r);
+void instr_660F6B_reg(int32_t r1, int32_t r2);
+void instr_660F6B_mem(int32_t addr, int32_t r);
+void instr_0F6C_mem(int32_t addr, int32_t r);
+void instr_0F6C_reg(int32_t r1, int32_t r2);
+void instr_660F6C(union reg128 source, int32_t r);
+void instr_660F6C_reg(int32_t r1, int32_t r2);
+void instr_660F6C_mem(int32_t addr, int32_t r);
+void instr_0F6D_mem(int32_t addr, int32_t r);
+void instr_0F6D_reg(int32_t r1, int32_t r2);
+void instr_660F6D(union reg128 source, int32_t r);
+void instr_660F6D_reg(int32_t r1, int32_t r2);
+void instr_660F6D_mem(int32_t addr, int32_t r);
+void instr_0F6E(int32_t source, int32_t r);
+void instr_0F6E_reg(int32_t r1, int32_t r2);
+void instr_0F6E_mem(int32_t addr, int32_t r);
+void instr_660F6E(int32_t source, int32_t r);
+void instr_660F6E_reg(int32_t r1, int32_t r2);
+void instr_660F6E_mem(int32_t addr, int32_t r);
+void instr_0F6F(union reg64 source, int32_t r);
+void instr_0F6F_reg(int32_t r1, int32_t r2);
+void instr_0F6F_mem(int32_t addr, int32_t r);
+void instr_660F6F(union reg128 source, int32_t r);
+void instr_660F6F_reg(int32_t r1, int32_t r2);
+void instr_660F6F_mem(int32_t addr, int32_t r);
+void instr_F30F6F(union reg128 source, int32_t r);
+void instr_F30F6F_reg(int32_t r1, int32_t r2);
+void instr_F30F6F_mem(int32_t addr, int32_t r);
+void instr_0F70(union reg64 source, int32_t r, int32_t imm8);
+void instr_0F70_reg(int32_t r1, int32_t r2, int32_t imm);
+void instr_0F70_mem(int32_t addr, int32_t r, int32_t imm);
+void instr_660F70(union reg128 source, int32_t r, int32_t imm8);
+void instr_660F70_reg(int32_t r1, int32_t r2, int32_t imm);
+void instr_660F70_mem(int32_t addr, int32_t r, int32_t imm);
+void instr_F20F70(union reg128 source, int32_t r, int32_t imm8);
+void instr_F20F70_reg(int32_t r1, int32_t r2, int32_t imm);
+void instr_F20F70_mem(int32_t addr, int32_t r, int32_t imm);
+void instr_F30F70(union reg128 source, int32_t r, int32_t imm8);
+void instr_F30F70_reg(int32_t r1, int32_t r2, int32_t imm);
+void instr_F30F70_mem(int32_t addr, int32_t r, int32_t imm);
+void instr_0F71_2_mem(int32_t addr, int32_t r);
+void instr_0F71_4_mem(int32_t addr, int32_t r);
+void instr_0F71_6_mem(int32_t addr, int32_t r);
+void instr_0F71_2_reg(int32_t r, int32_t imm8);
+void instr_0F71_4_reg(int32_t r, int32_t imm8);
+void instr_0F71_6_reg(int32_t r, int32_t imm8);
+void instr_660F71_2_mem(int32_t addr, int32_t r);
+void instr_660F71_4_mem(int32_t addr, int32_t r);
+void instr_660F71_6_mem(int32_t addr, int32_t r);
+void instr_660F71_2_reg(int32_t r, int32_t imm8);
+void instr_660F71_4_reg(int32_t r, int32_t imm8);
+void instr_660F71_6_reg(int32_t r, int32_t imm8);
+void instr_0F72_2_mem(int32_t addr, int32_t r);
+void instr_0F72_4_mem(int32_t addr, int32_t r);
+void instr_0F72_6_mem(int32_t addr, int32_t r);
+void instr_0F72_2_reg(int32_t r, int32_t imm8);
+void instr_0F72_4_reg(int32_t r, int32_t imm8);
+void instr_0F72_6_reg(int32_t r, int32_t imm8);
+void instr_660F72_2_mem(int32_t addr, int32_t r);
+void instr_660F72_4_mem(int32_t addr, int32_t r);
+void instr_660F72_6_mem(int32_t addr, int32_t r);
+void instr_660F72_2_reg(int32_t r, int32_t imm8);
+void instr_660F72_4_reg(int32_t r, int32_t imm8);
+void instr_660F72_6_reg(int32_t r, int32_t imm8);
+void instr_0F73_2_mem(int32_t addr, int32_t r);
+void instr_0F73_3_mem(int32_t addr, int32_t r);
+void instr_0F73_3_reg(int32_t addr, int32_t r);
+void instr_0F73_6_mem(int32_t addr, int32_t r);
+void instr_0F73_7_mem(int32_t addr, int32_t r);
+void instr_0F73_7_reg(int32_t addr, int32_t r);
+void instr_0F73_2_reg(int32_t r, int32_t imm8);
+void instr_0F73_6_reg(int32_t r, int32_t imm8);
+void instr_660F73_2_mem(int32_t addr, int32_t r);
+void instr_660F73_3_mem(int32_t addr, int32_t r);
+void instr_660F73_6_mem(int32_t addr, int32_t r);
+void instr_660F73_7_mem(int32_t addr, int32_t r);
+void instr_660F73_2_reg(int32_t r, int32_t imm8);
+void instr_660F73_3_reg(int32_t r, int32_t imm8);
+void instr_660F73_6_reg(int32_t r, int32_t imm8);
+void instr_660F73_7_reg(int32_t r, int32_t imm8);
+void instr_0F74(union reg64 source, int32_t r);
+void instr_0F74_reg(int32_t r1, int32_t r2);
+void instr_0F74_mem(int32_t addr, int32_t r);
+void instr_660F74(union reg128 source, int32_t r);
+void instr_660F74_reg(int32_t r1, int32_t r2);
+void instr_660F74_mem(int32_t addr, int32_t r);
+void instr_0F75(union reg64 source, int32_t r);
+void instr_0F75_reg(int32_t r1, int32_t r2);
+void instr_0F75_mem(int32_t addr, int32_t r);
+void instr_660F75(union reg128 source, int32_t r);
+void instr_660F75_reg(int32_t r1, int32_t r2);
+void instr_660F75_mem(int32_t addr, int32_t r);
+void instr_0F76(union reg64 source, int32_t r);
+void instr_0F76_reg(int32_t r1, int32_t r2);
+void instr_0F76_mem(int32_t addr, int32_t r);
+void instr_660F76(union reg128 source, int32_t r);
+void instr_660F76_reg(int32_t r1, int32_t r2);
+void instr_660F76_mem(int32_t addr, int32_t r);
+void instr_0F77(void);
+void instr_0F78(void);
+void instr_0F79(void);
+void instr_0F7A(void);
+void instr_0F7B(void);
+void instr_0F7C(void);
+void instr_0F7D(void);
+int32_t instr_0F7E(int32_t r);
+void instr_0F7E_reg(int32_t r1, int32_t r2);
+void instr_0F7E_mem(int32_t addr, int32_t r);
+int32_t instr_660F7E(int32_t r);
+void instr_660F7E_reg(int32_t r1, int32_t r2);
+void instr_660F7E_mem(int32_t addr, int32_t r);
+void instr_F30F7E_mem(int32_t addr, int32_t r);
+void instr_F30F7E_reg(int32_t r1, int32_t r2);
+void instr_0F7F_mem(int32_t addr, int32_t r);
+void instr_0F7F_reg(int32_t r1, int32_t r2);
+void instr_660F7F_mem(int32_t addr, int32_t r);
+void instr_660F7F_reg(int32_t r1, int32_t r2);
+void instr_F30F7F_mem(int32_t addr, int32_t r);
+void instr_F30F7F_reg(int32_t r1, int32_t r2);
+void instr16_0F80(int32_t imm);
+void instr32_0F80(int32_t imm);
+void instr16_0F81(int32_t imm);
+void instr32_0F81(int32_t imm);
+void instr16_0F82(int32_t imm);
+void instr32_0F82(int32_t imm);
+void instr16_0F83(int32_t imm);
+void instr32_0F83(int32_t imm);
+void instr16_0F84(int32_t imm);
+void instr32_0F84(int32_t imm);
+void instr16_0F85(int32_t imm);
+void instr32_0F85(int32_t imm);
+void instr16_0F86(int32_t imm);
+void instr32_0F86(int32_t imm);
+void instr16_0F87(int32_t imm);
+void instr32_0F87(int32_t imm);
+void instr16_0F88(int32_t imm);
+void instr32_0F88(int32_t imm);
+void instr16_0F89(int32_t imm);
+void instr32_0F89(int32_t imm);
+void instr16_0F8A(int32_t imm);
+void instr32_0F8A(int32_t imm);
+void instr16_0F8B(int32_t imm);
+void instr32_0F8B(int32_t imm);
+void instr16_0F8C(int32_t imm);
+void instr32_0F8C(int32_t imm);
+void instr16_0F8D(int32_t imm);
+void instr32_0F8D(int32_t imm);
+void instr16_0F8E(int32_t imm);
+void instr32_0F8E(int32_t imm);
+void instr16_0F8F(int32_t imm);
+void instr32_0F8F(int32_t imm);
+void instr_0F90_reg(int32_t r, int32_t unused);
+void instr_0F91_reg(int32_t r, int32_t unused);
+void instr_0F92_reg(int32_t r, int32_t unused);
+void instr_0F93_reg(int32_t r, int32_t unused);
+void instr_0F94_reg(int32_t r, int32_t unused);
+void instr_0F95_reg(int32_t r, int32_t unused);
+void instr_0F96_reg(int32_t r, int32_t unused);
+void instr_0F97_reg(int32_t r, int32_t unused);
+void instr_0F98_reg(int32_t r, int32_t unused);
+void instr_0F99_reg(int32_t r, int32_t unused);
+void instr_0F9A_reg(int32_t r, int32_t unused);
+void instr_0F9B_reg(int32_t r, int32_t unused);
+void instr_0F9C_reg(int32_t r, int32_t unused);
+void instr_0F9D_reg(int32_t r, int32_t unused);
+void instr_0F9E_reg(int32_t r, int32_t unused);
+void instr_0F9F_reg(int32_t r, int32_t unused);
+void instr_0F90_mem(int32_t addr, int32_t unused);
+void instr_0F91_mem(int32_t addr, int32_t unused);
+void instr_0F92_mem(int32_t addr, int32_t unused);
+void instr_0F93_mem(int32_t addr, int32_t unused);
+void instr_0F94_mem(int32_t addr, int32_t unused);
+void instr_0F95_mem(int32_t addr, int32_t unused);
+void instr_0F96_mem(int32_t addr, int32_t unused);
+void instr_0F97_mem(int32_t addr, int32_t unused);
+void instr_0F98_mem(int32_t addr, int32_t unused);
+void instr_0F99_mem(int32_t addr, int32_t unused);
+void instr_0F9A_mem(int32_t addr, int32_t unused);
+void instr_0F9B_mem(int32_t addr, int32_t unused);
+void instr_0F9C_mem(int32_t addr, int32_t unused);
+void instr_0F9D_mem(int32_t addr, int32_t unused);
+void instr_0F9E_mem(int32_t addr, int32_t unused);
+void instr_0F9F_mem(int32_t addr, int32_t unused);
+void instr16_0FA0(void);
+void instr32_0FA0(void);
+void instr16_0FA1(void);
+void instr32_0FA1(void);
+void instr_0FA2(void);
+void instr16_0FA3_reg(int32_t r1, int32_t r2);
+void instr16_0FA3_mem(int32_t addr, int32_t r);
+void instr32_0FA3_reg(int32_t r1, int32_t r2);
+void instr32_0FA3_mem(int32_t addr, int32_t r);
+void instr16_0FA4_mem(int32_t addr, int32_t r, int32_t imm);
+void instr16_0FA4_reg(int32_t r1, int32_t r, int32_t imm);
+void instr32_0FA4_mem(int32_t addr, int32_t r, int32_t imm);
+void instr32_0FA4_reg(int32_t r1, int32_t r, int32_t imm);
+void instr16_0FA5_mem(int32_t addr, int32_t r);
+void instr16_0FA5_reg(int32_t r1, int32_t r);
+void instr32_0FA5_mem(int32_t addr, int32_t r);
+void instr32_0FA5_reg(int32_t r1, int32_t r);
+void instr_0FA6(void);
+void instr_0FA7(void);
+void instr16_0FA8(void);
+void instr32_0FA8(void);
+void instr16_0FA9(void);
+void instr32_0FA9(void);
+void instr_0FAA(void);
+void instr16_0FAB_reg(int32_t r1, int32_t r2);
+void instr16_0FAB_mem(int32_t addr, int32_t r);
+void instr32_0FAB_reg(int32_t r1, int32_t r2);
+void instr32_0FAB_mem(int32_t addr, int32_t r);
+void instr16_0FAC_mem(int32_t addr, int32_t r, int32_t imm);
+void instr16_0FAC_reg(int32_t r1, int32_t r, int32_t imm);
+void instr32_0FAC_mem(int32_t addr, int32_t r, int32_t imm);
+void instr32_0FAC_reg(int32_t r1, int32_t r, int32_t imm);
+void instr16_0FAD_mem(int32_t addr, int32_t r);
+void instr16_0FAD_reg(int32_t r1, int32_t r);
+void instr32_0FAD_mem(int32_t addr, int32_t r);
+void instr32_0FAD_reg(int32_t r1, int32_t r);
+void instr_0FAE_0_reg(int32_t r);
+void instr_0FAE_0_mem(int32_t addr);
+void instr_0FAE_1_reg(int32_t r);
+void instr_0FAE_1_mem(int32_t addr);
+void instr_0FAE_2_reg(int32_t r);
+void instr_0FAE_2_mem(int32_t addr);
+void instr_0FAE_3_reg(int32_t r);
+void instr_0FAE_3_mem(int32_t addr);
+void instr_0FAE_4_reg(int32_t r);
+void instr_0FAE_4_mem(int32_t addr);
+void instr_0FAE_5_reg(int32_t r);
+void instr_0FAE_5_mem(int32_t addr);
+void instr_0FAE_6_reg(int32_t r);
+void instr_0FAE_6_mem(int32_t addr);
+void instr_0FAE_7_reg(int32_t r);
+void instr_0FAE_7_mem(int32_t addr);
+void instr16_0FAF_mem(int32_t addr, int32_t r);
+void instr16_0FAF_reg(int32_t r1, int32_t r);
+void instr32_0FAF_mem(int32_t addr, int32_t r);
+void instr32_0FAF_reg(int32_t r1, int32_t r);
+void instr_0FB0_reg(int32_t r1, int32_t r2);
+void instr_0FB0_mem(int32_t addr, int32_t r);
+void instr16_0FB1_reg(int32_t r1, int32_t r2);
+void instr16_0FB1_mem(int32_t addr, int32_t r);
+void instr32_0FB1_reg(int32_t r1, int32_t r2);
+void instr32_0FB1_mem(int32_t addr, int32_t r);
+void instr16_0FB2_reg(int32_t unused, int32_t unused2);
+void instr16_0FB2_mem(int32_t addr, int32_t r);
+void instr32_0FB2_reg(int32_t unused, int32_t unused2);
+void instr32_0FB2_mem(int32_t addr, int32_t r);
+void instr16_0FB3_reg(int32_t r1, int32_t r2);
+void instr16_0FB3_mem(int32_t addr, int32_t r);
+void instr32_0FB3_reg(int32_t r1, int32_t r2);
+void instr32_0FB3_mem(int32_t addr, int32_t r);
+void instr16_0FB4_reg(int32_t unused, int32_t unused2);
+void instr16_0FB4_mem(int32_t addr, int32_t r);
+void instr32_0FB4_reg(int32_t unused, int32_t unused2);
+void instr32_0FB4_mem(int32_t addr, int32_t r);
+void instr16_0FB5_reg(int32_t unused, int32_t unused2);
+void instr16_0FB5_mem(int32_t addr, int32_t r);
+void instr32_0FB5_reg(int32_t unused, int32_t unused2);
+void instr32_0FB5_mem(int32_t addr, int32_t r);
+void instr16_0FB6_mem(int32_t addr, int32_t r);
+void instr16_0FB6_reg(int32_t r1, int32_t r);
+void instr32_0FB6_mem(int32_t addr, int32_t r);
+void instr32_0FB6_reg(int32_t r1, int32_t r);
+void instr16_0FB7_mem(int32_t addr, int32_t r);
+void instr16_0FB7_reg(int32_t r1, int32_t r);
+void instr32_0FB7_mem(int32_t addr, int32_t r);
+void instr32_0FB7_reg(int32_t r1, int32_t r);
+void instr16_0FB8_reg(int32_t r1, int32_t r2);
+void instr16_0FB8_mem(int32_t addr, int32_t r);
+void instr16_F30FB8_mem(int32_t addr, int32_t r);
+void instr16_F30FB8_reg(int32_t r1, int32_t r);
+void instr32_0FB8_reg(int32_t r1, int32_t r2);
+void instr32_0FB8_mem(int32_t addr, int32_t r);
+void instr32_F30FB8_mem(int32_t addr, int32_t r);
+void instr32_F30FB8_reg(int32_t r1, int32_t r);
+void instr_0FB9(void);
+void instr16_0FBA_4_reg(int32_t r, int32_t imm);
+void instr16_0FBA_4_mem(int32_t addr, int32_t imm);
+void instr16_0FBA_5_reg(int32_t r, int32_t imm);
+void instr16_0FBA_5_mem(int32_t addr, int32_t imm);
+void instr16_0FBA_6_reg(int32_t r, int32_t imm);
+void instr16_0FBA_6_mem(int32_t addr, int32_t imm);
+void instr16_0FBA_7_reg(int32_t r, int32_t imm);
+void instr16_0FBA_7_mem(int32_t addr, int32_t imm);
+void instr32_0FBA_4_reg(int32_t r, int32_t imm);
+void instr32_0FBA_4_mem(int32_t addr, int32_t imm);
+void instr32_0FBA_5_reg(int32_t r, int32_t imm);
+void instr32_0FBA_5_mem(int32_t addr, int32_t imm);
+void instr32_0FBA_6_reg(int32_t r, int32_t imm);
+void instr32_0FBA_6_mem(int32_t addr, int32_t imm);
+void instr32_0FBA_7_reg(int32_t r, int32_t imm);
+void instr32_0FBA_7_mem(int32_t addr, int32_t imm);
+void instr16_0FBB_reg(int32_t r1, int32_t r2);
+void instr16_0FBB_mem(int32_t addr, int32_t r);
+void instr32_0FBB_reg(int32_t r1, int32_t r2);
+void instr32_0FBB_mem(int32_t addr, int32_t r);
+void instr16_0FBC_mem(int32_t addr, int32_t r);
+void instr16_0FBC_reg(int32_t r1, int32_t r);
+void instr32_0FBC_mem(int32_t addr, int32_t r);
+void instr32_0FBC_reg(int32_t r1, int32_t r);
+void instr16_0FBD_mem(int32_t addr, int32_t r);
+void instr16_0FBD_reg(int32_t r1, int32_t r);
+void instr32_0FBD_mem(int32_t addr, int32_t r);
+void instr32_0FBD_reg(int32_t r1, int32_t r);
+void instr16_0FBE_mem(int32_t addr, int32_t r);
+void instr16_0FBE_reg(int32_t r1, int32_t r);
+void instr32_0FBE_mem(int32_t addr, int32_t r);
+void instr32_0FBE_reg(int32_t r1, int32_t r);
+void instr16_0FBF_mem(int32_t addr, int32_t r);
+void instr16_0FBF_reg(int32_t r1, int32_t r);
+void instr32_0FBF_mem(int32_t addr, int32_t r);
+void instr32_0FBF_reg(int32_t r1, int32_t r);
+void instr_0FC0_mem(int32_t addr, int32_t r);
+void instr_0FC0_reg(int32_t r1, int32_t r);
+void instr16_0FC1_mem(int32_t addr, int32_t r);
+void instr16_0FC1_reg(int32_t r1, int32_t r);
+void instr32_0FC1_mem(int32_t addr, int32_t r);
+void instr32_0FC1_reg(int32_t r1, int32_t r);
+void instr_0FC2(void);
+void instr_0FC3_reg(int32_t r1, int32_t r2);
+void instr_0FC3_mem(int32_t addr, int32_t r);
+void instr_0FC4(int32_t source, int32_t r, int32_t imm8);
+void instr_0FC4_reg(int32_t r1, int32_t r2, int32_t imm);
+void instr_0FC4_mem(int32_t addr, int32_t r, int32_t imm);
+void instr_660FC4(int32_t source, int32_t r, int32_t imm8);
+void instr_660FC4_reg(int32_t r1, int32_t r2, int32_t imm);
+void instr_660FC4_mem(int32_t addr, int32_t r, int32_t imm);
+void instr_0FC5_mem(int32_t addr, int32_t r, int32_t imm8);
+void instr_0FC5_reg(int32_t r1, int32_t r2, int32_t imm8);
+void instr_660FC5_mem(int32_t addr, int32_t r, int32_t imm8);
+void instr_660FC5_reg(int32_t r1, int32_t r2, int32_t imm8);
+void instr_0FC6(void);
+void instr_0FC7_1_reg(int32_t r);
+void instr_0FC7_1_mem(int32_t addr);
+void instr_0FC7_6_reg(int32_t r);
+void instr_0FC7_6_mem(int32_t addr);
+void instr_0FC8(void);
+void instr_0FC9(void);
+void instr_0FCA(void);
+void instr_0FCB(void);
+void instr_0FCC(void);
+void instr_0FCD(void);
+void instr_0FCE(void);
+void instr_0FCF(void);
+void instr_0FD0(void);
+void instr_0FD1(union reg64 source, int32_t r);
+void instr_0FD1_reg(int32_t r1, int32_t r2);
+void instr_0FD1_mem(int32_t addr, int32_t r);
+void instr_660FD1(union reg128 source, int32_t r);
+void instr_660FD1_reg(int32_t r1, int32_t r2);
+void instr_660FD1_mem(int32_t addr, int32_t r);
+void instr_0FD2(union reg64 source, int32_t r);
+void instr_0FD2_reg(int32_t r1, int32_t r2);
+void instr_0FD2_mem(int32_t addr, int32_t r);
+void instr_660FD2(union reg128 source, int32_t r);
+void instr_660FD2_reg(int32_t r1, int32_t r2);
+void instr_660FD2_mem(int32_t addr, int32_t r);
+void instr_0FD3(union reg64 source, int32_t r);
+void instr_0FD3_reg(int32_t r1, int32_t r2);
+void instr_0FD3_mem(int32_t addr, int32_t r);
+void instr_660FD3(union reg128 source, int32_t r);
+void instr_660FD3_reg(int32_t r1, int32_t r2);
+void instr_660FD3_mem(int32_t addr, int32_t r);
+void instr_0FD4(union reg64 source, int32_t r);
+void instr_0FD4_reg(int32_t r1, int32_t r2);
+void instr_0FD4_mem(int32_t addr, int32_t r);
+void instr_660FD4(union reg128 source, int32_t r);
+void instr_660FD4_reg(int32_t r1, int32_t r2);
+void instr_660FD4_mem(int32_t addr, int32_t r);
+void instr_0FD5(union reg64 source, int32_t r);
+void instr_0FD5_reg(int32_t r1, int32_t r2);
+void instr_0FD5_mem(int32_t addr, int32_t r);
+void instr_660FD5(union reg128 source, int32_t r);
+void instr_660FD5_reg(int32_t r1, int32_t r2);
+void instr_660FD5_mem(int32_t addr, int32_t r);
+void instr_0FD6_mem(int32_t addr, int32_t r);
+void instr_0FD6_reg(int32_t r1, int32_t r2);
+void instr_660FD6_mem(int32_t addr, int32_t r);
+void instr_660FD6_reg(int32_t r1, int32_t r2);
+void instr_F20FD6_mem(int32_t addr, int32_t r);
+void instr_F20FD6_reg(int32_t r1, int32_t r2);
+void instr_F30FD6_mem(int32_t addr, int32_t r);
+void instr_F30FD6_reg(int32_t r1, int32_t r2);
+void instr_0FD7_mem(int32_t addr, int32_t r);
+void instr_0FD7_reg(int32_t r1, int32_t r2);
+void instr_660FD7_mem(int32_t addr, int32_t r);
+void instr_660FD7_reg(int32_t r1, int32_t r2);
+void instr_0FD8(union reg64 source, int32_t r);
+void instr_0FD8_reg(int32_t r1, int32_t r2);
+void instr_0FD8_mem(int32_t addr, int32_t r);
+void instr_660FD8(union reg128 source, int32_t r);
+void instr_660FD8_reg(int32_t r1, int32_t r2);
+void instr_660FD8_mem(int32_t addr, int32_t r);
+void instr_0FD9(union reg64 source, int32_t r);
+void instr_0FD9_reg(int32_t r1, int32_t r2);
+void instr_0FD9_mem(int32_t addr, int32_t r);
+void instr_660FD9(union reg128 source, int32_t r);
+void instr_660FD9_reg(int32_t r1, int32_t r2);
+void instr_660FD9_mem(int32_t addr, int32_t r);
+void instr_0FDA(union reg64 source, int32_t r);
+void instr_0FDA_reg(int32_t r1, int32_t r2);
+void instr_0FDA_mem(int32_t addr, int32_t r);
+void instr_660FDA(union reg128 source, int32_t r);
+void instr_660FDA_reg(int32_t r1, int32_t r2);
+void instr_660FDA_mem(int32_t addr, int32_t r);
+void instr_0FDB(union reg64 source, int32_t r);
+void instr_0FDB_reg(int32_t r1, int32_t r2);
+void instr_0FDB_mem(int32_t addr, int32_t r);
+void instr_660FDB(union reg128 source, int32_t r);
+void instr_660FDB_reg(int32_t r1, int32_t r2);
+void instr_660FDB_mem(int32_t addr, int32_t r);
+void instr_0FDC(union reg64 source, int32_t r);
+void instr_0FDC_reg(int32_t r1, int32_t r2);
+void instr_0FDC_mem(int32_t addr, int32_t r);
+void instr_660FDC(union reg128 source, int32_t r);
+void instr_660FDC_reg(int32_t r1, int32_t r2);
+void instr_660FDC_mem(int32_t addr, int32_t r);
+void instr_0FDD(union reg64 source, int32_t r);
+void instr_0FDD_reg(int32_t r1, int32_t r2);
+void instr_0FDD_mem(int32_t addr, int32_t r);
+void instr_660FDD(union reg128 source, int32_t r);
+void instr_660FDD_reg(int32_t r1, int32_t r2);
+void instr_660FDD_mem(int32_t addr, int32_t r);
+void instr_0FDE(union reg64 source, int32_t r);
+void instr_0FDE_reg(int32_t r1, int32_t r2);
+void instr_0FDE_mem(int32_t addr, int32_t r);
+void instr_660FDE(union reg128 source, int32_t r);
+void instr_660FDE_reg(int32_t r1, int32_t r2);
+void instr_660FDE_mem(int32_t addr, int32_t r);
+void instr_0FDF(union reg64 source, int32_t r);
+void instr_0FDF_reg(int32_t r1, int32_t r2);
+void instr_0FDF_mem(int32_t addr, int32_t r);
+void instr_660FDF(union reg128 source, int32_t r);
+void instr_660FDF_reg(int32_t r1, int32_t r2);
+void instr_660FDF_mem(int32_t addr, int32_t r);
+void instr_0FE0(union reg64 source, int32_t r);
+void instr_0FE0_reg(int32_t r1, int32_t r2);
+void instr_0FE0_mem(int32_t addr, int32_t r);
+void instr_660FE0(union reg128 source, int32_t r);
+void instr_660FE0_reg(int32_t r1, int32_t r2);
+void instr_660FE0_mem(int32_t addr, int32_t r);
+void instr_0FE1(union reg64 source, int32_t r);
+void instr_0FE1_reg(int32_t r1, int32_t r2);
+void instr_0FE1_mem(int32_t addr, int32_t r);
+void instr_660FE1(union reg128 source, int32_t r);
+void instr_660FE1_reg(int32_t r1, int32_t r2);
+void instr_660FE1_mem(int32_t addr, int32_t r);
+void instr_0FE2(union reg64 source, int32_t r);
+void instr_0FE2_reg(int32_t r1, int32_t r2);
+void instr_0FE2_mem(int32_t addr, int32_t r);
+void instr_660FE2(union reg128 source, int32_t r);
+void instr_660FE2_reg(int32_t r1, int32_t r2);
+void instr_660FE2_mem(int32_t addr, int32_t r);
+void instr_0FE3(union reg64 source, int32_t r);
+void instr_0FE3_reg(int32_t r1, int32_t r2);
+void instr_0FE3_mem(int32_t addr, int32_t r);
+void instr_660FE3(union reg128 source, int32_t r);
+void instr_660FE3_reg(int32_t r1, int32_t r2);
+void instr_660FE3_mem(int32_t addr, int32_t r);
+void instr_0FE4(union reg64 source, int32_t r);
+void instr_0FE4_reg(int32_t r1, int32_t r2);
+void instr_0FE4_mem(int32_t addr, int32_t r);
+void instr_660FE4(union reg128 source, int32_t r);
+void instr_660FE4_reg(int32_t r1, int32_t r2);
+void instr_660FE4_mem(int32_t addr, int32_t r);
+void instr_0FE5(union reg64 source, int32_t r);
+void instr_0FE5_reg(int32_t r1, int32_t r2);
+void instr_0FE5_mem(int32_t addr, int32_t r);
+void instr_660FE5(union reg128 source, int32_t r);
+void instr_660FE5_reg(int32_t r1, int32_t r2);
+void instr_660FE5_mem(int32_t addr, int32_t r);
+void instr_0FE6_mem(int32_t addr, int32_t r);
+void instr_0FE6_reg(int32_t r1, int32_t r2);
+void instr_660FE6_mem(int32_t addr, int32_t r);
+void instr_660FE6_reg(int32_t r1, int32_t r2);
+void instr_F20FE6_mem(int32_t addr, int32_t r);
+void instr_F20FE6_reg(int32_t r1, int32_t r2);
+void instr_F30FE6_mem(int32_t addr, int32_t r);
+void instr_F30FE6_reg(int32_t r1, int32_t r2);
+void instr_0FE7_mem(int32_t addr, int32_t r);
+void instr_0FE7_reg(int32_t r1, int32_t r2);
+void instr_660FE7_reg(int32_t r1, int32_t r2);
+void instr_660FE7_mem(int32_t addr, int32_t r);
+void instr_0FE8(union reg64 source, int32_t r);
+void instr_0FE8_reg(int32_t r1, int32_t r2);
+void instr_0FE8_mem(int32_t addr, int32_t r);
+void instr_660FE8(union reg128 source, int32_t r);
+void instr_660FE8_reg(int32_t r1, int32_t r2);
+void instr_660FE8_mem(int32_t addr, int32_t r);
+void instr_0FE9(union reg64 source, int32_t r);
+void instr_0FE9_reg(int32_t r1, int32_t r2);
+void instr_0FE9_mem(int32_t addr, int32_t r);
+void instr_660FE9(union reg128 source, int32_t r);
+void instr_660FE9_reg(int32_t r1, int32_t r2);
+void instr_660FE9_mem(int32_t addr, int32_t r);
+void instr_0FEA(union reg64 source, int32_t r);
+void instr_0FEA_reg(int32_t r1, int32_t r2);
+void instr_0FEA_mem(int32_t addr, int32_t r);
+void instr_660FEA(union reg128 source, int32_t r);
+void instr_660FEA_reg(int32_t r1, int32_t r2);
+void instr_660FEA_mem(int32_t addr, int32_t r);
+void instr_0FEB(union reg64 source, int32_t r);
+void instr_0FEB_reg(int32_t r1, int32_t r2);
+void instr_0FEB_mem(int32_t addr, int32_t r);
+void instr_660FEB(union reg128 source, int32_t r);
+void instr_660FEB_reg(int32_t r1, int32_t r2);
+void instr_660FEB_mem(int32_t addr, int32_t r);
+void instr_0FEC(union reg64 source, int32_t r);
+void instr_0FEC_reg(int32_t r1, int32_t r2);
+void instr_0FEC_mem(int32_t addr, int32_t r);
+void instr_660FEC(union reg128 source, int32_t r);
+void instr_660FEC_reg(int32_t r1, int32_t r2);
+void instr_660FEC_mem(int32_t addr, int32_t r);
+void instr_0FED(union reg64 source, int32_t r);
+void instr_0FED_reg(int32_t r1, int32_t r2);
+void instr_0FED_mem(int32_t addr, int32_t r);
+void instr_660FED(union reg128 source, int32_t r);
+void instr_660FED_reg(int32_t r1, int32_t r2);
+void instr_660FED_mem(int32_t addr, int32_t r);
+void instr_0FEE(union reg64 source, int32_t r);
+void instr_0FEE_reg(int32_t r1, int32_t r2);
+void instr_0FEE_mem(int32_t addr, int32_t r);
+void instr_660FEE(union reg128 source, int32_t r);
+void instr_660FEE_reg(int32_t r1, int32_t r2);
+void instr_660FEE_mem(int32_t addr, int32_t r);
+void instr_0FEF(union reg64 source, int32_t r);
+void instr_0FEF_reg(int32_t r1, int32_t r2);
+void instr_0FEF_mem(int32_t addr, int32_t r);
+void instr_660FEF(union reg128 source, int32_t r);
+void instr_660FEF_reg(int32_t r1, int32_t r2);
+void instr_660FEF_mem(int32_t addr, int32_t r);
+void instr_0FF0(void);
+void instr_0FF1(union reg64 source, int32_t r);
+void instr_0FF1_reg(int32_t r1, int32_t r2);
+void instr_0FF1_mem(int32_t addr, int32_t r);
+void instr_660FF1(union reg128 source, int32_t r);
+void instr_660FF1_reg(int32_t r1, int32_t r2);
+void instr_660FF1_mem(int32_t addr, int32_t r);
+void instr_0FF2(union reg64 source, int32_t r);
+void instr_0FF2_reg(int32_t r1, int32_t r2);
+void instr_0FF2_mem(int32_t addr, int32_t r);
+void instr_660FF2(union reg128 source, int32_t r);
+void instr_660FF2_reg(int32_t r1, int32_t r2);
+void instr_660FF2_mem(int32_t addr, int32_t r);
+void instr_0FF3(union reg64 source, int32_t r);
+void instr_0FF3_reg(int32_t r1, int32_t r2);
+void instr_0FF3_mem(int32_t addr, int32_t r);
+void instr_660FF3(union reg128 source, int32_t r);
+void instr_660FF3_reg(int32_t r1, int32_t r2);
+void instr_660FF3_mem(int32_t addr, int32_t r);
+void instr_0FF4(union reg64 source, int32_t r);
+void instr_0FF4_reg(int32_t r1, int32_t r2);
+void instr_0FF4_mem(int32_t addr, int32_t r);
+void instr_660FF4(union reg128 source, int32_t r);
+void instr_660FF4_reg(int32_t r1, int32_t r2);
+void instr_660FF4_mem(int32_t addr, int32_t r);
+void instr_0FF5(union reg64 source, int32_t r);
+void instr_0FF5_reg(int32_t r1, int32_t r2);
+void instr_0FF5_mem(int32_t addr, int32_t r);
+void instr_660FF5(union reg128 source, int32_t r);
+void instr_660FF5_reg(int32_t r1, int32_t r2);
+void instr_660FF5_mem(int32_t addr, int32_t r);
+void instr_0FF6(union reg64 source, int32_t r);
+void instr_0FF6_reg(int32_t r1, int32_t r2);
+void instr_0FF6_mem(int32_t addr, int32_t r);
+void instr_660FF6(union reg128 source, int32_t r);
+void instr_660FF6_reg(int32_t r1, int32_t r2);
+void instr_660FF6_mem(int32_t addr, int32_t r);
+void instr_0FF7_mem(int32_t addr, int32_t r);
+void instr_0FF7_reg(int32_t r1, int32_t r2);
+void instr_660FF7_mem(int32_t addr, int32_t r);
+void instr_660FF7_reg(int32_t r1, int32_t r2);
+void instr_0FF8(union reg64 source, int32_t r);
+void instr_0FF8_reg(int32_t r1, int32_t r2);
+void instr_0FF8_mem(int32_t addr, int32_t r);
+void instr_660FF8(union reg128 source, int32_t r);
+void instr_660FF8_reg(int32_t r1, int32_t r2);
+void instr_660FF8_mem(int32_t addr, int32_t r);
+void instr_0FF9(union reg64 source, int32_t r);
+void instr_0FF9_reg(int32_t r1, int32_t r2);
+void instr_0FF9_mem(int32_t addr, int32_t r);
+void instr_660FF9(union reg128 source, int32_t r);
+void instr_660FF9_reg(int32_t r1, int32_t r2);
+void instr_660FF9_mem(int32_t addr, int32_t r);
+void instr_0FFA(union reg64 source, int32_t r);
+void instr_0FFA_reg(int32_t r1, int32_t r2);
+void instr_0FFA_mem(int32_t addr, int32_t r);
+void instr_660FFA(union reg128 source, int32_t r);
+void instr_660FFA_reg(int32_t r1, int32_t r2);
+void instr_660FFA_mem(int32_t addr, int32_t r);
+void instr_0FFB(union reg64 source, int32_t r);
+void instr_0FFB_reg(int32_t r1, int32_t r2);
+void instr_0FFB_mem(int32_t addr, int32_t r);
+void instr_660FFB(union reg128 source, int32_t r);
+void instr_660FFB_reg(int32_t r1, int32_t r2);
+void instr_660FFB_mem(int32_t addr, int32_t r);
+void instr_0FFC(union reg64 source, int32_t r);
+void instr_0FFC_reg(int32_t r1, int32_t r2);
+void instr_0FFC_mem(int32_t addr, int32_t r);
+void instr_660FFC(union reg128 source, int32_t r);
+void instr_660FFC_reg(int32_t r1, int32_t r2);
+void instr_660FFC_mem(int32_t addr, int32_t r);
+void instr_0FFD(union reg64 source, int32_t r);
+void instr_0FFD_reg(int32_t r1, int32_t r2);
+void instr_0FFD_mem(int32_t addr, int32_t r);
+void instr_660FFD(union reg128 source, int32_t r);
+void instr_660FFD_reg(int32_t r1, int32_t r2);
+void instr_660FFD_mem(int32_t addr, int32_t r);
+void instr_0FFE(union reg64 source, int32_t r);
+void instr_0FFE_reg(int32_t r1, int32_t r2);
+void instr_0FFE_mem(int32_t addr, int32_t r);
+void instr_660FFE(union reg128 source, int32_t r);
+void instr_660FFE_reg(int32_t r1, int32_t r2);
+void instr_660FFE_mem(int32_t addr, int32_t r);
+void instr_0FFF(void);
+void run_instruction0f_16(int32_t opcode);
+void run_instruction0f_32(int32_t opcode);
+void jit_instruction0f_16(int32_t opcode);
+void jit_instruction0f_32(int32_t opcode);

src/native/log.c → src/native/log.h

@@ -1,15 +1,13 @@
 #include <stdint.h>
-#include <math.h>
 #include <assert.h>
 #include <stdbool.h>
 
 #include <stdio.h>
 
 #include "const.h"
-#include "global_pointers.h"
-void logop(int32_t, int32_t);
 
-void dbg_trace(void);
+extern void logop(int32_t, int32_t);
+extern void dbg_trace(void);
 
 #define dbg_log(...) { if(DEBUG) { printf(__VA_ARGS__); } }
 #define dbg_assert(condition) { if(DEBUG) { if(!(condition)) dbg_log(#condition); assert(condition); } }

src/native/memory.c

@@ -1,21 +1,24 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <assert.h>
+
 #include "const.h"
 #include "global_pointers.h"
+#include "memory.h"
+#include "log.h"
+
+extern int32_t mmap_read8(uint32_t);
+extern int32_t mmap_read16(uint32_t);
+extern int32_t mmap_read32(uint32_t);
+extern void mmap_write8(uint32_t, int32_t);
+extern void mmap_write16(uint32_t, int32_t);
+extern void mmap_write32(uint32_t, int32_t);
 
 bool in_mapped_range(uint32_t addr)
 {
     return (addr >= 0xA0000 && addr < 0xC0000) || addr >= *memory_size;
 }
 
-int32_t mmap_read8(uint32_t);
-int32_t mmap_read16(uint32_t);
-int32_t mmap_read32(uint32_t);
-void mmap_write8(uint32_t, int32_t);
-void mmap_write16(uint32_t, int32_t);
-void mmap_write32(uint32_t, int32_t);
-
 /*
  * There are 3 primary ways a cached basic block will be dirtied:
  * 1. A write dirties basic block A independently (A is clean and

src/native/memory.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <stdint.h>
+
+bool in_mapped_range(uint32_t addr);
+void jit_dirty_cache(uint32_t start_addr, uint32_t end_addr);
+void jit_dirty_cache_small(uint32_t start_addr, uint32_t end_addr);
+void jit_empty_cache(void);
+int32_t read8(uint32_t addr);
+int32_t read16(uint32_t addr);
+int32_t read_aligned16(uint32_t addr);
+int32_t read32s(uint32_t addr);
+int64_t read64s(uint32_t addr);
+int32_t read_aligned32(uint32_t addr);
+void write8(uint32_t addr, int32_t value);
+void write16(uint32_t addr, int32_t value);
+void write_aligned16(uint32_t addr, uint32_t value);
+void write32(uint32_t addr, int32_t value);
+void write_aligned32(int32_t addr, int32_t value);
+void write64(uint32_t addr, int64_t value);

src/native/misc_instr.c

@@ -7,20 +7,12 @@
 
 #include "const.h"
 #include "global_pointers.h"
+#include "fpu.h"
+#include "log.h"
+#include "cpu.h"
+#include "misc_instr.h"
 
-static int32_t get_stack_pointer(int32_t);
-static void adjust_stack_reg(int32_t);
-void branch_taken();
-void branch_not_taken();
-void writable_or_pagefault(int32_t, int32_t);
-
-
-static void write_reg8(int32_t index, int32_t value);
-static int32_t read_reg16(int32_t index);
-static void write_reg16(int32_t index, int32_t value);
-static int32_t read_reg32(int32_t index);
-static void write_reg32(int32_t index, int32_t value);
-
+extern void writable_or_pagefault(int32_t, int32_t);
 
 int32_t getcf()
 {
@@ -152,7 +144,7 @@ void jmpcc32(bool condition, int32_t imm32)
     }
 }
 
-static void cmovcc16(bool condition, int32_t value, int32_t r)
+void cmovcc16(bool condition, int32_t value, int32_t r)
 {
     if(condition)
     {
@@ -160,7 +152,7 @@ static void cmovcc16(bool condition, int32_t value, int32_t r)
     }
 }
 
-static void cmovcc32(bool condition, int32_t value, int32_t r)
+void cmovcc32(bool condition, int32_t value, int32_t r)
 {
     if(condition)
     {
@@ -168,7 +160,7 @@ static void cmovcc32(bool condition, int32_t value, int32_t r)
     }
 }
 
-static int32_t get_stack_pointer(int32_t offset)
+int32_t get_stack_pointer(int32_t offset)
 {
     if(*stack_size_32)
     {
@@ -180,7 +172,7 @@ static int32_t get_stack_pointer(int32_t offset)
     }
 }
 
-static void adjust_stack_reg(int32_t adjustment)
+void adjust_stack_reg(int32_t adjustment)
 {
     if(*stack_size_32)
     {
@@ -293,11 +285,6 @@ void setcc_mem(bool condition, int32_t addr) {
     safe_write8(addr, condition ? 1 : 0);
 }
 
-int32_t fpu_load_status_word();
-void fpu_set_status_word(int32_t);
-void fpu_store_m80(uint32_t, double_t);
-double_t fpu_load_m80(uint32_t);
-
 void fxsave(uint32_t addr)
 {
     writable_or_pagefault(addr, 512);

src/native/misc_instr.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+int32_t getcf(void);
+int32_t getpf(void);
+int32_t getaf(void);
+int32_t getzf(void);
+int32_t getsf(void);
+int32_t getof(void);
+int32_t test_o(void);
+int32_t test_b(void);
+int32_t test_z(void);
+int32_t test_s(void);
+int32_t test_p(void);
+int32_t test_be(void);
+int32_t test_l(void);
+int32_t test_le(void);
+void jmp_rel16(int32_t rel16);
+void jmpcc8(bool condition, int32_t imm8);
+void jmpcc16(bool condition, int32_t imm16);
+void jmpcc32(bool condition, int32_t imm32);
+void cmovcc16(bool condition, int32_t value, int32_t r);
+void cmovcc32(bool condition, int32_t value, int32_t r);
+int32_t get_stack_pointer(int32_t offset);
+void adjust_stack_reg(int32_t adjustment);
+void push16(int32_t imm16);
+void push32(int32_t imm32);
+int32_t pop16(void);
+int32_t pop32s(void);
+void pusha16(void);
+void pusha32(void);
+void setcc_reg(bool condition, int32_t r);
+void setcc_mem(bool condition, int32_t addr);
+void fxsave(uint32_t addr);
+void fxrstor(uint32_t addr);
+int32_t xchg8(int32_t data, int32_t r8);
+int32_t xchg16(int32_t data, int32_t r16);
+void xchg16r(int32_t r16);
+int32_t xchg32(int32_t data, int32_t r32);
+void xchg32r(int32_t r32);

src/native/modrm.c

@@ -3,14 +3,10 @@
 #include <assert.h>
 #include <stdbool.h>
 
-#include <stdio.h>
-
 #include "const.h"
 #include "global_pointers.h"
-
-// XXX: Remove these declarations when they are implemented in C
-static int32_t resolve_sib(bool);
-
+#include "cpu.h"
+#include "modrm.h"
 
 #define ds get_seg_prefix_ds
 #define ss get_seg_prefix_ss
@@ -31,7 +27,7 @@ static int32_t resolve_sib(bool);
     MODRM_ENTRY(0x40 | row, seg(((value) + read_imm8s() & 0xFFFF)))\
     MODRM_ENTRY(0x80 | row, seg(((value) + read_imm16() & 0xFFFF)))\
 
-static int32_t resolve_modrm16(int32_t modrm_byte)
+int32_t resolve_modrm16(int32_t modrm_byte)
 {
     switch(modrm_byte)
     {
@@ -63,7 +59,7 @@ static int32_t resolve_modrm16(int32_t modrm_byte)
     MODRM_ENTRY(0x40 | row, seg((value) + read_imm8s()))\
     MODRM_ENTRY(0x80 | row, seg((value) + read_imm32s()))\
 
-static int32_t resolve_modrm32(int32_t modrm_byte)
+int32_t resolve_modrm32(int32_t modrm_byte)
 {
     switch(modrm_byte)
     {

src/native/modrm.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+int32_t resolve_modrm16(int32_t modrm_byte);
+int32_t resolve_modrm32(int32_t modrm_byte);
+static int32_t resolve_sib_(bool mod);
+static int32_t resolve_sib(bool mod);
+static int32_t resolve_modrm32_(int32_t modrm_byte);

src/native/profiler/profiler.c

@@ -5,6 +5,8 @@
 
 #if ENABLE_PROFILER
 
+struct profiler_data profiler_arr[PROFILER_NAME_COUNT] = {{0, 0, false}};
+struct profiler_stat profiler_stat_arr[PROFILER_NAME_COUNT] = {{0}};
 double profiler_init_time = 0;
 
 void profiler_init()

src/native/profiler/profiler.h

@@ -1,19 +1,19 @@
+#pragma once
+
 #include <stdbool.h>
 #include <stdint.h>
 
-#ifndef _PROFILER_H
-#define _PROFILER_H
-
-
 #define PROFILER_NAME_COUNT 5
 
 struct profiler_data {
     double total;
     double current_start;
     bool capturing;
-} profiler_arr[PROFILER_NAME_COUNT] = {{0, 0, false}};
+};
 
-const char *profiler_names[] = {
+extern struct profiler_data profiler_arr[PROFILER_NAME_COUNT];
+
+static const char *profiler_names[] = {
     "IDLE",
     "DO_MANY_CYCLES",
     "GEN_INSTR",
@@ -42,7 +42,9 @@ enum stat_name {
 
 struct profiler_stat {
     int32_t count;
-} profiler_stat_arr[PROFILER_NAME_COUNT] = {{0}};
+};
+
+extern struct profiler_stat profiler_stat_arr[PROFILER_NAME_COUNT];
 
 void profiler_init();
 void profiler_start(enum profile_name name);
@@ -53,6 +55,4 @@ void profiler_stat_increment(enum stat_name stat);
 int32_t profiler_stat_get(enum stat_name stat);
 
 // JS import
-double get_time();
-
-#endif
+extern double get_time();

src/native/shared.h

@@ -1,7 +1,9 @@
-#ifndef _SHARED_H
-#define _SHARED_H
+#pragma once
 
 #include <stdint.h>
+#include <stdbool.h>
+#include <math.h>
+
 #include "const.h"
 
 union reg128 {
@@ -40,18 +42,22 @@ struct code_cache {
     // DIRTY_ARR_SHIFT). Value only has meaning in relation with the
     // group_dirtiness value.
     uint32_t group_status;
-} jit_cache_arr[WASM_TABLE_SIZE] = {{0, {0}, 0, 0, 0}};
+};
+
+extern struct code_cache jit_cache_arr[WASM_TABLE_SIZE];
 
 // Flag indicating whether the instruction that just ran was a jump of some sort
-uint32_t jit_jump = 0;
+extern uint32_t jit_jump;
 
 // Count of how many times prime_hash(address) has been called through a jump
-int32_t hot_code_addresses[HASH_PRIME] = {0};
+extern int32_t hot_code_addresses[HASH_PRIME];
 // An array indicating the current "initial group status" for entries that map
 // to the same group due to the shift
-uint32_t group_dirtiness[1 + (0xffffffff >> DIRTY_ARR_SHIFT)] = {0};
-
-void call_indirect(int32_t index);
-void jit_clear_func(int32_t index);
-
-#endif
+extern uint32_t group_dirtiness[1 + (0xffffffff >> DIRTY_ARR_SHIFT)];
+
+extern void call_indirect(int32_t index);
+extern void jit_clear_func(int32_t index);
+extern void call_interrupt_vector(int32_t interrupt_nr, bool is_software_int, bool has_error_code, int32_t error_code);
+extern void throw_cpu_exception(void);
+extern double_t math_pow(double_t, double_t);
+extern double_t microtick(void);

src/native/sse_instr.c

@@ -1,3 +1,9 @@
+#include <stdint.h>
+
+#include "shared.h"
+#include "sse_instr.h"
+#include "cpu.h"
+
 void mov_r_m64(int32_t addr, int32_t r)
 {
     // mov* m64, mm

src/native/sse_instr.h

@@ -1,5 +1,8 @@
-#ifndef _SSE_H
-#define _SSE_H
+#pragma once
+
+#include <stdint.h>
+
+#include "shared.h"
 
 void mov_r_m64(int32_t addr, int32_t r);
 void movl_r128_m64(int32_t addr, int32_t r);
@@ -8,12 +11,10 @@ void mov_r_m128(int32_t addr, int32_t r);
 void mov_rm_r128(union reg128 source, int32_t r);
 void movh_m64_r128(int32_t addr, int32_t r);
 void movh_r128_m64(int32_t addr, int32_t r);
-
 void pand_r128(union reg128 source, int32_t r);
 void pandn_r128(union reg128 source, int32_t r);
 void pxor_r128(union reg128 source, int32_t r);
 void por_r128(union reg128 source, int32_t r);
-
 void psrlw_r64(int32_t r, uint32_t shift);
 void psraw_r64(int32_t r, uint32_t shift);
 void psllw_r64(int32_t r, uint32_t shift);
@@ -22,7 +23,6 @@ void psrad_r64(int32_t r, uint32_t shift);
 void pslld_r64(int32_t r, uint32_t shift);
 void psrlq_r64(int32_t r, uint32_t shift);
 void psllq_r64(int32_t r, uint32_t shift);
-
 void psrlw_r128(int32_t r, uint32_t shift);
 void psraw_r128(int32_t r, uint32_t shift);
 void psllw_r128(int32_t r, uint32_t shift);
@@ -31,5 +31,3 @@ void psrad_r128(int32_t r, uint32_t shift);
 void pslld_r128(int32_t r, uint32_t shift);
 void psrlq_r128(int32_t r, uint32_t shift);
 void psllq_r128(int32_t r, uint32_t shift);
-
-#endif

src/native/string.c

@@ -1,4 +1,21 @@
 #include <stdint.h>
+#include <stdbool.h>
+
+#include "global_pointers.h"
+#include "cpu.h"
+#include "memory.h"
+#include "log.h"
+#include "arith.h"
+#include "string.h"
+
+extern void test_privileges_for_io(int32_t, int32_t);
+extern void writable_or_pagefault(int32_t, int32_t);
+extern int32_t io_port_read8(int32_t);
+extern int32_t io_port_read16(int32_t);
+extern int32_t io_port_read32(int32_t);
+extern void io_port_write8(int32_t, int32_t);
+extern void io_port_write16(int32_t, int32_t);
+extern void io_port_write32(int32_t, int32_t);
 
 #define MAX_COUNT_PER_CYCLE 0x1000
 #define MIN(x, y) (x < y ? x : y)

src/native/string.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <stdint.h>
+
+int32_t string_get_cycle_count(int32_t size, int32_t address);
+int32_t string_get_cycle_count2(int32_t size, int32_t addr1, int32_t addr2);
+void movsb_rep(void);
+void movsb_no_rep(void);
+void movsb(void);
+void movsw_rep(void);
+void movsw_no_rep(void);
+void movsw(void);
+void movsd_rep(void);
+void movsd_no_rep(void);
+void movsd(void);
+void cmpsb_rep(void);
+void cmpsb_no_rep(void);
+void cmpsb(void);
+void cmpsw_rep(void);
+void cmpsw_no_rep(void);
+void cmpsw(void);
+void cmpsd_rep(void);
+void cmpsd_no_rep(void);
+void cmpsd(void);
+void stosb_rep(void);
+void stosb_no_rep(void);
+void stosb(void);
+void stosw_rep(void);
+void stosw_no_rep(void);
+void stosw(void);
+void stosd_rep(void);
+void stosd_no_rep(void);
+void stosd(void);
+void lodsb_rep(void);
+void lodsb_no_rep(void);
+void lodsb(void);
+void lodsw_rep(void);
+void lodsw_no_rep(void);
+void lodsw(void);
+void lodsd_rep(void);
+void lodsd_no_rep(void);
+void lodsd(void);
+void scasb_rep(void);
+void scasb_no_rep(void);
+void scasb(void);
+void scasw_rep(void);
+void scasw_no_rep(void);
+void scasw(void);
+void scasd_rep(void);
+void scasd_no_rep(void);
+void scasd(void);
+void insb_rep(void);
+void insb_no_rep(void);
+void insb(void);
+void insw_rep(void);
+void insw_no_rep(void);
+void insw(void);
+void insd_rep(void);
+void insd_no_rep(void);
+void insd(void);
+void outsb_rep(void);
+void outsb_no_rep(void);
+void outsb(void);
+void outsw_rep(void);
+void outsw_no_rep(void);
+void outsw(void);
+void outsd_rep(void);
+void outsd_no_rep(void);
+void outsd(void);