Add DXContainer

[beanz]

Summary

DXIL is wrapped in a container format defined by the DirectX 11
specification. Codebases differ in calling this format either DXBC or
DXILContainer.

Since eventually we want to add support for DXBC as a target
architecture and the format is used by DXBC and DXIL, I've termed it
DXContainer here.

Most of the changes in this patch are just adding cases to switch
statements to address warnings.

[pete]

LGTM

llvm/include/llvm/ADT/Triple.h

270

Not sure if it matters, or if code anywhere cares, but these are in alphabetical order.

llvm/include/llvm/ADT/Triple.h

enum EnvironmentType {
     Amplification,
 
     LastEnvironmentType = Amplification
   };
   enum ObjectFormatType {
     UnknownObjectFormat,
 
     COFF,
+    DXContainer,
     ELF,
     GOFF,
     MachO,
     Wasm,
     XCOFF,
   };
 
 private:
   std::string Data;
 
   /// The parsed arch type.
   ArchType Arch;
 
   /// The parsed subarchitecture type.

llvm/include/llvm/MC/MCContext.h

 /// sections that it creates.
 ///
 class MCContext {
 public:
   using SymbolTable = StringMap<MCSymbol *, BumpPtrAllocator &>;
   using DiagHandlerTy =
       std::function<void(const SMDiagnostic &, bool, const SourceMgr &,
                          std::vector<const MDNode *> &)>;
-  enum Environment { IsMachO, IsELF, IsGOFF, IsCOFF, IsWasm, IsXCOFF };
+  enum Environment {
+    IsMachO,
+    IsELF,
+    IsGOFF,
+    IsCOFF,
+    IsWasm,
+    IsXCOFF,
+    IsDXContainer
+  };
 
 private:
   Environment Env;
 
   /// The name of the Segment where Swift5 Reflection Section data will be
   /// outputted
   StringRef Swift5ReflectionSegmentName;
 

llvm/include/llvm/MC/TargetRegistry.h

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)

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

static const char *getSectionNameForBitcode(const Triple &T) {
   case Triple::UnknownObjectFormat:
     return ".llvmbc";
   case Triple::GOFF:
     llvm_unreachable("GOFF is not yet implemented");
     break;
   case Triple::XCOFF:
     llvm_unreachable("XCOFF is not yet implemented");
     break;
+  case Triple::DXContainer:
+    llvm_unreachable("DXContainer is not yet implemented");
+    break;
   }
   llvm_unreachable("Unimplemented ObjectFormatType");
 }
 
 static const char *getSectionNameForCommandline(const Triple &T) {
   switch (T.getObjectFormat()) {
   case Triple::MachO:
     return "__LLVM,__cmdline";
   case Triple::COFF:
   case Triple::ELF:
   case Triple::Wasm:
   case Triple::UnknownObjectFormat:
     return ".llvmcmd";
   case Triple::GOFF:
     llvm_unreachable("GOFF is not yet implemented");
     break;
   case Triple::XCOFF:
     llvm_unreachable("XCOFF is not yet implemented");
     break;
+  case Triple::DXContainer:
+    llvm_unreachable("DXC is not yet implemented");
+    break;
   }
   llvm_unreachable("Unimplemented ObjectFormatType");
 }
 
 void llvm::embedBitcodeInModule(llvm::Module &M, llvm::MemoryBufferRef Buf,
                                 bool EmbedBitcode, bool EmbedCmdline,
                                 const std::vector<uint8_t> &CmdArgs) {
   // Save llvm.compiler.used and remove it.

llvm/lib/MC/MCContext.cpp

case Triple::Wasm:
     Env = IsWasm;
     break;
   case Triple::XCOFF:
     Env = IsXCOFF;
     break;
   case Triple::GOFF:
     Env = IsGOFF;
     break;
+  case Triple::DXContainer:
+    Env = IsDXContainer;
+    break;
   case Triple::UnknownObjectFormat:
     report_fatal_error("Cannot initialize MC for unknown object file format.");
     break;
   }
 }
 
 MCContext::~MCContext() {
   if (AutoReset)
MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name,
   case MCContext::IsGOFF:
     return new (Name, *this) MCSymbolGOFF(Name, IsTemporary);
   case MCContext::IsMachO:
     return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
   case MCContext::IsWasm:
     return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
   case MCContext::IsXCOFF:
     return createXCOFFSymbolImpl(Name, IsTemporary);
+  case MCContext::IsDXContainer:
+    break;
   }
   return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
                                     IsTemporary);
 }
 
 MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
                                   bool CanBeUnnamed) {
   if (CanBeUnnamed && !UseNamesOnTempLabels)

llvm/lib/MC/MCObjectFileInfo.cpp

case MCContext::IsGOFF:
     initGOFFMCObjectFileInfo(TheTriple);
     break;
   case MCContext::IsWasm:
     initWasmMCObjectFileInfo(TheTriple);
     break;
   case MCContext::IsXCOFF:
     initXCOFFMCObjectFileInfo(TheTriple);
     break;
+  case MCContext::IsDXContainer:
+    break;
   }
 }
 
 MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
                                                    uint64_t Hash) const {
   switch (Ctx->getTargetTriple().getObjectFormat()) {
   case Triple::ELF:
     return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
                               utostr(Hash), /*IsComdat=*/true);
   case Triple::Wasm:
     return Ctx->getWasmSection(Name, SectionKind::getMetadata(), 0,
                                utostr(Hash), MCContext::GenericSectionID);
   case Triple::MachO:
   case Triple::COFF:
   case Triple::GOFF:
   case Triple::XCOFF:
+  case Triple::DXContainer:
   case Triple::UnknownObjectFormat:
     report_fatal_error("Cannot get DWARF comdat section for this object file "
                        "format: not implemented.");
     break;
   }
   llvm_unreachable("Unknown ObjectFormatType");
 }
 

llvm/lib/MC/MCParser/AsmParser.cpp

case MCContext::IsGOFF:
     PlatformParser.reset(createGOFFAsmParser());
     break;
   case MCContext::IsWasm:
     PlatformParser.reset(createWasmAsmParser());
     break;
   case MCContext::IsXCOFF:
     PlatformParser.reset(createXCOFFAsmParser());
     break;
+  case MCContext::IsDXContainer:
+    llvm_unreachable("DXContainer is not supported yet");
+    break;
   }
 
   PlatformParser->Initialize(*this);
   initializeDirectiveKindMap();
   initializeCVDefRangeTypeMap();
 
   NumOfMacroInstantiations = 0;
 }

llvm/lib/Support/Triple.cpp

static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
   switch (Kind) {
   case Triple::UnknownObjectFormat: return "";
   case Triple::COFF:  return "coff";
   case Triple::ELF:   return "elf";
   case Triple::GOFF:  return "goff";
   case Triple::MachO: return "macho";
   case Triple::Wasm:  return "wasm";
   case Triple::XCOFF: return "xcoff";
+  case Triple::DXContainer:  return "dxcontainer";
   }
   llvm_unreachable("unknown object format type");
 }
 
 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
   switch (T.getArch()) {
   case Triple::UnknownArch:
   case Triple::aarch64:
case Triple::wasm64:
     return Triple::Wasm;
 
   case Triple::spirv32:
   case Triple::spirv64:
     // TODO: In future this will be Triple::SPIRV.
     return Triple::UnknownObjectFormat;
 
   case Triple::dxil:
-    return Triple::UnknownObjectFormat;
+    return Triple::DXContainer;
   }
   llvm_unreachable("unknown architecture");
 }
 
 /// Construct a triple from the string representation provided.
 ///
 /// This stores the string representation and parses the various pieces into
 /// enum members.

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

bool ARMAsmParser::parsePrefix(ARMMCExpr::VariantKind &RefKind) {
   case MCContext::IsCOFF:
     CurrentFormat = COFF;
     break;
   case MCContext::IsWasm:
     CurrentFormat = WASM;
     break;
   case MCContext::IsGOFF:
   case MCContext::IsXCOFF:
+  case MCContext::IsDXContainer:
     llvm_unreachable("unexpected object format");
     break;
   }
 
   if (~Prefix->SupportedFormats & CurrentFormat) {
     Error(Parser.getTok().getLoc(),
           "cannot represent relocation in the current file format");
     return true;

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

 StringRef ModuleAddressSanitizer::getGlobalMetadataSection() const {
   switch (TargetTriple.getObjectFormat()) {
   case Triple::COFF:  return ".ASAN$GL";
   case Triple::ELF:   return "asan_globals";
   case Triple::MachO: return "__DATA,__asan_globals,regular";
   case Triple::Wasm:
   case Triple::GOFF:
   case Triple::XCOFF:
+  case Triple::DXContainer:
     report_fatal_error(
         "ModuleAddressSanitizer not implemented for object file format");
   case Triple::UnknownObjectFormat:
     break;
   }
   llvm_unreachable("unsupported object format");
 }
 

llvm/unittests/ADT/TripleTest.cpp

TEST(TripleTest, FileFormat) {
   EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
 
   Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
   EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
 
   Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
   EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
 
+  EXPECT_EQ(Triple::DXContainer,
+            Triple("dxil-unknown-shadermodel").getObjectFormat());
+
   Triple T = Triple("");
   T.setObjectFormat(Triple::ELF);
   EXPECT_EQ(Triple::ELF, T.getObjectFormat());
 
   T.setObjectFormat(Triple::MachO);
   EXPECT_EQ(Triple::MachO, T.getObjectFormat());
 
   T.setObjectFormat(Triple::XCOFF);