[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

2

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

[kuhar]

llvm/lib/Target/DirectX/DxilEmitMetadata.cpp

24 ↗

(On Diff #427823)

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

28 ↗

(On Diff #427823)

use StringLiteral

29 ↗

(On Diff #427823)

nit: we can use contexpr

llvm/test/CodeGen/DirectX/dxil_ver.ll

15

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 ↗

(On Diff #427823)

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 ↗

(On Diff #427823)

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 ↗

(On Diff #427823)

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

64

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

64

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

64

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

[beanz]

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

64

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
   DXILOpLowering.cpp
   DXILPointerType.cpp
   DXILPrepare.cpp
+  DXILTranslateMetadata.cpp
   PointerTypeAnalysis.cpp
 
   LINK_COMPONENTS
   Core
   Support
   DirectXInfo
   DXILBitWriter
 
   ADD_TO_COMPONENT
   DirectX
 )
 
 add_subdirectory(MCTargetDesc)
 add_subdirectory(TargetInfo)
 add_subdirectory(DXILWriter)

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

+//===- DXILTranslateMetadata.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;
+
+static uint32_t ConstMDToUint32(const MDOperand &MDO) {
+  ConstantInt *pConst = mdconst::extract<ConstantInt>(MDO);
+  return (uint32_t)pConst->getZExtValue();
+}
+
+static ConstantAsMetadata *Uint32ToConstMD(unsigned v, LLVMContext &Ctx) {
+  return ConstantAsMetadata::get(
+      Constant::getIntegerValue(IntegerType::get(Ctx, 32), APInt(32, v)));
+}
+
+constexpr StringLiteral ValVerKey = "dx.valver";
+constexpr unsigned DXILVersionNumFields = 2;
+
+static 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[0] = Uint32ToConstMD(ValidatorVer.getMajor(), Ctx);
+  MDVals[1] = Uint32ToConstMD(ValidatorVer.getMinor().getValueOr(0), Ctx);
+
+  DXILValidatorVersionMD->addOperand(MDNode::get(Ctx, MDVals));
+}
+
+static VersionTuple loadDXILValidatorVersion(MDNode *ValVerMD) {
+  if (ValVerMD->getNumOperands() != DXILVersionNumFields)
+    return VersionTuple();
+
+  unsigned Major = ConstMDToUint32(ValVerMD->getOperand(0));
+  unsigned Minor = ConstMDToUint32(ValVerMD->getOperand(1));
+  return VersionTuple(Major, Minor);
+}
+
+static void cleanModule(Module &M) {
+  M.getOrInsertModuleFlagsMetadata()->eraseFromParent();
+}
+
+namespace {
+class DXILTranslateMetadata : public ModulePass {
+public:
+  static char ID; // Pass identification, replacement for typeid
+  explicit DXILTranslateMetadata() : ModulePass(ID), ValidatorVer(1, 0) {}
+
+  StringRef getPassName() const override { return "DXIL Metadata Emit"; }
+
+  bool runOnModule(Module &M) override;
+
+private:
+  VersionTuple ValidatorVer;
+};
+
+} // namespace
+
+bool DXILTranslateMetadata::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;
+}
+
+char DXILTranslateMetadata::ID = 0;
+
+ModulePass *llvm::createDXILTranslateMetadataPass() {
+  return new DXILTranslateMetadata();
+}
+
+INITIALIZE_PASS(DXILTranslateMetadata, "dxil-metadata-emit",
+                "DXIL Metadata Emit", false, false)

llvm/lib/Target/DirectX/DirectX.h

 ModulePass *createDXILPrepareModulePass();
 
 /// Initializer for DXILOpLowering
 void initializeDXILOpLoweringLegacyPass(PassRegistry &);
 
 /// Pass to lowering LLVM intrinsic call to DXIL op function call.
 ModulePass *createDXILOpLoweringLegacyPass();
 
+/// Initializer for DXILTranslateMetadata.
+void initializeDXILTranslateMetadataPass(PassRegistry &);
+
+/// Pass to emit metadata for DXIL.
+ModulePass *createDXILTranslateMetadataPass();
 } // namespace llvm
 
 #endif // LLVM_LIB_TARGET_DIRECTX_DIRECTX_H

llvm/lib/Target/DirectX/DirectXTargetMachine.cpp

 
 using namespace llvm;
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTarget() {
   RegisterTargetMachine<DirectXTargetMachine> X(getTheDirectXTarget());
   auto *PR = PassRegistry::getPassRegistry();
   initializeDXILPrepareModulePass(*PR);
   initializeDXILOpLoweringLegacyPass(*PR);
+  initializeDXILTranslateMetadataPass(*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(createDXILOpLoweringLegacyPass());
   PM.add(createDXILPrepareModulePass());
+  PM.add(createDXILTranslateMetadataPass());
   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/test/CodeGen/DirectX/dxil_ver.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-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)"}