wip

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/builder/gpu_offload.rs

@@ -9,7 +9,7 @@ use crate::builder::SBuilder;
 use crate::common::AsCCharPtr;
 use crate::llvm::AttributePlace::Function;
 use crate::llvm::{self, Linkage, Visibility};
-use crate::{LlvmCodegenBackend, SimpleCx, attributes};
+use crate::{LlvmCodegenBackend, ModuleLlvm, SimpleCx, attributes};
 
 fn create_struct_ty<'ll>(
     cx: &'ll SimpleCx<'_>,
@@ -31,18 +31,19 @@ pub(crate) fn gen_image_wrapper_module<'ll>(
     old_cx: &SimpleCx<'ll>,
 ) {
     unsafe {
-        let llcx = llvm::LLVMRustContextCreate(false);
-        let module_name = CString::new("offload.wrapper.module").unwrap();
-        let llmod = llvm::LLVMModuleCreateWithNameInContext(module_name.as_ptr(), llcx);
-        let cx = SimpleCx::new(llmod, llcx, cgcx.pointer_size);
+        let dl_cstr = llvm::LLVMGetDataLayoutStr(old_cx.llmod);
+        let target_cstr = llvm::LLVMGetTarget(old_cx.llmod);
+        let name = "offload.wrapper.module";
+        let tm_factory_config =
+            rustc_codegen_ssa::back::write::TargetMachineFactoryConfig::new(cgcx, name);
+        let dcx = cgcx.create_dcx();
+        let tm = (cgcx.tm_factory)(tm_factory_config).unwrap();
+        let m: crate::ModuleLlvm = ModuleLlvm::new_simple(name, dl_cstr, target_cstr, tm);
+        let cx = SimpleCx::new(m.llmod(), m.llcx, cgcx.pointer_size);
         let tptr = cx.type_ptr();
         let ti64 = cx.type_i64();
         let ti32 = cx.type_i32();
         let ti16 = cx.type_i16();
-        let dl_cstr = llvm::LLVMGetDataLayoutStr(old_cx.llmod);
-        llvm::LLVMSetDataLayout(llmod, dl_cstr);
-        let target_cstr = llvm::LLVMGetTarget(old_cx.llmod);
-        llvm::LLVMSetTarget(llmod, target_cstr);
 
         let entry_fields = [ti64, ti16, ti16, ti32, tptr, tptr, ti64, ti64, tptr];
         create_struct_ty(&cx, "__tgt_offload_entry", &entry_fields);

compiler/rustc_codegen_llvm/src/context.rs

@@ -160,6 +160,22 @@ fn to_llvm_tls_model(tls_model: TlsModel) -> llvm::ThreadLocalMode {
     }
 }
 
+pub(crate) unsafe fn create_simple_module<'ll>(
+    llcx: &'ll llvm::Context,
+    target_data_layout: *const i8,
+    target_triple: *const i8,
+    mod_name: &str,
+) -> &'ll llvm::Module {
+    let mod_name = SmallCStr::new(mod_name);
+    let llmod = unsafe { llvm::LLVMModuleCreateWithNameInContext(mod_name.as_ptr(), llcx) };
+    unsafe {
+        llvm::LLVMSetDataLayout(llmod, target_data_layout);
+        llvm::LLVMSetTarget(llmod, target_triple);
+    }
+    let llvm_version = llvm_util::get_version();
+    llmod
+}
+
 pub(crate) unsafe fn create_module<'ll>(
     tcx: TyCtxt<'_>,
     llcx: &'ll llvm::Context,
@@ -210,7 +226,7 @@ pub(crate) unsafe fn create_module<'ll>(
 
     // Ensure the data-layout values hardcoded remain the defaults.
     {
-        let tm = crate::back::write::create_informational_target_machine(tcx.sess, false);
+        let tm = crate::back::write::create_informational_target_machine(sess, false);
         unsafe {
             llvm::LLVMRustSetDataLayoutFromTargetMachine(llmod, tm.raw());
         }

compiler/rustc_codegen_llvm/src/lib.rs

@@ -399,6 +399,21 @@ unsafe impl Send for ModuleLlvm {}
 unsafe impl Sync for ModuleLlvm {}
 
 impl ModuleLlvm {
+    fn new_simple(
+        name: &str,
+        dl_cstr: *const i8,
+        target_cstr: *const i8,
+        cgcx: &CodegenContext<LlvmCodegenBackend>,
+        dcx: DiagCtxtHandle<'_>,
+    ) -> Self {
+        unsafe {
+            let llcx = llvm::LLVMRustContextCreate(false);
+            let llmod_raw = context::create_simple_module(llcx, dl_cstr, target_cstr, name);
+            let tm = ModuleLlvm::tm_from_cgcx(cgcx, name, dcx)?;
+            ModuleLlvm { llmod_raw, llcx, tm: ManuallyDrop::new(tm) }
+        }
+    }
+
     fn new(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
             let llcx = llvm::LLVMRustContextCreate(tcx.sess.fewer_names());
@@ -423,6 +438,20 @@ impl ModuleLlvm {
         }
     }
 
+    fn tm_from_cgcx(
+        cgcx: &CodegenContext<LlvmCodegenBackend>,
+        name: &str,
+        dcx: DiagCtxtHandle<'_>,
+    ) -> Result<OwnedTargetMachine, FatalError> {
+        let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, name);
+        match (cgcx.tm_factory)(tm_factory_config) {
+            Ok(m) => Ok(m),
+            Err(e) => {
+                return Err(dcx.emit_almost_fatal(ParseTargetMachineConfig(e)));
+            }
+        }
+    }
+
     fn parse(
         cgcx: &CodegenContext<LlvmCodegenBackend>,
         name: &CStr,
@@ -432,13 +461,7 @@ impl ModuleLlvm {
         unsafe {
             let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
             let llmod_raw = back::lto::parse_module(llcx, name, buffer, dcx)?;
-            let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, name.to_str().unwrap());
-            let tm = match (cgcx.tm_factory)(tm_factory_config) {
-                Ok(m) => m,
-                Err(e) => {
-                    return Err(dcx.emit_almost_fatal(ParseTargetMachineConfig(e)));
-                }
-            };
+            let tm = ModuleLlvm::tm_from_cgcx(cgcx, name, dcx)?;
 
             Ok(ModuleLlvm { llmod_raw, llcx, tm: ManuallyDrop::new(tm) })
         }