[DIrectX backend] emit metadata for entry.

[python3kgae]

Summary

New named metadata "dx.entryPoints" is added to save all entries.

Each entry is in format of
!{ptr to function, name, signature, resource table, extra}

For compute shader, the extra will save num of threads in format of {i32 x, i32 y, i32 z}

For library profile, an empty entry will be added to save the resource table for the library.

Signature and resource table metadata is not generated yet.

[python3kgae]

Rebase, update Name for metadata and test.

[beanz]

Rather than copying code from DXC which relies on lots of defined constants, and is very non-LLVM in style, we should focus on adding useful OO abstractions for working with the DXIL metadata.

I refactored the code for writing the dx.valver metadata in D134397. That pattern may not apply to all the metadata we need to generate, but we should break away from what DXC did.

[python3kgae]

Rebase for DXILMetadata.h/cpp

[python3kgae]

In D131807#3809994, @beanz wrote:

Rather than copying code from DXC which relies on lots of defined constants, and is very non-LLVM in style, we should focus on adding useful OO abstractions for working with the DXIL metadata.

I refactored the code for writing the dx.valver metadata in D134397. That pattern may not apply to all the metadata we need to generate, but we should break away from what DXC did.

Following the pattern in https://reviews.llvm.org/D134469 for dx.shaderModel.

[python3kgae]

Refactor code to make it easier to understand.

[python3kgae]

Cleanup header

[beanz]

Please break the testcase updates where you are just changing the triple out into a separate change, and feel free to land it without review.

I have a lot of little bits of feedback, but I'm about to post my change for dx.resources, so we can look at how these two will come together.

Not as part of this change, but at some point soon I want to refactor some of this code into a new library under llvm/lib/Frontend, so that we can share some of this code between the backend and Clang to reduce duplication.

llvm/lib/Target/DirectX/DXILMetadata.cpp

23

These function names don't conform to LLVM coding standards:

https://releases.llvm.org/8.0.0/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

Function names should be verb phrases that are imperative. I specifically removed this when I refactored the dx.valver change because it didn't conform to the coding standards and I felt that this abstraction made the code harder to read.

If we want to have a shorthand method for creating metadata, we should probably add new APIs to the IRBuilder, or other existing LLVM types rather than adding static methods like this.

50

This is a pattern that comes from DXC which we shouldn't bring with us upstream.

Using constant variables for every random constant value was important for vending DXIL headers, but that isn't something we're going to support out of the LLVM codebase. The downside to this pattern is that you either need to view code in an IDE with hover over to tell you the value, or you need to constantly jump back and forth to understand the code. There isn't really much of an upside because our coding standards require tests, so any misspellings should be caught in test cases.

59

I question what benefit we get from this being a union, but since there is only one type of shader we're supporting initially, I think you should just have a struct that is the compute shader properties.

71

Prefer StringRef::getAsInteger because it returns error conditions.

91

The places where these tags are used in DXIL are metadata nodes that store key-value pairs. The tags should be an enumeration, not a local constant.

146

I don't see how this enumeration is clearer than just having the indexes since it is just used right below.

149

Can this be called if Fn is null? That seems like a bad state to be in.

179

Rather than a default case we could enumerate each of the other profiles, and rather than an unreachable an assert makes more sense.

[python3kgae]

Code cleanup to match comments.

[python3kgae]

In D131807#3816334, @beanz wrote:

Please break the testcase updates where you are just changing the triple out into a separate change, and feel free to land it without review.

I have a lot of little bits of feedback, but I'm about to post my change for dx.resources, so we can look at how these two will come together.

Not as part of this change, but at some point soon I want to refactor some of this code into a new library under llvm/lib/Frontend, so that we can share some of this code between the backend and Clang to reduce duplication.

Will create separate change for the triple only test update.
For 'dx.resource', the plan is to add entry md after 'dx.resources' is added. Then M.getNamedMetadata('dx.resources') to find the named MD created when create 'dx.resources'.

llvm/lib/Target/DirectX/DXILMetadata.cpp

149

That happens on the library profile when accessing the resource table from the entry metadata.

We should remove it for future shader model.
For older shader models, if driver only read resource table from the "dx.resources" metadata, we could remove it too. Not sure if anyone depends on the current format.

[python3kgae]

Rebase and read resources from "dx.resources".

[python3kgae]

Rebase and fix new tests.

[python3kgae]

Fix newline before enable auto newline in VSCode.

[python3kgae]

Rebase

[python3kgae]

Remove left constexpr StringLiteral.
Use llvm::zip to avoid index variable.
Use Env - Pixel to get shader kind.

[beanz]

You have some stub code in here to handle emitting shader flags, but the value is always set to 0 resulting in nothing being written and thus no tests.

Either we should remove the shader flags code entirely from this change, or we should read the flag value and pass them through. We do have support for some shader flags.

llvm/lib/Target/DirectX/DXILMetadata.cpp

62

nit: please add a blank line here

65

We should be able to read the triple from the module and override the environment with the value from the attribute only if the module's environment is library. That saves re-parsing the string unnecessarily.

76

nit: IMO, using auto as the type from a std::get assignment is pretty unintelligible. Can you please make this and the one below explicit types.

78

The branch here seems odd, a [[maybe_unused]] return result is clearer.

86

nit: please add whitespace between functions

105

I know you're only handling three possible values of this enum, but we should just move all the cases over. We can also lose the DXIL prefix on them since they're all in the DirectX backend DXIL metadata objects already.

110

nit: space between functions.

120

nit: space between functions

127

nit: space between functions

142

nit: space between functions.

150

nit: space between functions.

156

[python3kgae]

Add ShaderFlags.
Not emit resource table when no resource.
Also fix nit style issues.

[beanz]

LGTM

llvm/lib/Target/DirectX/DXILMetadata.h

 public:
   ValidatorVersionMD(Module &M);
 
   void update(VersionTuple ValidatorVer);
 
   bool isEmpty();
 };
 
+void createEntryMD(Module &M);
+
 } // namespace dxil
 } // namespace llvm
 
 #endif // LLVM_TARGET_DIRECTX_DXILMETADATA_H

llvm/lib/Target/DirectX/DXILMetadata.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "DXILMetadata.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/VersionTuple.h"
+#include "llvm/ADT/Triple.h"
 
 using namespace llvm;
 using namespace llvm::dxil;
 
+static ConstantAsMetadata *uint32ToConstMD(unsigned V, LLVMContext &Ctx) {
+  return ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Ctx), V));
+}
+
+static ConstantAsMetadata *uint64ToConstMD(uint64_t V, LLVMContext &Ctx) {
+  return ConstantAsMetadata::get(ConstantInt::get(Type::getInt64Ty(Ctx), V));
+}
+
 ValidatorVersionMD::ValidatorVersionMD(Module &M)
     : Entry(M.getOrInsertNamedMetadata("dx.valver")) {}
 
 void ValidatorVersionMD::update(VersionTuple ValidatorVer) {
   auto &Ctx = Entry->getParent()->getContext();
-  IRBuilder<> B(Ctx);
   Metadata *MDVals[2];
 
-  MDVals[0] = ConstantAsMetadata::get(B.getInt32(ValidatorVer.getMajor()));
-  MDVals[1] =
-      ConstantAsMetadata::get(B.getInt32(ValidatorVer.getMinor().value_or(0)));
+  MDVals[0] = uint32ToConstMD(ValidatorVer.getMajor(), Ctx);
+  MDVals[1] = uint32ToConstMD(ValidatorVer.getMinor().value_or(0), Ctx);
 
   if (isEmpty())
     Entry->addOperand(MDNode::get(Ctx, MDVals));
   else
     Entry->setOperand(0, MDNode::get(Ctx, MDVals));
 }
 
 bool ValidatorVersionMD::isEmpty() { return Entry->getNumOperands() == 0; }
+
+namespace {
+constexpr StringLiteral DXILEntryKey = "hlsl.shader";
+
+struct EntryProps {
+  Triple::EnvironmentType ShaderKind;
+  union {
+    // Compute shader.
+    struct {
+      unsigned NumThreads[3];
+    } CS;
+  } ShaderProps;
+  EntryProps(Function &F) {
+    Attribute EntryAttr = F.getFnAttribute(DXILEntryKey);
+    StringRef EntryProfile = EntryAttr.getValueAsString();
+    Triple T("", "", "", EntryProfile);
+    ShaderKind = T.getEnvironment();
+    if (ShaderKind == Triple::EnvironmentType::Compute) {
+      constexpr StringLiteral NumThreadsKey = "hlsl.numthreads";
+      auto NumThreadsStr = F.getFnAttribute(NumThreadsKey).getValueAsString();
+      SmallVector<StringRef> NumThreads;
+      NumThreadsStr.split(NumThreads, ',');
+      assert(NumThreads.size() == 3 && "invalid numthreads");
+      ShaderProps.CS.NumThreads[0] = std::stoi(NumThreads[0].str());
+      ShaderProps.CS.NumThreads[1] = std::stoi(NumThreads[1].str());
+      ShaderProps.CS.NumThreads[2] = std::stoi(NumThreads[2].str());
+    }
+  }
+  MDTuple *emitDXILEntryProps(uint64_t RawShaderFlag, LLVMContext &Ctx) {
+    std::vector<Metadata *> MDVals;
+
+    if (RawShaderFlag != 0)
+      appendShaderFlags(MDVals, RawShaderFlag, Ctx);
+
+    if (ShaderKind == Triple::EnvironmentType::Compute)
+      appendNumThreads(MDVals, Ctx);
+    // FIXME: support more props.
+    // See https://github.com/llvm/llvm-project/issues/57948.
+    return MDNode::get(Ctx, MDVals);
+  }
+
+private:
+  void appendNumThreads(std::vector<Metadata *> &MDVals, LLVMContext &Ctx) {
+    constexpr unsigned DXILNumThreadsTag = 4;
+    MDVals.emplace_back(uint32ToConstMD(DXILNumThreadsTag, Ctx));
+
+    std::vector<Metadata *> NumThreadVals;
+    NumThreadVals.emplace_back(
+        uint32ToConstMD(ShaderProps.CS.NumThreads[0], Ctx));
+    NumThreadVals.emplace_back(
+        uint32ToConstMD(ShaderProps.CS.NumThreads[1], Ctx));
+    NumThreadVals.emplace_back(
+        uint32ToConstMD(ShaderProps.CS.NumThreads[2], Ctx));
+    MDVals.emplace_back(MDNode::get(Ctx, NumThreadVals));
+  }
+  void appendShaderFlags(std::vector<Metadata *> &MDVals,
+                         uint64_t RawShaderFlag, LLVMContext &Ctx) {
+    constexpr unsigned DxilShaderFlagsTag = 0;
+    MDVals.emplace_back(uint32ToConstMD(DxilShaderFlagsTag, Ctx));
+    MDVals.emplace_back(uint64ToConstMD(RawShaderFlag, Ctx));
+  }
+};
+
+class EntryMD {
+  Function &F;
+  LLVMContext &Ctx;
+  EntryProps Props;
+
+public:
+  EntryMD(Function &F) : F(F), Ctx(F.getContext()), Props(F) {}
+  MDTuple *emitEntryTuple(MDTuple *Resources, uint64_t RawShaderFlag) {
+    // FIXME: add signature for profile other than CS.
+    // See https://github.com/llvm/llvm-project/issues/57928.
+    MDTuple *Signatures = nullptr;
+    return emitDxilEntryPointTuple(&F, F.getName().str(), Signatures, Resources,
+                                   Props.emitDXILEntryProps(RawShaderFlag, Ctx),
+                                   Ctx);
+  }
+
+  // Library will have empty entry metadata which only store the resource table
+  // metadata.
+  static MDTuple *emitEmptyEntryForLib(MDTuple *Resources, LLVMContext &Ctx) {
+    return emitDxilEntryPointTuple(nullptr, "", nullptr, Resources, nullptr,
+                                   Ctx);
+  }
+
+private:
+  static MDTuple *emitDxilEntryPointTuple(Function *Fn, const std::string &Name,
+                                          MDTuple *Signatures,
+                                          MDTuple *Resources,
+                                          MDTuple *Properties,
+                                          LLVMContext &Ctx) {
+    enum EntryMDNode {
+      EntryMDFn = 0,
+      EntryMDName,
+      EntryMDSignature,
+      EntryMDResources,
+      EntryMDProps,
+      EntryMDSize
+    };
+    Metadata *MDVals[EntryMDSize];
+    MDVals[EntryMDFn] = Fn ? ValueAsMetadata::get(Fn) : nullptr;
+    MDVals[EntryMDName] = MDString::get(Ctx, Name.c_str());
+    MDVals[EntryMDSignature] = Signatures;
+    MDVals[EntryMDResources] = Resources;
+    MDVals[EntryMDProps] = Properties;
+    return MDNode::get(Ctx, MDVals);
+  }
+};
+} // namespace
+
+void dxil::createEntryMD(Module &M) {
+  SmallVector<Function *> EntryList;
+  for (auto &F : M.functions()) {
+    if (!F.hasFnAttribute(DXILEntryKey))
+      continue;
+    EntryList.emplace_back(&F);
+  }
+
+  auto &Ctx = M.getContext();
+  // FIXME: generate metadata for resource.
+  // See https://github.com/llvm/llvm-project/issues/57926.
+  MDTuple *MDResources = nullptr;
+
+  // FIXME: build shader flags.
+  // See https://github.com/llvm/llvm-project/issues/57925
+  uint64_t ShaderFlags = 0;
+
+  std::vector<MDNode *> Entries;
+  Triple T = Triple(M.getTargetTriple());
+  switch (T.getEnvironment()) {
+  default:
+    llvm_unreachable("invalid profile");
+    break;
+  case Triple::EnvironmentType::Library: {
+    // Add empty entry to put resource metadata.
+    MDTuple *EmptyEntry = EntryMD::emitEmptyEntryForLib(MDResources, Ctx);
+    Entries.emplace_back(EmptyEntry);
+
+    for (Function *Entry : EntryList) {
+      EntryMD MD(*Entry);
+      Entries.emplace_back(MD.emitEntryTuple(nullptr, ShaderFlags));
+    }
+  } break;
+  // FIXME: support more shader profiles.
+  // See https://github.com/llvm/llvm-project/issues/57927.
+  case Triple::EnvironmentType::Compute: {
+    assert(EntryList.size() == 1 &&
+           "non-lib profiles should only have one entry");
+    EntryMD MD(*EntryList.front());
+    Entries.emplace_back(MD.emitEntryTuple(MDResources, ShaderFlags));
+  } break;
+  }
+
+  constexpr StringLiteral DXILEntryPointsMDName = "dx.entryPoints";
+  NamedMDNode *EntryPointsNamedMD =
+      M.getOrInsertNamedMetadata(DXILEntryPointsMDName);
+  for (auto *Entry : Entries)
+    EntryPointsNamedMD->addOperand(Entry);
+}

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

 
 } // namespace
 
 bool DXILTranslateMetadata::runOnModule(Module &M) {
 
   dxil::ValidatorVersionMD ValVerMD(M);
   if (ValVerMD.isEmpty())
     ValVerMD.update(VersionTuple(1, 0));
+
+  dxil::createEntryMD(M);
   return false;
 }
 
 char DXILTranslateMetadata::ID = 0;
 
 ModulePass *llvm::createDXILTranslateMetadataPass() {
   return new DXILTranslateMetadata();
 }
 
 INITIALIZE_PASS(DXILTranslateMetadata, "dxil-metadata-emit",
                 "DXIL Metadata Emit", false, false)

llvm/test/CodeGen/DirectX/conflicting-bitcast-insert.ll

 ; RUN: llc --filetype=asm %s -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 define i64 @test(ptr %p) {
   store i32 0, ptr %p
   %v = load i64, ptr %p
   ret i64 %v
 }
 
 ; CHECK: define i64 @test(ptr %p) {

llvm/test/CodeGen/DirectX/empty_cs_entry.ll

+; RUN: opt -S -dxil-metadata-emit < %s | FileCheck %s
+target datalayout = "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"
+target triple = "dxil-unknown-shadermodel6.7-compute"
+
+;CHECK:!dx.entryPoints = !{![[entry:[0-9]+]]}
+
+;CHECK:![[entry]] = !{ptr @entry, !"entry", null, null, ![[extra:[0-9]+]]}
+;CHECK:![[extra]] = !{i32 4, ![[numthreads:[0-9]+]]}
+;CHECK:![[numthreads]] = !{i32 1, i32 2, i32 1}
+
+; Function Attrs: noinline nounwind
+define void @entry() #0 {
+entry:
+  ret void
+}
+
+attributes #0 = { noinline nounwind "hlsl.numthreads"="1,2,1" "hlsl.shader"="compute" }

llvm/test/CodeGen/DirectX/fneg-conversion.ll

 ; RUN: llc %s --filetype=asm -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 define float @negateF(float %0) {
 ; CHECK:  %2 = fsub float -0.000000e+00, %0
   %2 = fneg float %0
   ret float %2
 }
 
 define double @negateD(double %0) {
 ; CHECK: %2 = fsub double -0.000000e+00, %0
   %2 = fneg double %0
   ret double %2
 }

llvm/test/CodeGen/DirectX/lib_entry.ll

+; RUN: opt -S -dxil-metadata-emit < %s | FileCheck %s
+target datalayout = "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"
+target triple = "dxil-unknown-shadermodel6.7-library"
+
+;CHECK:!dx.entryPoints = !{![[empty_entry:[0-9]+]], ![[entry:[0-9]+]]}
+
+; Make sure generate empty entry for lib profile.
+;CHECK![[empty_entry]] = !{null, !"", null, null, null}
+
+;CHECK:![[entry]] = !{ptr @entry, !"entry", null, null, ![[extra:[0-9]+]]}
+;CHECK:![[extra]] = !{i32 4, ![[numthreads:[0-9]+]]}
+;CHECK:![[numthreads]] = !{i32 1, i32 2, i32 1}
+
+; Function Attrs: noinline nounwind
+define void @entry() #0 {
+entry:
+  ret void
+}
+
+attributes #0 = { noinline nounwind "hlsl.numthreads"="1,2,1" "hlsl.shader"="compute" }

llvm/test/CodeGen/DirectX/omit-bitcast-insert.ll

 ; RUN: llc --filetype=asm %s -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 define i64 @test(ptr %p) {
   %v = load i64, ptr %p
   ret i64 %v
 }
 
 ; CHECK: define i64 @test(ptr %p) {
 ; CHECK-NEXT: %v = load i64, ptr %p, align 8

llvm/test/CodeGen/DirectX/strip-fn-attrs.ll

 ; RUN: llc %s --filetype=asm -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 ; CHECK: Function Attrs: nounwind readnone
 ; Function Attrs: norecurse nounwind readnone willreturn
 define dso_local float @fma(float %0, float %1, float %2) local_unnamed_addr #0 {
   %4 = fmul float %0, %1
   %5 = fadd float %4, %2
   ret float %5
 }

llvm/test/tools/dxil-dis/BasicIR.ll

 ; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s
 
 ; CHECK: define i32 @foo(i32 %X, i32 %Y) {
 ; CHECK:   %Z = sub i32 %X, %Y
 ; CHECK:   %Q = add i32 %Z, %Y
 ; CHECK:   ret i32 %Q
 ; CHECK: }
 
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 define i32 @foo(i32 %X, i32 %Y) {
   %Z = sub i32 %X, %Y
   %Q = add i32 %Z, %Y
   ret i32 %Q
 }

llvm/test/tools/dxil-dis/attribute-filter.ll

 ; RUN: llc %s --filetype=obj -o - | dxil-dis -o - | FileCheck %s
 
-; CHECK: target triple = "dxil-unknown-unknown"
-target triple = "dxil-unknown-unknown"
+; CHECK: target triple = "dxil-unknown-shadermodel6.7-library"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 ; CHECK: Function Attrs: nounwind readnone
 ; Function Attrs: norecurse nounwind readnone willreturn
 define float @fma(float %0, float %1, float %2) #0 {
   %4 = fmul float %0, %1
   %5 = fadd float %4, %2
   ret float %5
 }
 
 ; CHECK: attributes #0 = { nounwind readnone "disable-tail-calls"="false" }
 attributes #0 = { norecurse nounwind readnone willreturn "disable-tail-calls"="false" }

llvm/test/tools/dxil-dis/debug-info.ll

 ; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
 
 ; CHECK: define float @fma(float, float, float) unnamed_addr #0 !dbg [[Fn:[!][0-9]+]]
 ; Function Attrs: norecurse nounwind readnone willreturn
 define dso_local float @fma(float %0, float %1, float %2) local_unnamed_addr #0 !dbg !6 {
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata float %0, metadata [[VarX:[!][0-9]+]], metadata [[Expr:[!][0-9]+]]), !dbg [[Line1:[!][0-9]+]]
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata float %1, metadata [[VarY:[!][0-9]+]], metadata [[Expr]]), !dbg [[Line1]]
 ; CHECK-NEXT: call void @llvm.dbg.value(metadata float %2, metadata [[VarZ:[!][0-9]+]], metadata [[Expr]]), !dbg [[Line1]]

llvm/test/tools/dxil-dis/di-compile-unit.ll

 ; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "Some Compiler", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
 !1 = !DIFile(filename: "di-compile-unit.src", directory: "/some-path")
 !2 = !{}
 !3 = !{i32 7, !"Dwarf Version", i32 2}
 !4 = !{i32 2, !"Debug Info Version", i32 3}
 
 ; CHECK: !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "Some Compiler", isOptimized: true, runtimeVersion: 0, emissionKind: 1, enums: !2)
 ; CHECK: !1 = !DIFile(filename: "di-compile-unit.src", directory: "/some-path")
 ; CHECK: !2 = !{}
 ; CHECK: !3 = !{i32 7, !"Dwarf Version", i32 2}
 ; CHECK: !4 = !{i32 2, !"Debug Info Version", i32 3}

llvm/test/tools/dxil-dis/di-subprogram.ll

 ; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4}
 !llvm.used = !{!5}
 !llvm.lines = !{!13, !14, !15, !16}
 
 ; CHECK: !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "Some Compiler", isOptimized: true, runtimeVersion: 0, emissionKind: 1, enums: !2)
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "Some Compiler", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)

llvm/test/tools/dxil-dis/di-subrotine.ll

 ; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 !llvm.used = !{!0}
 
 !0 = !DISubroutineType(types: !1)
 !1 = !{!2, !2, !2, !2}
 !2 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)
 
 ; CHECK: !0 = !DISubroutineType(types: !1)
 ; CHECK: !1 = !{!2, !2, !2, !2}
 ; CHECK: !2 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)

llvm/test/tools/dxil-dis/metadata.ll

 ; RUN: llc --filetype=obj %s -o - | dxil-dis 
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 !llvm.foo = !{!0}
 !llvm.bar = !{!1}
 
 !0 = !{i32 42}
 !1 = !{!"Some MDString"}
 
 ; CHECK: !llvm.foo = !{!0}
 ; CHECK: !llvm.bar = !{!1}
 ; CHECK: !0 = !{i32 42}
 ; CHECK: !1 = !{!"Some MDString"}

llvm/test/tools/dxil-dis/opaque-gep.ll

 ; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 define i32 @fn(ptr %0)  {
   %2 = getelementptr i32, ptr %0, i32 4
   %3 = load i32, ptr %2
   ret i32 %3
 }
 
 ; CHECK:        define i32 @fn(i32*) 

llvm/test/tools/dxil-dis/opaque-pointers.ll

 ; RUN: llc --filetype=obj %s -o - | dxil-dis -o - | FileCheck %s
-target triple = "dxil-unknown-unknown"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 define i64 @test(ptr %p) {
   store i32 0, ptr %p
   %v = load i64, ptr %p
   ret i64 %v
 }
 
 ; CHECK: define i64 @test(i8* %p) {

llvm/test/tools/dxil-dis/opaque-value_as_metadata.ll

 ; RUN: llc --filetype=obj %s -o - 2>&1 | dxil-dis -o - | FileCheck %s
 target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
-target triple = "dxil-ms-dx"
+target triple = "dxil-unknown-shadermodel6.7-library"
 
 %"$Globals" = type { float }
 
 @CBV = external constant %"$Globals"
 
 define void @main() {
   ret void
 }