Merge pull request rust-lang#152 from willtunnels/set_target-fix

Set target fix

Author: TheDan64

src/module.rs

@@ -16,7 +16,6 @@ use llvm_sys::LLVMLinkage;
 use llvm_sys::LLVMModuleFlagBehavior;
 
 use std::cell::{Cell, RefCell, Ref};
-#[llvm_versions(3.9..=latest)]
 use std::ffi::CStr;
 use std::ffi::CString;
 use std::fs::File;
@@ -35,7 +34,7 @@ use crate::data_layout::DataLayout;
 use crate::execution_engine::ExecutionEngine;
 use crate::memory_buffer::MemoryBuffer;
 use crate::support::LLVMString;
-use crate::targets::{Target, InitializationConfig};
+use crate::targets::{InitializationConfig, Target, TargetTriple};
 use crate::types::{AsTypeRef, BasicType, FunctionType, BasicTypeEnum};
 use crate::values::{AsValueRef, FunctionValue, GlobalValue, MetadataValue};
 #[llvm_versions(7.0..=latest)]
@@ -321,59 +320,58 @@ impl<'ctx> Module<'ctx> {
         Some(BasicTypeEnum::new(type_))
     }
 
-    /// Sets a `Target` to this `Module`.
+    /// Assigns a `TargetTriple` to this `Module`.
     ///
     /// # Example
     ///
     /// ```rust,no_run
     /// use inkwell::context::Context;
-    /// use inkwell::targets::Target;
+    /// use inkwell::targets::{Target, TargetTriple};
     ///
     /// Target::initialize_x86(&Default::default());
-    ///
     /// let context = Context::create();
     /// let module = context.create_module("mod");
-    /// let target = Target::from_name("x86-64").unwrap();
+    /// let triple = TargetTriple::create("x86_64-pc-linux-gnu");
     ///
-    /// assert!(module.get_target().is_none());
+    /// assert_eq!(module.get_triple(), TargetTriple::create(""));
     ///
-    /// module.set_target(&target);
+    /// module.set_triple(&triple);
     ///
-    /// assert_eq!(module.get_target().unwrap(), target);
+    /// assert_eq!(module.get_triple(), triple);
     /// ```
-    pub fn set_target(&self, target: &Target) {
+    pub fn set_triple(&self, triple: &TargetTriple) {
         unsafe {
-            LLVMSetTarget(self.module.get(), target.get_name().as_ptr())
+            LLVMSetTarget(self.module.get(), triple.as_ptr())
         }
     }
 
-    /// Gets the `Target` assigned to this `Module`, if any.
+    /// Gets the `TargetTriple` assigned to this `Module`. If none has been
+    /// assigned, the triple will default to "".
     ///
     /// # Example
     ///
     /// ```rust,no_run
     /// use inkwell::context::Context;
-    /// use inkwell::targets::Target;
+    /// use inkwell::targets::{Target, TargetTriple};
     ///
     /// Target::initialize_x86(&Default::default());
-    ///
     /// let context = Context::create();
     /// let module = context.create_module("mod");
-    /// let target = Target::from_name("x86-64").unwrap();
+    /// let triple = TargetTriple::create("x86_64-pc-linux-gnu");
     ///
-    /// assert!(module.get_target().is_none());
+    /// assert_eq!(module.get_triple(), TargetTriple::create(""));
     ///
-    /// module.set_target(&target);
+    /// module.set_triple(&triple);
     ///
-    /// assert_eq!(module.get_target().unwrap(), target);
+    /// assert_eq!(module.get_triple(), triple);
     /// ```
-    pub fn get_target(&self) -> Option<Target> {
+    pub fn get_triple(&self) -> TargetTriple {
         // REVIEW: This isn't an owned LLVMString, is it? If so, need to deallocate.
         let target_str = unsafe {
             LLVMGetTarget(self.module.get())
         };
 
-        Target::from_name_raw(target_str)
+        TargetTriple::new(LLVMString::create_from_c_str(unsafe { CStr::from_ptr(target_str) }))
     }
 
     /// Creates an `ExecutionEngine` from this `Module`.
@@ -398,12 +396,12 @@ impl<'ctx> Module<'ctx> {
             .map_err(|mut err_string| {
                 err_string.push('\0');
 
-                LLVMString::create(&err_string)
+                LLVMString::create_from_str(&err_string)
             })?;
 
         if self.owned_by_ee.borrow().is_some() {
             let string = "This module is already owned by an ExecutionEngine.\0";
-            return Err(LLVMString::create(string));
+            return Err(LLVMString::create_from_str(string));
         }
 
         let mut execution_engine = MaybeUninit::uninit();
@@ -449,12 +447,12 @@ impl<'ctx> Module<'ctx> {
             .map_err(|mut err_string| {
                 err_string.push('\0');
 
-                LLVMString::create(&err_string)
+                LLVMString::create_from_str(&err_string)
             })?;
 
         if self.owned_by_ee.borrow().is_some() {
             let string = "This module is already owned by an ExecutionEngine.\0";
-            return Err(LLVMString::create(string));
+            return Err(LLVMString::create_from_str(string));
         }
 
         let mut execution_engine = MaybeUninit::uninit();
@@ -502,12 +500,12 @@ impl<'ctx> Module<'ctx> {
             .map_err(|mut err_string| {
                 err_string.push('\0');
 
-                LLVMString::create(&err_string)
+                LLVMString::create_from_str(&err_string)
             })?;
 
         if self.owned_by_ee.borrow().is_some() {
             let string = "This module is already owned by an ExecutionEngine.\0";
-            return Err(LLVMString::create(string));
+            return Err(LLVMString::create_from_str(string));
         }
 
         let mut execution_engine = MaybeUninit::uninit();
@@ -1212,7 +1210,7 @@ impl<'ctx> Module<'ctx> {
     pub fn link_in_module(&self, other: Self) -> Result<(), LLVMString> {
         if other.owned_by_ee.borrow().is_some() {
             let string = "Cannot link a module which is already owned by an ExecutionEngine.\0";
-            return Err(LLVMString::create(string));
+            return Err(LLVMString::create_from_str(string));
         }
 
         #[cfg(any(feature = "llvm3-6", feature = "llvm3-7"))]

src/support/mod.rs

@@ -33,7 +33,16 @@ impl LLVMString {
     }
 
     /// This method will allocate a c string through LLVM
-    pub(crate) fn create(string: &str) -> LLVMString {
+    pub(crate) fn create_from_c_str(string: &CStr) -> LLVMString {
+        let ptr = unsafe {
+            LLVMCreateMessage(string.as_ptr() as *const _)
+        };
+
+        LLVMString::new(ptr)
+    }
+
+    /// This method will allocate a c string through LLVM
+    pub(crate) fn create_from_str(string: &str) -> LLVMString {
         debug_assert_eq!(string.as_bytes()[string.as_bytes().len() - 1], 0);
 
         let ptr = unsafe {

src/targets.rs

@@ -1,5 +1,3 @@
-#[llvm_versions(7.0..=latest)]
-use either::Either;
 use llvm_sys::target::{
     LLVMABIAlignmentOfType, LLVMABISizeOfType, LLVMByteOrder, LLVMByteOrdering,
     LLVMCallFrameAlignmentOfType, LLVMCopyStringRepOfTargetData, LLVMCreateTargetData,
@@ -35,6 +33,7 @@ use crate::{AddressSpace, OptimizationLevel};
 
 use std::default::Default;
 use std::ffi::{CStr, CString};
+use std::fmt;
 use std::mem::MaybeUninit;
 use std::path::Path;
 use std::ptr;
@@ -96,6 +95,53 @@ impl Default for InitializationConfig {
     }
 }
 
+#[derive(Eq)]
+pub struct TargetTriple {
+    pub(crate) triple: LLVMString,
+}
+
+impl TargetTriple {
+    pub(crate) fn new(triple: LLVMString) -> TargetTriple {
+        TargetTriple {
+            triple,
+        }
+    }
+
+    pub fn create(triple: &str) -> TargetTriple {
+        let c_string = CString::new(triple).expect("Conversion to CString failed unexpectedly");
+
+        TargetTriple {
+            triple: LLVMString::create_from_c_str(c_string.as_c_str())
+        }
+    }
+
+    pub fn as_str(&self) -> &CStr {
+        unsafe { CStr::from_ptr(self.as_ptr()) }
+    }
+
+    pub fn as_ptr(&self) -> *const ::libc::c_char {
+        self.triple.as_ptr()
+    }
+}
+
+impl PartialEq for TargetTriple {
+    fn eq(&self, other: &TargetTriple) -> bool {
+        self.triple == other.triple
+    }
+}
+
+impl fmt::Debug for TargetTriple {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "TargetTriple({:?})", self.triple)
+    }
+}
+
+impl fmt::Display for TargetTriple {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write!(f, "TargetTriple({:?})", self.triple)
+    }
+}
+
 static TARGET_LOCK: Lazy<RwLock<()>> = Lazy::new(|| RwLock::new(()));
 
 // NOTE: Versions verified as target-complete: 3.6, 3.7, 3.8, 3.9, 4.0
@@ -858,14 +904,13 @@ impl Target {
 
     pub fn create_target_machine(
         &self,
-        triple: &str,
+        triple: &TargetTriple,
         cpu: &str,
         features: &str,
         level: OptimizationLevel,
         reloc_mode: RelocMode,
         code_model: CodeModel,
     ) -> Option<TargetMachine> {
-        let triple = CString::new(triple).expect("Conversion to CString failed unexpectedly");
         let cpu = CString::new(cpu).expect("Conversion to CString failed unexpectedly");
         let features = CString::new(features).expect("Conversion to CString failed unexpectedly");
         let level = match level {
@@ -957,14 +1002,13 @@ impl Target {
         Some(Target::new(target))
     }
 
-    pub fn from_triple(triple: &str) -> Result<Self, LLVMString> {
-        let c_string = CString::new(triple).expect("Conversion to CString failed unexpectedly");
+    pub fn from_triple(triple: &TargetTriple) -> Result<Self, LLVMString> {
         let mut target = ptr::null_mut();
         let mut err_string = MaybeUninit::uninit();
 
         let code = {
             let _guard = TARGET_LOCK.read();
-            unsafe { LLVMGetTargetFromTriple(c_string.as_ptr(), &mut target, err_string.as_mut_ptr()) }
+            unsafe { LLVMGetTargetFromTriple(triple.as_ptr(), &mut target, err_string.as_mut_ptr()) }
         };
 
         if code == 1 {
@@ -1006,10 +1050,10 @@ impl TargetMachine {
         Target::new(target)
     }
 
-    pub fn get_triple(&self) -> LLVMString {
+    pub fn get_triple(&self) -> TargetTriple {
         let ptr = unsafe { LLVMGetTargetMachineTriple(self.target_machine) };
 
-        LLVMString::new(ptr)
+        TargetTriple::new(LLVMString::new(ptr))
     }
 
     /// Gets the default triple for the current system.
@@ -1023,31 +1067,21 @@ impl TargetMachine {
     ///
     /// let default_triple = TargetMachine::get_default_triple();
     ///
-    /// assert_eq!(*default_triple, *CString::new("x86_64-pc-linux-gnu").unwrap());
+    /// assert_eq!(default_triple.as_str(), CString::new("x86_64-pc-linux-gnu").unwrap().as_c_str());
     /// ```
-    pub fn get_default_triple() -> LLVMString {
+    pub fn get_default_triple() -> TargetTriple {
         let llvm_string = unsafe { LLVMGetDefaultTargetTriple() };
 
-        LLVMString::new(llvm_string)
+        TargetTriple::new(LLVMString::new(llvm_string))
     }
 
     #[llvm_versions(7.0..=latest)]
-    pub fn normalize_target_triple(triple: Either<&str, &CStr>) -> LLVMString {
+    pub fn normalize_triple(triple: &TargetTriple) -> TargetTriple {
         use llvm_sys::target_machine::LLVMNormalizeTargetTriple;
 
-        let ptr = match triple {
-            Either::Left(triple_str) => {
-                let c_string =
-                    CString::new(triple_str).expect("Conversion to CString failed unexpectedly");
+        let normalized = unsafe { LLVMNormalizeTargetTriple(triple.as_ptr()) };
 
-                unsafe { LLVMNormalizeTargetTriple(c_string.as_ptr()) }
-            }
-            Either::Right(triple_cstr) => unsafe {
-                LLVMNormalizeTargetTriple(triple_cstr.as_ptr())
-            },
-        };
-
-        LLVMString::new(ptr)
+        TargetTriple::new(LLVMString::new(normalized))
     }
 
     /// Gets a string containing the host CPU's name (triple).
@@ -1112,15 +1146,23 @@ impl TargetMachine {
     /// ```no_run
     /// use inkwell::OptimizationLevel;
     /// use inkwell::context::Context;
-    /// use inkwell::targets::{CodeModel, RelocMode, FileType, Target, TargetMachine, InitializationConfig};
+    /// use inkwell::targets::{CodeModel, RelocMode, FileType, Target, TargetMachine, TargetTriple, InitializationConfig};
     ///
     /// Target::initialize_x86(&InitializationConfig::default());
     ///
     /// let opt = OptimizationLevel::Default;
     /// let reloc = RelocMode::Default;
     /// let model = CodeModel::Default;
     /// let target = Target::from_name("x86-64").unwrap();
-    /// let target_machine = target.create_target_machine("x86_64-pc-linux-gnu", "x86-64", "+avx2", opt, reloc, model).unwrap();
+    /// let target_machine = target.create_target_machine(
+    ///     &TargetTriple::create("x86_64-pc-linux-gnu"),
+    ///     "x86-64",
+    ///     "+avx2",
+    ///     opt,
+    ///     reloc,
+    ///     model
+    /// )
+    /// .unwrap();
     ///
     /// let context = Context::create();
     /// let module = context.create_module("my_module");
@@ -1166,7 +1208,7 @@ impl TargetMachine {
     /// ```no_run
     /// use inkwell::OptimizationLevel;
     /// use inkwell::context::Context;
-    /// use inkwell::targets::{CodeModel, RelocMode, FileType, Target, TargetMachine, InitializationConfig};
+    /// use inkwell::targets::{CodeModel, RelocMode, FileType, Target, TargetMachine, TargetTriple, InitializationConfig};
     ///
     /// use std::path::Path;
     ///
@@ -1177,7 +1219,15 @@ impl TargetMachine {
     /// let model = CodeModel::Default;
     /// let path = Path::new("/tmp/some/path/main.asm");
     /// let target = Target::from_name("x86-64").unwrap();
-    /// let target_machine = target.create_target_machine("x86_64-pc-linux-gnu", "x86-64", "+avx2", opt, reloc, model).unwrap();
+    /// let target_machine = target.create_target_machine(
+    ///     &TargetTriple::create("x86_64-pc-linux-gnu"),
+    ///     "x86-64",
+    ///     "+avx2",
+    ///     opt,
+    ///     reloc,
+    ///     model
+    /// )
+    /// .unwrap();
     ///
     /// let context = Context::create();
     /// let module = context.create_module("my_module");