[OpenMP] Try to embed offloading objects after codegen

[jhuber6]

Summary

Currently we use the -fembed-offload-object option to embed a binary
file into the host as a named section. This is currently only used as a
codegen action, meaning we only handle this option correctly when the
input is a bitcode file. This patch adds the same handling to embed an
offloading object after we complete code generation. This allows us to
embed the object correctly if the input file is source or bitcode.

[jdoerfert]

Can we have a test for this?

clang/include/clang/CodeGen/BackendUtil.h

48

Seems unrelated, please remove it from this patch.

clang/lib/CodeGen/BackendUtil.cpp

1774

Same as above?

[jhuber6]

In D120270#3336272, @jdoerfert wrote:

Can we have a test for this?

Sure.

clang/include/clang/CodeGen/BackendUtil.h

48

Yeah this is unrelated somewhat, just felt like changing it after doing another pass through. I can probably just commit this separately.

[jhuber6]

Removing unrelated changes and adding test.

[jdoerfert]

LG, wait for the other patches though.

clang/include/clang/CodeGen/BackendUtil.h

void EmitBackendOutput(DiagnosticsEngine &Diags, const HeaderSearchOptions &,
                          const CodeGenOptions &CGOpts,
                          const TargetOptions &TOpts, const LangOptions &LOpts,
                          StringRef TDesc, llvm::Module *M, BackendAction Action,
                          std::unique_ptr<raw_pwrite_stream> OS);
 
   void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
                     llvm::MemoryBufferRef Buf);
 
-  void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts,
+  void EmbedObject(llvm::Module &M, const CodeGenOptions &CGOpts,
                    DiagnosticsEngine &Diags);
 }
 
 #endif

clang/lib/CodeGen/BackendUtil.cpp

void clang::EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
   if (CGOpts.getEmbedBitcode() == CodeGenOptions::Embed_Off)
     return;
   llvm::embedBitcodeInModule(
       *M, Buf, CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Marker,
       CGOpts.getEmbedBitcode() != CodeGenOptions::Embed_Bitcode,
       CGOpts.CmdArgs);
 }
 
-void clang::EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts,
+void clang::EmbedObject(llvm::Module &M, const CodeGenOptions &CGOpts,
                         DiagnosticsEngine &Diags) {
   if (CGOpts.OffloadObjects.empty())
     return;
 
   for (StringRef OffloadObject : CGOpts.OffloadObjects) {
     if (OffloadObject.count(',') != 1) {
       Diags.Report(Diags.getCustomDiagID(
           DiagnosticsEngine::Error, "Invalid string pair for embedding '%0'"))
           << OffloadObject;
       return;
     }
     auto FilenameAndSection = OffloadObject.split(',');
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ObjectOrErr =
         llvm::MemoryBuffer::getFileOrSTDIN(std::get<0>(FilenameAndSection));
     if (std::error_code EC = ObjectOrErr.getError()) {
       auto DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
                                           "could not open '%0' for embedding");
-      Diags.Report(DiagID) << std::get<0>(FilenameAndSection);
+      Diags.Report(DiagID) << FilenameAndSection.first;
       return;
     }
 
     SmallString<128> SectionName(
-        {".llvm.offloading.", std::get<1>(FilenameAndSection)});
-    llvm::embedBufferInModule(*M, **ObjectOrErr, SectionName);
+        {".llvm.offloading.", FilenameAndSection.second});
+    llvm::embedBufferInModule(M, **ObjectOrErr, SectionName);
   }
 }

clang/lib/CodeGen/CodeGenAction.cpp

void CodeGenAction::ExecuteAction() {
 
   const TargetOptions &TargetOpts = CI.getTargetOpts();
   if (TheModule->getTargetTriple() != TargetOpts.Triple) {
     Diagnostics.Report(SourceLocation(), diag::warn_fe_override_module)
         << TargetOpts.Triple;
     TheModule->setTargetTriple(TargetOpts.Triple);
   }
 
-  EmbedObject(TheModule.get(), CodeGenOpts, Diagnostics);
+  EmbedObject(*TheModule.get(), CodeGenOpts, Diagnostics);
   EmbedBitcode(TheModule.get(), CodeGenOpts, *MainFile);
 
   LLVMContext &Ctx = TheModule->getContext();
 
   // Restore any diagnostic handler previously set before returning from this
   // function.
   struct RAII {
     LLVMContext &Ctx;

clang/lib/CodeGen/CodeGenModule.cpp

 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
+#include "clang/CodeGen/BackendUtil.h"
 #include "clang/CodeGen/ConstantInitBuilder.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DataLayout.h"
void CodeGenModule::Release() {
   if (SanStats)
     SanStats->finish();
 
   if (CodeGenOpts.Autolink &&
       (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
     EmitModuleLinkOptions();
   }
 
+  // If there is device offloading code embed it in the host now.
+  EmbedObject(getModule(), CodeGenOpts, getDiags());
+
   // On ELF we pass the dependent library specifiers directly to the linker
   // without manipulating them. This is in contrast to other platforms where
   // they are mapped to a specific linker option by the compiler. This
   // difference is a result of the greater variety of ELF linkers and the fact
   // that ELF linkers tend to handle libraries in a more complicated fashion
   // than on other platforms. This forces us to defer handling the dependent
   // libs to the linker.
   //