[DX] Add analysis and printer for shader flags

[beanz]

Summary

This adds infrastructural pieces for an analysis to compute the DXIL
shader flags. In this state the analysis can compute two fairly
straightforward feature flags for use of double-precision floating
point values and the DX 11.1 extended double support.

This patch does conflict with D135190, conflicts will be resolved prior
to merging.

[python3kgae]

llvm/lib/Target/DirectX/DXILShaderFlags.h

33

undef SHADER_FLAG after use?

[beanz]

llvm/lib/Target/DirectX/DXILShaderFlags.h

33

The header undef’s the macro.

llvm/lib/Target/DirectX/CMakeLists.txt

add_llvm_target(DirectXCodeGen
   DirectXSubtarget.cpp
   DirectXTargetMachine.cpp
   DXILMetadata.cpp
   DXILOpBuilder.cpp
   DXILOpLowering.cpp
   DXILPrepare.cpp
   DXILResource.cpp
   DXILResourceAnalysis.cpp
+  DXILShaderFlags.cpp
   DXILTranslateMetadata.cpp
   PointerTypeAnalysis.cpp
 
   LINK_COMPONENTS
   AsmPrinter
   Core
   SelectionDAG
   Support

llvm/lib/Target/DirectX/DXILShaderFlags.h

+//===- DXILShaderFlags.h - DXIL Shader Flags helper objects ---------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This file contains helper objects and APIs for working with DXIL
+///       Shader Flags.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TARGET_DIRECTX_DXILSHADERFLAGS_H
+#define LLVM_TARGET_DIRECTX_DXILSHADERFLAGS_H
+
+#include "llvm/BinaryFormat/DXContainer.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstdint>
+
+namespace llvm {
+class Module;
+class GlobalVariable;
+
+namespace dxil {
+
+struct ComputedShaderFlags {
+#define SHADER_FLAG(bit, FlagName, Str) bool FlagName : 1;
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+
+#define SHADER_FLAG(bit, FlagName, Str) FlagName = false;
+  ComputedShaderFlags() {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+  }
+
+  operator uint64_t() const {
+    uint64_t FlagValue = 0;
+#define SHADER_FLAG(bit, FlagName, Str)                                        \
+  FlagValue |=                                                                 \
+      FlagName ? static_cast<uint64_t>(dxbc::FeatureFlags::FlagName) : 0ull;
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+    return FlagValue;
+  }
+
+  static ComputedShaderFlags computeFlags(Module &M);
+  void print(raw_ostream &OS = dbgs()) const;
+  LLVM_DUMP_METHOD void dump() const { print(); }
+};
+
+class ShaderFlagsAnalysis : public AnalysisInfoMixin<ShaderFlagsAnalysis> {
+  friend AnalysisInfoMixin<ShaderFlagsAnalysis>;
+  static AnalysisKey Key;
+
+public:
+  ShaderFlagsAnalysis() = default;
+
+  using Result = ComputedShaderFlags;
+
+  ComputedShaderFlags run(Module &M, ModuleAnalysisManager &AM);
+};
+
+/// Printer pass for ShaderFlagsAnalysis results.
+class ShaderFlagsAnalysisPrinter
+    : public PassInfoMixin<ShaderFlagsAnalysisPrinter> {
+  raw_ostream &OS;
+
+public:
+  explicit ShaderFlagsAnalysisPrinter(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // namespace dxil
+} // namespace llvm
+
+#endif // LLVM_TARGET_DIRECTX_DXILSHADERFLAGS_H

llvm/lib/Target/DirectX/DXILShaderFlags.cpp

+//===- DXILShaderFlags.cpp - DXIL Shader Flags helper objects -------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This file contains helper objects and APIs for working with DXIL
+///       Shader Flags.
+///
+//===----------------------------------------------------------------------===//
+
+#include "DXILShaderFlags.h"
+#include "DirectX.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/FormatVariadic.h"
+
+using namespace llvm;
+using namespace llvm::dxil;
+
+static void updateFlags(ComputedShaderFlags &Flags, const Instruction &I) {
+  Type *Ty = I.getType();
+  if (Ty->isDoubleTy()) {
+    Flags.Doubles = true;
+    switch (I.getOpcode()) {
+    case Instruction::FDiv:
+    case Instruction::UIToFP:
+    case Instruction::SIToFP:
+    case Instruction::FPToUI:
+    case Instruction::FPToSI:
+      Flags.DX11_1_DoubleExtensions = true;
+      break;
+    }
+  }
+}
+
+ComputedShaderFlags ComputedShaderFlags::computeFlags(Module &M) {
+  ComputedShaderFlags Flags;
+  for (const auto &F : M)
+    for (const auto &BB : F)
+      for (const auto &I : BB)
+        updateFlags(Flags, I);
+  return Flags;
+}
+
+void ComputedShaderFlags::print(raw_ostream &OS) const {
+  uint64_t FlagVal = (uint64_t) * this;
+  OS << formatv("; Shader Flags Value: {0:x8}\n;\n", FlagVal);
+  if (FlagVal == 0)
+    return;
+  OS << "; Note: shader requires additional functionality:\n";
+#define SHADER_FLAG(bit, FlagName, Str)                                        \
+  if (FlagName)                                                                \
+    OS << ";       " Str "\n";
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+  OS << ";\n";
+}
+
+AnalysisKey ShaderFlagsAnalysis::Key;
+
+ComputedShaderFlags ShaderFlagsAnalysis::run(Module &M,
+                                             ModuleAnalysisManager &AM) {
+  return ComputedShaderFlags::computeFlags(M);
+}
+
+PreservedAnalyses ShaderFlagsAnalysisPrinter::run(Module &M,
+                                                  ModuleAnalysisManager &AM) {
+  ComputedShaderFlags Flags = AM.getResult<ShaderFlagsAnalysis>(M);
+  Flags.print(OS);
+  return PreservedAnalyses::all();
+}

llvm/lib/Target/DirectX/DirectXTargetMachine.cpp

 //===- DirectXTargetMachine.cpp - DirectX Target Implementation -*- 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file contains DirectX target initializer.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "DirectXTargetMachine.h"
 #include "DXILResourceAnalysis.h"
+#include "DXILShaderFlags.h"
 #include "DXILWriter/DXILWriterPass.h"
 #include "DirectX.h"
 #include "DirectXSubtarget.h"
 #include "DirectXTargetTransformInfo.h"
 #include "TargetInfo/DirectXTargetInfo.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"

 void DirectXTargetMachine::registerPassBuilderCallbacks(PassBuilder &PB) {
   PB.registerPipelineParsingCallback(
       [](StringRef PassName, ModulePassManager &PM,
          ArrayRef<PassBuilder::PipelineElement>) {
         if (PassName == "print-dxil-resource") {
           PM.addPass(DXILResourcePrinterPass(dbgs()));
           return true;
         }
+        if (PassName == "print-dx-shader-flags") {
+          PM.addPass(dxil::ShaderFlagsAnalysisPrinter(dbgs()));
+          return true;
+        }
         return false;
       });
 
   PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &MAM) {
     MAM.registerPass([&] { return DXILResourceAnalysis(); });
+    MAM.registerPass([&] { return dxil::ShaderFlagsAnalysis(); });
   });
 }
 
 bool DirectXTargetMachine::addPassesToEmitFile(
     PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
     CodeGenFileType FileType, bool DisableVerify,
     MachineModuleInfoWrapperPass *MMIWP) {
   TargetPassConfig *PassConfig = createPassConfig(PM);

llvm/test/CodeGen/DirectX/ShaderFlags/double-extensions.ll

+; RUN: opt -S --passes="print-dx-shader-flags" 2>&1 %s | FileCheck %s
+
+target triple = "dxil-pc-shadermodel6.7-library"
+
+; CHECK: ; Shader Flags Value: 0x00000021
+; CHECK: ; Note: shader requires additional functionality:
+; CHECK-NEXT: ;       Double-precision floating point
+; CHECK-NEXT: ;       Double-precision extensions for 11.1
+; CHECK-NEXT: {{^;$}}
+define double @div(double %a, double %b) {
+  %res = fdiv double %a, %b
+  ret double %res
+}

llvm/test/CodeGen/DirectX/ShaderFlags/doubles.ll

+; RUN: opt -S --passes="print-dx-shader-flags" 2>&1 %s | FileCheck %s
+
+target triple = "dxil-pc-shadermodel6.7-library"
+
+; CHECK: ; Shader Flags Value: 0x00000001
+; CHECK: ; Note: shader requires additional functionality:
+; CHECK-NEXT: ;       Double-precision floating point
+; CHECK-NEXT: {{^;$}}
+define double @add(double %a, double %b) {
+  %sum = fadd double %a, %b
+  ret double %sum
+}

llvm/test/CodeGen/DirectX/ShaderFlags/no_flags.ll

+; RUN: opt -S --passes="print-dx-shader-flags" 2>&1 %s | FileCheck %s
+
+target triple = "dxil-pc-shadermodel6.7-library"
+
+; CHECK: ; Shader Flags Value: 0x00000000
+define i32 @add(i32 %a, i32 %b) {
+  %sum = add i32 %a, %b
+  ret i32 %sum
+}