[DirectX] Embed DXIL in LLVM Module

[beanz]

Summary

At the end of the codegen pipeline for DXIL we will emit the DXIL into
a global variable in the Module annotated for the "DXIL" section.

This will be used by the MCDXContainerStreamer to emit the DXIL into a
DXContainer DXIL part.

Other parts of the DXContainer will be constructed similarly by
serializing their values into GlobalVariables.

This will allow DXIL to flow into DXContainers through the normal
MCStreamer flow used in the MC layer.

Depends on D122270

[kuhar]

llvm/lib/Target/DirectX/DXILWriter/DXILWriterPass.cpp

69–70

1. Are we sure that WriteDXILToFile flushes the stream before returning?
2. We don't need the assignment, you can do ArrayRef<uint8_t> X(A, B) to run the constructor that takes two pointers/.
3. Use reinterpret_cast instead of C-style casts.

74

nit: the type if obvious from the RHS, so we can use auto *GV

80

Can you add a brief comment on why we return false? It appears like the module might be modified by one of the function calls above.

[kuhar]

llvm/lib/Target/DirectX/DXILWriter/DXILWriterPass.cpp

69–70

There's also arrayRefFromStringRef in StringExtras.h, but I'm not 100% sure if non-const ArrayRef is convertible to const-typed one.

[python3kgae]

llvm/test/CodeGen/DirectX/embed-dxil.ll

2

Could this be an opt test?
Once https://reviews.llvm.org/D124805 is in, we'll have opt work for passes which name started with dxil-.
Maybe we can change the pass name to dxil-embed?

[beanz]

llvm/lib/Target/DirectX/DXILWriter/DXILWriterPass.cpp

69–70

raw_string_ostream is unbuffered, so flushing does nothing.

Will address the other feedback in an updated patch.

80

Yea… I should probably just make it return true. I was thinking that the change wasn’t semantically important, but returning true is probably the better approach.

llvm/test/CodeGen/DirectX/embed-dxil.ll

2

Yea, making it an opt test might be better. I also might change the patch to not run the pass as part of the codegen pipeline for asm output because it is less important there. Once I get the MCStreamer and ASMPrinters up this should all come together nicely.

[beanz]

Updates based on review feedback.

[kuhar]

LGTM

llvm/lib/Target/DirectX/DXILWriter/CMakeLists.txt

 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../)
 
 add_llvm_component_library(LLVMDXILBitWriter
   DXILBitcodeWriter.cpp
   DXILValueEnumerator.cpp
   DXILWriterPass.cpp
 
   DEPENDS
   intrinsics_gen
 
   LINK_COMPONENTS
   BitWriter
   Core
   MC
   Object
   Support
+  TransformUtils
   )

llvm/lib/Target/DirectX/DXILWriter/DXILWriterPass.h

 class Module;
 class raw_ostream;
 
 /// Create and return a pass that writes the module to the specified
 /// ostream. Note that this pass is designed for use with the legacy pass
 /// manager.
 ModulePass *createDXILWriterPass(raw_ostream &Str);
 
+/// Create and return a pass that writes the module to a global variable in the
+/// module for later emission in the MCStreamer. Note that this pass is designed
+/// for use with the legacy pass manager because it is run in CodeGen only.
+ModulePass *createDXILEmbedderPass();
+
 } // namespace llvm
 
 #endif

llvm/lib/Target/DirectX/DXILWriter/DXILWriterPass.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "DXILWriterPass.h"
 #include "DXILBitcodeWriter.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
+#include "llvm/Support/Alignment.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
 using namespace llvm::dxil;
 
 namespace {
 class WriteDXILPass : public llvm::ModulePass {
   raw_ostream &OS; // raw_ostream to print on
 
public:
   bool runOnModule(Module &M) override {
     WriteDXILToFile(M, OS);
     return false;
   }
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 };
+
+class EmbedDXILPass : public llvm::ModulePass {
+public:
+  static char ID; // Pass identification, replacement for typeid
+  EmbedDXILPass() : ModulePass(ID) {
+    initializeEmbedDXILPassPass(*PassRegistry::getPassRegistry());
+  }
+
+  StringRef getPassName() const override { return "DXIL Embedder"; }
+
+  bool runOnModule(Module &M) override {
+    std::string Data;
+    llvm::raw_string_ostream OS(Data);
+    WriteDXILToFile(M, OS);
+
+    Constant *ModuleConstant =
+        ConstantDataArray::get(M.getContext(), arrayRefFromStringRef(Data));
+    auto *GV = new llvm::GlobalVariable(M, ModuleConstant->getType(), true,
+                                        GlobalValue::PrivateLinkage,
+                                        ModuleConstant, "dx.dxil");
+    GV->setSection("DXIL");
+    GV->setAlignment(Align(4));
+    appendToCompilerUsed(M, {GV});
+    return true;
+  }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+};
 } // namespace
 
 char WriteDXILPass::ID = 0;
 INITIALIZE_PASS_BEGIN(WriteDXILPass, "write-bitcode", "Write Bitcode", false,
                       true)
 INITIALIZE_PASS_DEPENDENCY(ModuleSummaryIndexWrapperPass)
 INITIALIZE_PASS_END(WriteDXILPass, "write-bitcode", "Write Bitcode", false,
                     true)
 
 ModulePass *llvm::createDXILWriterPass(raw_ostream &Str) {
   return new WriteDXILPass(Str);
 }
+
+char EmbedDXILPass::ID = 0;
+INITIALIZE_PASS(EmbedDXILPass, "dxil-embed", "Embed DXIL", false, true)
+
+ModulePass *llvm::createDXILEmbedderPass() { return new EmbedDXILPass(); }

llvm/lib/Target/DirectX/DirectX.h

 
 namespace llvm {
 class ModulePass;
 class PassRegistry;
 
 /// Initializer for dxil writer pass
 void initializeWriteDXILPassPass(PassRegistry &);
 
+/// Initializer for dxil embedder pass
+void initializeEmbedDXILPassPass(PassRegistry &);
+
 /// Initializer for DXIL-prepare
 void initializeDXILPrepareModulePass(PassRegistry &);
 
 /// Pass to convert modules into DXIL-compatable modules
 ModulePass *createDXILPrepareModulePass();
 
 /// Initializer for DXILOpLowering
 void initializeDXILOpLoweringLegacyPass(PassRegistry &);

llvm/lib/Target/DirectX/DirectXTargetMachine.cpp

 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 using namespace llvm;
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTarget() {
   RegisterTargetMachine<DirectXTargetMachine> X(getTheDirectXTarget());
   auto *PR = PassRegistry::getPassRegistry();
   initializeDXILPrepareModulePass(*PR);
+  initializeEmbedDXILPassPass(*PR);
   initializeDXILOpLoweringLegacyPass(*PR);
   initializeDXILTranslateMetadataPass(*PR);
 }
 
 class DXILTargetObjectFile : public TargetLoweringObjectFile {
 public:
   DXILTargetObjectFile() = default;
 
bool DirectXTargetMachine::addPassesToEmitFile(
     PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
     CodeGenFileType FileType, bool DisableVerify,
     MachineModuleInfoWrapperPass *MMIWP) {
   PM.add(createDXILOpLoweringLegacyPass());
   PM.add(createDXILPrepareModulePass());
   PM.add(createDXILTranslateMetadataPass());
   switch (FileType) {
   case CGFT_AssemblyFile:
+    if (TargetPassConfig::willCompleteCodeGenPipeline()) {
+      PM.add(createDXILEmbedderPass());
+    }
     PM.add(createPrintModulePass(Out, "", true));
     break;
   case CGFT_ObjectFile:
     // TODO: Use MC Object streamer to write DXContainer
     PM.add(createDXILWriterPass(Out));
     break;
   case CGFT_Null:
     break;

llvm/test/CodeGen/DirectX/embed-dxil.ll

+; RUN: llc %s --filetype=asm -o - | FileCheck %s
+; RUN: opt %s -dxil-embed -S -o - | FileCheck %s
+target triple = "dxil-unknown-unknown"
+
+define i32 @add(i32 %a, i32 %b) {
+  %sum = add i32 %a, %b
+  ret i32 %sum
+}
+
+; CHECK: @dx.dxil = private constant [[BC_TYPE:\[[0-9]+ x i8\]]] c"BC\C0\DE{{[^"]+}}", section "DXIL", align 4
+; CHECK: @llvm.compiler.used = appending global [1 x ptr] [ptr @dx.dxil], section "llvm.metadata"