Start using MaybeUninit for outptrs

TheDan64 · TheDan64 · commit 86d26edbfa60 · 2019-09-07T00:00:06.000-04:00
diff --git a/README.md b/README.md
@@ -5,15 +5,15 @@
 [![codecov](https://codecov.io/gh/TheDan64/inkwell/branch/master/graph/badge.svg)](https://codecov.io/gh/TheDan64/inkwell)
 [![lines of code](https://tokei.rs/b1/github/TheDan64/inkwell)](https://github.com/Aaronepower/tokei)
 [![Join the chat at https://gitter.im/inkwell-rs/Lobby](https://badges.gitter.im/inkwell-rs/Lobby.svg)](https://gitter.im/inkwell-rs/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-![Minimum rustc 1.34](https://img.shields.io/badge/rustc-1.34+-brightgreen.svg)
+![Minimum rustc 1.36](https://img.shields.io/badge/rustc-1.36+-brightgreen.svg)
 
 **I**t's a **N**ew **K**ind of **W**rapper for **E**xposing **LL**VM (*S*afely)
 
 Inkwell aims to help you pen your own programming languages by safely wrapping llvm-sys. It provides a more strongly typed interface than the underlying LLVM API so that certain types of errors can be caught at compile time instead of at LLVM's runtime. This means we are trying to replicate LLVM IR's strong typing as closely as possible. The ultimate goal is to make LLVM safer from the rust end and a bit easier to learn (via documentation) and use.
 
 ## Requirements
 
-* Rust 1.34+
+* Rust 1.36+
 * Rust Stable, Beta, or Nightly
 * LLVM 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 6.0, 7.0, or 8.0
 
diff --git a/src/execution_engine.rs b/src/execution_engine.rs
@@ -12,7 +12,7 @@ use std::rc::Rc;
 use std::ops::Deref;
 use std::ffi::CString;
 use std::fmt::{self, Debug, Display, Formatter};
-use std::mem::{forget, zeroed, transmute_copy, size_of};
+use std::mem::{forget, transmute_copy, size_of, MaybeUninit};
 
 static EE_INNER_PANIC: &str = "ExecutionEngineInner should exist until Drop";
 
@@ -224,17 +224,20 @@ impl ExecutionEngine {
             _ => ()
         }
 
-        let mut new_module = unsafe { zeroed() };
-        let mut err_string = unsafe { zeroed() };
+        let mut new_module = MaybeUninit::uninit();
+        let mut err_string = MaybeUninit::uninit();
 
         let code = unsafe {
-            LLVMRemoveModule(self.execution_engine_inner(), module.module.get(), &mut new_module, &mut err_string)
+            LLVMRemoveModule(self.execution_engine_inner(), module.module.get(), new_module.as_mut_ptr(), err_string.as_mut_ptr())
         };
 
         if code == 1 {
-            return Err(RemoveModuleError::LLVMError(LLVMString::new(err_string)));
+            let err_str = unsafe { err_string.assume_init() };
+            return Err(RemoveModuleError::LLVMError(LLVMString::new(err_str)));
         }
 
+        let new_module = unsafe { new_module.assume_init() };
+
         module.module.set(new_module);
         *module.owned_by_ee.borrow_mut() = None;
 
@@ -349,14 +352,16 @@ impl ExecutionEngine {
         }
 
         let c_string = CString::new(fn_name).expect("Conversion to CString failed unexpectedly");
-        let mut function = unsafe { zeroed() };
+        let mut function = MaybeUninit::uninit();
 
         let code = unsafe {
-            LLVMFindFunction(self.execution_engine_inner(), c_string.as_ptr(), &mut function)
+            LLVMFindFunction(self.execution_engine_inner(), c_string.as_ptr(), function.as_mut_ptr())
         };
 
         if code == 0 {
-            return FunctionValue::new(function).ok_or(FunctionLookupError::FunctionNotFound)
+            let fn_val = unsafe { function.assume_init() };
+
+            return FunctionValue::new(fn_val).ok_or(FunctionLookupError::FunctionNotFound)
         };
 
         Err(FunctionLookupError::FunctionNotFound)
diff --git a/src/memory_buffer.rs b/src/memory_buffer.rs
@@ -6,7 +6,7 @@ use crate::object_file::ObjectFile;
 use crate::support::LLVMString;
 
 use std::ffi::CString;
-use std::mem::{forget, zeroed};
+use std::mem::{forget, MaybeUninit};
 use std::path::Path;
 use std::ptr;
 use std::slice;
@@ -28,32 +28,34 @@ impl MemoryBuffer {
     pub fn create_from_file(path: &Path) -> Result<Self, LLVMString> {
         let path = CString::new(path.to_str().expect("Did not find a valid Unicode path string")).expect("Failed to convert to CString");
         let mut memory_buffer = ptr::null_mut();
-        let mut err_string = unsafe { zeroed() };
+        let mut err_string = MaybeUninit::uninit();
 
         let return_code = unsafe {
             // REVIEW: Unclear why this expects *const i8 instead of *const u8
-            LLVMCreateMemoryBufferWithContentsOfFile(path.as_ptr() as *const i8, &mut memory_buffer, &mut err_string)
+            LLVMCreateMemoryBufferWithContentsOfFile(path.as_ptr() as *const i8, &mut memory_buffer, err_string.as_mut_ptr())
         };
 
         // TODO: Verify 1 is error code (LLVM can be inconsistent)
         if return_code == 1 {
-            return Err(LLVMString::new(err_string));
+            let err_str = unsafe { err_string.assume_init() };
+            return Err(LLVMString::new(err_str));
         }
 
         Ok(MemoryBuffer::new(memory_buffer))
     }
 
     pub fn create_from_stdin() -> Result<Self, LLVMString> {
         let mut memory_buffer = ptr::null_mut();
-        let mut err_string = unsafe { zeroed() };
+        let mut err_string = MaybeUninit::uninit();
 
         let return_code = unsafe {
-            LLVMCreateMemoryBufferWithSTDIN(&mut memory_buffer, &mut err_string)
+            LLVMCreateMemoryBufferWithSTDIN(&mut memory_buffer, err_string.as_mut_ptr())
         };
 
         // TODO: Verify 1 is error code (LLVM can be inconsistent)
         if return_code == 1 {
-            return Err(LLVMString::new(err_string));
+            let err_str = unsafe { err_string.assume_init() };
+            return Err(LLVMString::new(err_str));
         }
 
         Ok(MemoryBuffer::new(memory_buffer))
diff --git a/src/module.rs b/src/module.rs
@@ -20,7 +20,7 @@ use std::cell::{Cell, RefCell, Ref};
 use std::ffi::CStr;
 use std::ffi::CString;
 use std::fs::File;
-use std::mem::{forget, zeroed};
+use std::mem::{forget, MaybeUninit};
 use std::path::Path;
 use std::ptr;
 use std::rc::Rc;
@@ -433,17 +433,20 @@ impl Module {
             return Err(LLVMString::create(string));
         }
 
-        let mut execution_engine = unsafe { zeroed() };
-        let mut err_string = unsafe { zeroed() };
+        let mut execution_engine = MaybeUninit::uninit();
+        let mut err_string = MaybeUninit::uninit();
         let code = unsafe {
-            LLVMCreateExecutionEngineForModule(&mut execution_engine, self.module.get(), &mut err_string) // Takes ownership of module
+            // Takes ownership of module
+            LLVMCreateExecutionEngineForModule(execution_engine.as_mut_ptr(), self.module.get(), err_string.as_mut_ptr())
         };
 
         if code == 1 {
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
         let context = self.non_global_context.clone();
+        let execution_engine = unsafe { execution_engine.assume_init() };
         let execution_engine = ExecutionEngine::new(Rc::new(execution_engine), context, false);
 
         *self.owned_by_ee.borrow_mut() = Some(execution_engine.clone());
@@ -481,18 +484,21 @@ impl Module {
             return Err(LLVMString::create(string));
         }
 
-        let mut execution_engine = unsafe { zeroed() };
-        let mut err_string = unsafe { zeroed() };
+        let mut execution_engine = MaybeUninit::uninit();
+        let mut err_string = MaybeUninit::uninit();
 
         let code = unsafe {
-            LLVMCreateInterpreterForModule(&mut execution_engine, self.module.get(), &mut err_string) // Takes ownership of module
+            // Takes ownership of module
+            LLVMCreateInterpreterForModule(execution_engine.as_mut_ptr(), self.module.get(), err_string.as_mut_ptr())
         };
 
         if code == 1 {
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
         let context = self.non_global_context.clone();
+        let execution_engine = unsafe { execution_engine.assume_init() };
         let execution_engine = ExecutionEngine::new(Rc::new(execution_engine), context, false);
 
         *self.owned_by_ee.borrow_mut() = Some(execution_engine.clone());
@@ -531,18 +537,21 @@ impl Module {
             return Err(LLVMString::create(string));
         }
 
-        let mut execution_engine = unsafe { zeroed() };
-        let mut err_string = unsafe { zeroed() };
+        let mut execution_engine = MaybeUninit::uninit();
+        let mut err_string = MaybeUninit::uninit();
 
         let code = unsafe {
-            LLVMCreateJITCompilerForModule(&mut execution_engine, self.module.get(), opt_level as u32, &mut err_string) // Takes ownership of module
+            // Takes ownership of module
+            LLVMCreateJITCompilerForModule(execution_engine.as_mut_ptr(), self.module.get(), opt_level as u32, err_string.as_mut_ptr())
         };
 
         if code == 1 {
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
         let context = self.non_global_context.clone();
+        let execution_engine = unsafe { execution_engine.assume_init() };
         let execution_engine = ExecutionEngine::new(Rc::new(execution_engine), context, true);
 
         *self.owned_by_ee.borrow_mut() = Some(execution_engine.clone());
@@ -659,14 +668,15 @@ impl Module {
     /// # Remarks
     /// See also: http://llvm.org/doxygen/Analysis_2Analysis_8cpp_source.html
     pub fn verify(&self) -> Result<(), LLVMString> {
-        let mut err_str = unsafe { zeroed() };
+        let mut err_str = MaybeUninit::uninit();
 
         let action = LLVMVerifierFailureAction::LLVMReturnStatusAction;
 
         let code = unsafe {
-            LLVMVerifyModule(self.module.get(), action, &mut err_str)
+            LLVMVerifyModule(self.module.get(), action, err_str.as_mut_ptr())
         };
 
+        let err_str = unsafe { err_str.assume_init() };
         if code == 1 && !err_str.is_null() {
             return Err(LLVMString::new(err_str));
         }
@@ -767,12 +777,13 @@ impl Module {
     pub fn print_to_file<P: AsRef<Path>>(&self, path: P) -> Result<(), LLVMString> {
         let path_str = path.as_ref().to_str().expect("Did not find a valid Unicode path string");
         let path = CString::new(path_str).expect("Could not convert path to CString");
-        let mut err_string = unsafe { zeroed() };
+        let mut err_string = MaybeUninit::uninit();
         let return_code = unsafe {
-            LLVMPrintModuleToFile(self.module.get(), path.as_ptr() as *const i8, &mut err_string)
+            LLVMPrintModuleToFile(self.module.get(), path.as_ptr() as *const i8, err_string.as_mut_ptr())
         };
 
         if return_code == 1 {
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
@@ -1063,21 +1074,24 @@ impl Module {
     ///
     /// ```
     pub fn parse_bitcode_from_buffer(buffer: &MemoryBuffer) -> Result<Self, LLVMString> {
-        let mut module = unsafe { zeroed() };
-        let mut err_string = unsafe { zeroed() };
+        let mut module = MaybeUninit::uninit();
+        let mut err_string = MaybeUninit::uninit();
 
         // LLVM has a newer version of this function w/o the error result since 3.8 but this deprecated function
         // hasen't yet been removed even in the unreleased LLVM 7. Seems fine to use instead of switching to their
         // error diagnostics handler
         #[allow(deprecated)]
         let success = unsafe {
-            LLVMParseBitcode(buffer.memory_buffer, &mut module, &mut err_string)
+            LLVMParseBitcode(buffer.memory_buffer, module.as_mut_ptr(), err_string.as_mut_ptr())
         };
 
         if success != 0 {
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
+        let module = unsafe { module.assume_init() };
+
         Ok(Module::new(module, None))
     }
 
@@ -1100,21 +1114,24 @@ impl Module {
     ///
     /// ```
     pub fn parse_bitcode_from_buffer_in_context(buffer: &MemoryBuffer, context: &Context) -> Result<Self, LLVMString> {
-        let mut module = unsafe { zeroed() };
-        let mut err_string = unsafe { zeroed() };
+        let mut module = MaybeUninit::uninit();
+        let mut err_string = MaybeUninit::uninit();
 
         // LLVM has a newer version of this function w/o the error result since 3.8 but this deprecated function
         // hasen't yet been removed even in the unreleased LLVM 7. Seems fine to use instead of switching to their
         // error diagnostics handler
         #[allow(deprecated)]
         let success = unsafe {
-            LLVMParseBitcodeInContext(*context.context, buffer.memory_buffer, &mut module, &mut err_string)
+            LLVMParseBitcodeInContext(*context.context, buffer.memory_buffer, module.as_mut_ptr(), err_string.as_mut_ptr())
         };
 
         if success != 0 {
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
+        let module = unsafe { module.assume_init() };
+
         Ok(Module::new(module, Some(&context)))
     }
 
diff --git a/src/targets.rs b/src/targets.rs
@@ -33,7 +33,7 @@ use crate::{AddressSpace, OptimizationLevel};
 
 use std::default::Default;
 use std::ffi::{CStr, CString};
-use std::mem::zeroed;
+use std::mem::MaybeUninit;
 use std::path::Path;
 use std::ptr;
 use std::sync::RwLock;
@@ -961,16 +961,15 @@ impl Target {
     pub fn from_triple(triple: &str) -> Result<Self, LLVMString> {
         let c_string = CString::new(triple).expect("Conversion to CString failed unexpectedly");
         let mut target = ptr::null_mut();
-        let mut err_string = unsafe { zeroed() };
+        let mut err_string = MaybeUninit::uninit();
 
-        let code =
-        {
+        let code = {
             let _guard = TARGET_LOCK.read().unwrap();
-            unsafe { LLVMGetTargetFromTriple(c_string.as_ptr(), &mut target, &mut err_string) }
+            unsafe { LLVMGetTargetFromTriple(c_string.as_ptr(), &mut target, err_string.as_mut_ptr()) }
         };
 
         if code == 1 {
-            // REVIEW: 1 is error value
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
@@ -1139,7 +1138,7 @@ impl TargetMachine {
         file_type: FileType,
     ) -> Result<MemoryBuffer, LLVMString> {
         let mut memory_buffer = ptr::null_mut();
-        let mut err_string = unsafe { zeroed() };
+        let mut err_string = MaybeUninit::uninit();
         let return_code = unsafe {
             let module_ptr = module.module.get();
             let file_type_ptr = file_type.as_llvm_file_type();
@@ -1148,12 +1147,13 @@ impl TargetMachine {
                 self.target_machine,
                 module_ptr,
                 file_type_ptr,
-                &mut err_string,
+                err_string.as_mut_ptr(),
                 &mut memory_buffer,
             )
         };
 
         if return_code == 1 {
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
@@ -1199,7 +1199,7 @@ impl TargetMachine {
             .to_str()
             .expect("Did not find a valid Unicode path string");
         let path_c_string = CString::new(path).expect("Conversion to CString failed unexpectedly");
-        let mut err_string = unsafe { zeroed() };
+        let mut err_string = MaybeUninit::uninit();
         let return_code = unsafe {
             // REVIEW: Why does LLVM need a mutable ptr to path...?
             let module_ptr = module.module.get();
@@ -1211,11 +1211,12 @@ impl TargetMachine {
                 module_ptr,
                 path_ptr,
                 file_type_ptr,
-                &mut err_string,
+                err_string.as_mut_ptr(),
             )
         };
 
         if return_code == 1 {
+            let err_string = unsafe { err_string.assume_init() };
             return Err(LLVMString::new(err_string));
         }
 
diff --git a/tests/all/test_targets.rs b/tests/all/test_targets.rs
@@ -66,14 +66,15 @@ use std::str::from_utf8;
 
 #[test]
 fn test_target_and_target_machine() {
+    Target::initialize_native(&InitializationConfig::default()).expect("Failed to initialize native target");
+
     let bad_target = Target::from_name("asd");
 
     assert!(bad_target.is_none());
 
-    let _bad_target2 = Target::from_triple("x86_64-pc-linux-gnu");
+    let bad_target2 = Target::from_triple("sadas");
 
-    // REVIEW: Inconsistent success :(
-    // assert_eq!(*bad_target2.unwrap_err(), *CString::new("Unable to find target for this triple (no targets are registered)").unwrap());
+    assert_eq!(bad_target2.unwrap_err().to_string(), "No available targets are compatible with this triple.");
 
     Target::initialize_x86(&InitializationConfig::default());
 
