[DirectX] Add DirectX target object writer

[beanz]

Summary

This is the last piece to bring together writing DXContainer files
containing DXIL through the DirectX backend.

While this change only has one test, all of the tests under
llvm/test/tools/dxil-dis also exercise this code. With this change the
output object file type for the dxil target is now DXContainer. Each of
the existing tests will generate DXContainer files, and the dxil-dis
tests additionally verify that the DXContainers generated are
well-formed and can be parsed by the DirectXShaderCompiler tools.

Depends on D127153 and D127165

[beanz]

Updating test case to verify shader version and kind fields.

[beanz]

Fix a typo

[kuhar]

llvm/lib/Target/DirectX/DirectXSubtarget.h

49

https://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers ?

llvm/lib/Target/DirectX/MCTargetDesc/DirectXMCTargetDesc.cpp

138–139

nit: return directly? Also below.

[beanz]

Updates based on review feedback. Thanks @kuhar!

[kuhar]

LGTM but please get a second approval before submitting

[MaskRay]

llvm/lib/Target/DirectX/DirectXTargetMachine.cpp

107

remove braces https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

llvm/lib/Target/DirectX/MCTargetDesc/DirectXContainerObjectWriter.cpp

21

delete blank line

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

25

[[#]] in place of {{[0-9]+}}

[beanz]

Updates based on feedback from @MaskRay! Thank you!

[python3kgae]

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

3–4

Is it possible to extract the dxil part out of the container and run dxil-dis to test the output dxil?

[python3kgae]

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

4

better use library instead of compute.
This is not a legal compute shader.

[beanz]

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

3–4

There are a few reasons _not_ to use dxil-dis here.

First and foremost, this test is testing the structure of the generated DXContainer file, not the dxil encoding itself. In that regard dxil-dis doesn't help because while it can extract the bitcode from a DXContainer, it doesn't actually dump any of the structural information about the container itself (which is what is important here).

Additionally dxil-dis is an optional external dependency. Tests that rely on dxil-dis only run if you have dxil-dis available, and I don't expect most LLVM developers will have dxil-dis available. Maximizing test coverage while not depending on external dependencies is a big win.

[beanz]

Changing shader to library. Thanks @python3kgae!

[beanz]

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

3–4

Also worth noting here: with this change llc with -filetype=obj will produce DXContainer files when targeting DXIL. This will result in all the existing dxil-dis tests that use llc to operate on DXContainers instead of bitcode files. The tests all work as long as you have a reasonably up-to-date dxil-dis because that feature was added to dxil-dis recently.

[python3kgae]

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

3–4

Then could we have a separate dxil-dis test in dxil-dis folder to make sure the whole pipeline works?

[beanz]

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

3–4

We don't need to add tests for that. The existing dxil-dis tests will already provide that coverage.

llvm/lib/Target/DirectX/DirectXAsmPrinter.cpp

void DXILAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
   // If there is no initializer or the section is implicit, do nothing
   if (!GV->hasInitializer() || GV->hasImplicitSection())
     return;
   // Skip the LLVM metadata
   if (GV->getSection() == "llvm.metadata")
     return;
   SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM);
   MCSection *TheSection = getObjFileLowering().SectionForGlobal(GV, GVKind, TM);
-  OutStreamer->SwitchSection(TheSection);
+  OutStreamer->switchSection(TheSection);
   emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
 }
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXAsmPrinter() {
   RegisterAsmPrinter<DXILAsmPrinter> X(getTheDirectXTarget());
 }

llvm/lib/Target/DirectX/DirectXSubtarget.h

 //===-- DirectXSubtarget.h - Define Subtarget for DirectX -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the DirectX specific subclass of TargetSubtargetInfo.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DIRECTX_DIRECTXSUBTARGET_H
 #define LLVM_DIRECTX_DIRECTXSUBTARGET_H
 
+#include "DirectXFrameLowering.h"
+#include "DirectXInstrInfo.h"
 #include "DirectXTargetLowering.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/Target/TargetMachine.h"
 
 #define GET_SUBTARGETINFO_HEADER
 #include "DirectXGenSubtargetInfo.inc"
 
 namespace llvm {
 
 class DirectXTargetMachine;
 
 class DirectXSubtarget : public DirectXGenSubtargetInfo {
+  DirectXFrameLowering FL;
   DirectXTargetLowering TL;
+  DirectXInstrInfo InstrInfo;
+
+  virtual void anchor(); // virtual anchor method
 
 public:
   DirectXSubtarget(const Triple &TT, StringRef CPU, StringRef FS,
                    const DirectXTargetMachine &TM);
 
   /// Parses a subtarget feature string, setting appropriate options.
   /// \note Definition of function is auto generated by `tblgen`.
   void ParseSubtargetFeatures(StringRef CPU, StringRef TuneCPU, StringRef FS);
 
   const DirectXTargetLowering *getTargetLowering() const override {
     return &TL;
   }
+
+  const DirectXFrameLowering *getFrameLowering() const override { return &FL; }
+
+  const DirectXInstrInfo *getInstrInfo() const override { return &InstrInfo; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DIRECTX_DIRECTXSUBTARGET_H

llvm/lib/Target/DirectX/DirectXSubtarget.cpp

 #define DEBUG_TYPE "directx-subtarget"
 
 #define GET_SUBTARGETINFO_CTOR
 #define GET_SUBTARGETINFO_TARGET_DESC
 #include "DirectXGenSubtargetInfo.inc"
 
 DirectXSubtarget::DirectXSubtarget(const Triple &TT, StringRef CPU,
                                    StringRef FS, const DirectXTargetMachine &TM)
-    : DirectXGenSubtargetInfo(TT, CPU, CPU, FS), TL(TM, *this) {}
+    : DirectXGenSubtargetInfo(TT, CPU, CPU, FS), FL(*this), TL(TM, *this) {}
+
+void DirectXSubtarget::anchor() {}

llvm/lib/Target/DirectX/DirectXTargetMachine.cpp

 //===----------------------------------------------------------------------===//
 
 #include "DirectXTargetMachine.h"
 #include "DXILWriter/DXILWriterPass.h"
 #include "DirectX.h"
 #include "DirectXSubtarget.h"
 #include "DirectXTargetTransformInfo.h"
 #include "TargetInfo/DirectXTargetInfo.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LegacyPassManager.h"
+#include "llvm/MC/MCSectionDXContainer.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #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;
 
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override {
-    llvm_unreachable("Not supported!");
+    return getContext().getDXContainerSection(GO->getSection(), Kind);
   }
 
 protected:
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override {
     llvm_unreachable("Not supported!");
   }
 };
DirectXTargetMachine::DirectXTargetMachine(const Target &T, const Triple &TT,
                                            Optional<CodeModel::Model> CM,
                                            CodeGenOpt::Level OL, bool JIT)
     : LLVMTargetMachine(T,
                         "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-"
                         "f32:32-f64:64-n8:16:32:64",
                         TT, CPU, FS, Options, Reloc::Static, CodeModel::Small,
                         OL),
       TLOF(std::make_unique<DXILTargetObjectFile>()),
-      Subtarget(std::make_unique<DirectXSubtarget>(TT, CPU, FS, *this)) {}
+      Subtarget(std::make_unique<DirectXSubtarget>(TT, CPU, FS, *this)) {
+  initAsmInfo();
+}
 
 DirectXTargetMachine::~DirectXTargetMachine() {}
 
 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());
-    }
+  switch (FileType) {
+  case CGFT_AssemblyFile:
     PM.add(createPrintModulePass(Out, "", true));
     break;
   case CGFT_ObjectFile:
-    // TODO: Use MC Object streamer to write DXContainer
+    if (TargetPassConfig::willCompleteCodeGenPipeline()) {
+      if (!MMIWP)
+        MMIWP = new MachineModuleInfoWrapperPass(this);
+      PM.add(MMIWP);
+      if (addAsmPrinter(PM, Out, DwoOut, FileType,
+                        MMIWP->getMMI().getContext()))
+        return true;
+    } else
       PM.add(createDXILWriterPass(Out));
     break;
   case CGFT_Null:
     break;
   }
   return false;
 }
 
 bool DirectXTargetMachine::addPassesToEmitMC(PassManagerBase &PM,

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

 add_llvm_component_library(LLVMDirectXDesc
+  DirectXContainerObjectWriter.cpp
   DirectXMCTargetDesc.cpp
 
   LINK_COMPONENTS
   DirectXInfo
   Support
 
   ADD_TO_COMPONENT
   DirectX
   )

llvm/lib/Target/DirectX/MCTargetDesc/DirectXContainerObjectWriter.h

+//===-- DirectXContainerObjectWriter.h - DX object writer ------*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains DXContainer object writers for the DirectX backend.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DIRECTX_DIRECTXCONTAINEROBJECTWRITER_H
+#define LLVM_DIRECTX_DIRECTXCONTAINEROBJECTWRITER_H
+
+#include "llvm/MC/MCObjectWriter.h"
+
+namespace llvm {
+
+std::unique_ptr<MCObjectTargetWriter> createDXContainerTargetObjectWriter();
+
+}
+
+#endif // LLVM_DIRECTX_DIRECTXCONTAINEROBJECTWRITER_H

llvm/lib/Target/DirectX/MCTargetDesc/DirectXContainerObjectWriter.cpp

+//===-- DirectXContainerObjectWriter.cpp - DX object writer ----*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains DXContainer object writers for the DirectX backend.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DirectXContainerObjectWriter.h"
+#include "llvm/MC/MCDXContainerWriter.h"
+
+using namespace llvm;
+
+namespace {
+class DirectXContainerObjectWriter : public MCDXContainerTargetWriter {
+public:
+  DirectXContainerObjectWriter() : MCDXContainerTargetWriter() {}
+};
+} // namespace
+
+std::unique_ptr<MCObjectTargetWriter>
+llvm::createDXContainerTargetObjectWriter() {
+  return std::make_unique<DirectXContainerObjectWriter>();
+}

llvm/lib/Target/DirectX/MCTargetDesc/DirectXMCTargetDesc.cpp

 //===- DirectXMCTargetDesc.cpp - DirectX Target Implementation --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file contains DirectX target initializer.
 ///
 //===----------------------------------------------------------------------===//
 
+#include "DirectXMCTargetDesc.h"
+#include "DirectXContainerObjectWriter.h"
+#include "TargetInfo/DirectXTargetInfo.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/MC/LaneBitmask.h"
 #include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCDXContainerWriter.h"
+#include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSchedule.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Compiler.h"
+#include <memory>
 
 using namespace llvm;
 
+#define GET_INSTRINFO_MC_DESC
+#define GET_INSTRINFO_MC_HELPERS
+#include "DirectXGenInstrInfo.inc"
+
 #define GET_SUBTARGETINFO_MC_DESC
 #include "DirectXGenSubtargetInfo.inc"
 
-extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTargetMC() {}
+#define GET_REGINFO_MC_DESC
+#include "DirectXGenRegisterInfo.inc"
+
+namespace {
+
+// DXILInstPrinter is a null stub because DXIL instructions aren't printed.
+class DXILInstPrinter : public MCInstPrinter {
+public:
+  DXILInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
+                  const MCRegisterInfo &MRI)
+      : MCInstPrinter(MAI, MII, MRI) {}
+
+  void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
+                 const MCSubtargetInfo &STI, raw_ostream &O) override {}
+
+  std::pair<const char *, uint64_t> getMnemonic(const MCInst *MI) override {
+    return std::make_pair<const char *, uint64_t>("", 0ull);
+  }
+
+private:
+};
+
+class DXILMCCodeEmitter : public MCCodeEmitter {
+public:
+  DXILMCCodeEmitter() {}
+
+  void encodeInstruction(const MCInst &MI, raw_ostream &OS,
+                         SmallVectorImpl<MCFixup> &Fixups,
+                         const MCSubtargetInfo &STI) const override {}
+};
+
+class DXILAsmBackend : public MCAsmBackend {
+
+public:
+  DXILAsmBackend(const MCSubtargetInfo &STI) : MCAsmBackend(support::little) {}
+  ~DXILAsmBackend() override = default;
+
+  void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
+                  const MCValue &Target, MutableArrayRef<char> Data,
+                  uint64_t Value, bool IsResolved,
+                  const MCSubtargetInfo *STI) const override {}
+
+  std::unique_ptr<MCObjectTargetWriter>
+  createObjectTargetWriter() const override {
+    return createDXContainerTargetObjectWriter();
+  }
+
+  unsigned getNumFixupKinds() const override { return 0; }
+
+  bool writeNopData(raw_ostream &OS, uint64_t Count,
+                    const MCSubtargetInfo *STI) const override {
+    return true;
+  }
+
+  bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
+                            const MCRelaxableFragment *DF,
+                            const MCAsmLayout &Layout) const override {
+    return true;
+  }
+};
+
+class DirectXMCAsmInfo : public MCAsmInfo {
+public:
+  explicit DirectXMCAsmInfo(const Triple &TT, const MCTargetOptions &Options)
+      : MCAsmInfo() {}
+};
+
+} // namespace
+
+static MCInstPrinter *createDXILMCInstPrinter(const Triple &T,
+                                              unsigned SyntaxVariant,
+                                              const MCAsmInfo &MAI,
+                                              const MCInstrInfo &MII,
+                                              const MCRegisterInfo &MRI) {
+  if (SyntaxVariant == 0)
+    return new DXILInstPrinter(MAI, MII, MRI);
+  return nullptr;
+}
+
+MCCodeEmitter *createDXILMCCodeEmitter(const MCInstrInfo &MCII,
+                                       MCContext &Ctx) {
+  return new DXILMCCodeEmitter();
+}
+
+MCAsmBackend *createDXILMCAsmBackend(const Target &T,
+                                     const MCSubtargetInfo &STI,
+                                     const MCRegisterInfo &MRI,
+                                     const MCTargetOptions &Options) {
+  return new DXILAsmBackend(STI);
+}
+
+static MCSubtargetInfo *
+createDirectXMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) {
+  return createDirectXMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
+}
+
+static MCRegisterInfo *createDirectXMCRegisterInfo(const Triple &Triple) {
+  return new MCRegisterInfo();
+}
+
+static MCInstrInfo *createDirectXMCInstrInfo() { return new MCInstrInfo(); }
+
+extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTargetMC() {
+  Target &T = getTheDirectXTarget();
+  RegisterMCAsmInfo<DirectXMCAsmInfo> X(T);
+  TargetRegistry::RegisterMCInstrInfo(T, createDirectXMCInstrInfo);
+  TargetRegistry::RegisterMCInstPrinter(T, createDXILMCInstPrinter);
+  TargetRegistry::RegisterMCRegInfo(T, createDirectXMCRegisterInfo);
+  TargetRegistry::RegisterMCSubtargetInfo(T, createDirectXMCSubtargetInfo);
+  TargetRegistry::RegisterMCCodeEmitter(T, createDXILMCCodeEmitter);
+  TargetRegistry::RegisterMCAsmBackend(T, createDXILMCAsmBackend);
+}

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"
+; RUN: llc %s --filetype=obj -o - | obj2yaml | FileCheck %s --check-prefix=DXC
+target triple = "dxil-unknown-shadermodel6.5-library"
 
 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"
+
+; This is using regex matches on some sizes, offsets and fields. These are all
+; going to change as the DirectX backend continues to evolve and implement more
+; features. Rather than extending this test to cover those future features, this
+; test's matches are extremely fuzzy so that it won't break.
+
+; DXC: --- !dxcontainer
+; DXC-NEXT: Header:
+; DXC-NEXT:   Hash:            [ 0x0, 0x0, 0x0,
+; DXC:   Version:
+; DXC-NEXT:     Major:           1
+; DXC-NEXT:     Minor:           0
+; DXC-NEXT:   FileSize:        [[#]]
+; DXC-NEXT:   PartCount:       [[#]]
+; DXC-NEXT:   PartOffsets:     [ {{[0-9, ]+}} ]
+; DXC-NEXT: Parts:
+
+; In verifying the DXIL part, this test captures the size of the part, and
+; derives the program header and dxil size fields from the part's size.
+
+; DXC:   - Name:            DXIL
+; DXC-NEXT:     Size:            [[#SIZE:]]
+; DXC-NEXT:     Program:
+; DXC-NEXT:       MajorVersion:    6
+; DXC-NEXT:       MinorVersion:    5
+; DXC-NEXT:       ShaderKind:      5
+; DXC-NEXT:       Size:            [[#div(SIZE,4) - 2]]
+; DXC-NEXT:       DXILMajorVersion: [[#]]
+; DXC-NEXT:       DXILMinorVersion: [[#]]
+; DXC-NEXT:       DXILSize:        [[#SIZE - 32]]
+; DXC-NEXT:       DXIL:            [ 0x42, 0x43, 0xC0, 0xDE,