[llvm-branch-commits] [DirectX] Wire up CodeGenPassBuilder (PR #244834)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Fri Nov 20 23:43:37 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-directx

Author: Aiden Grossman (boomanaiden154)

<details>
<summary>Changes</summary>

Introduce DirectXCodeGenPassBuilder and wire up the pass pipeline to be
the same as the existing DirectXPassConfig/addPassesToEmitFile.

Assisted-By: LLM


---
Full diff: https://github.com/llvm/llvm-project/pull/244834.diff


5 Files Affected:

- (modified) llvm/lib/Target/DirectX/CMakeLists.txt (+2) 
- (added) llvm/lib/Target/DirectX/DirectXCodeGenPassBuilder.cpp (+155) 
- (modified) llvm/lib/Target/DirectX/DirectXTargetMachine.cpp (-9) 
- (modified) llvm/lib/Target/DirectX/DirectXTargetMachine.h (+7) 
- (added) llvm/test/CodeGen/DirectX/newpm-pipeline.ll (+42) 


``````````diff
diff --git a/llvm/lib/Target/DirectX/CMakeLists.txt b/llvm/lib/Target/DirectX/CMakeLists.txt
index 4fa67e28ace95..938ca31641962 100644
--- a/llvm/lib/Target/DirectX/CMakeLists.txt
+++ b/llvm/lib/Target/DirectX/CMakeLists.txt
@@ -14,6 +14,7 @@ add_public_tablegen_target(DirectXCommonTableGen)
 add_llvm_target(DirectXCodeGen
   CBufferDataLayout.cpp
   DirectXAsmPrinter.cpp
+  DirectXCodeGenPassBuilder.cpp
   DirectXInstrInfo.cpp
   DirectXRegisterInfo.cpp
   DirectXSubtarget.cpp
@@ -58,6 +59,7 @@ add_llvm_target(DirectXCodeGen
   FrontendHLSL
   IPO
   MC
+  Passes
   ScalarOpts
   SelectionDAG
   Support
diff --git a/llvm/lib/Target/DirectX/DirectXCodeGenPassBuilder.cpp b/llvm/lib/Target/DirectX/DirectXCodeGenPassBuilder.cpp
new file mode 100644
index 0000000000000..5679a8b66a568
--- /dev/null
+++ b/llvm/lib/Target/DirectX/DirectXCodeGenPassBuilder.cpp
@@ -0,0 +1,155 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 "DXILRootSignature.h"
+#include "DXILShaderFlags.h"
+#include "DXILSignatureAnalysis.h"
+#include "DXILWriter/DXILWriterPass.h"
+#include "DirectX.h"
+#include "DirectXAsmPrinter.h"
+#include "DirectXTargetMachine.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/IR/PassInstrumentation.h"
+#include "llvm/Passes/CodeGenPassBuilder.h"
+#include "llvm/Passes/PassBuilder.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/VersionTuple.h"
+#include "llvm/Target/CGPassBuilderOption.h"
+#include "llvm/Transforms/IPO/GlobalDCE.h"
+#include "llvm/Transforms/Scalar/DeadStoreElimination.h"
+#include "llvm/Transforms/Scalar/Scalarizer.h"
+#include "llvm/Transforms/Utils/StripConvergenceIntrinsics.h"
+
+using namespace llvm;
+
+namespace {
+
+class DirectXCodeGenPassBuilder : public CodeGenPassBuilder {
+  DirectXTargetMachine &getTM() const {
+    return static_cast<DirectXTargetMachine &>(TM);
+  }
+
+public:
+  explicit DirectXCodeGenPassBuilder(DirectXTargetMachine &TM,
+                                     const CGPassBuilderOption &Opts,
+                                     PassInstrumentationCallbacks *PIC)
+      : CodeGenPassBuilder(TM, Opts, PIC) {}
+
+protected:
+  Error buildPipelineImpl(PassManagerWrapper &PMW, ModuleAnalysisManager &MAM,
+                          raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
+                          CodeGenFileType FileType, MCContext &Ctx) override;
+  void addCodeGenPrepare(PassManagerWrapper &PMW) override;
+  void addAsmPrinterBegin(PassManagerWrapper &PMW) override;
+  void addAsmPrinter(PassManagerWrapper &PMW) override;
+  void addAsmPrinterEnd(PassManagerWrapper &PMW) override;
+};
+
+} // namespace
+
+void DirectXCodeGenPassBuilder::addCodeGenPrepare(PassManagerWrapper &PMW) {
+  CodeGenOptLevel OptLevel = getOptLevel();
+
+  addFunctionPass(StripConvergenceIntrinsicsPass(), PMW);
+  flushFPMsToMPM(PMW);
+  addModulePass(DXILFinalizeLinkagePass(), PMW);
+  if (OptLevel != CodeGenOptLevel::None)
+    addModulePass(GlobalDCEPass(), PMW);
+  addModulePass(DXILMemIntrinsicsPass(), PMW);
+  addModulePass(DXILCBufferAccessPass(), PMW);
+  addFunctionPass(DXILRemoveUnusedResourcesPass(), PMW);
+  addFunctionPass(DXILResourceAccessPass(), PMW);
+  flushFPMsToMPM(PMW);
+  addModulePass(DXILIntrinsicExpansionPass(), PMW);
+  addModulePass(DXILDataScalarizationPass(), PMW);
+  if (getTM().getTargetTriple().getOSVersion() < VersionTuple(6, 9)) {
+    ScalarizerPassOptions DxilScalarOptions;
+    DxilScalarOptions.ScalarizeLoadStore = true;
+    addFunctionPass(ScalarizerPass(DxilScalarOptions), PMW);
+    flushFPMsToMPM(PMW);
+  }
+  addModulePass(DXILFlattenArraysPass(), PMW);
+  addFunctionPass(DXILForwardHandleAccessesPass(), PMW);
+  if (OptLevel != CodeGenOptLevel::None)
+    addFunctionPass(DSEPass(), PMW);
+  addFunctionPass(DXILLegalizePass(), PMW);
+  flushFPMsToMPM(PMW);
+  addModulePass(DXILResourceImplicitBindingPass(), PMW);
+  addModulePass(DXILTranslateMetadataPass(), PMW);
+  addModulePass(DXILPostOptimizationValidationPass(), PMW);
+  addModulePass(DXILOpLoweringPass(), PMW);
+  addModulePass(DXILPrepareModulePass(), PMW);
+  addModulePass(DXILDebugInfoPass(), PMW);
+}
+
+void DirectXCodeGenPassBuilder::addAsmPrinterBegin(PassManagerWrapper &PMW) {
+  addModulePass(DXILAsmPrinterBeginPass(), PMW, /*Force=*/true);
+}
+
+void DirectXCodeGenPassBuilder::addAsmPrinter(PassManagerWrapper &PMW) {
+  addMachineFunctionPass(DXILAsmPrinterPass(), PMW);
+}
+
+void DirectXCodeGenPassBuilder::addAsmPrinterEnd(PassManagerWrapper &PMW) {
+  addModulePass(DXILAsmPrinterEndPass(), PMW, /*Force=*/true);
+}
+
+Error DirectXCodeGenPassBuilder::buildPipelineImpl(PassManagerWrapper &PMW,
+                                                   ModuleAnalysisManager &MAM,
+                                                   raw_pwrite_stream &Out,
+                                                   raw_pwrite_stream *DwoOut,
+                                                   CodeGenFileType FileType,
+                                                   MCContext &Ctx) {
+  addModulePass(RequireAnalysisPass<MachineModuleAnalysis, Module>(), PMW,
+                /*Force=*/true);
+  addCodeGenPrepare(PMW);
+  flushFPMsToMPM(PMW);
+
+  switch (FileType) {
+  case CodeGenFileType::AssemblyFile:
+    addModulePass(DXILPrettyPrinterPass(Out), PMW, /*Force=*/true);
+    break;
+  case CodeGenFileType::ObjectFile:
+    if (CompletesPipeline) {
+      addModulePass(DXILEmbedderPass(), PMW, /*Force=*/true);
+      // We embed the other DXContainer globals after embedding DXIL so that the
+      // globals don't pollute the DXIL.
+      addModulePass(DXILContainerGlobalsPass(), PMW, /*Force=*/true);
+      addModulePass(DXILContainerPDBPass(), PMW, /*Force=*/true);
+
+      if (auto Err = registerAsmPrinter(MAM, Out, DwoOut, FileType, Ctx))
+        return Err;
+
+      addAsmPrinterBegin(PMW);
+      addAsmPrinter(PMW);
+      flushFPMsToMPM(PMW, /*FreeMachineFunctions=*/true);
+      addAsmPrinterEnd(PMW);
+    } else {
+      addModulePass(DXILWriterPass(Out), PMW, /*Force=*/true);
+    }
+    break;
+  case CodeGenFileType::Null:
+    break;
+  }
+
+  return Error::success();
+}
+
+void DirectXTargetMachine::registerPassBuilderCallbacks(PassBuilder &PB){
+#define GET_PASS_REGISTRY "DirectXPassRegistry.def"
+#include "llvm/Passes/TargetPassRegistry.inc"
+}
+
+Error DirectXTargetMachine::buildCodeGenPipeline(
+    ModulePassManager &MPM, ModuleAnalysisManager &MAM, raw_pwrite_stream &Out,
+    raw_pwrite_stream *DwoOut, CodeGenFileType FileType,
+    const CGPassBuilderOption &Opt, MCContext &Ctx,
+    PassInstrumentationCallbacks *PIC) {
+  auto CGPB = DirectXCodeGenPassBuilder(*this, Opt, PIC);
+  return CGPB.buildPipeline(MPM, MAM, Out, DwoOut, FileType, Ctx);
+}
diff --git a/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp b/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
index 13cfc1eef81ca..d9841bf0f9fb4 100644
--- a/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
+++ b/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
@@ -12,12 +12,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "DirectXTargetMachine.h"
-#include "DXILRootSignature.h"
-#include "DXILShaderFlags.h"
-#include "DXILSignatureAnalysis.h"
 #include "DXILWriter/DXILWriterPass.h"
 #include "DirectX.h"
-#include "DirectXAsmPrinter.h"
 #include "DirectXSubtarget.h"
 #include "DirectXTargetTransformInfo.h"
 #include "TargetInfo/DirectXTargetInfo.h"
@@ -155,11 +151,6 @@ DirectXTargetMachine::DirectXTargetMachine(const Target &T, const Triple &TT,
 
 DirectXTargetMachine::~DirectXTargetMachine() {}
 
-void DirectXTargetMachine::registerPassBuilderCallbacks(PassBuilder &PB) {
-#define GET_PASS_REGISTRY "DirectXPassRegistry.def"
-#include "llvm/Passes/TargetPassRegistry.inc"
-}
-
 bool DirectXTargetMachine::addPassesToEmitFile(
     PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
     CodeGenFileType FileType, bool DisableVerify,
diff --git a/llvm/lib/Target/DirectX/DirectXTargetMachine.h b/llvm/lib/Target/DirectX/DirectXTargetMachine.h
index 7ba80d2ba5de1..208a68fdd1708 100644
--- a/llvm/lib/Target/DirectX/DirectXTargetMachine.h
+++ b/llvm/lib/Target/DirectX/DirectXTargetMachine.h
@@ -47,7 +47,14 @@ class DirectXTargetMachine : public CodeGenTargetMachineImpl {
   }
 
   TargetTransformInfo getTargetTransformInfo(const Function &F) const override;
+
   void registerPassBuilderCallbacks(PassBuilder &PB) override;
+
+  Error buildCodeGenPipeline(ModulePassManager &MPM, ModuleAnalysisManager &MAM,
+                             raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
+                             CodeGenFileType FileType,
+                             const CGPassBuilderOption &Opt, MCContext &Ctx,
+                             PassInstrumentationCallbacks *PIC) override;
 };
 } // namespace llvm
 
diff --git a/llvm/test/CodeGen/DirectX/newpm-pipeline.ll b/llvm/test/CodeGen/DirectX/newpm-pipeline.ll
new file mode 100644
index 0000000000000..05ec46dfe5806
--- /dev/null
+++ b/llvm/test/CodeGen/DirectX/newpm-pipeline.ll
@@ -0,0 +1,42 @@
+; RUN: llc -enable-new-pm -mtriple=dxil-pc-shadermodel6.3-library -O0 -filetype=asm -print-pipeline-passes=tree < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=CHECK,SCALARIZE,ASM
+; RUN: llc -enable-new-pm -mtriple=dxil-pc-shadermodel6.3-library -O3 -filetype=asm -print-pipeline-passes=tree < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=CHECK,OPT,SCALARIZE,ASM
+; RUN: llc -enable-new-pm -mtriple=dxil-pc-shadermodel6.10-library -O3 -filetype=obj -print-pipeline-passes=tree < %s 2>&1 \
+; RUN:   | FileCheck %s --check-prefixes=CHECK,OPT,OBJ
+
+; CHECK: require<MachineModuleAnalysis>
+; CHECK-NEXT: function
+; CHECK-NEXT:   strip-convergence-intrinsics
+; CHECK-NEXT: dxil-finalize-linkage
+; OPT-NEXT: globaldce
+; CHECK-NEXT: dxil-mem-intrinsics
+; CHECK-NEXT: dxil-cbuffer-access
+; CHECK-NEXT: function
+; CHECK-NEXT:   dxil-remove-unused-resources
+; CHECK-NEXT:   dxil-resource-access
+; CHECK-NEXT: dxil-intrinsic-expansion
+; CHECK-NEXT: dxil-data-scalarization
+; SCALARIZE-NEXT: function
+; SCALARIZE-NEXT:   scalarizer
+; CHECK-NEXT: dxil-flatten-arrays
+; CHECK-NEXT: function
+; CHECK-NEXT:   dxil-forward-handle-accesses
+; OPT-NEXT:   dse
+; CHECK-NEXT:   dxil-legalize
+; CHECK-NEXT: dxil-resource-implicit-binding
+; CHECK-NEXT: dxil-translate-metadata
+; CHECK-NEXT: dxil-post-optimization-validation
+; CHECK-NEXT: dxil-op-lower
+; CHECK-NEXT: dxil-prepare-module
+; CHECK-NEXT: dxil-debug-info
+; ASM-NEXT: dxil-pretty-printer
+; OBJ-NEXT: dxil-embedder
+; OBJ-NEXT: dxil-container-globals
+; OBJ-NEXT: dxil-container-pdb
+; OBJ-NEXT: dxil-asm-printer-begin
+; OBJ-NEXT: function
+; OBJ-NEXT:   machine-function
+; OBJ-NEXT:     dxil-asm-printer
+; OBJ-NEXT:   free-machine-function
+; OBJ-NEXT: dxil-asm-printer-end

``````````

</details>


https://github.com/llvm/llvm-project/pull/244834


More information about the llvm-branch-commits mailing list