working

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -779,25 +779,15 @@ pub(crate) unsafe fn llvm_optimize(
         let out_obj_c = CString::new("/p/lustre1/drehwald1/prog/offload/r/host.o").unwrap();
 
         unsafe {
-            //let buf = llvm::LLVMRustModuleBufferFromFile(lib_bc_c.as_ptr()).unwrap();
+            // 1) Bundle device module into offload image host.out (device TM)
             let buf = llvm::LLVMRustModuleBufferCreate(module.module_llvm.llmod());
-
             let ok =
                 llvm::LLVMRustBundleImages(buf, module.module_llvm.tm.raw(), host_out_c.as_ptr());
-            // 1) Bundle device module into offload image host.out (device TM)
-            //let ok = llvm::LLVMRustBundleImages(
-            //    module.module_llvm.llmod(),
-            //    module.module_llvm.tm.raw(),
-            //    host_out_c.as_ptr(),
-            //);
             assert!(ok, "LLVMRustBundleImages (device -> host.out) failed");
 
             // 2) Finalize host: lib.bc + host.out -> host.offload.o (host TM created in C++)
-            let ok = llvm::LLVMRustFinalizeOffload(
-                lib_bc_c.as_ptr(),
-                host_out_c.as_ptr(),
-                out_obj_c.as_ptr(),
-            );
+            let buf = llvm::LLVMRustModuleBufferFromFile(lib_bc_c.as_ptr()).unwrap();
+            let ok = llvm::LLVMRustFinalizeOffload(buf, host_out_c.as_ptr(), out_obj_c.as_ptr());
             assert!(ok, "LLVMRustFinalizeOffload (host finalize) failed");
         }
         dbg!("done");

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1724,12 +1724,12 @@ mod Offload {
         /// Processes the module and writes it in an offload compatible way into a "host.out" file.
         pub(crate) fn LLVMRustBundleImages<'a>(
             p: &ModuleBuffer,
-            //M: &'a Module,
             TM: &'a TargetMachine,
             host_out: *const c_char,
         ) -> bool;
         pub(crate) fn LLVMRustFinalizeOffload(
-            lib_bc_path: *const c_char,
+            p: &ModuleBuffer,
+            //lib_bc_path: *const c_char,
             host_out_path: *const c_char,
             out_obj_path: *const c_char,
         ) -> bool;

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -44,6 +44,7 @@
 // available. As such, we only try to build it in the first place, if
 // llvm.offload is enabled.
 #ifdef OFFLOAD
+#include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Object/OffloadBinary.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
@@ -1544,12 +1545,6 @@ extern "C" bool LLVMRustBundleImages(const LLVMRustModuleBuffer *MBuf, TargetMac
   // Recreate a MemoryBuffer from the bytes in LLVMRustModuleBuffer
   StringRef Storage(MBuf->data.data(), MBuf->data.size());
   auto MB = MemoryBuffer::getMemBufferCopy(Storage, "device.bc");
-  //auto MB = LLVMRustModuleBufferCreate(M);
-  //std::string Storage;
-  //llvm::raw_string_ostream OS1(Storage);
-  //llvm::WriteBitcodeToFile(*unwrap(M), OS1);
-  //OS1.flush();
-  //auto MB = llvm::MemoryBuffer::getMemBufferCopy(Storage, "device.bc");
 
   SmallVector<char, 1024> BinaryData;
   raw_svector_ostream OS2(BinaryData);
@@ -1575,7 +1570,6 @@ extern "C" bool LLVMRustBundleImages(const LLVMRustModuleBuffer *MBuf, TargetMac
   return true;
 }
 
-#include "llvm/Bitcode/BitcodeReader.h"
 Expected<std::unique_ptr<Module>>
 loadHostModuleFromBitcode(LLVMContext &Ctx, StringRef LibBCPath) {
   auto MBOrErr = MemoryBuffer::getFile(LibBCPath);
@@ -1706,25 +1700,31 @@ static std::unique_ptr<TargetMachine> createHostTargetMachine() {
 
 // Top-level entry: host finalize in second rustc invocation
 // lib.bc (from first rustc) + host.out (from LLVMRustBundleImages) => host.offload.o
-extern "C" bool LLVMRustFinalizeOffload(const char *LibBCPath,
+extern "C" bool LLVMRustFinalizeOffload(const LLVMRustModuleBuffer *MBuf,
                                         const char *HostOutPath,
                                         const char *OutObjPath) {
-  LLVMContext Ctx;
+   LLVMContext Ctx;
+   llvm::errs() << "Before A\n";
 
-  // 1. Load host lib.bc
-  auto ModOrErr = loadHostModuleFromBitcode(Ctx, LibBCPath);
+  // new:
+  StringRef Storage(MBuf->data.data(), MBuf->data.size());
+  MemoryBufferRef Ref(Storage, "host.bc");
+  auto ModOrErr = parseBitcodeFile(Ref, Ctx);
   if (!ModOrErr)
     return !errorToBool(ModOrErr.takeError());
   std::unique_ptr<Module> HostM = std::move(*ModOrErr);
+  llvm::errs() << "A done\n";
 
   // 2. Embed host.out
   if (Error E = embedHostOutIntoHostModule(*HostM, HostOutPath))
     return !errorToBool(std::move(E));
+  llvm::errs() << "B done\n";
 
   // 3. Create host TM and emit host object
   auto HostTM = createHostTargetMachine();
   if (!HostTM)
     return false;
+  llvm::errs() << "C done\n";
 
   if (Error E = emitHostObjectWithTM(*HostM, *HostTM, OutObjPath))
     return !errorToBool(std::move(E));