[DirectX backend] Add pass to emit dxil metadata.

[python3kgae]

Summary

A new pass DxilEmitMetadata is added to translate information saved in llvm ir into metadata to match DXIL spec.

Only generate DXIL validator version in this PR.

In llvm ir, validator version is saved in ModuleFlag with "dx.valver" as Key.

!llvm.module.flags = !{!0, !1}
!1 = !{i32 6, !"dx.valver", !2}
!2 = !{i32 1, i32 1}

DXIL validator version has major and minor versions that are specified as named metadata:

!dx.valver = !{!2}
!2 = !{i32 1, i32 7}

[python3kgae]

llvm/test/CodeGen/DirectX/dxil_ver.ll

1

Will change to opt test once the parent PR is in.

[kuhar]

llvm/lib/Target/DirectX/DxilEmitMetadata.cpp

24

Could you space things out more? I'd expect one empty line after each function.

28

use StringLiteral

29

nit: we can use contexpr

llvm/test/CodeGen/DirectX/dxil_ver.ll

14

nit: can you add an empty line at the of the file?

[beanz]

Two super nitpick points off the top:
(1) Please be consistent that DXIL is all capitalized. I'd like LLVM to not have the annoyance issues that DXC's codebase has where DXIL is inconsistently capitalized.
(2) Can we instead name the pass "DXILTranslateMetadata"? The pass doesn't actually emit the metadata, it is translating it from one form in the module to another.

llvm/lib/Target/DirectX/DxilEmitMetadata.cpp

23

File-scoped functions should be static:

https://www.llvm.org/docs/CodingStandards.html#anonymous-namespaces

Also, your function says it is converting to a 32-bit unsigned integer, but the return type is unsigned (which is usually but not guaranteed to be 32-bits), use uint32_t instead.

nit: Uint32->UInt32 (unsigned int is two words not one)

31

Stylistically, I don't love declaring these constants. They're not used in a bunch of places and I feel like version tuples are well enough understood that we should be able to intuit the format.

That said, you don't need to change it.

92

This is unused and does nothing. Should it be here?

[python3kgae]

Update based on comments.

[kuhar]

LGTM but please get another one before submitting.

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

63 ↗

(On Diff #428126)

You can open this namespace higher up so that you don't need to annotate each function with static

[beanz]

LGTM.

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

63 ↗

(On Diff #428126)

not to nitpick, but that comment contradicts the coding standards, and is the opposite of the feedback I provided :)

see: https://www.llvm.org/docs/CodingStandards.html#anonymous-namespaces

[kuhar]

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

63 ↗

(On Diff #428126)

TIL, I thought that the guideline was the inverse. Thanks, @beanz.

[beanz]

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

63 ↗

(On Diff #428126)

I literally made the same mistake like two weeks ago (hence having the link handy) 😄

[python3kgae]

Rebase to fix merge conflict.

[python3kgae]

Fix merge error.

[python3kgae]

Resolve merge conflict.

llvm/lib/Target/DirectX/CMakeLists.txt

 add_llvm_component_group(DirectX)
 
 set(LLVM_TARGET_DEFINITIONS DirectX.td)
 
 tablegen(LLVM DirectXGenSubtargetInfo.inc -gen-subtarget)
 
 add_public_tablegen_target(DirectXCommonTableGen)
 
 add_llvm_target(DirectXCodeGen
   DirectXSubtarget.cpp
   DirectXTargetMachine.cpp
+  DxilEmitMetadata.cpp
   DXILPointerType.cpp
   DXILPrepare.cpp
   PointerTypeAnalysis.cpp
 
   LINK_COMPONENTS
   Core
   Support
   DirectXInfo

llvm/lib/Target/DirectX/DirectX.h

 /// Initializer for dxil writer pass
 void initializeWriteDXILPassPass(PassRegistry &);
 
 /// Initializer for DXIL-prepare
 void initializeDXILPrepareModulePass(PassRegistry &);
 
 /// Pass to convert modules into DXIL-compatable modules
 ModulePass *createDXILPrepareModulePass();
+
+/// Initializer for DxilEmitMetadata.
+void initializeDxilEmitMetadataPass(PassRegistry &);
+
+/// Pass to emit metadata for DXIL.
+ModulePass *createDxilEmitMetadataPass();
 } // namespace llvm
 
 #endif // LLVM_LIB_TARGET_DIRECTX_DIRECTX_H

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);
+  initializeDxilEmitMetadataPass(*PR);
 }
 
 class DXILTargetObjectFile : public TargetLoweringObjectFile {
 public:
   DXILTargetObjectFile() = default;
 
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override {

 
 DirectXTargetMachine::~DirectXTargetMachine() {}
 
 bool DirectXTargetMachine::addPassesToEmitFile(
     PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
     CodeGenFileType FileType, bool DisableVerify,
     MachineModuleInfoWrapperPass *MMIWP) {
   PM.add(createDXILPrepareModulePass());
+  PM.add(createDxilEmitMetadataPass());
   switch (FileType) {
   case CGFT_AssemblyFile:
     PM.add(createPrintModulePass(Out, "", true));
     break;
   case CGFT_ObjectFile:
     // TODO: Use MC Object streamer to write DXContainer
     PM.add(createDXILWriterPass(Out));
     break;

llvm/lib/Target/DirectX/DxilEmitMetadata.cpp

+//===- DxilEmitMetadata.cpp - Pass to emit dxil metadata --------*- 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 "DirectX.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Pass.h"
+
+using namespace llvm;
+
+namespace {
+unsigned ConstMDToUint32(const MDOperand &MDO) {
+  ConstantInt *pConst = mdconst::extract<ConstantInt>(MDO);
+  return (unsigned)pConst->getZExtValue();
+}
+ConstantAsMetadata *Uint32ToConstMD(unsigned v, LLVMContext &Ctx) {
+  return ConstantAsMetadata::get(
+      Constant::getIntegerValue(IntegerType::get(Ctx, 32), APInt(32, v)));
+}
+const StringRef ValVerKey = "dx.valver";
+const unsigned DxilVersionNumFields = 2;
+const unsigned DxilVersionMajorIdx = 0; // DXIL version major.
+const unsigned DxilVersionMinorIdx = 1; // DXIL version minor.
+
+void emitDxilValidatorVersion(Module &M, VersionTuple &ValidatorVer) {
+  NamedMDNode *DxilValidatorVersionMD = M.getNamedMetadata(ValVerKey);
+
+  // Allow re-writing the validator version, since this can be changed at
+  // later points.
+  if (DxilValidatorVersionMD)
+    M.eraseNamedMetadata(DxilValidatorVersionMD);
+
+  DxilValidatorVersionMD = M.getOrInsertNamedMetadata(ValVerKey);
+
+  auto &Ctx = M.getContext();
+  Metadata *MDVals[DxilVersionNumFields];
+  MDVals[DxilVersionMajorIdx] = Uint32ToConstMD(ValidatorVer.getMajor(), Ctx);
+  MDVals[DxilVersionMinorIdx] =
+      Uint32ToConstMD(ValidatorVer.getMinor().getValueOr(0), Ctx);
+
+  DxilValidatorVersionMD->addOperand(MDNode::get(Ctx, MDVals));
+}
+
+VersionTuple loadDxilValidatorVersion(MDNode *ValVerMD) {
+  if (ValVerMD->getNumOperands() != DxilVersionNumFields)
+    return VersionTuple();
+
+  unsigned Major = ConstMDToUint32(ValVerMD->getOperand(DxilVersionMajorIdx));
+  unsigned Minor = ConstMDToUint32(ValVerMD->getOperand(DxilVersionMinorIdx));
+  return VersionTuple(Major, Minor);
+}
+
+void cleanModule(Module &M) {
+  M.getOrInsertModuleFlagsMetadata()->eraseFromParent();
+}
+} // namespace
+
+namespace {
+class DxilEmitMetadata : public ModulePass {
+public:
+  static char ID; // Pass identification, replacement for typeid
+  explicit DxilEmitMetadata() : ModulePass(ID), ValidatorVer(1, 0) {}
+
+  StringRef getPassName() const override { return "HLSL DXIL Metadata Emit"; }
+
+  bool runOnModule(Module &M) override;
+
+private:
+  VersionTuple ValidatorVer;
+  void emitDXILVersion(Module &M);
+};
+
+bool DxilEmitMetadata::runOnModule(Module &M) {
+  if (MDNode *ValVerMD = cast_or_null<MDNode>(M.getModuleFlag(ValVerKey))) {
+    auto ValVer = loadDxilValidatorVersion(ValVerMD);
+    if (!ValVer.empty())
+      ValidatorVer = ValVer;
+  }
+  emitDxilValidatorVersion(M, ValidatorVer);
+  cleanModule(M);
+  return false;
+}
+
+void DxilEmitMetadata::emitDXILVersion(Module &M) {}
+
+} // namespace
+
+char DxilEmitMetadata::ID = 0;
+
+ModulePass *llvm::createDxilEmitMetadataPass() {
+  return new DxilEmitMetadata();
+}
+
+INITIALIZE_PASS(DxilEmitMetadata, "dxil-metadata-emit",
+                "HLSL DXIL Metadata Emit", false, false)

llvm/test/CodeGen/DirectX/dxil_ver.ll

+; RUN: llc %s --filetype=asm -o - | 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-pc-shadermodel6.3-library"
+
+; CHECK:!dx.valver = !{![[valver:[0-9]+]]}
+; CHECK:![[valver]] = !{i32 1, i32 1}
+
+!llvm.module.flags = !{!0, !1}
+!llvm.ident = !{!3}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 6, !"dx.valver", !2}
+!2 = !{i32 1, i32 1}
+!3 = !{!"clang version 15.0.0 (https://github.com/llvm/llvm-project 71de12113a0661649ecb2f533fba4a2818a1ad68)"}
 No newline at end of file