Replace the first of 4 binary invocations for offload

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -765,6 +765,23 @@ pub(crate) unsafe fn llvm_optimize(
             llvm_plugins.len(),
         )
     };
+
+    if cgcx.target_is_like_gpu && config.offload.contains(&config::Offload::Enable) {
+        //let triple = SmallCStr::new(&versioned_llvm_target(sess));
+        //let arch = SmallCStr::new(llvm_util::target_cpu(sess));
+        //let arch = c"gfx90a";
+        //let triple = c"amdgcn-amd-amdhsa";
+        unsafe {
+            llvm::rustBundleImages(
+                module.module_llvm.llmod(),
+                module.module_llvm.tm.raw(), //triple.as_ptr(),
+                                             //triple.count_bytes(),
+                                             //arch.as_ptr(),
+                                             //arch.count_bytes(),
+            );
+        }
+    }
+
     result.into_result().unwrap_or_else(|()| llvm_err(dcx, LlvmError::RunLlvmPasses))
 }
 

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -2026,6 +2026,14 @@ unsafe extern "C" {
 
     // Operations on functions
     pub(crate) fn LLVMRustOffloadMapper<'a>(Fn: &'a Value, Fn: &'a Value);
+    pub(crate) fn rustBundleImages<'a>(
+        M: &'a Module,
+        TM: &'a TargetMachine,
+        //triple: *const c_char,
+        //tripleLen: size_t,
+        //arch: *const c_char,
+        //archLen: size_t,
+    ) -> bool;
     pub(crate) fn LLVMRustGetOrInsertFunction<'a>(
         M: &'a Module,
         Name: *const c_char,

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -39,6 +39,15 @@
 #include "llvm/Transforms/Utils/ValueMapper.h"
 #include <iostream>
 
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Object/ArchiveWriter.h"
+#include "llvm/Object/OffloadBinary.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Signals.h"
+
 // for raw `write` in the bad-alloc handler
 #ifdef _MSC_VER
 #include <io.h>
@@ -57,6 +66,56 @@ using namespace llvm;
 using namespace llvm::sys;
 using namespace llvm::object;
 
+static Error writeFile(StringRef Filename, StringRef Data) {
+  Expected<std::unique_ptr<FileOutputBuffer>> OutputOrErr =
+      FileOutputBuffer::create(Filename, Data.size());
+  if (!OutputOrErr)
+    return OutputOrErr.takeError();
+  std::unique_ptr<FileOutputBuffer> Output = std::move(*OutputOrErr);
+  llvm::copy(Data, Output->getBufferStart());
+  if (Error E = Output->commit())
+    return E;
+  return Error::success();
+}
+#include "llvm/Target/TargetMachine.h"
+extern "C" bool rustBundleImages(LLVMModuleRef M, TargetMachine &TM) {
+  //Module *Mptr = unwrap(M);
+  std::string Storage;
+  llvm::raw_string_ostream OS1(Storage);
+
+  llvm::WriteBitcodeToFile(*unwrap(M), OS1);
+  //llvm::WriteBitcodeToFile(*Mptr, OS1);
+  OS1.flush();
+  auto MB = llvm::MemoryBuffer::getMemBufferCopy(Storage, "module.bc");
+
+  SmallVector<char, 1024> BinaryData;
+  raw_svector_ostream OS(BinaryData);
+  BumpPtrAllocator Alloc;
+  StringSaver Saver(Alloc);
+
+  DenseMap<StringRef, StringRef> Args;
+
+  {
+    OffloadBinary::OffloadingImage ImageBinary{};
+    ImageBinary.TheImageKind = object::IMG_Bitcode;
+    ImageBinary.Image = std::move(MB);
+    ImageBinary.TheOffloadKind = object::OFK_OpenMP;
+    //ImageBinary.StringData["triple"] = triple;
+    //ImageBinary.StringData["arch"] = arch;
+    ImageBinary.StringData["triple"] = TM.getTargetTriple().str();
+    ImageBinary.StringData["arch"] = TM.getTargetCPU();
+    llvm::SmallString<0> Buffer = OffloadBinary::write(ImageBinary);
+    if (Buffer.size() % OffloadBinary::getAlignment() != 0)
+      // Offload binary has invalid size alignment
+      return false;
+    OS << Buffer;
+  }
+  if (Error E = writeFile("host.out",
+                          StringRef(BinaryData.begin(), BinaryData.size())))
+    return false;
+  return true;
+}
+
 // This opcode is an LLVM detail that could hypothetically change (?), so
 // verify that the hard-coded value in `dwarf_const.rs` still agrees with LLVM.
 static_assert(dwarf::DW_OP_LLVM_fragment == 0x1000);