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 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
