Resolve rust-lang#149

Author: willtunnels

src/module.rs

@@ -35,7 +35,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)]
@@ -341,9 +341,9 @@ impl<'ctx> Module<'ctx> {
     ///
     /// assert_eq!(module.get_target().unwrap(), target);
     /// ```
-    pub fn set_target(&self, target: &Target) {
+    pub fn set_target(&self, target_triple: &TargetTriple) {
         unsafe {
-            LLVMSetTarget(self.module.get(), target.get_name().as_ptr())
+            LLVMSetTarget(self.module.get(), target_triple.as_ptr())
         }
     }
 
@@ -367,13 +367,13 @@ impl<'ctx> Module<'ctx> {
     ///
     /// assert_eq!(module.get_target().unwrap(), target);
     /// ```
-    pub fn get_target(&self) -> Option<Target> {
+    pub fn get_target(&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_borrowed(target_str)
     }
 
     /// Creates an `ExecutionEngine` from this `Module`.

src/targets.rs

@@ -28,13 +28,14 @@ use crate::data_layout::DataLayout;
 use crate::memory_buffer::MemoryBuffer;
 use crate::module::Module;
 use crate::passes::PassManager;
-use crate::support::LLVMString;
+use crate::support::{LLVMString, LLVMStringOrRaw};
 use crate::types::{AnyType, AsTypeRef, IntType, StructType};
 use crate::values::{AsValueRef, GlobalValue};
 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 +97,64 @@ impl Default for InitializationConfig {
     }
 }
 
+#[derive(Eq)]
+pub struct TargetTriple {
+    pub(crate) target_triple: LLVMStringOrRaw,
+}
+
+impl TargetTriple {
+    pub(crate) fn new_owned(target_triple: *const ::libc::c_char) -> TargetTriple {
+        debug_assert!(!target_triple.is_null());
+
+        TargetTriple {
+            target_triple: LLVMStringOrRaw::Owned(LLVMString::new(target_triple)),
+        }
+    }
+
+    pub(crate) fn new_borrowed(target_triple: *const ::libc::c_char) -> TargetTriple {
+        debug_assert!(!target_triple.is_null());
+
+        TargetTriple {
+            target_triple: LLVMStringOrRaw::Borrowed(target_triple),
+        }
+    }
+
+    pub fn create(target_triple: &str) -> TargetTriple {
+        let mut target_triple_copy = target_triple.to_owned();
+        target_triple_copy.push('\0');
+
+        TargetTriple {
+            target_triple: LLVMStringOrRaw::Owned(LLVMString::create(&target_triple_copy))
+        }
+    }
+
+    pub fn as_str(&self) -> &CStr {
+        self.target_triple.as_str()
+    }
+
+    pub fn as_ptr(&self) -> *const ::libc::c_char {
+        match self.target_triple {
+            LLVMStringOrRaw::Owned(ref llvm_string) => llvm_string.ptr,
+            LLVMStringOrRaw::Borrowed(ptr) => ptr,
+        }
+    }
+}
+
+impl PartialEq for TargetTriple {
+    fn eq(&self, other: &TargetTriple) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+
+impl fmt::Debug for TargetTriple {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("DataLayout")
+            .field("address", &self.as_ptr())
+            .field("repr", &self.as_str())
+            .finish()
+    }
+}
+
 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

tests/all/test_module.rs

@@ -4,7 +4,7 @@ use self::inkwell::OptimizationLevel;
 use self::inkwell::context::Context;
 use self::inkwell::memory_buffer::MemoryBuffer;
 use self::inkwell::module::Module;
-use self::inkwell::targets::Target;
+use self::inkwell::targets::TargetTriple;
 
 use std::env::temp_dir;
 use std::ffi::CString;
@@ -316,27 +316,25 @@ fn test_print_to_file() {
 
 #[test]
 fn test_get_set_target() {
-    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");
 
     #[cfg(not(any(feature = "llvm3-6", feature = "llvm3-7", feature = "llvm3-8")))]
     assert_eq!(*module.get_name(), *CString::new("mod").unwrap());
-    assert!(module.get_target().is_none());
+    assert_eq!(module.get_target(), TargetTriple::create(""));
 
     #[cfg(not(any(feature = "llvm3-6", feature = "llvm3-7", feature = "llvm3-8", feature = "llvm3-9",
                   feature = "llvm4-0", feature = "llvm5-0", feature = "llvm6-0")))]
     assert_eq!(*module.get_source_file_name(), *CString::new("mod").unwrap());
 
     #[cfg(not(any(feature = "llvm3-6", feature = "llvm3-7", feature = "llvm3-8")))]
     module.set_name("mod2");
-    module.set_target(&target);
+    module.set_target(&triple);
 
     #[cfg(not(any(feature = "llvm3-6", feature = "llvm3-7", feature = "llvm3-8")))]
     assert_eq!(*module.get_name(), *CString::new("mod2").unwrap());
-    assert_eq!(module.get_target().unwrap(), target);
+    assert_eq!(module.get_target(), triple);
 
     #[cfg(not(any(feature = "llvm3-6", feature = "llvm3-7", feature = "llvm3-8", feature = "llvm3-9",
                   feature = "llvm4-0", feature = "llvm5-0", feature = "llvm6-0")))]