[llvm-branch-commits] [DirectX] Port DXContainerGlobals to NewPM (PR #238167)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Nov 2 16:53:01 PST 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-directx
Author: Aiden Grossman (boomanaiden154)
<details>
<summary>Changes</summary>
Standard NewPM pass porting. There are a lot of function_refs because
this pass uses a lot of Analyses. I don't think there is a cleaner way
to do this.
---
Full diff: https://github.com/llvm/llvm-project/pull/238167.diff
4 Files Affected:
- (modified) llvm/lib/Target/DirectX/DXContainerGlobals.cpp (+138-99)
- (modified) llvm/lib/Target/DirectX/DirectX.h (+8-2)
- (modified) llvm/lib/Target/DirectX/DirectXPassRegistry.def (+1)
- (modified) llvm/lib/Target/DirectX/DirectXTargetMachine.cpp (+2-2)
``````````diff
diff --git a/llvm/lib/Target/DirectX/DXContainerGlobals.cpp b/llvm/lib/Target/DirectX/DXContainerGlobals.cpp
index f3cff5494f858..88d31003d0f05 100644
--- a/llvm/lib/Target/DirectX/DXContainerGlobals.cpp
+++ b/llvm/lib/Target/DirectX/DXContainerGlobals.cpp
@@ -23,8 +23,10 @@
#include "llvm/Analysis/DXILResource.h"
#include "llvm/BinaryFormat/DXContainer.h"
#include "llvm/CodeGen/Passes.h"
+#include "llvm/IR/Analysis.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
#include "llvm/InitializePasses.h"
#include "llvm/MC/DXContainerInfo.h"
#include "llvm/MC/DXContainerPSVInfo.h"
@@ -49,29 +51,10 @@ cl::opt<bool> dxil::PdbInPrivate("dx-pdb-in-private",
cl::desc("Store PDB in private user data"));
namespace {
-class DXContainerGlobals : public llvm::ModulePass {
-
- GlobalVariable *buildContainerGlobal(Module &M, Constant *Content,
- StringRef Name, StringRef SectionName);
- void addSection(Module &M, SmallVector<GlobalValue *> &Globals,
- StringRef SectionData, StringRef MetadataName,
- StringRef SectionName);
- GlobalVariable *getFeatureFlags(Module &M);
- void computeShaderHashAndDebugName(Module &M,
- SmallVector<GlobalValue *> &Globals);
- GlobalVariable *buildSignature(Module &M, Signature &Sig, StringRef Name,
- StringRef SectionName);
- void addSignature(Module &M, SmallVector<GlobalValue *> &Globals);
- void addRootSignature(Module &M, SmallVector<GlobalValue *> &Globals);
- void addResourcesForPSV(Module &M, PSVRuntimeInfo &PSV);
- void addPipelineStateValidationInfo(Module &M,
- SmallVector<GlobalValue *> &Globals);
- void addCompilerVersion(Module &M, SmallVector<GlobalValue *> &Globals);
- void addSourceInfo(Module &M, SmallVector<GlobalValue *> &Globals);
-
+class DXContainerGlobalsLegacy : public ModulePass {
public:
static char ID; // Pass identification, replacement for typeid
- DXContainerGlobals() : ModulePass(ID) {}
+ DXContainerGlobalsLegacy() : ModulePass(ID) {}
StringRef getPassName() const override {
return "DXContainer Global Emitter";
@@ -92,43 +75,38 @@ class DXContainerGlobals : public llvm::ModulePass {
} // namespace
-bool DXContainerGlobals::runOnModule(Module &M) {
- llvm::SmallVector<GlobalValue *> Globals;
- Globals.push_back(getFeatureFlags(M));
- computeShaderHashAndDebugName(M, Globals);
- addSignature(M, Globals);
- addRootSignature(M, Globals);
- addPipelineStateValidationInfo(M, Globals);
- addCompilerVersion(M, Globals);
- addSourceInfo(M, Globals);
- appendToCompilerUsed(M, Globals);
- return true;
+static GlobalVariable *buildContainerGlobal(Module &M, Constant *Content,
+ StringRef Name,
+ StringRef SectionName) {
+ auto *GV = new llvm::GlobalVariable(
+ M, Content->getType(), true, GlobalValue::PrivateLinkage, Content, Name);
+ GV->setSection(SectionName);
+ GV->setAlignment(Align(4));
+ return GV;
}
-GlobalVariable *DXContainerGlobals::getFeatureFlags(Module &M) {
- uint64_t CombinedFeatureFlags = getAnalysis<ShaderFlagsAnalysisWrapper>()
- .getShaderFlags()
- .getCombinedFlags()
- .getFeatureFlags();
+static GlobalVariable *
+getFeatureFlags(Module &M,
+ function_ref<const ModuleShaderFlags &()> GetShaderFlags) {
+ uint64_t CombinedFeatureFlags =
+ GetShaderFlags().getCombinedFlags().getFeatureFlags();
Constant *FeatureFlagsConstant =
ConstantInt::get(M.getContext(), APInt(64, CombinedFeatureFlags));
return buildContainerGlobal(M, FeatureFlagsConstant, "dx.sfi0", "SFI0");
}
-void DXContainerGlobals::addSection(Module &M,
- SmallVector<GlobalValue *> &Globals,
- StringRef SectionData,
- StringRef MetadataName,
- StringRef SectionName) {
+static void addSection(Module &M, SmallVector<GlobalValue *> &Globals,
+ StringRef SectionData, StringRef MetadataName,
+ StringRef SectionName) {
Constant *SectionConstant = ConstantDataArray::getString(
M.getContext(), SectionData, /*AddNull*/ false);
Globals.emplace_back(
buildContainerGlobal(M, SectionConstant, MetadataName, SectionName));
}
-void DXContainerGlobals::computeShaderHashAndDebugName(
- Module &M, SmallVector<GlobalValue *> &Globals) {
+static void computeShaderHashAndDebugName(Module &M,
+ SmallVector<GlobalValue *> &Globals) {
ConstantDataArray *DXILConstant;
MD5 Digest;
dxbc::ShaderHash HashData = {0, {0}};
@@ -199,23 +177,12 @@ void DXContainerGlobals::computeShaderHashAndDebugName(
addSection(M, Globals, ILDNData, "dx.ildn", "ILDN");
}
-GlobalVariable *DXContainerGlobals::buildContainerGlobal(
- Module &M, Constant *Content, StringRef Name, StringRef SectionName) {
- auto *GV = new llvm::GlobalVariable(
- M, Content->getType(), true, GlobalValue::PrivateLinkage, Content, Name);
- GV->setSection(SectionName);
- GV->setAlignment(Align(4));
- return GV;
-}
-
-GlobalVariable *DXContainerGlobals::buildSignature(Module &M, Signature &Sig,
- StringRef Name,
- StringRef SectionName) {
+static GlobalVariable *buildSignature(Module &M, Signature &Sig, StringRef Name,
+ StringRef SectionName,
+ const dxil::ModuleMetadataInfo &MMI) {
SmallString<256> Data;
raw_svector_ostream OS(Data);
- VersionTuple V = getAnalysis<DXILMetadataAnalysisWrapperPass>()
- .getModuleMetadata()
- .ValidatorVersion;
+ VersionTuple V = MMI.ValidatorVersion;
bool Legacy = !V.empty() && V != VersionTuple(0, 0) && V < VersionTuple(1, 7);
Sig.write(OS, /*PadToDword=*/!Legacy);
Constant *Constant =
@@ -223,32 +190,33 @@ GlobalVariable *DXContainerGlobals::buildSignature(Module &M, Signature &Sig,
return buildContainerGlobal(M, Constant, Name, SectionName);
}
-void DXContainerGlobals::addSignature(Module &M,
- SmallVector<GlobalValue *> &Globals) {
- const auto &MMI =
- getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata();
- const auto &Signatures =
- getAnalysis<SignatureAnalysisWrapper>().getSignatureInfo();
+static void
+addSignature(Module &M, SmallVector<GlobalValue *> &Globals,
+ function_ref<dxil::ModuleMetadataInfo &()> GetModuleMetadataInfo,
+ function_ref<const ModuleSignatureInfo &()> GetSignatureInfo) {
+ const ModuleMetadataInfo &MMI = GetModuleMetadataInfo();
+ const ModuleSignatureInfo &Signatures = GetSignatureInfo();
Signature InputSig, OutputSig;
if (MMI.ShaderProfile != Triple::Library && MMI.EntryPropertyVec.size() == 1)
if (const auto *Sig = Signatures.get(MMI.EntryPropertyVec[0].Entry))
Sig->buildSignatures(InputSig, OutputSig, MMI.ValidatorVersion);
- Globals.emplace_back(buildSignature(M, InputSig, "dx.isg1", "ISG1"));
- Globals.emplace_back(buildSignature(M, OutputSig, "dx.osg1", "OSG1"));
+ Globals.emplace_back(buildSignature(M, InputSig, "dx.isg1", "ISG1", MMI));
+ Globals.emplace_back(buildSignature(M, OutputSig, "dx.osg1", "OSG1", MMI));
}
-void DXContainerGlobals::addRootSignature(Module &M,
- SmallVector<GlobalValue *> &Globals) {
+static void addRootSignature(
+ Module &M, SmallVector<GlobalValue *> &Globals,
+ function_ref<dxil::ModuleMetadataInfo &()> GetModuleMetadataInfo,
+ function_ref<RootSignatureBindingInfo &()> GetRootSignatureBindingInfo) {
- dxil::ModuleMetadataInfo &MMI =
- getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata();
+ dxil::ModuleMetadataInfo &MMI = GetModuleMetadataInfo();
// Root Signature in Library don't compile to DXContainer.
if (MMI.ShaderProfile == llvm::Triple::Library)
return;
- auto &RSA = getAnalysis<RootSignatureAnalysisWrapper>().getRSInfo();
+ RootSignatureBindingInfo &RSA = GetRootSignatureBindingInfo();
const Function *EntryFunction = nullptr;
if (MMI.ShaderProfile != llvm::Triple::RootSignature) {
@@ -268,11 +236,12 @@ void DXContainerGlobals::addRootSignature(Module &M,
addSection(M, Globals, Data, "dx.rts0", "RTS0");
}
-void DXContainerGlobals::addResourcesForPSV(Module &M, PSVRuntimeInfo &PSV) {
- const DXILResourceMap &DRM =
- getAnalysis<DXILResourceWrapperPass>().getResourceMap();
- DXILResourceTypeMap &DRTM =
- getAnalysis<DXILResourceTypeWrapperPass>().getResourceTypeMap();
+static void
+addResourcesForPSV(Module &M, PSVRuntimeInfo &PSV,
+ function_ref<DXILResourceMap &()> GetResourceMap,
+ function_ref<DXILResourceTypeMap &()> GetResourceTypeMap) {
+ const DXILResourceMap &DRM = GetResourceMap();
+ DXILResourceTypeMap &DRTM = GetResourceTypeMap();
auto MakeBinding =
[](const dxil::ResourceInfo::ResourceBinding &Binding,
@@ -350,34 +319,34 @@ void DXContainerGlobals::addResourcesForPSV(Module &M, PSVRuntimeInfo &PSV) {
}
}
-void DXContainerGlobals::addPipelineStateValidationInfo(
- Module &M, SmallVector<GlobalValue *> &Globals) {
+static void addPipelineStateValidationInfo(
+ Module &M, SmallVector<GlobalValue *> &Globals,
+ function_ref<dxil::ModuleMetadataInfo &()> GetModuleMetadataInfo,
+ function_ref<DXILResourceMap &()> GetResourceMap,
+ function_ref<DXILResourceTypeMap &()> GetResourceTypeMap,
+ function_ref<const ModuleShaderFlags &()> GetModuleShaderFlags,
+ function_ref<const ModuleSignatureInfo &()> GetModuleSignatureInfo) {
SmallString<256> Data;
raw_svector_ostream OS(Data);
PSVRuntimeInfo PSV;
PSV.BaseData.MinimumWaveLaneCount = 0;
PSV.BaseData.MaximumWaveLaneCount = std::numeric_limits<uint32_t>::max();
- dxil::ModuleMetadataInfo &MMI =
- getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata();
+ dxil::ModuleMetadataInfo &MMI = GetModuleMetadataInfo();
assert(MMI.EntryPropertyVec.size() == 1 ||
MMI.ShaderProfile == Triple::Library ||
MMI.ShaderProfile == Triple::RootSignature);
PSV.BaseData.ShaderStage =
static_cast<uint8_t>(MMI.ShaderProfile - Triple::Pixel);
- addResourcesForPSV(M, PSV);
+ addResourcesForPSV(M, PSV, GetResourceMap, GetResourceTypeMap);
unsigned PSVVersion = 3;
if (MMI.ShaderProfile != Triple::Library &&
MMI.EntryPropertyVec.size() == 1) {
const Function *Entry = MMI.EntryPropertyVec[0].Entry;
- bool UsesViewID = getAnalysis<ShaderFlagsAnalysisWrapper>()
- .getShaderFlags()
- .getFunctionFlags(Entry)
- .ViewID;
+ bool UsesViewID = GetModuleShaderFlags().getFunctionFlags(Entry).ViewID;
PSV.BaseData.UsesViewID = UsesViewID;
- const auto &Signatures =
- getAnalysis<SignatureAnalysisWrapper>().getSignatureInfo();
+ const ModuleSignatureInfo &Signatures = GetModuleSignatureInfo();
if (const auto *Sig = Signatures.get(Entry)) {
Sig->updatePSV(PSV, MMI.ValidatorVersion, UsesViewID);
// Preserve the existing empty-signature path, and select an ABI version
@@ -423,8 +392,7 @@ void DXContainerGlobals::addPipelineStateValidationInfo(
addSection(M, Globals, Data, "dx.psv0", "PSV0");
}
-void DXContainerGlobals::addCompilerVersion(
- Module &M, SmallVector<GlobalValue *> &Globals) {
+static void addCompilerVersion(Module &M, SmallVector<GlobalValue *> &Globals) {
if (M.debug_compile_units().empty())
return;
@@ -435,10 +403,10 @@ void DXContainerGlobals::addCompilerVersion(
addSection(M, Globals, Data, "dx.vers", "VERS");
}
-void DXContainerGlobals::addSourceInfo(Module &M,
- SmallVector<GlobalValue *> &Globals) {
- dxil::ModuleMetadataInfo &MMI =
- getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata();
+static void addSourceInfo(
+ Module &M, SmallVector<GlobalValue *> &Globals,
+ function_ref<dxil::ModuleMetadataInfo &()> GetModuleMetadataInfo) {
+ dxil::ModuleMetadataInfo &MMI = GetModuleMetadataInfo();
if (!MMI.SourceInfo || SourceInDebugModule)
return;
@@ -451,17 +419,88 @@ void DXContainerGlobals::addSourceInfo(Module &M,
addSection(M, Globals, Data, "dx.srci", "SRCI");
}
-char DXContainerGlobals::ID = 0;
-INITIALIZE_PASS_BEGIN(DXContainerGlobals, "dxil-globals",
+static bool runContainerGlobalsOnModule(
+ Module &M, function_ref<dxil::ModuleMetadataInfo &()> GetModuleMetadataInfo,
+ function_ref<DXILResourceMap &()> GetResourceMap,
+ function_ref<DXILResourceTypeMap &()> GetResourceTypeMap,
+ function_ref<const ModuleShaderFlags &()> GetModuleShaderFlags,
+ function_ref<const ModuleSignatureInfo &()> GetModuleSignatureInfo,
+ function_ref<RootSignatureBindingInfo &()> GetRootSignatureBindingInfo) {
+ llvm::SmallVector<GlobalValue *> Globals;
+ Globals.push_back(getFeatureFlags(M, GetModuleShaderFlags));
+ computeShaderHashAndDebugName(M, Globals);
+ addSignature(M, Globals, GetModuleMetadataInfo, GetModuleSignatureInfo);
+ addRootSignature(M, Globals, GetModuleMetadataInfo,
+ GetRootSignatureBindingInfo);
+ addPipelineStateValidationInfo(M, Globals, GetModuleMetadataInfo,
+ GetResourceMap, GetResourceTypeMap,
+ GetModuleShaderFlags, GetModuleSignatureInfo);
+ addCompilerVersion(M, Globals);
+ addSourceInfo(M, Globals, GetModuleMetadataInfo);
+ appendToCompilerUsed(M, Globals);
+ return true;
+}
+
+bool DXContainerGlobalsLegacy::runOnModule(Module &M) {
+ return runContainerGlobalsOnModule(
+ M,
+ [&]() -> ModuleMetadataInfo & {
+ return getAnalysis<DXILMetadataAnalysisWrapperPass>()
+ .getModuleMetadata();
+ },
+ [&]() -> DXILResourceMap & {
+ return getAnalysis<DXILResourceWrapperPass>().getResourceMap();
+ },
+ [&]() -> DXILResourceTypeMap & {
+ return getAnalysis<DXILResourceTypeWrapperPass>().getResourceTypeMap();
+ },
+ [&]() -> const ModuleShaderFlags & {
+ return getAnalysis<ShaderFlagsAnalysisWrapper>().getShaderFlags();
+ },
+ [&]() -> const ModuleSignatureInfo & {
+ return getAnalysis<SignatureAnalysisWrapper>().getSignatureInfo();
+ },
+ [&]() -> RootSignatureBindingInfo & {
+ return getAnalysis<RootSignatureAnalysisWrapper>().getRSInfo();
+ });
+}
+
+PreservedAnalyses DXContainerGlobalsPass::run(Module &M,
+ ModuleAnalysisManager &MAM) {
+ runContainerGlobalsOnModule(
+ M,
+ [&]() -> ModuleMetadataInfo & {
+ return MAM.getResult<DXILMetadataAnalysis>(M);
+ },
+ [&]() -> DXILResourceMap & {
+ return MAM.getResult<DXILResourceAnalysis>(M);
+ },
+ [&]() -> DXILResourceTypeMap & {
+ return MAM.getResult<DXILResourceTypeAnalysis>(M);
+ },
+ [&]() -> const ModuleShaderFlags & {
+ return MAM.getResult<ShaderFlagsAnalysis>(M);
+ },
+ [&]() -> const ModuleSignatureInfo & {
+ return MAM.getResult<SignatureAnalysis>(M);
+ },
+ [&]() -> RootSignatureBindingInfo & {
+ return MAM.getResult<RootSignatureAnalysis>(M);
+ });
+ return PreservedAnalyses::all();
+}
+
+char DXContainerGlobalsLegacy::ID = 0;
+INITIALIZE_PASS_BEGIN(DXContainerGlobalsLegacy, "dxil-globals",
"DXContainer Global Emitter", false, true)
INITIALIZE_PASS_DEPENDENCY(ShaderFlagsAnalysisWrapper)
INITIALIZE_PASS_DEPENDENCY(SignatureAnalysisWrapper)
INITIALIZE_PASS_DEPENDENCY(DXILMetadataAnalysisWrapperPass)
INITIALIZE_PASS_DEPENDENCY(DXILResourceTypeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(DXILResourceWrapperPass)
-INITIALIZE_PASS_END(DXContainerGlobals, "dxil-globals",
+INITIALIZE_PASS_END(DXContainerGlobalsLegacy, "dxil-globals",
"DXContainer Global Emitter", false, true)
-ModulePass *llvm::createDXContainerGlobalsPass() {
- return new DXContainerGlobals();
+ModulePass *llvm::createDXContainerGlobalsLegacyPass() {
+ return new DXContainerGlobalsLegacy();
}
diff --git a/llvm/lib/Target/DirectX/DirectX.h b/llvm/lib/Target/DirectX/DirectX.h
index 537681a6d1d91..d33dd8b97a919 100644
--- a/llvm/lib/Target/DirectX/DirectX.h
+++ b/llvm/lib/Target/DirectX/DirectX.h
@@ -255,10 +255,16 @@ void initializeRootSignatureAnalysisWrapperPass(PassRegistry &);
void initializeSignatureAnalysisWrapperPass(PassRegistry &);
/// Initializer for DXContainerGlobals pass.
-void initializeDXContainerGlobalsPass(PassRegistry &);
+void initializeDXContainerGlobalsLegacyPass(PassRegistry &);
/// Pass for generating DXContainer part globals.
-ModulePass *createDXContainerGlobalsPass();
+class DXContainerGlobalsPass
+ : public RequiredPassInfoMixin<DXContainerGlobalsPass> {
+public:
+ PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
+};
+
+ModulePass *createDXContainerGlobalsLegacyPass();
/// Initializer for DXContainerPDB pass.
void initializeDXContainerPDBPass(PassRegistry &);
diff --git a/llvm/lib/Target/DirectX/DirectXPassRegistry.def b/llvm/lib/Target/DirectX/DirectXPassRegistry.def
index 6e140e5a8f8f5..3da41c3dc7dda 100644
--- a/llvm/lib/Target/DirectX/DirectXPassRegistry.def
+++ b/llvm/lib/Target/DirectX/DirectXPassRegistry.def
@@ -24,6 +24,7 @@ MODULE_ANALYSIS("dxil-signature-analysis", dxil::SignatureAnalysis())
#ifndef MODULE_PASS
#define MODULE_PASS(NAME, CREATE_PASS)
#endif
+MODULE_PASS("dx-container-globals", DXContainerGlobalsPass())
MODULE_PASS("dxil-cbuffer-access", DXILCBufferAccessPass())
MODULE_PASS("dxil-finalize-linkage", DXILFinalizeLinkagePass())
MODULE_PASS("dxil-data-scalarization", DXILDataScalarizationPass())
diff --git a/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp b/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
index 433f4ba81ffd0..6fa23113d1393 100644
--- a/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
+++ b/llvm/lib/Target/DirectX/DirectXTargetMachine.cpp
@@ -58,7 +58,7 @@ LLVMInitializeDirectXTarget() {
initializeDXILPrepareModuleLegacyPass(*PR);
initializeEmbedDXILPassPass(*PR);
initializeWriteDXILPassPass(*PR);
- initializeDXContainerGlobalsPass(*PR);
+ initializeDXContainerGlobalsLegacyPass(*PR);
initializeDXContainerPDBPass(*PR);
initializeGlobalDCELegacyPassPass(*PR);
initializeDXILOpLoweringLegacyPass(*PR);
@@ -182,7 +182,7 @@ bool DirectXTargetMachine::addPassesToEmitFile(
PM.add(createDXILEmbedderPass());
// We embed the other DXContainer globals after embedding DXIL so that the
// globals don't pollute the DXIL.
- PM.add(createDXContainerGlobalsPass());
+ PM.add(createDXContainerGlobalsLegacyPass());
PM.add(createDXContainerPDBPass());
if (addAsmPrinter(PM, Out, DwoOut, FileType,
``````````
</details>
https://github.com/llvm/llvm-project/pull/238167
More information about the llvm-branch-commits
mailing list