From 628503e4d4e5896badec12beb71bbef923ef1d29 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Tue, 6 Jan 2015 02:10:51 +0000 Subject: [PATCH] [PM] Add a utility to the new pass manager for generating a pass which is a no-op other than requiring some analysis results be available. This can be used in real pass pipelines to force the usually lazy analysis running to eagerly compute something at a specific point, and it can be used to test the pass manager infrastructure (my primary use at the moment). I've also added bit of pipeline parsing magic to support generating these directly from the opt command so that you can directly use these when debugging your analysis. The syntax is: require This can be used at any level of the pass manager. For example: cgscc(function(require,no-op-function)) This would produce a no-op function pass requiring my-analysis, followed by a fully no-op function pass, both of these in a function pass manager which is nested inside of a bottom-up CGSCC pass manager which is in the top-level (implicit) module pass manager. I have zero attachment to the particular syntax I'm using here. Consider it a straw man for use while I'm testing and fleshing things out. Suggestions for better syntax welcome, and I'll update everything based on any consensus that develops. I've used this new functionality to more directly test the analysis printing rather than relying on the cgscc pass manager running an analysis for me. This is still minimally tested because I need to have analyses to run first! ;] That patch is next, but wanted to keep this one separate for easier review and discussion. llvm-svn: 225236 --- llvm/include/llvm/IR/PassManager.h | 22 +++++++++++++++ llvm/test/Other/new-pass-manager.ll | 6 ++--- llvm/tools/opt/Passes.cpp | 42 +++++++++++++++++++++++++++++ 3 files changed, 66 insertions(+), 4 deletions(-) diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h index 59855b5fc91c..c1025434cc7b 100644 --- a/llvm/include/llvm/IR/PassManager.h +++ b/llvm/include/llvm/IR/PassManager.h @@ -769,6 +769,28 @@ createModuleToFunctionPassAdaptor(FunctionPassT Pass) { return std::move(ModuleToFunctionPassAdaptor(std::move(Pass))); } +/// \brief A template utility pass to force an analysis result to be available. +/// +/// This is a no-op pass which simply forces a specific analysis pass's result +/// to be available when it is run. +template struct NoopAnalysisRequirementPass { + /// \brief Run this pass over some unit of IR. + /// + /// This pass can be run over any unit of IR and use any analysis manager + /// provided they satisfy the basic API requirements. When this pass is + /// created, these methods can be instantiated to satisfy whatever the + /// context requires. + template + PreservedAnalyses run(T &&Arg, AnalysisManagerT *AM) { + if (AM) + (void)AM->template getResult(std::forward(Arg)); + + return PreservedAnalyses::all(); + } + + static StringRef name() { return "No-op Analysis Requirement Pass"; } +}; + } #endif diff --git a/llvm/test/Other/new-pass-manager.ll b/llvm/test/Other/new-pass-manager.ll index bb338d42253a..9c1f46929ff5 100644 --- a/llvm/test/Other/new-pass-manager.ll +++ b/llvm/test/Other/new-pass-manager.ll @@ -86,13 +86,11 @@ ; CHECK-NO-VERIFY-NOT: VerifierPass ; CHECK-NO-VERIFY: Finished module pass manager -; RUN: opt -disable-output -debug-pass-manager -debug-cgscc-pass-manager -passes='cgscc(no-op-cgscc)' %s 2>&1 \ +; RUN: opt -disable-output -debug-pass-manager -passes='require' %s 2>&1 \ ; RUN: | FileCheck %s --check-prefix=CHECK-LCG-ANALYSIS ; CHECK-LCG-ANALYSIS: Starting module pass manager -; CHECK-LCG-ANALYSIS: Running module pass: ModuleToPostOrderCGSCCPassAdaptor -; CHECK-LCG-ANALYSIS: Running module analysis: CGSCCAnalysisManagerModuleProxy +; CHECK-LCG-ANALYSIS: Running module pass: No-op Analysis Requirement Pass ; CHECK-LCG-ANALYSIS: Running module analysis: Lazy CallGraph Analysis -; CHECK-LCG-ANALYSIS: Starting CGSCC pass manager run. ; Make sure no-op passes that preserve all analyses don't even try to do any ; analysis invalidation. diff --git a/llvm/tools/opt/Passes.cpp b/llvm/tools/opt/Passes.cpp index 6ac044a0d05b..d20becbe5eab 100644 --- a/llvm/tools/opt/Passes.cpp +++ b/llvm/tools/opt/Passes.cpp @@ -54,6 +54,12 @@ static bool isModulePassName(StringRef Name) { #define MODULE_PASS(NAME, CREATE_PASS) if (Name == NAME) return true; #include "PassRegistry.def" + // We also support building a require pass around any analysis. +#define MODULE_ANALYSIS(NAME, CREATE_PASS) \ + if (Name == "require<" NAME ">") \ + return true; +#include "PassRegistry.def" + return false; } @@ -63,6 +69,12 @@ static bool isCGSCCPassName(StringRef Name) { #define CGSCC_PASS(NAME, CREATE_PASS) if (Name == NAME) return true; #include "PassRegistry.def" + // We also support building a require pass around any analysis. +#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ + if (Name == "require<" NAME ">") \ + return true; +#include "PassRegistry.def" + return false; } @@ -72,6 +84,12 @@ static bool isFunctionPassName(StringRef Name) { #define FUNCTION_PASS(NAME, CREATE_PASS) if (Name == NAME) return true; #include "PassRegistry.def" + // We also support building a require pass around any analysis. +#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ + if (Name == "require<" NAME ">") \ + return true; +#include "PassRegistry.def" + return false; } @@ -88,6 +106,14 @@ static bool parseModulePassName(ModulePassManager &MPM, StringRef Name) { } #include "PassRegistry.def" + // We also support building a require pass around any analysis. +#define MODULE_ANALYSIS(NAME, CREATE_PASS) \ + if (Name == "require<" NAME ">") { \ + MPM.addPass(NoopAnalysisRequirementPass()); \ + return true; \ + } +#include "PassRegistry.def" + return false; } @@ -104,6 +130,14 @@ static bool parseCGSCCPassName(CGSCCPassManager &CGPM, StringRef Name) { } #include "PassRegistry.def" + // We also support building a require pass around any analysis. +#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ + if (Name == "require<" NAME ">") { \ + CGPM.addPass(NoopAnalysisRequirementPass()); \ + return true; \ + } +#include "PassRegistry.def" + return false; } @@ -120,6 +154,14 @@ static bool parseFunctionPassName(FunctionPassManager &FPM, StringRef Name) { } #include "PassRegistry.def" + // We also support building a require pass around any analysis. +#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ + if (Name == "require<" NAME ">") { \ + FPM.addPass(NoopAnalysisRequirementPass()); \ + return true; \ + } +#include "PassRegistry.def" + return false; }