Rust: Improved code size a tiny bit further

Author: Sewer56

src-rust/src/buffers.rs

@@ -9,7 +9,6 @@ use crate::utilities::disable_write_xor_execute::{
 };
 use crate::utilities::icache_clear::clear_instruction_cache;
 use crate::utilities::mathematics::round_up;
-use core::cmp::max;
 use core::ptr::{copy_nonoverlapping, NonNull};
 use core::u8;
 

src-rust/src/internal/locator_header_finder.rs

@@ -52,18 +52,19 @@ impl LocatorHeaderFinder {
     fn open_or_create_memory_mapped_file() -> Box<dyn MemoryMappedFile> {
         // no_std
         let mut name = String::from("/Reloaded.Memory.Buffers.MemoryBuffer, PID ");
-        name.push_str(&get_sys_info().this_process_id.to_string());
+        let sys_info = get_sys_info();
+        name.push_str(&sys_info.this_process_id.to_string());
 
         #[cfg(target_os = "windows")]
         return Box::new(WindowsMemoryMappedFile::new(
             &name,
-            get_sys_info().allocation_granularity as usize,
+            sys_info.allocation_granularity as usize,
         ));
 
         #[cfg(unix)]
         return Box::new(UnixMemoryMappedFile::new(
             &name,
-            get_sys_info().allocation_granularity as usize,
+            sys_info.allocation_granularity as usize,
         ));
     }
 

src-rust/src/structs/internal/locator_header.rs

@@ -338,11 +338,11 @@ impl LocatorHeader {
         }
 
         // Allocate the next locator.
-        let alloc_size = get_sys_info().allocation_granularity;
+        let sys_info = get_sys_info();
+        let alloc_size = sys_info.allocation_granularity;
         unsafe {
             let addr = alloc::alloc::alloc(
-                Layout::from_size_align(alloc_size as usize, get_sys_info().page_size as usize)
-                    .unwrap(),
+                Layout::from_size_align(alloc_size as usize, sys_info.page_size as usize).unwrap(),
             );
             if addr.is_null() {
                 self.unlock();

src-rust/src/structs/params/buffer_allocator_settings.rs

@@ -40,11 +40,12 @@ pub struct BufferAllocatorSettings {
 impl BufferAllocatorSettings {
     /// Initializes the buffer allocator with default settings.
     pub fn new() -> Self {
+        let sys_info = get_sys_info();
         Self {
             min_address: 0,
-            max_address: get_sys_info().max_address,
+            max_address: sys_info.max_address,
             size: 4096,
-            target_process_id: get_sys_info().this_process_id,
+            target_process_id: sys_info.this_process_id,
             retry_count: 8,
             brute_force: true,
         }
@@ -73,15 +74,15 @@ impl BufferAllocatorSettings {
     /// Sanitizes the input values.
     pub fn sanitize(&mut self) {
         // On Windows, VirtualAlloc treats 0 as 'any address', we might aswell avoid this out the gate.
-        if cfg!(windows) && (self.min_address < get_sys_info().allocation_granularity as usize) {
-            self.min_address = get_sys_info().allocation_granularity as usize;
+        let sys_info = get_sys_info();
+        if cfg!(windows) && (self.min_address < sys_info.allocation_granularity as usize) {
+            self.min_address = sys_info.allocation_granularity as usize;
         }
 
         self.size = max(self.size, 1);
-        self.size = mathematics::round_up(
-            self.size as usize,
-            get_sys_info().allocation_granularity as usize,
-        ) as u32;
+        self.size =
+            mathematics::round_up(self.size as usize, sys_info.allocation_granularity as usize)
+                as u32;
     }
 }
 

src-rust/src/utilities/cached.rs

@@ -13,11 +13,16 @@ pub fn get_sys_info() -> &'static Cached {
             return CACHED.as_ref().unwrap_unchecked();
         }
 
-        CACHED = Some(Cached::new());
+        make_sys_info();
         return CACHED.as_ref().unwrap_unchecked();
     }
 }
 
+#[inline(never)] // bloats the binary
+fn make_sys_info() {
+    unsafe { CACHED = Some(Cached::new()) };
+}
+
 pub struct Cached {
     pub max_address: usize,
     pub allocation_granularity: i32,

src-rust/src/utilities/map_parser_utilities.rs

@@ -42,6 +42,8 @@ impl MemoryMapEntryTrait for MemoryMapEntry {
 /// # Arguments
 ///
 /// * `regions` - A slice of MemoryMapEntry that contains the regions.
+
+#[cfg_attr(feature = "size_opt", optimize(size))]
 pub fn get_free_regions<T: MemoryMapEntryTrait>(regions: &[T]) -> Vec<MemoryMapEntry> {
     let mut last_end_address: usize = 0;
     let mut free_regions = Vec::with_capacity(regions.len() + 2); // +2 for start and finish