@aptre/v86 0.5.0

package/src/rust/prefix.rs

@@ -0,0 +1,15 @@
+pub const PREFIX_REPZ: u8 = 0b01000;
+pub const PREFIX_REPNZ: u8 = 0b10000;
+pub const PREFIX_MASK_REP: u8 = PREFIX_REPZ | PREFIX_REPNZ;
+
+pub const PREFIX_MASK_OPSIZE: u8 = 0b100000;
+pub const PREFIX_MASK_ADDRSIZE: u8 = 0b1000000;
+
+pub const PREFIX_66: u8 = PREFIX_MASK_OPSIZE;
+pub const PREFIX_67: u8 = PREFIX_MASK_ADDRSIZE;
+pub const PREFIX_F2: u8 = PREFIX_REPNZ;
+pub const PREFIX_F3: u8 = PREFIX_REPZ;
+
+pub const SEG_PREFIX_ZERO: u8 = 7;
+
+pub const PREFIX_MASK_SEGMENT: u8 = 0b111;

package/src/rust/profiler.rs

@@ -0,0 +1,155 @@
+#[allow(non_camel_case_types)]
+pub enum stat {
+    COMPILE,
+    COMPILE_SKIPPED_NO_NEW_ENTRY_POINTS,
+    COMPILE_WRONG_ADDRESS_SPACE,
+    COMPILE_CUT_OFF_AT_END_OF_PAGE,
+    COMPILE_WITH_LOOP_SAFETY,
+    COMPILE_PAGE,
+    COMPILE_BASIC_BLOCK,
+    COMPILE_DUPLICATED_BASIC_BLOCK,
+    COMPILE_WASM_BLOCK,
+    COMPILE_WASM_LOOP,
+    COMPILE_DISPATCHER,
+    COMPILE_ENTRY_POINT,
+    COMPILE_WASM_TOTAL_BYTES,
+
+    RUN_INTERPRETED,
+    RUN_INTERPRETED_NEW_PAGE,
+    RUN_INTERPRETED_PAGE_HAS_CODE,
+    RUN_INTERPRETED_PAGE_HAS_ENTRY_AFTER_PAGE_WALK,
+    RUN_INTERPRETED_NEAR_END_OF_PAGE,
+    RUN_INTERPRETED_DIFFERENT_STATE,
+    RUN_INTERPRETED_DIFFERENT_STATE_CPL3,
+    RUN_INTERPRETED_DIFFERENT_STATE_FLAT,
+    RUN_INTERPRETED_DIFFERENT_STATE_IS32,
+    RUN_INTERPRETED_DIFFERENT_STATE_SS32,
+    RUN_INTERPRETED_MISSED_COMPILED_ENTRY_RUN_INTERPRETED,
+    RUN_INTERPRETED_STEPS,
+
+    RUN_FROM_CACHE,
+    RUN_FROM_CACHE_STEPS,
+
+    DIRECT_EXIT,
+    INDIRECT_JUMP,
+    INDIRECT_JUMP_NO_ENTRY,
+    NORMAL_PAGE_CHANGE,
+    NORMAL_FALLTHRU,
+    NORMAL_FALLTHRU_WITH_TARGET_BLOCK,
+    NORMAL_BRANCH,
+    NORMAL_BRANCH_WITH_TARGET_BLOCK,
+    CONDITIONAL_JUMP,
+    CONDITIONAL_JUMP_PAGE_CHANGE,
+    CONDITIONAL_JUMP_EXIT,
+    CONDITIONAL_JUMP_FALLTHRU,
+    CONDITIONAL_JUMP_FALLTHRU_WITH_TARGET_BLOCK,
+    CONDITIONAL_JUMP_BRANCH,
+    CONDITIONAL_JUMP_BRANCH_WITH_TARGET_BLOCK,
+    DISPATCHER_SMALL,
+    DISPATCHER_LARGE,
+    LOOP,
+
+    LOOP_SAFETY,
+
+    CONDITION_OPTIMISED,
+    CONDITION_UNOPTIMISED,
+    CONDITION_UNOPTIMISED_PF,
+    CONDITION_UNOPTIMISED_UNHANDLED_L,
+    CONDITION_UNOPTIMISED_UNHANDLED_LE,
+
+    FAILED_PAGE_CHANGE,
+
+    SAFE_READ_FAST,
+    SAFE_READ_SLOW_PAGE_CROSSED,
+    SAFE_READ_SLOW_NOT_VALID,
+    SAFE_READ_SLOW_NOT_USER,
+    SAFE_READ_SLOW_IN_MAPPED_RANGE,
+
+    SAFE_WRITE_FAST,
+    SAFE_WRITE_SLOW_PAGE_CROSSED,
+    SAFE_WRITE_SLOW_NOT_VALID,
+    SAFE_WRITE_SLOW_NOT_USER,
+    SAFE_WRITE_SLOW_IN_MAPPED_RANGE,
+    SAFE_WRITE_SLOW_READ_ONLY,
+    SAFE_WRITE_SLOW_HAS_CODE,
+
+    SAFE_READ_WRITE_FAST,
+    SAFE_READ_WRITE_SLOW_PAGE_CROSSED,
+    SAFE_READ_WRITE_SLOW_NOT_VALID,
+    SAFE_READ_WRITE_SLOW_NOT_USER,
+    SAFE_READ_WRITE_SLOW_IN_MAPPED_RANGE,
+    SAFE_READ_WRITE_SLOW_READ_ONLY,
+    SAFE_READ_WRITE_SLOW_HAS_CODE,
+
+    PAGE_FAULT,
+    TLB_MISS,
+
+    MAIN_LOOP,
+    MAIN_LOOP_IDLE,
+    DO_MANY_CYCLES,
+    CYCLE_INTERNAL,
+
+    INVALIDATE_ALL_MODULES_NO_FREE_WASM_INDICES,
+    INVALIDATE_MODULE_WRITTEN_WHILE_COMPILED,
+    INVALIDATE_MODULE_UNUSED_AFTER_OVERWRITE,
+    INVALIDATE_MODULE_DIRTY_PAGE,
+
+    INVALIDATE_PAGE_HAD_CODE,
+    INVALIDATE_PAGE_HAD_ENTRY_POINTS,
+    DIRTY_PAGE_DID_NOT_HAVE_CODE,
+
+    RUN_FROM_CACHE_EXIT_SAME_PAGE,
+    RUN_FROM_CACHE_EXIT_NEAR_END_OF_PAGE,
+    RUN_FROM_CACHE_EXIT_DIFFERENT_PAGE,
+
+    CLEAR_TLB,
+    FULL_CLEAR_TLB,
+    TLB_FULL,
+    TLB_GLOBAL_FULL,
+
+    MODRM_SIMPLE_REG,
+    MODRM_SIMPLE_REG_WITH_OFFSET,
+    MODRM_SIMPLE_CONST_OFFSET,
+    MODRM_COMPLEX,
+
+    SEG_OFFSET_OPTIMISED,
+    SEG_OFFSET_NOT_OPTIMISED,
+    SEG_OFFSET_NOT_OPTIMISED_ES,
+    SEG_OFFSET_NOT_OPTIMISED_FS,
+    SEG_OFFSET_NOT_OPTIMISED_GS,
+    SEG_OFFSET_NOT_OPTIMISED_NOT_FLAT,
+}
+
+#[allow(non_upper_case_globals)]
+pub static mut stat_array: [u64; 500] = [0; 500];
+
+pub fn stat_increment(stat: stat) { stat_increment_by(stat, 1); }
+
+pub fn stat_increment_by(stat: stat, by: u64) {
+    if cfg!(feature = "profiler") {
+        unsafe { stat_array[stat as usize] += by }
+    }
+}
+
+#[no_mangle]
+pub fn profiler_init() {
+    unsafe {
+        #[allow(static_mut_refs)]
+        for x in stat_array.iter_mut() {
+            *x = 0
+        }
+    }
+}
+
+#[no_mangle]
+pub fn profiler_stat_get(stat: stat) -> f64 {
+    if cfg!(feature = "profiler") {
+        unsafe { stat_array[stat as usize] as f64 }
+    }
+    else {
+        0.0
+    }
+}
+
+#[no_mangle]
+pub fn profiler_is_enabled() -> bool { cfg!(feature = "profiler") }

package/src/rust/regs.rs

@@ -0,0 +1,38 @@
+pub const ES: u32 = 0;
+pub const CS: u32 = 1;
+pub const SS: u32 = 2;
+pub const DS: u32 = 3;
+pub const FS: u32 = 4;
+pub const GS: u32 = 5;
+
+pub const EAX: u32 = 0;
+pub const ECX: u32 = 1;
+pub const EDX: u32 = 2;
+pub const EBX: u32 = 3;
+pub const ESP: u32 = 4;
+pub const EBP: u32 = 5;
+pub const ESI: u32 = 6;
+pub const EDI: u32 = 7;
+
+pub const AX: u32 = 0;
+pub const CX: u32 = 1;
+pub const DX: u32 = 2;
+pub const BX: u32 = 3;
+pub const SP: u32 = 4;
+pub const BP: u32 = 5;
+pub const SI: u32 = 6;
+pub const DI: u32 = 7;
+
+pub const AL: u32 = 0;
+pub const CL: u32 = 1;
+pub const DL: u32 = 2;
+pub const BL: u32 = 3;
+pub const AH: u32 = 4;
+pub const CH: u32 = 5;
+pub const DH: u32 = 6;
+pub const BH: u32 = 7;
+
+pub const CR0_EM: u32 = 1 << 2;
+pub const CR0_TS: u32 = 1 << 3;
+
+pub const CR4_TSD: u32 = 1 << 2;

package/src/rust/softfloat.rs

@@ -0,0 +1,286 @@
+extern "C" {
+    fn extF80M_add(x: *const F80, y: *const F80, ptr: *mut F80);
+    fn extF80M_sub(x: *const F80, y: *const F80, ptr: *mut F80);
+    fn extF80M_mul(x: *const F80, y: *const F80, ptr: *mut F80);
+    fn extF80M_div(x: *const F80, y: *const F80, ptr: *mut F80);
+    //fn extF80M_rem(x: *const F80, y: *const F80, ptr: *mut F80);
+    fn extF80M_sqrt(x: *const F80, ptr: *mut F80);
+
+    fn extF80M_roundToInt(x: *const F80, rounding_mode: u8, raise_inexact: bool, dst: *mut F80);
+
+    fn extF80M_eq(x: *const F80, y: *const F80) -> bool;
+    //fn extF80M_eq_signaling(x: *const F80, y: *const F80) -> bool;
+
+    //fn extF80M_le(x: *const F80, y: *const F80) -> bool;
+    //fn extF80M_le_quiet(x: *const F80, y: *const F80) -> bool;
+    fn extF80M_lt(x: *const F80, y: *const F80) -> bool;
+    fn extF80M_lt_quiet(x: *const F80, y: *const F80) -> bool;
+
+    fn extF80M_to_i32(src: *const F80, rounding_mode: u8, raise_inexact: bool) -> i32;
+    fn extF80M_to_i64(src: *const F80, rounding_mode: u8, raise_inexact: bool) -> i64;
+    fn i32_to_extF80M(src: i32, dst: *mut F80);
+    fn i64_to_extF80M(src: i64, dst: *mut F80);
+
+    fn f32_to_extF80M(src: i32, dst: *mut F80);
+    fn f64_to_extF80M(src: u64, dst: *mut F80);
+    fn extF80M_to_f32(src: *const F80) -> i32;
+    fn extF80M_to_f64(src: *const F80) -> u64;
+
+    static mut softfloat_roundingMode: u8;
+    static mut extF80_roundingPrecision: u8;
+    static mut softfloat_exceptionFlags: u8;
+}
+
+pub enum RoundingMode {
+    NearEven,
+    Trunc,
+    Floor,
+    Ceil,
+}
+pub enum Precision {
+    P80,
+    P64,
+    P32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct F80 {
+    pub mantissa: u64,
+    pub sign_exponent: u16,
+}
+impl F80 {
+    pub const ZERO: F80 = F80 {
+        mantissa: 0,
+        sign_exponent: 0,
+    };
+    pub const ONE: F80 = F80 {
+        mantissa: 0x8000000000000000,
+        sign_exponent: 0x3FFF,
+    };
+    pub const LN_10: F80 = F80 {
+        mantissa: 0x935D8DDDAAA8B000,
+        sign_exponent: 0x4000,
+    };
+    pub const LN_2: F80 = F80 {
+        mantissa: 0xB17217F7D1CF7800,
+        sign_exponent: 0x3FFE,
+    };
+    pub const PI: F80 = F80 {
+        mantissa: 0xC90FDAA22168C000,
+        sign_exponent: 0x4000,
+    };
+    pub const LOG2_E: F80 = F80 {
+        mantissa: 0xB8AA3B295C17F000,
+        sign_exponent: 0x3FFF,
+    };
+    pub const INDEFINITE_NAN: F80 = F80 {
+        mantissa: 0xC000000000000000,
+        sign_exponent: 0x7FFF,
+    };
+    pub const POS_INFINITY: F80 = F80 {
+        mantissa: 0x8000000000000000,
+        sign_exponent: 0x7FFF,
+    };
+    pub const NEG_INFINITY: F80 = F80 {
+        mantissa: 0x8000000000000000,
+        sign_exponent: 0xFFFF,
+    };
+
+    pub fn sign(&self) -> bool { (self.sign_exponent >> 15) == 1 }
+    pub fn exponent(&self) -> i16 { (self.sign_exponent as i16 & 0x7FFF) - 0x3FFF }
+
+    pub fn of_i32(src: i32) -> F80 {
+        let mut x = F80::ZERO;
+        unsafe { i32_to_extF80M(src, &mut x) };
+        x
+    }
+    pub fn of_i64(src: i64) -> F80 {
+        let mut x = F80::ZERO;
+        unsafe { i64_to_extF80M(src, &mut x) };
+        x
+    }
+
+    pub fn of_f32(src: i32) -> F80 {
+        let mut x = F80::ZERO;
+        unsafe { f32_to_extF80M(src, &mut x) };
+        x
+    }
+
+    pub fn of_f64(src: u64) -> F80 {
+        let mut x = F80::ZERO;
+        unsafe { f64_to_extF80M(src, &mut x) };
+        x
+    }
+    fn of_f64x(src: f64) -> F80 { F80::of_f64(f64::to_bits(src)) }
+
+    pub fn to_f32(&self) -> i32 { unsafe { extF80M_to_f32(self) } }
+    pub fn to_f64(&self) -> u64 { unsafe { extF80M_to_f64(self) } }
+    fn to_f64x(&self) -> f64 { f64::from_bits(self.to_f64()) }
+
+    pub fn to_i32(&self) -> i32 { unsafe { extF80M_to_i32(self, softfloat_roundingMode, false) } }
+    pub fn to_i64(&self) -> i64 { unsafe { extF80M_to_i64(self, softfloat_roundingMode, false) } }
+
+    pub fn truncate_to_i32(&self) -> i32 { unsafe { extF80M_to_i32(self, 1, false) } }
+    pub fn truncate_to_i64(&self) -> i64 { unsafe { extF80M_to_i64(self, 1, false) } }
+
+    pub fn cos(self) -> F80 { F80::of_f64x(self.to_f64x().cos()) }
+    pub fn sin(self) -> F80 { F80::of_f64x(self.to_f64x().sin()) }
+    pub fn tan(self) -> F80 { F80::of_f64x(self.to_f64x().tan()) }
+    pub fn atan(self) -> F80 { F80::of_f64x(self.to_f64x().atan()) }
+    pub fn atan2(self, other: F80) -> F80 { F80::of_f64x(self.to_f64x().atan2(other.to_f64x())) }
+
+    pub fn log2(self) -> F80 { F80::of_f64x(self.to_f64x().log2()) }
+    pub fn ln(self) -> F80 { F80::of_f64x(self.to_f64x().ln()) }
+
+    pub fn abs(self) -> F80 {
+        F80 {
+            mantissa: self.mantissa,
+            sign_exponent: self.sign_exponent & !0x8000,
+        }
+    }
+    pub fn two_pow(self) -> F80 { F80::of_f64x(2.0f64.powf(self.to_f64x())) }
+    pub fn round(self) -> F80 {
+        let mut result = F80::ZERO;
+        unsafe { extF80M_roundToInt(&self, softfloat_roundingMode, false, &mut result) };
+        result
+    }
+    pub fn trunc(self) -> F80 {
+        let mut result = F80::ZERO;
+        unsafe { extF80M_roundToInt(&self, 1, false, &mut result) };
+        result
+    }
+
+    pub fn sqrt(self) -> F80 {
+        let mut result = F80::ZERO;
+        unsafe { extF80M_sqrt(&self, &mut result) };
+        result
+    }
+
+    pub fn is_finite(self) -> bool {
+        // TODO: Can probably be done more efficiently
+        self != F80::POS_INFINITY && self != F80::NEG_INFINITY
+    }
+    pub fn is_nan(self) -> bool {
+        // TODO: Can probably be done more efficiently
+        self != self
+    }
+
+    pub fn set_rounding_mode(mode: RoundingMode) {
+        unsafe {
+            softfloat_roundingMode = match mode {
+                RoundingMode::NearEven => 0,
+                RoundingMode::Trunc => 1,
+                RoundingMode::Floor => 2,
+                RoundingMode::Ceil => 3,
+            }
+        };
+    }
+    pub fn set_precision(precision: Precision) {
+        unsafe {
+            extF80_roundingPrecision = match precision {
+                Precision::P80 => 80,
+                Precision::P64 => 64,
+                Precision::P32 => 32,
+            }
+        };
+    }
+
+    pub fn get_exception_flags() -> u8 {
+        let f = unsafe { softfloat_exceptionFlags };
+        // translate softfloat's flags to x87 status flags
+        f >> 4 & 1 | f >> 1 & 4 | f << 3 & 16
+    }
+    pub fn clear_exception_flags() { unsafe { softfloat_exceptionFlags = 0 } }
+
+    pub fn partial_cmp_quiet(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        // TODO: Can probably be done more efficiently
+        if unsafe { extF80M_lt_quiet(self, other) } {
+            Some(std::cmp::Ordering::Less)
+        }
+        else if unsafe { extF80M_lt_quiet(other, self) } {
+            Some(std::cmp::Ordering::Greater)
+        }
+        else if self == other {
+            Some(std::cmp::Ordering::Equal)
+        }
+        else {
+            None
+        }
+    }
+}
+
+impl std::ops::Add for F80 {
+    type Output = F80;
+    fn add(self, other: Self) -> Self {
+        let mut result = F80::ZERO;
+        unsafe { extF80M_add(&self, &other, &mut result) };
+        result
+    }
+}
+impl std::ops::Sub for F80 {
+    type Output = F80;
+    fn sub(self, other: Self) -> Self {
+        let mut result = F80::ZERO;
+        unsafe { extF80M_sub(&self, &other, &mut result) };
+        result
+    }
+}
+impl std::ops::Neg for F80 {
+    type Output = F80;
+    fn neg(self) -> Self {
+        let mut result = self;
+        result.sign_exponent ^= 1 << 15;
+        result
+    }
+}
+impl std::ops::Mul for F80 {
+    type Output = F80;
+    fn mul(self, other: Self) -> Self {
+        let mut result = F80::ZERO;
+        unsafe { extF80M_mul(&self, &other, &mut result) };
+        result
+    }
+}
+impl std::ops::Div for F80 {
+    type Output = F80;
+    fn div(self, other: Self) -> Self {
+        let mut result = F80::ZERO;
+        unsafe { extF80M_div(&self, &other, &mut result) };
+        result
+    }
+}
+impl std::ops::Rem for F80 {
+    type Output = F80;
+    fn rem(self, other: Self) -> Self {
+        let quot = (self / other).trunc();
+        self - quot * other
+        // Uses round-to-nearest instead of truncation
+        //let mut result = F80::ZERO;
+        //unsafe {
+        //    extF80M_rem(&self, &other, &mut result)
+        //};
+        //result
+    }
+}
+
+impl PartialEq for F80 {
+    fn eq(&self, other: &Self) -> bool { unsafe { extF80M_eq(self, other) } }
+}
+impl PartialOrd for F80 {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        // TODO: Can probably be done more efficiently
+        if unsafe { extF80M_lt(self, other) } {
+            Some(std::cmp::Ordering::Less)
+        }
+        else if unsafe { extF80M_lt(other, self) } {
+            Some(std::cmp::Ordering::Greater)
+        }
+        else if self == other {
+            Some(std::cmp::Ordering::Equal)
+        }
+        else {
+            None
+        }
+    }
+}

package/src/rust/state_flags.rs

@@ -0,0 +1,27 @@
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct CachedStateFlags(u8);
+
+impl CachedStateFlags {
+    const MASK_IS_32: u8 = 1 << 0;
+    const MASK_SS32: u8 = 1 << 1;
+    const MASK_CPL3: u8 = 1 << 2;
+    const MASK_FLAT_SEGS: u8 = 1 << 3;
+
+    pub const EMPTY: CachedStateFlags = CachedStateFlags(0);
+
+    pub fn of_u32(f: u32) -> CachedStateFlags {
+        dbg_assert!(
+            f as u8
+                & !(Self::MASK_IS_32 | Self::MASK_SS32 | Self::MASK_CPL3 | Self::MASK_FLAT_SEGS)
+                == 0
+        );
+        CachedStateFlags(f as u8)
+    }
+    pub fn to_u32(&self) -> u32 { self.0 as u32 }
+
+    pub fn cpl3(&self) -> bool { self.0 & CachedStateFlags::MASK_CPL3 != 0 }
+    pub fn has_flat_segmentation(&self) -> bool { self.0 & CachedStateFlags::MASK_FLAT_SEGS != 0 }
+    pub fn is_32(&self) -> bool { self.0 & CachedStateFlags::MASK_IS_32 != 0 }
+    pub fn ssize_32(&self) -> bool { self.0 & CachedStateFlags::MASK_SS32 != 0 }
+}

package/src/rust/wasmgen/mod.rs

@@ -0,0 +1,2 @@
+pub mod wasm_builder;
+mod wasm_opcodes;