All tests passing on Windows. (#608)

* test_default_triple fix

* All tests passing on Windows.

* Formatting.

* Formatting.

* Formatting.

* Forgot to configure windows dep for windows.

* I think it should work now.

* I don't know what I'm doing.

* Hopefully this satisfies clippy.

* I could have sworn that I just committed this.

Author: ErisianArchitect

Cargo.toml

@@ -170,5 +170,12 @@ serde = { version = "1.0", default-features = false, features = [
 gumdrop = "0.8.1"
 regex = "1"
 
+[target.'cfg(windows)'.dev-dependencies.windows]
+version = "0.62.2"
+features = [
+    "Win32_System_SystemInformation",
+    "Win32_System_Memory"
+]
+
 [badges]
 codecov = { repository = "TheDan64/inkwell" }

tests/all/test_execution_engine.rs

@@ -8,6 +8,15 @@ use inkwell::module::Linkage;
 use inkwell::targets::{CodeModel, InitializationConfig, Target};
 use inkwell::{AddressSpace, IntPredicate, OptimizationLevel};
 
+#[cfg(target_os = "windows")]
+use windows::Win32::System::{
+    Memory::{
+        VirtualAlloc, VirtualFree, VirtualProtect, MEM_COMMIT, MEM_RELEASE, MEM_RESERVE, PAGE_EXECUTE_READ,
+        PAGE_READWRITE,
+    },
+    SystemInformation::{GetSystemInfo, SYSTEM_INFO},
+};
+
 type Thunk = unsafe extern "C" fn();
 
 #[test]
@@ -374,8 +383,20 @@ struct MockMemoryManagerData {
 impl MockMemoryManager {
     pub fn new() -> Self {
         let capacity_bytes = 128 * 1024;
+        #[cfg(unix)]
         let page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize };
 
+        #[cfg(target_os = "windows")]
+        let page_size = {
+            let mut info = std::mem::MaybeUninit::<SYSTEM_INFO>::uninit();
+            unsafe {
+                GetSystemInfo(info.as_mut_ptr());
+            }
+            let info = unsafe { info.assume_init() };
+            info.dwPageSize as usize
+        };
+
+        #[cfg(unix)]
         let code_buff_ptr = unsafe {
             std::ptr::NonNull::new_unchecked(libc::mmap(
                 std::ptr::null_mut(),
@@ -387,6 +408,14 @@ impl MockMemoryManager {
             ) as *mut u8)
         };
 
+        #[cfg(target_os = "windows")]
+        let code_buff_ptr = unsafe {
+            std::ptr::NonNull::new_unchecked(
+                VirtualAlloc(None, capacity_bytes, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE).cast::<u8>(),
+            )
+        };
+
+        #[cfg(unix)]
         let data_buff_ptr = unsafe {
             std::ptr::NonNull::new_unchecked(libc::mmap(
                 std::ptr::null_mut(),
@@ -398,6 +427,13 @@ impl MockMemoryManager {
             ) as *mut u8)
         };
 
+        #[cfg(target_os = "windows")]
+        let data_buff_ptr = unsafe {
+            std::ptr::NonNull::new_unchecked(
+                VirtualAlloc(None, capacity_bytes, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE).cast::<u8>(),
+            )
+        };
+
         Self {
             data: Rc::new(RefCell::new(MockMemoryManagerData {
                 fixed_capacity_bytes: capacity_bytes,
@@ -460,6 +496,7 @@ impl McjitMemoryManager for MockMemoryManager {
 
         data.finalize_calls += 1;
 
+        #[cfg(unix)]
         unsafe {
             libc::mprotect(
                 data.code_buff_ptr.as_ptr() as *mut libc::c_void,
@@ -473,6 +510,25 @@ impl McjitMemoryManager for MockMemoryManager {
             );
         }
 
+        #[cfg(windows)]
+        unsafe {
+            let mut old_protect = PAGE_READWRITE;
+            VirtualProtect(
+                data.code_buff_ptr.as_ptr() as *mut _,
+                data.fixed_capacity_bytes,
+                PAGE_EXECUTE_READ,
+                &mut old_protect,
+            )
+            .expect("VirtualProtect failed");
+            VirtualProtect(
+                data.data_buff_ptr.as_ptr() as *mut _,
+                data.fixed_capacity_bytes,
+                PAGE_READWRITE,
+                &mut old_protect,
+            )
+            .expect("VirtualProtect failed");
+        }
+
         Ok(())
     }
 
@@ -481,6 +537,7 @@ impl McjitMemoryManager for MockMemoryManager {
 
         data.destroy_calls += 1;
 
+        #[cfg(unix)]
         unsafe {
             libc::munmap(
                 data.code_buff_ptr.as_ptr() as *mut libc::c_void,
@@ -491,5 +548,11 @@ impl McjitMemoryManager for MockMemoryManager {
                 data.fixed_capacity_bytes,
             );
         }
+
+        #[cfg(windows)]
+        unsafe {
+            VirtualFree(data.code_buff_ptr.as_ptr() as *mut _, 0, MEM_RELEASE).expect("Failed to free memory.");
+            VirtualFree(data.data_buff_ptr.as_ptr() as *mut _, 0, MEM_RELEASE).expect("Failed to free memory.");
+        }
     }
 }

tests/all/test_module.rs

@@ -305,7 +305,7 @@ fn test_clone() {
 }
 
 #[test]
-fn test_print_to_file() {
+fn test_print_to_file_good_path() {
     let context = Context::create();
     let module = context.create_module("mod");
     let void_type = context.void_type();
@@ -317,20 +317,38 @@ fn test_print_to_file() {
     builder.position_at_end(basic_block);
     builder.build_return(None).unwrap();
 
-    let bad_path = Path::new("/tmp/some/silly/path/that/sure/doesn't/exist");
-
-    assert_eq!(
-        module.print_to_file(bad_path).unwrap_err().to_str(),
-        Ok("No such file or directory")
-    );
-
     let mut temp_path = temp_dir();
 
     temp_path.push("module");
 
     assert!(module.print_to_file(&temp_path).is_ok());
 }
 
+#[test]
+fn test_print_to_file_bad_path() {
+    let context = Context::create();
+    let module = context.create_module("mod");
+    let void_type = context.void_type();
+    let fn_type = void_type.fn_type(&[], false);
+    let f = module.add_function("f", fn_type, None);
+    let basic_block = context.append_basic_block(f, "entry");
+    let builder = context.create_builder();
+
+    builder.position_at_end(basic_block);
+    builder.build_return(None).unwrap();
+
+    #[cfg(unix)]
+    let bad_path = Path::new("/tmp/some/silly/path/that/sure/doesn't/exist");
+    #[cfg(windows)]
+    let bad_path = Path::new("/does/not/exist/hopefully");
+
+    match module.print_to_file(bad_path).unwrap_err().to_str() {
+        Ok("no such file or directory") | Ok("No such file or directory") => (),
+        Ok(err) => panic!("Some other error: {err}"),
+        Err(_) => panic!("Should have failed."),
+    }
+}
+
 #[test]
 fn test_get_set_target() {
     Target::initialize_x86(&Default::default());

tests/all/test_object_file.rs

@@ -154,7 +154,10 @@ fn test_symbol_iterator() {
                 "a" => {
                     assert!(!has_symbol_a);
                     has_symbol_a = true;
+                    #[cfg(unix)]
                     assert_eq!(symbol.size(), 1);
+                    #[cfg(windows)]
+                    assert_eq!(symbol.size(), 0);
                 },
                 "b" => {
                     assert!(!has_symbol_b);

tests/all/test_targets.rs

@@ -186,20 +186,25 @@ fn test_default_triple() {
         vec!["pc", "unknown", "redhat"]
     } else if cfg!(target_os = "macos") {
         vec!["apple"]
+    } else if cfg!(target_os = "windows") {
+        vec!["pc", "unknown", "uwp"]
     } else {
         vec![]
     };
 
     let has_known_vendor = vendors.iter().any(|vendor| default_triple.contains(*vendor));
     assert!(has_known_vendor, "Target triple '{default_triple}' has unknown vendor");
 
-    let os = [
-        #[cfg(target_os = "linux")]
-        "linux",
-        #[cfg(target_os = "macos")]
-        "darwin",
-    ];
-    let has_known_os = os.iter().any(|os| default_triple.contains(*os));
+    let has_known_os = if cfg!(target_os = "linux") {
+        default_triple.contains("linux")
+    } else if cfg!(target_os = "macos") {
+        default_triple.contains("macos")
+    } else if cfg!(target_os = "windows") {
+        default_triple.contains("windows")
+    } else {
+        false
+    };
+
     assert!(has_known_os, "Target triple '{default_triple}' has unknown OS");
 
     // TODO: CFG for other supported major OSes