[DirectX][MC] Add MC support for DXContainer

[beanz]

Summary

DXContainer files resemble traditional object files in that they are
comprised of parts which resemble sections. Adding DXContainer as an
object file format in the MC layer will allow emitting DXContainer
objects through the normal object emission pipeline.

[beanz]

Properly setting the shader kind and version.

[beanz]

Fixing an include guard.

[kuhar]

llvm/include/llvm/MC/MCContext.h

666

nit: Other function comments start with 3 slashes

llvm/include/llvm/MC/MCDXContainerStreamer.h

10

Could we also describe what features this implementation *does* use and why it's needed for DXContainers?

36

Shouldn't one virtual function be defined in a cpp file? https://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers

Separately, I'm concerned about unused argument warnings. (Also with other functions in this patch. If there are existing functions with named but unused arguments in the surrounding code, please disregard this comment.)

llvm/include/llvm/MC/MCDXContainerWriter.h

26

Also here

llvm/include/llvm/MC/MCSectionDXContainer.h

34

Also here

llvm/lib/MC/MCContext.cpp

847

Can we use a more descriptive variable name? The uses like R.first->second don't help much wrt readability.

For example, what if we renamed Section -> SectionName and did something like:

auto ItInsertedPair = DXCUniquingMap.try_emplace(SectionName);
StringMapEntry<MCSectionDXContainer *> &Entry = *ItInsertedPair.first;

if (!ItInsertedPair.second)
  return Entry;

Entry.setValue(new (DXCAllocator.Allocate()) MCSectionDXContainer(SectionName, K, nullptr));
...

return Entry.getValue();

(pseudocode, I haven't actually tried it)

851

Isn't this the same as the Section argument?

llvm/lib/MC/MCDXContainerStreamer.cpp

24

ubernit: auto *S, since the type is obvious

llvm/lib/MC/MCDXContainerWriter.cpp

51

How did you pick this constant?

76

nit: This is probably pedantic, but I think technically characters don't have to use ASCII on all platforms and it would be safer to use exact hex values.

[beanz]

Updates coming.

llvm/lib/MC/MCContext.cpp

851

It should be the same text, but is likely a different address. The address from the StringMap is guaranteed to remain valid through the lifetime of the object writer, while the input may come from an IR construct that has a different lifetime (aren't unowned StringRefs fun?).

llvm/lib/MC/MCDXContainerWriter.cpp

51

DXContainers generally end up with 7-10 parts. I picked the next power of two above that range so that it would likely all fit in the space. I'll elaborate in a comment.

76

So... I will concede that technically someone could attempt to compile LLVM for a non-ASCII platform, and this _could_ be a problem. If someone were to use this on a non-ASCII platform this would be the least of our problems because we do a lot of string-compares on binary data, and we generally encode section names and other "strings" as ASCII.

How about a happy middle ground, I can make these explicit UTF-8 constants. I prefer the readability of characters rather than needing to keep an ASCII chart handy.

[kuhar]

llvm/lib/MC/MCContext.cpp

851

Gah... Can you explain this in a comment?

llvm/lib/MC/MCDXContainerWriter.cpp

76

Ack. I think both of your options are practical. Thanks for explaining.

[beanz]

llvm/lib/MC/MCDXContainerWriter.cpp

76

Gah! UTF-8 character literals are C++17 :(

Since we do have other places (like the ELF ZILB constant) where we assume character literals are ASCII, and I'm completely unaware of any non-ASCII platform that supports enough memory to build or run LLVM, I'm going to prefer to keep this as characters.

[beanz]

Updates based on PR feedback. Thanks @kuhar!

[beanz]

One last bit of feedback from @kuhar that I missed in the last update.

[kuhar]

LGTM but please get a second approval before submitting

[rengolin]

I don't know much about DX but this looks like object emission to me. :)

I guess any problem from these changes will only show up in DX lowering, so not very high risk to other targets...

llvm/lib/MC/MCObjectFileInfo.cpp

1015

What about the DXIL section, do you need to initialise it here, too?

[beanz]

llvm/lib/MC/MCObjectFileInfo.cpp

1015

I treat the DXIL section as a data section the same way other backends emit bitcode into sections, so it gets initialized when the global variable emission gets triggered.

[rengolin]

Makes sense, I have no additional comments. LGTM, thanks!

[arsenm]

Probably should have something in docs that explains what this is

[MaskRay]

llvm/include/llvm/MC/MCDXContainerWriter.h

21

delete blank line

[MaskRay]

llvm/include/llvm/MC/MCSectionDXContainer.h

31

delete

llvm/lib/MC/MCDXContainerWriter.cpp

96

101

108

[beanz]

Updating based on feedback from @MaskRay.

Working on additional documentation as well.

[beanz]

@arsenm, I've posted two additional documentation PRs. One specific to the DirectX backend (D127640), and one for object file support in the code generator more generally (D127645).

llvm/include/llvm/MC/MCContext.h

 class CodeViewContext;
 class MCAsmInfo;
 class MCInst;
 class MCLabel;
 class MCObjectFileInfo;
 class MCRegisterInfo;
 class MCSection;
 class MCSectionCOFF;
+class MCSectionDXContainer;
 class MCSectionELF;
 class MCSectionGOFF;
 class MCSectionMachO;
 class MCSectionSPIRV;
 class MCSectionWasm;
 class MCSectionXCOFF;
 class MCStreamer;
 class MCSubtargetInfo;
private:
 
   /// Allocator object used for creating machine code objects.
   ///
   /// We use a bump pointer allocator to avoid the need to track all allocated
   /// objects.
   BumpPtrAllocator Allocator;
 
   SpecificBumpPtrAllocator<MCSectionCOFF> COFFAllocator;
+  SpecificBumpPtrAllocator<MCSectionDXContainer> DXCAllocator;
   SpecificBumpPtrAllocator<MCSectionELF> ELFAllocator;
   SpecificBumpPtrAllocator<MCSectionMachO> MachOAllocator;
   SpecificBumpPtrAllocator<MCSectionGOFF> GOFFAllocator;
   SpecificBumpPtrAllocator<MCSectionSPIRV> SPIRVAllocator;
   SpecificBumpPtrAllocator<MCSectionWasm> WasmAllocator;
   SpecificBumpPtrAllocator<MCSectionXCOFF> XCOFFAllocator;
   SpecificBumpPtrAllocator<MCInst> MCInstAllocator;
 
private:
   };
 
   StringMap<MCSectionMachO *> MachOUniquingMap;
   std::map<ELFSectionKey, MCSectionELF *> ELFUniquingMap;
   std::map<COFFSectionKey, MCSectionCOFF *> COFFUniquingMap;
   std::map<std::string, MCSectionGOFF *> GOFFUniquingMap;
   std::map<WasmSectionKey, MCSectionWasm *> WasmUniquingMap;
   std::map<XCOFFSectionKey, MCSectionXCOFF *> XCOFFUniquingMap;
+  StringMap<MCSectionDXContainer *> DXCUniquingMap;
   StringMap<bool> RelSecNames;
 
   SpecificBumpPtrAllocator<MCSubtargetInfo> MCSubtargetAllocator;
 
   /// Do automatic reset in destructor
   bool AutoReset;
 
   MCTargetOptions const *TargetOptions;
public:
 
   MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                 unsigned Flags, const Twine &Group,
                                 unsigned UniqueID, const char *BeginSymName);
 
   MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                 unsigned Flags, const MCSymbolWasm *Group,
                                 unsigned UniqueID, const char *BeginSymName);
   
+  /// Get the section for the provided Section name
+  MCSectionDXContainer *getDXContainerSection(StringRef Section, SectionKind K);
+
   bool hasXCOFFSection(StringRef Section,
                        XCOFF::CsectProperties CsectProp) const;
 
   MCSectionXCOFF *getXCOFFSection(
       StringRef Section, SectionKind K,
       Optional<XCOFF::CsectProperties> CsectProp = None,
       bool MultiSymbolsAllowed = false, const char *BeginSymName = nullptr,
       Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSubtypeFlags = None);

llvm/include/llvm/MC/MCDXContainerStreamer.h

+//===- MCDXContainerStreamer.h - MCDXContainerStreamer Interface ---*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Overrides MCObjectStreamer to disable all unnecessary features with stubs.
+// The DXContainer format isn't a fully featured object format. It doesn't
+// support symbols, and initially it will not support instruction data since it
+// is used as a bitcode container for DXIL.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCDXCONTAINERSTREAMER_H
+#define LLVM_MC_MCDXCONTAINERSTREAMER_H
+
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCObjectStreamer.h"
+#include "llvm/MC/MCObjectWriter.h"
+
+namespace llvm {
+class MCAssembler;
+class MCExpr;
+class MCInst;
+class raw_ostream;
+
+class MCDXContainerStreamer : public MCObjectStreamer {
+public:
+  MCDXContainerStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
+                        std::unique_ptr<MCObjectWriter> OW,
+                        std::unique_ptr<MCCodeEmitter> Emitter)
+      : MCObjectStreamer(Context, std::move(TAB), std::move(OW),
+                         std::move(Emitter)) {}
+
+  bool emitSymbolAttribute(MCSymbol *, MCSymbolAttr) override { return false; }
+  void emitCommonSymbol(MCSymbol *, uint64_t, unsigned) override {}
+  void emitZerofill(MCSection *, MCSymbol *Symbol = nullptr, uint64_t Size = 0,
+                    unsigned ByteAlignment = 0, SMLoc Loc = SMLoc()) override {}
+
+private:
+  void emitInstToData(const MCInst &, const MCSubtargetInfo &) override;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_MC_MCDXCONTAINERSTREAMER_H

llvm/include/llvm/MC/MCDXContainerWriter.h

+//===- llvm/MC/MCDXContainerWriter.h - DXContainer 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCDXCONTAINERWRITER_H
+#define LLVM_MC_MCDXCONTAINERWRITER_H
+
+#include "llvm/ADT/Triple.h"
+#include "llvm/MC/MCObjectWriter.h"
+
+namespace llvm {
+
+class raw_pwrite_stream;
+
+class MCDXContainerTargetWriter : public MCObjectTargetWriter {
+
+protected:
+  MCDXContainerTargetWriter() {}
+
+public:
+  virtual ~MCDXContainerTargetWriter();
+
+  Triple::ObjectFormatType getFormat() const override {
+    return Triple::DXContainer;
+  }
+  static bool classof(const MCObjectTargetWriter *W) {
+    return W->getFormat() == Triple::DXContainer;
+  }
+};
+
+/// Construct a new DXContainer writer instance.
+///
+/// \param MOTW - The target specific DXContainer writer subclass.
+/// \param OS - The stream to write to.
+/// \returns The constructed object writer.
+std::unique_ptr<MCObjectWriter>
+createDXContainerObjectWriter(std::unique_ptr<MCDXContainerTargetWriter> MOTW,
+                              raw_pwrite_stream &OS);
+
+} // end namespace llvm
+
+#endif // LLVM_MC_MCDXCONTAINERWRITER_H

llvm/include/llvm/MC/MCObjectFileInfo.h

private:
 
   void initMachOMCObjectFileInfo(const Triple &T);
   void initELFMCObjectFileInfo(const Triple &T, bool Large);
   void initGOFFMCObjectFileInfo(const Triple &T);
   void initCOFFMCObjectFileInfo(const Triple &T);
   void initSPIRVMCObjectFileInfo(const Triple &T);
   void initWasmMCObjectFileInfo(const Triple &T);
   void initXCOFFMCObjectFileInfo(const Triple &T);
+  void initDXContainerObjectFileInfo(const Triple &T);
   MCSection *getDwarfComdatSection(const char *Name, uint64_t Hash) const;
 
 public:
   void setSDKVersion(const VersionTuple &TheSDKVersion) {
     SDKVersion = TheSDKVersion;
   }
 
   const VersionTuple &getSDKVersion() const { return SDKVersion; }

llvm/include/llvm/MC/MCSection.h

public:
   enum SectionVariant {
     SV_COFF = 0,
     SV_ELF,
     SV_GOFF,
     SV_MachO,
     SV_Wasm,
     SV_XCOFF,
     SV_SPIRV,
+    SV_DXContainer,
   };
 
   /// Express the state of bundle locked groups while emitting code.
   enum BundleLockStateType {
     NotBundleLocked,
     BundleLocked,
     BundleLockedAlignToEnd
   };

llvm/include/llvm/MC/MCSectionDXContainer.h

+//===- MCSectionDXContainer.h - DXContainer MC Sections ---------*- 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 MCSectionDXContainer class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCSECTIONDXCONTAINER_H
+#define LLVM_MC_MCSECTIONDXCONTAINER_H
+
+#include "llvm/MC/MCSection.h"
+#include "llvm/MC/SectionKind.h"
+
+namespace llvm {
+
+class MCSymbol;
+
+class MCSectionDXContainer final : public MCSection {
+  friend class MCContext;
+
+  MCSectionDXContainer(StringRef Name, SectionKind K, MCSymbol *Begin)
+      : MCSection(SV_DXContainer, Name, K, Begin) {}
+
+public:
+  ~MCSectionDXContainer() = default;
+  void printSwitchToSection(const MCAsmInfo &, const Triple &, raw_ostream &,
+                            const MCExpr *) const override;
+  bool useCodeAlign() const override { return false; }
+  bool isVirtualSection() const override { return false; }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_MC_MCSECTIONDXCONTAINER_H

llvm/include/llvm/MC/TargetRegistry.h

MCStreamer *createXCOFFStreamer(MCContext &Ctx,
                                 std::unique_ptr<MCObjectWriter> &&OW,
                                 std::unique_ptr<MCCodeEmitter> &&CE,
                                 bool RelaxAll);
 MCStreamer *createSPIRVStreamer(MCContext &Ctx,
                                 std::unique_ptr<MCAsmBackend> &&TAB,
                                 std::unique_ptr<MCObjectWriter> &&OW,
                                 std::unique_ptr<MCCodeEmitter> &&CE,
                                 bool RelaxAll);
+MCStreamer *createDXContainerStreamer(MCContext &Ctx,
+                                      std::unique_ptr<MCAsmBackend> &&TAB,
+                                      std::unique_ptr<MCObjectWriter> &&OW,
+                                      std::unique_ptr<MCCodeEmitter> &&CE,
+                                      bool RelaxAll);
 
 MCRelocationInfo *createMCRelocationInfo(const Triple &TT, MCContext &Ctx);
 
 MCSymbolizer *createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo,
                                  LLVMSymbolLookupCallback SymbolLookUp,
                                  void *DisInfo, MCContext *Ctx,
                                  std::unique_ptr<MCRelocationInfo> &&RelInfo);
 
using XCOFFStreamerCtorTy =
                       std::unique_ptr<MCAsmBackend> &&TAB,
                       std::unique_ptr<MCObjectWriter> &&OW,
                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
   using SPIRVStreamerCtorTy =
       MCStreamer *(*)(const Triple &T, MCContext &Ctx,
                       std::unique_ptr<MCAsmBackend> &&TAB,
                       std::unique_ptr<MCObjectWriter> &&OW,
                       std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
   
+  using DXContainerStreamerCtorTy =
+      MCStreamer *(*)(const Triple &T, MCContext &Ctx,
+                      std::unique_ptr<MCAsmBackend> &&TAB,
+                      std::unique_ptr<MCObjectWriter> &&OW,
+                      std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
+
   using NullTargetStreamerCtorTy = MCTargetStreamer *(*)(MCStreamer &S);
   using AsmTargetStreamerCtorTy = MCTargetStreamer *(*)(
       MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
       bool IsVerboseAsm);
   using ObjectTargetStreamerCtorTy = MCTargetStreamer *(*)(
       MCStreamer &S, const MCSubtargetInfo &STI);
   using MCRelocationInfoCtorTy = MCRelocationInfo *(*)(const Triple &TT,
                                                        MCContext &Ctx);
private:
 
   // Construction functions for the various object formats, if registered.
   COFFStreamerCtorTy COFFStreamerCtorFn = nullptr;
   MachOStreamerCtorTy MachOStreamerCtorFn = nullptr;
   ELFStreamerCtorTy ELFStreamerCtorFn = nullptr;
   WasmStreamerCtorTy WasmStreamerCtorFn = nullptr;
   XCOFFStreamerCtorTy XCOFFStreamerCtorFn = nullptr;
   SPIRVStreamerCtorTy SPIRVStreamerCtorFn = nullptr;
+  DXContainerStreamerCtorTy DXContainerStreamerCtorFn = nullptr;
 
   /// Construction function for this target's null TargetStreamer, if
   /// registered (default = nullptr).
   NullTargetStreamerCtorTy NullTargetStreamerCtorFn = nullptr;
 
   /// Construction function for this target's asm TargetStreamer, if
   /// registered (default = nullptr).
   AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn = nullptr;
MCStreamer *createMCObjectStreamer(const Triple &T, MCContext &Ctx,
                                      std::unique_ptr<MCCodeEmitter> &&Emitter,
                                      const MCSubtargetInfo &STI, bool RelaxAll,
                                      bool IncrementalLinkerCompatible,
                                      bool DWARFMustBeAtTheEnd) const {
     MCStreamer *S = nullptr;
     switch (T.getObjectFormat()) {
     case Triple::UnknownObjectFormat:
       llvm_unreachable("Unknown object format");
-    case Triple::DXContainer:
-      llvm_unreachable("DXContainer is unsupported through MC");
     case Triple::COFF:
       assert(T.isOSWindows() && "only Windows COFF is supported");
       S = COFFStreamerCtorFn(Ctx, std::move(TAB), std::move(OW),
                              std::move(Emitter), RelaxAll,
                              IncrementalLinkerCompatible);
       break;
     case Triple::MachO:
       if (MachOStreamerCtorFn)
MCStreamer *createMCObjectStreamer(const Triple &T, MCContext &Ctx,
     case Triple::SPIRV:
       if (SPIRVStreamerCtorFn)
         S = SPIRVStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
                                 std::move(Emitter), RelaxAll);
       else
         S = createSPIRVStreamer(Ctx, std::move(TAB), std::move(OW),
                                 std::move(Emitter), RelaxAll);
       break;
+    case Triple::DXContainer:
+      if (DXContainerStreamerCtorFn)
+        S = DXContainerStreamerCtorFn(T, Ctx, std::move(TAB), std::move(OW),
+                              std::move(Emitter), RelaxAll);
+      else
+        S = createDXContainerStreamer(Ctx, std::move(TAB), std::move(OW),
+                                      std::move(Emitter), RelaxAll);
+      break;
     }
     if (ObjectTargetStreamerCtorFn)
       ObjectTargetStreamerCtorFn(*S, STI);
     return S;
   }
 
   MCStreamer *createAsmStreamer(MCContext &Ctx,
                                 std::unique_ptr<formatted_raw_ostream> OS,
struct TargetRegistry {
   static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn) {
     T.ELFStreamerCtorFn = Fn;
   }
 
   static void RegisterSPIRVStreamer(Target &T, Target::SPIRVStreamerCtorTy Fn) {
     T.SPIRVStreamerCtorFn = Fn;
   }
 
+  static void RegisterDXContainerStreamer(Target &T, Target::DXContainerStreamerCtorTy Fn) {
+    T.DXContainerStreamerCtorFn = Fn;
+  }
+
   static void RegisterWasmStreamer(Target &T, Target::WasmStreamerCtorTy Fn) {
     T.WasmStreamerCtorFn = Fn;
   }
 
   static void RegisterXCOFFStreamer(Target &T, Target::XCOFFStreamerCtorTy Fn) {
     T.XCOFFStreamerCtorFn = Fn;
   }
 

llvm/lib/MC/CMakeLists.txt

add_llvm_component_library(LLVMMC
   MCAsmInfoXCOFF.cpp
   MCAsmMacro.cpp
   MCAsmStreamer.cpp
   MCAssembler.cpp
   MCCodeEmitter.cpp
   MCCodeView.cpp
   MCContext.cpp
   MCDwarf.cpp
+  MCDXContainerStreamer.cpp
+  MCDXContainerWriter.cpp
   MCELFObjectTargetWriter.cpp
   MCELFStreamer.cpp
   MCExpr.cpp
   MCFragment.cpp
   MCInst.cpp
   MCInstPrinter.cpp
   MCInstrAnalysis.cpp
   MCInstrDesc.cpp
   MCInstrInfo.cpp
   MCLabel.cpp
   MCLinkerOptimizationHint.cpp
   MCMachOStreamer.cpp
   MCMachObjectTargetWriter.cpp
   MCNullStreamer.cpp
   MCObjectFileInfo.cpp
   MCObjectStreamer.cpp
   MCObjectWriter.cpp
   MCPseudoProbe.cpp
   MCRegisterInfo.cpp
   MCSchedule.cpp
   MCSection.cpp
   MCSectionCOFF.cpp
+  MCSectionDXContainer.cpp
   MCSectionELF.cpp
   MCSectionMachO.cpp
   MCSectionWasm.cpp
   MCSectionXCOFF.cpp
   MCStreamer.cpp
   MCSPIRVStreamer.cpp
   MCSubtargetInfo.cpp
   MCSymbol.cpp

llvm/lib/MC/MCAsmBackend.cpp

 //===- MCAsmBackend.cpp - Target MC Assembly Backend ----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/STLArrayExtras.h"
+#include "llvm/MC/MCDXContainerWriter.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCMachObjectWriter.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSPIRVObjectWriter.h"
 #include "llvm/MC/MCWasmObjectWriter.h"
 #include "llvm/MC/MCWinCOFFObjectWriter.h"
 #include "llvm/MC/MCXCOFFObjectWriter.h"
case Triple::SPIRV:
     return createSPIRVObjectWriter(
         cast<MCSPIRVObjectTargetWriter>(std::move(TW)), OS);
   case Triple::Wasm:
     return createWasmObjectWriter(cast<MCWasmObjectTargetWriter>(std::move(TW)),
                                   OS);
   case Triple::XCOFF:
     return createXCOFFObjectWriter(
         cast<MCXCOFFObjectTargetWriter>(std::move(TW)), OS);
+  case Triple::DXContainer:
+    return createDXContainerObjectWriter(
+        cast<MCDXContainerTargetWriter>(std::move(TW)), OS);
   default:
     llvm_unreachable("unexpected object format");
   }
 }
 
 std::unique_ptr<MCObjectWriter>
 MCAsmBackend::createDwoObjectWriter(raw_pwrite_stream &OS,
                                     raw_pwrite_stream &DwoOS) const {

llvm/lib/MC/MCContext.cpp

 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCLabel.h"
 #include "llvm/MC/MCSectionCOFF.h"
+#include "llvm/MC/MCSectionDXContainer.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionSPIRV.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"

 void MCContext::reset() {
   SrcMgr = nullptr;
   InlineSrcMgr.reset();
   LocInfos.clear();
   DiagHandler = defaultDiagHandler;
 
   // Call the destructors so the fragments are freed
   COFFAllocator.DestroyAll();
+  DXCAllocator.DestroyAll();
   ELFAllocator.DestroyAll();
   GOFFAllocator.DestroyAll();
   MachOAllocator.DestroyAll();
   WasmAllocator.DestroyAll();
   XCOFFAllocator.DestroyAll();
   MCInstAllocator.DestroyAll();
   SPIRVAllocator.DestroyAll();
 
void MCContext::reset() {
   CVContext.reset();
 
   MachOUniquingMap.clear();
   ELFUniquingMap.clear();
   GOFFUniquingMap.clear();
   COFFUniquingMap.clear();
   WasmUniquingMap.clear();
   XCOFFUniquingMap.clear();
+  DXCUniquingMap.clear();
 
   ELFEntrySizeMap.clear();
   ELFSeenGenericMergeableSections.clear();
 
   NextID.clear();
   AllowTemporaryLabels = true;
   DwarfLocSeen = false;
   GenDwarfForAssembly = false;
MCSectionSPIRV *MCContext::getSPIRVSection() {
   F->setParent(Result);
 
   if (Begin)
     Begin->setFragment(F);
 
   return Result;
 }
 
+MCSectionDXContainer *MCContext::getDXContainerSection(StringRef Section,
+                                                       SectionKind K) {
+  // Do the lookup, if we have a hit, return it.
+  auto ItInsertedPair = DXCUniquingMap.try_emplace(Section);
+  if (!ItInsertedPair.second)
+    return ItInsertedPair.first->second;
+
+  auto MapIt = ItInsertedPair.first;
+  StringRef Name = MapIt->first();
+  MapIt->second =
+      new (DXCAllocator.Allocate()) MCSectionDXContainer(Name, K, nullptr);
+
+  // The first fragment will store the header
+  auto *F = new MCDataFragment();
+  MapIt->second->getFragmentList().insert(MapIt->second->begin(), F);
+  F->setParent(MapIt->second);
+
+  return MapIt->second;
+}
+
 MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {
   return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI);
 }
 
 void MCContext::addDebugPrefixMapEntry(const std::string &From,
                                        const std::string &To) {
   DebugPrefixMap.insert(std::make_pair(From, To));
 }

llvm/lib/MC/MCDXContainerStreamer.cpp

+//===- lib/MC/MCDXContainerStreamer.cpp - DXContainer Impl ----*- 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 the object streamer for DXContainer files.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCDXContainerStreamer.h"
+#include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/TargetRegistry.h"
+
+using namespace llvm;
+
+void MCDXContainerStreamer::emitInstToData(const MCInst &,
+                                           const MCSubtargetInfo &) {}
+
+MCStreamer *llvm::createDXContainerStreamer(
+    MCContext &Context, std::unique_ptr<MCAsmBackend> &&MAB,
+    std::unique_ptr<MCObjectWriter> &&OW, std::unique_ptr<MCCodeEmitter> &&CE,
+    bool RelaxAll) {
+  auto *S = new MCDXContainerStreamer(Context, std::move(MAB), std::move(OW),
+                                      std::move(CE));
+  if (RelaxAll)
+    S->getAssembler().setRelaxAll(true);
+  return S;
+}

llvm/lib/MC/MCDXContainerWriter.cpp

+//===- llvm/MC/MCDXContainerWriter.cpp - DXContainer 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCDXContainerWriter.h"
+#include "llvm/BinaryFormat/DXContainer.h"
+#include "llvm/MC/MCAsmLayout.h"
+#include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCSection.h"
+#include "llvm/MC/MCValue.h"
+#include "llvm/Support/Alignment.h"
+#include "llvm/Support/EndianStream.h"
+
+using namespace llvm;
+
+MCDXContainerTargetWriter::~MCDXContainerTargetWriter() {}
+
+namespace {
+class DXContainerObjectWriter : public MCObjectWriter {
+  ::support::endian::Writer W;
+
+  /// The target specific DXContainer writer instance.
+  std::unique_ptr<MCDXContainerTargetWriter> TargetObjectWriter;
+
+public:
+  DXContainerObjectWriter(std::unique_ptr<MCDXContainerTargetWriter> MOTW,
+                          raw_pwrite_stream &OS)
+      : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {}
+
+  ~DXContainerObjectWriter() override {}
+
+private:
+  void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
+                        const MCFragment *Fragment, const MCFixup &Fixup,
+                        MCValue Target, uint64_t &FixedValue) override {}
+
+  void executePostLayoutBinding(MCAssembler &Asm,
+                                const MCAsmLayout &Layout) override {}
+
+  uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
+};
+} // namespace
+
+uint64_t DXContainerObjectWriter::writeObject(MCAssembler &Asm,
+                                              const MCAsmLayout &Layout) {
+  // Start the file size as the header plus the size of the part offsets.
+  // Presently DXContainer files usually contain 7-10 parts. Reserving space for
+  // 16 part offsets gives us a little room for growth.
+  llvm::SmallVector<uint64_t, 16> PartOffsets;
+  uint64_t PartOffset = 0;
+  for (const MCSection &Sec : Asm) {
+    uint64_t SectionSize = Layout.getSectionAddressSize(&Sec);
+    // Skip empty sections...
+    if (SectionSize == 0)
+      continue;
+
+    assert(SectionSize < std::numeric_limits<uint32_t>::max() &&
+           "Section size too large for DXContainer");
+
+    PartOffsets.push_back(PartOffset);
+    PartOffset += sizeof(dxbc::PartHeader) + SectionSize;
+    PartOffset = alignTo(PartOffset, Align(4ul));
+  }
+  assert(PartOffset < std::numeric_limits<uint32_t>::max() &&
+         "Part data too large for DXContainer");
+
+  uint64_t PartStart =
+      sizeof(dxbc::Header) + (PartOffsets.size() * sizeof(uint32_t));
+  uint64_t FileSize = PartStart + PartOffset;
+  assert(FileSize < std::numeric_limits<uint32_t>::max() &&
+         "File size too large for DXContainer");
+
+  // Write the header
+  W.write<char>({'D', 'X', 'B', 'C'});
+  // Hash 16-bytes of 0's
+  W.OS.write_zeros(16);
+  // Version
+  W.write<uint16_t>(1u);
+  W.write<uint16_t>(0u);
+  // FileSize
+  W.write<uint32_t>(static_cast<uint32_t>(FileSize));
+  // Part count
+  W.write<uint32_t>(static_cast<uint32_t>(PartOffsets.size()));
+  // Offsets
+  for (uint64_t Offset : PartOffsets)
+    W.write<uint32_t>(static_cast<uint32_t>(PartStart + Offset));
+
+  for (const MCSection &Sec : Asm) {
+    uint64_t SectionSize = Layout.getSectionAddressSize(&Sec);
+    // Skip empty sections...
+    if (SectionSize == 0)
+      continue;
+
+    unsigned Start = W.OS.tell();
+    // Write section header
+    W.write<char>(ArrayRef<char>(Sec.getName().data(), 4));
+
+    uint64_t PartSize = SectionSize + sizeof(dxbc::PartHeader);
+
+    if (Sec.getName() == "DXIL")
+      PartSize += sizeof(dxbc::ProgramHeader);
+    // DXContainer parts should be 4-byte aligned
+    PartSize = alignTo(PartSize, Align(4));
+    W.write<uint32_t>(static_cast<uint32_t>(PartSize));
+    if (Sec.getName() == "DXIL") {
+      dxbc::ProgramHeader Header;
+      bzero(reinterpret_cast<void *>(&Header), sizeof(dxbc::ProgramHeader));
+
+      const Triple &TT = Asm.getContext().getTargetTriple();
+      VersionTuple Version = TT.getOSVersion();
+      Header.MajorVersion = static_cast<uint8_t>(Version.getMajor());
+      if (Version.getMinor().hasValue())
+        Header.MinorVersion = static_cast<uint8_t>(*Version.getMinor());
+      if (TT.hasEnvironment())
+        Header.ShaderKind =
+            static_cast<uint16_t>(TT.getEnvironment() - Triple::Pixel);
+
+      // The program header's size field is in 32-bit words.
+      Header.Size = (SectionSize + sizeof(dxbc::ProgramHeader) + 3) / 4;
+      memcpy(Header.Bitcode.Magic, "DXIL", 4);
+      Header.Bitcode.Offset = sizeof(dxbc::BitcodeHeader);
+      Header.Bitcode.Size = SectionSize;
+      if (sys::IsBigEndianHost)
+        Header.swapBytes();
+      W.write<char>(ArrayRef<char>(reinterpret_cast<char *>(&Header),
+                                   sizeof(dxbc::ProgramHeader)));
+    }
+    Asm.writeSectionData(W.OS, &Sec, Layout);
+    unsigned Size = W.OS.tell() - Start;
+    W.OS.write_zeros(offsetToAlignment(Size, Align(4)));
+  }
+  return 0;
+}
+
+std::unique_ptr<MCObjectWriter> llvm::createDXContainerObjectWriter(
+    std::unique_ptr<MCDXContainerTargetWriter> MOTW, raw_pwrite_stream &OS) {
+  return std::make_unique<DXContainerObjectWriter>(std::move(MOTW), OS);
+}

llvm/lib/MC/MCObjectFileInfo.cpp

 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionCOFF.h"
+#include "llvm/MC/MCSectionDXContainer.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionGOFF.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSectionSPIRV.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/Support/Casting.h"
 
DwarfRangesSection = Ctx->getXCOFFSection(
       ".dwrnges", SectionKind::getMetadata(), /* CsectProperties */ None,
       /* MultiSymbolsAllowed */ true, ".dwrnges", XCOFF::SSUBTYP_DWRNGES);
 
   DwarfMacinfoSection = Ctx->getXCOFFSection(
       ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ None,
       /* MultiSymbolsAllowed */ true, ".dwmac", XCOFF::SSUBTYP_DWMAC);
 }
 
+void MCObjectFileInfo::initDXContainerObjectFileInfo(const Triple &T) {
+  // At the moment the DXBC section should end up empty.
+  TextSection = Ctx->getDXContainerSection("DXBC", SectionKind::getText());
+}
+
 MCObjectFileInfo::~MCObjectFileInfo() = default;
 
 void MCObjectFileInfo::initMCObjectFileInfo(MCContext &MCCtx, bool PIC,
                                             bool LargeCodeModel) {
   PositionIndependent = PIC;
   Ctx = &MCCtx;
 
   // Common.
case MCContext::IsSPIRV:
     break;
   case MCContext::IsWasm:
     initWasmMCObjectFileInfo(TheTriple);
     break;
   case MCContext::IsXCOFF:
     initXCOFFMCObjectFileInfo(TheTriple);
     break;
   case MCContext::IsDXContainer:
+    initDXContainerObjectFileInfo(TheTriple);
     break;
   }
 }
 
 MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
                                                    uint64_t Hash) const {
   switch (Ctx->getTargetTriple().getObjectFormat()) {
   case Triple::ELF:

llvm/lib/MC/MCSectionDXContainer.cpp

+//===- lib/MC/MCSectionDXContainer.cpp - DXContainer Section --------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCSectionDXContainer.h"
+
+using namespace llvm;
+
+void MCSectionDXContainer::printSwitchToSection(const MCAsmInfo &,
+                                                const Triple &, raw_ostream &,
+                                                const MCExpr *) const {}