Making unlikely and likely for stable compile

Author: acheron2302

crates/libmwemu/src/lib.rs

@@ -1,4 +1,3 @@
-#![feature(likely_unlikely)]
 #![allow(non_snake_case)]
 #![allow(dead_code)]
 #![allow(unused_variables)]
@@ -45,6 +44,7 @@ pub mod winapi;
 
 #[cfg(test)]
 mod tests;
+mod utils;
 
 use config::Config;
 use emu::Emu;

crates/libmwemu/src/maps/heap_allocation.rs

@@ -2,7 +2,8 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::ffi::c_char;
 use std::rc::{Rc, Weak};
-use std::{cmp, hint};
+use std::{cmp};
+use crate::utils::{likely, unlikely};
 
 type PRFrag = Option<Rc<RefCell<Fragment>>>;
 type PWFrag = Option<Weak<RefCell<Fragment>>>;
@@ -163,12 +164,12 @@ impl O1Heap {
     /// * `Some(usize)` - An offset into the heap's memory arena if successful
     /// * `None` - If there is insufficient memory or the request is invalid
     pub fn allocate(&mut self, amount: usize) -> Option<u64> {
-        if hint::unlikely(amount == 0) {
+        if unlikely(amount == 0) {
             return None;
         }
 
         // Update peak request size
-        if hint::likely(self.diagnostics.peak_request_size < amount) {
+        if likely(self.diagnostics.peak_request_size < amount) {
             self.diagnostics.peak_request_size = amount;
         }
 
@@ -185,7 +186,7 @@ impl O1Heap {
         let suitable_bins = self.nonempty_bin_mask & candidate_bin_mask;
 
         // Find smallest suitable bin
-        if hint::likely(suitable_bins != 0) {
+        if likely(suitable_bins != 0) {
             let smallest_bin_index = suitable_bins.trailing_zeros() as usize;
 
             if smallest_bin_index < NUM_BINS_MAX {
@@ -198,7 +199,7 @@ impl O1Heap {
                 frag_rc.borrow_mut().size = fragment_size as u32;
                 // Split if necessary
                 let leftover = frag_size - fragment_size as u32;
-                if hint::likely(leftover >= FRAGMENT_SIZE_MIN as u32) {
+                if likely(leftover >= FRAGMENT_SIZE_MIN as u32) {
                     let new_frag = Rc::new(RefCell::new(Fragment::new(frag_offset + fragment_size as u32, leftover)));
                     // Link the new fragment in the chain
                     let next_rc = frag_rc.borrow().next.clone();
@@ -236,12 +237,12 @@ impl O1Heap {
     // remove fragment from the bin
     fn unbin(&mut self, fragment: &Rc<RefCell<Fragment>>) {
         let size = fragment.borrow().size;
-        if hint::unlikely(size < FRAGMENT_SIZE_MIN as u32) {
+        if unlikely(size < FRAGMENT_SIZE_MIN as u32) {
             return;
         }
 
         let idx = self.log2_floor(size as usize / FRAGMENT_SIZE_MIN);
-        if hint::unlikely(idx >= NUM_BINS_MAX) {
+        if unlikely(idx >= NUM_BINS_MAX) {
             return;
         }
 

crates/libmwemu/src/utils.rs

@@ -0,0 +1,24 @@
+// TODO: remove the code when 'likely' and 'unlikely' are stable
+#[inline(always)]
+#[cold]
+fn cold_path() {}
+
+#[inline(always)]
+pub(crate) fn likely(b: bool) -> bool {
+    if b {
+        true
+    } else {
+        cold_path();
+        false
+    }
+}
+
+#[inline(always)]
+pub(crate) fn unlikely(b: bool) -> bool {
+    if b {
+        cold_path();
+        true
+    } else {
+        false
+    }
+}

crates/libmwemu/src/winapi/winapi32/kernel32/heap_alloc.rs

@@ -15,16 +15,23 @@ pub fn HeapAlloc(emu: &mut emu::Emu) {
         .read_dword(emu.regs().get_esp() + 8)
         .expect("kernel32!HeapAlloc cannot read the size") as u64;
 
-    emu.regs_mut().rax = emu.maps.alloc(size).unwrap_or_default();
+    let heap_addr: u64 = if size < 0x8000 {
+        let heap_manage = emu.heap_management.as_mut().unwrap();
+        heap_manage.allocate(size as usize).expect("failed to allocate heap")
+    } else {
+        let allocation = emu.maps.alloc(size).unwrap_or_default();
+        emu.maps
+            .create_map(
+                format!("alloc_{:x}", allocation).as_str(),
+                allocation,
+                size,
+                Permission::READ_WRITE,
+            )
+            .expect("kernel32!HeapAlloc out of memory");
+        allocation
+    };
 
-    emu.maps
-        .create_map(
-            format!("alloc_{:x}", emu.regs().get_eax() as u32).as_str(),
-            emu.regs().get_eax(),
-            size,
-            Permission::READ_WRITE,
-        )
-        .expect("kernel32!HeapAlloc out of memory");
+    emu.regs_mut().rax = heap_addr;
 
     log_red!(
         emu,

crates/libmwemu/src/winapi/winapi64/kernel32/heap_alloc.rs

@@ -22,7 +22,7 @@ pub fn HeapAlloc(emu: &mut emu::Emu) {
         allocation
     };
 
-    emu.regs_mut().rax = heap_addr;
+    emu.regs_mut().rax = heap_addr;  
 
     log_red!(
         emu,

crates/libmwemu/src/winapi/winapi64/kernel32/heap_free.rs

@@ -1,4 +1,4 @@
-use std::hint::likely;
+use crate::utils::likely;
 use crate::emu;
 
 pub fn HeapFree(emu: &mut emu::Emu) {