Index: include/llvm/Analysis/AliasAnalysis.h =================================================================== --- include/llvm/Analysis/AliasAnalysis.h +++ include/llvm/Analysis/AliasAnalysis.h @@ -966,35 +966,46 @@ // This type hase value semantics. We have to spell these out because MSVC // won't synthesize them. AAManager() {} - AAManager(AAManager &&Arg) - : FunctionResultGetters(std::move(Arg.FunctionResultGetters)) {} - AAManager(const AAManager &Arg) - : FunctionResultGetters(Arg.FunctionResultGetters) {} + AAManager(AAManager &&Arg) : ResultGetters(std::move(Arg.ResultGetters)) {} + AAManager(const AAManager &Arg) : ResultGetters(Arg.ResultGetters) {} AAManager &operator=(AAManager &&RHS) { - FunctionResultGetters = std::move(RHS.FunctionResultGetters); + ResultGetters = std::move(RHS.ResultGetters); return *this; } AAManager &operator=(const AAManager &RHS) { - FunctionResultGetters = RHS.FunctionResultGetters; + ResultGetters = RHS.ResultGetters; return *this; } /// Register a specific AA result. template void registerFunctionAnalysis() { - FunctionResultGetters.push_back(&getFunctionAAResultImpl); + ResultGetters.push_back(&getFunctionAAResultImpl); } - Result run(Function &F, AnalysisManager &AM) { + /// Register a specific AA result. + template void registerModuleAnalysis() { + ResultGetters.push_back(&getModuleAAResultImpl); + } + + /// \brief Opaque, unique identifier for this analysis pass. + static void *ID() { return (void *)&PassID; } + + Result run(Function &F, AnalysisManager *AM) { Result R; - for (auto &Getter : FunctionResultGetters) - (*Getter)(F, AM, R); + for (auto &Getter : ResultGetters) + (*Getter)(F, *AM, R); return R; } + /// \brief Provide access to a name for this pass for debugging purposes. + static StringRef name() { return "AAManager"; } + private: + static char PassID; + SmallVector &AM, AAResults &AAResults), - 4> FunctionResultGetters; + 4> ResultGetters; template static void getFunctionAAResultImpl(Function &F, @@ -1002,6 +1013,15 @@ AAResults &AAResults) { AAResults.addAAResult(AM.template getResult(F)); } + + template + static void getModuleAAResultImpl(Function &F, AnalysisManager &AM, + AAResults &AAResults) { + auto &MAM = + AM.getResult(F).getManager(); + if (auto *R = MAM.template getCachedResult(*F.getParent())) + AAResults.addAAResult(*R); + } }; /// A wrapper pass to provide the legacy pass manager access to a suitably Index: include/llvm/Analysis/AliasAnalysisEvaluator.h =================================================================== --- /dev/null +++ include/llvm/Analysis/AliasAnalysisEvaluator.h @@ -0,0 +1,67 @@ +//===- AliasAnalysisEvaluator.h - Alias Analysis Accuracy Evaluator -------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements a simple N^2 alias analysis accuracy evaluator. +// Basically, for each function in the program, it simply queries to see how the +// alias analysis implementation answers alias queries between each pair of +// pointers in the function. +// +// This is inspired and adapted from code by: Naveen Neelakantam, Francesco +// Spadini, and Wojciech Stryjewski. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_ANALYSIS_ALIASANALYSISEVALUATOR_H +#define LLVM_ANALYSIS_ALIASANALYSISEVALUATOR_H + +#include "llvm/IR/Function.h" +#include "llvm/IR/PassManager.h" + +namespace llvm { +class AAResults; + +class AAEvaluator { + int64_t FunctionCount; + int64_t NoAliasCount, MayAliasCount, PartialAliasCount, MustAliasCount; + int64_t NoModRefCount, ModCount, RefCount, ModRefCount; + +public: + AAEvaluator() + : FunctionCount(), NoAliasCount(), MayAliasCount(), PartialAliasCount(), + MustAliasCount(), NoModRefCount(), ModCount(), RefCount(), + ModRefCount() {} + AAEvaluator(AAEvaluator &&Arg) + : FunctionCount(Arg.FunctionCount), NoAliasCount(Arg.NoAliasCount), + MayAliasCount(Arg.MayAliasCount), + PartialAliasCount(Arg.PartialAliasCount), + MustAliasCount(Arg.MustAliasCount), NoModRefCount(Arg.NoModRefCount), + ModCount(Arg.ModCount), RefCount(Arg.RefCount), + ModRefCount(Arg.ModRefCount) { + Arg.FunctionCount = 0; + } + ~AAEvaluator(); + + static StringRef name() { return "AAEvaluator"; } + + /// \brief Run the pass over the function. + PreservedAnalyses run(Function &F, AnalysisManager *AM); + +private: + // Allow the legacy pass to run this using an internal API. + friend class AAEvalLegacyPass; + + void runInternal(Function &F, AAResults &AA); +}; + +/// Create a wrapper of the above for the legacy pass manager. +FunctionPass *createAAEvalPass(); + +} + +#endif Index: include/llvm/Analysis/CFLAliasAnalysis.h =================================================================== --- include/llvm/Analysis/CFLAliasAnalysis.h +++ include/llvm/Analysis/CFLAliasAnalysis.h @@ -34,6 +34,7 @@ public: explicit CFLAAResult(const TargetLibraryInfo &TLI); CFLAAResult(CFLAAResult &&Arg); + ~CFLAAResult(); /// Handle invalidation events from the new pass manager. /// Index: include/llvm/Analysis/GlobalsModRef.h =================================================================== --- include/llvm/Analysis/GlobalsModRef.h +++ include/llvm/Analysis/GlobalsModRef.h @@ -71,6 +71,7 @@ public: GlobalsAAResult(GlobalsAAResult &&Arg); + ~GlobalsAAResult(); static GlobalsAAResult analyzeModule(Module &M, const TargetLibraryInfo &TLI, CallGraph &CG); Index: include/llvm/Analysis/Passes.h =================================================================== --- include/llvm/Analysis/Passes.h +++ include/llvm/Analysis/Passes.h @@ -25,13 +25,6 @@ //===--------------------------------------------------------------------===// // - // createAAEvalPass - This pass implements a simple N^2 alias analysis - // accuracy evaluator. - // - FunctionPass *createAAEvalPass(); - - //===--------------------------------------------------------------------===// - // // createObjCARCAAWrapperPass - This pass implements ObjC-ARC-based // alias analysis. // Index: include/llvm/InitializePasses.h =================================================================== --- include/llvm/InitializePasses.h +++ include/llvm/InitializePasses.h @@ -59,7 +59,7 @@ /// initializeCodeGen - Initialize all passes linked into the CodeGen library. void initializeTarget(PassRegistry&); -void initializeAAEvalPass(PassRegistry&); +void initializeAAEvalLegacyPassPass(PassRegistry&); void initializeAddDiscriminatorsPass(PassRegistry&); void initializeADCEPass(PassRegistry&); void initializeBDCEPass(PassRegistry&); Index: include/llvm/LinkAllPasses.h =================================================================== --- include/llvm/LinkAllPasses.h +++ include/llvm/LinkAllPasses.h @@ -17,6 +17,7 @@ #include "llvm/ADT/Statistic.h" #include "llvm/Analysis/AliasSetTracker.h" +#include "llvm/Analysis/AliasAnalysisEvaluator.h" #include "llvm/Analysis/BasicAliasAnalysis.h" #include "llvm/Analysis/CFLAliasAnalysis.h" #include "llvm/Analysis/CallPrinter.h" Index: include/llvm/Passes/PassBuilder.h =================================================================== --- include/llvm/Passes/PassBuilder.h +++ include/llvm/Passes/PassBuilder.h @@ -17,6 +17,7 @@ #define LLVM_PASSES_PASSBUILDER_H #include "llvm/ADT/StringRef.h" +#include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/CGSCCPassManager.h" #include "llvm/IR/PassManager.h" @@ -54,7 +55,22 @@ /// This is an interface that can be used to populate a \c /// FunctionAnalysisManager with all registered function analyses. Callers can /// still manually register any additional analyses. - void registerFunctionAnalyses(FunctionAnalysisManager &FAM); + void registerFunctionAnalyses(FunctionAnalysisManager &FAM, + AAManager AAM = AAManager()); + + /// Parse a textual list of alias analyses and register them. + /// + /// This parses names of alias analyses out of a textual string and registers + /// them with the provided \c AAManager object. If they are not function + /// analyses, then they must be manually scheduled so that their cached + /// results are available when the \c AAManager is queried. + /// + /// The format of the string is a comma separated list of the alias analysis + /// names. The alias analyses are added (and eventually, queried) in the + /// order they appear in the string. + /// + /// Returns true if the string parsed successfully. + bool parseAliasAnalyses(AAManager &AAM, StringRef AAText); /// \brief Parse a textual pass pipeline description into a \c ModulePassManager. /// Index: lib/Analysis/AliasAnalysis.cpp =================================================================== --- lib/Analysis/AliasAnalysis.cpp +++ lib/Analysis/AliasAnalysis.cpp @@ -364,13 +364,15 @@ // Provide a definition for the root virtual destructor. AAResults::Concept::~Concept() {} +char AAManager::PassID; + AAResultsWrapperPass::AAResultsWrapperPass() : FunctionPass(ID) { initializeAAResultsWrapperPassPass(*PassRegistry::getPassRegistry()); } char AAResultsWrapperPass::ID = 0; -INITIALIZE_PASS_BEGIN(AAResultsWrapperPass, "aa", +INITIALIZE_PASS_BEGIN(AAResultsWrapperPass, "aa-wrapper", "Function Alias Analysis Results", false, true) INITIALIZE_PASS_DEPENDENCY(BasicAAWrapperPass) INITIALIZE_PASS_DEPENDENCY(CFLAAWrapperPass) @@ -379,7 +381,7 @@ INITIALIZE_PASS_DEPENDENCY(SCEVAAWrapperPass) INITIALIZE_PASS_DEPENDENCY(ScopedNoAliasAAWrapperPass) INITIALIZE_PASS_DEPENDENCY(TypeBasedAAWrapperPass) -INITIALIZE_PASS_END(AAResultsWrapperPass, "aa", +INITIALIZE_PASS_END(AAResultsWrapperPass, "aa-wrapper", "Function Alias Analysis Results", false, true) FunctionPass *llvm::createAAResultsWrapperPass() { Index: lib/Analysis/AliasAnalysisEvaluator.cpp =================================================================== --- lib/Analysis/AliasAnalysisEvaluator.cpp +++ lib/Analysis/AliasAnalysisEvaluator.cpp @@ -6,18 +6,8 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -// -// This file implements a simple N^2 alias analysis accuracy evaluator. -// Basically, for each function in the program, it simply queries to see how the -// alias analysis implementation answers alias queries between each pair of -// pointers in the function. -// -// This is inspired and adapted from code by: Naveen Neelakantam, Francesco -// Spadini, and Wojciech Stryjewski. -// -//===----------------------------------------------------------------------===// -#include "llvm/Analysis/Passes.h" +#include "llvm/Analysis/AliasAnalysisEvaluator.h" #include "llvm/ADT/SetVector.h" #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/IR/Constants.h" @@ -47,51 +37,9 @@ static cl::opt EvalAAMD("evaluate-aa-metadata", cl::ReallyHidden); -namespace { - class AAEval : public FunctionPass { - unsigned NoAliasCount, MayAliasCount, PartialAliasCount, MustAliasCount; - unsigned NoModRefCount, ModCount, RefCount, ModRefCount; - - public: - static char ID; // Pass identification, replacement for typeid - AAEval() : FunctionPass(ID) { - initializeAAEvalPass(*PassRegistry::getPassRegistry()); - } - - void getAnalysisUsage(AnalysisUsage &AU) const override { - AU.addRequired(); - AU.setPreservesAll(); - } - - bool doInitialization(Module &M) override { - NoAliasCount = MayAliasCount = PartialAliasCount = MustAliasCount = 0; - NoModRefCount = ModCount = RefCount = ModRefCount = 0; - - if (PrintAll) { - PrintNoAlias = PrintMayAlias = true; - PrintPartialAlias = PrintMustAlias = true; - PrintNoModRef = PrintMod = PrintRef = PrintModRef = true; - } - return false; - } - - bool runOnFunction(Function &F) override; - bool doFinalization(Module &M) override; - }; -} - -char AAEval::ID = 0; -INITIALIZE_PASS_BEGIN(AAEval, "aa-eval", - "Exhaustive Alias Analysis Precision Evaluator", false, true) -INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) -INITIALIZE_PASS_END(AAEval, "aa-eval", - "Exhaustive Alias Analysis Precision Evaluator", false, true) - -FunctionPass *llvm::createAAEvalPass() { return new AAEval(); } - static void PrintResults(const char *Msg, bool P, const Value *V1, const Value *V2, const Module *M) { - if (P) { + if (PrintAll || P) { std::string o1, o2; { raw_string_ostream os1(o1), os2(o2); @@ -110,7 +58,7 @@ static inline void PrintModRefResults(const char *Msg, bool P, Instruction *I, Value *Ptr, Module *M) { - if (P) { + if (PrintAll || P) { errs() << " " << Msg << ": Ptr: "; Ptr->printAsOperand(errs(), true, M); errs() << "\t<->" << *I << '\n'; @@ -120,7 +68,7 @@ static inline void PrintModRefResults(const char *Msg, bool P, CallSite CSA, CallSite CSB, Module *M) { - if (P) { + if (PrintAll || P) { errs() << " " << Msg << ": " << *CSA.getInstruction() << " <-> " << *CSB.getInstruction() << '\n'; } @@ -129,7 +77,7 @@ static inline void PrintLoadStoreResults(const char *Msg, bool P, const Value *V1, const Value *V2, const Module *M) { - if (P) { + if (PrintAll || P) { errs() << " " << Msg << ": " << *V1 << " <-> " << *V2 << '\n'; } @@ -140,9 +88,15 @@ && !isa(V); } -bool AAEval::runOnFunction(Function &F) { +PreservedAnalyses AAEvaluator::run(Function &F, AnalysisManager *AM) { + runInternal(F, AM->getResult(F)); + return PreservedAnalyses::all(); +} + +void AAEvaluator::runInternal(Function &F, AAResults &AA) { const DataLayout &DL = F.getParent()->getDataLayout(); - AliasAnalysis &AA = getAnalysis().getAAResults(); + + ++FunctionCount; SetVector Pointers; SetVector CallSites; @@ -181,8 +135,8 @@ } } - if (PrintNoAlias || PrintMayAlias || PrintPartialAlias || PrintMustAlias || - PrintNoModRef || PrintMod || PrintRef || PrintModRef) + if (PrintAll || PrintNoAlias || PrintMayAlias || PrintPartialAlias || + PrintMustAlias || PrintNoModRef || PrintMod || PrintRef || PrintModRef) errs() << "Function: " << F.getName() << ": " << Pointers.size() << " pointers, " << CallSites.size() << " call sites\n"; @@ -341,17 +295,18 @@ } } } - - return false; } -static void PrintPercent(unsigned Num, unsigned Sum) { - errs() << "(" << Num*100ULL/Sum << "." - << ((Num*1000ULL/Sum) % 10) << "%)\n"; +static void PrintPercent(int64_t Num, int64_t Sum) { + errs() << "(" << Num * 100LL / Sum << "." << ((Num * 1000LL / Sum) % 10) + << "%)\n"; } -bool AAEval::doFinalization(Module &M) { - unsigned AliasSum = +AAEvaluator::~AAEvaluator() { + if (FunctionCount == 0) + return; + + int64_t AliasSum = NoAliasCount + MayAliasCount + PartialAliasCount + MustAliasCount; errs() << "===== Alias Analysis Evaluator Report =====\n"; if (AliasSum == 0) { @@ -374,7 +329,7 @@ } // Display the summary for mod/ref analysis - unsigned ModRefSum = NoModRefCount + ModCount + RefCount + ModRefCount; + int64_t ModRefSum = NoModRefCount + ModCount + RefCount + ModRefCount; if (ModRefSum == 0) { errs() << " Alias Analysis Mod/Ref Evaluator Summary: no " "mod/ref!\n"; @@ -393,6 +348,46 @@ << ModCount * 100 / ModRefSum << "%/" << RefCount * 100 / ModRefSum << "%/" << ModRefCount * 100 / ModRefSum << "%\n"; } +} + +namespace llvm { +class AAEvalLegacyPass : public FunctionPass { + std::unique_ptr P; + +public: + static char ID; // Pass identification, replacement for typeid + AAEvalLegacyPass() : FunctionPass(ID) { + initializeAAEvalLegacyPassPass(*PassRegistry::getPassRegistry()); + } - return false; + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.addRequired(); + AU.setPreservesAll(); + } + + bool doInitialization(Module &M) override { + P.reset(new AAEvaluator()); + return false; + } + + bool runOnFunction(Function &F) override { + P->runInternal(F, getAnalysis().getAAResults()); + return false; + } + bool doFinalization(Module &M) override { + P.reset(); + return false; + } +}; } + +char AAEvalLegacyPass::ID = 0; +INITIALIZE_PASS_BEGIN(AAEvalLegacyPass, "aa-eval", + "Exhaustive Alias Analysis Precision Evaluator", false, + true) +INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass) +INITIALIZE_PASS_END(AAEvalLegacyPass, "aa-eval", + "Exhaustive Alias Analysis Precision Evaluator", false, + true) + +FunctionPass *llvm::createAAEvalPass() { return new AAEvalLegacyPass(); } Index: lib/Analysis/Analysis.cpp =================================================================== --- lib/Analysis/Analysis.cpp +++ lib/Analysis/Analysis.cpp @@ -20,7 +20,7 @@ /// initializeAnalysis - Initialize all passes linked into the Analysis library. void llvm::initializeAnalysis(PassRegistry &Registry) { - initializeAAEvalPass(Registry); + initializeAAEvalLegacyPassPass(Registry); initializeAliasSetPrinterPass(Registry); initializeBasicAAWrapperPassPass(Registry); initializeBlockFrequencyInfoWrapperPassPass(Registry); Index: lib/Analysis/CFLAliasAnalysis.cpp =================================================================== --- lib/Analysis/CFLAliasAnalysis.cpp +++ lib/Analysis/CFLAliasAnalysis.cpp @@ -55,6 +55,7 @@ CFLAAResult::CFLAAResult(const TargetLibraryInfo &TLI) : AAResultBase(TLI) {} CFLAAResult::CFLAAResult(CFLAAResult &&Arg) : AAResultBase(std::move(Arg)) {} +CFLAAResult::~CFLAAResult() {} // \brief Information we have about a function and would like to keep around struct CFLAAResult::FunctionInfo { Index: lib/Analysis/GlobalsModRef.cpp =================================================================== --- lib/Analysis/GlobalsModRef.cpp +++ lib/Analysis/GlobalsModRef.cpp @@ -796,6 +796,8 @@ FunctionInfos(std::move(Arg.FunctionInfos)), Handles(std::move(Arg.Handles)) {} +GlobalsAAResult::~GlobalsAAResult() {} + /*static*/ GlobalsAAResult GlobalsAAResult::analyzeModule(Module &M, const TargetLibraryInfo &TLI, CallGraph &CG) { Index: lib/Passes/PassBuilder.cpp =================================================================== --- lib/Passes/PassBuilder.cpp +++ lib/Passes/PassBuilder.cpp @@ -16,13 +16,21 @@ //===----------------------------------------------------------------------===// #include "llvm/Passes/PassBuilder.h" +#include "llvm/Analysis/AliasAnalysis.h" +#include "llvm/Analysis/AliasAnalysisEvaluator.h" #include "llvm/Analysis/AssumptionCache.h" +#include "llvm/Analysis/BasicAliasAnalysis.h" +#include "llvm/Analysis/CFLAliasAnalysis.h" #include "llvm/Analysis/CGSCCPassManager.h" +#include "llvm/Analysis/GlobalsModRef.h" #include "llvm/Analysis/LazyCallGraph.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/ScalarEvolution.h" +#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h" +#include "llvm/Analysis/ScopedNoAliasAA.h" #include "llvm/Analysis/TargetLibraryInfo.h" #include "llvm/Analysis/TargetTransformInfo.h" +#include "llvm/Analysis/TypeBasedAliasAnalysis.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/IRPrintingPasses.h" #include "llvm/IR/PassManager.h" @@ -108,7 +116,8 @@ #include "PassRegistry.def" } -void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) { +void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM, + AAManager AAM) { #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ FAM.registerPass(CREATE_PASS); #include "PassRegistry.def" @@ -146,6 +155,29 @@ return false; } +bool PassBuilder::parseAliasAnalyses(AAManager &AAM, StringRef AAText) { + SmallVector AANames; + AAText.split(AANames, ","); + for (StringRef Name : AANames) { + // Setup our macro handling and include the registry file. +#define FUNCTION_ALIAS_ANALYSIS(NAME, TYPE) \ + if (Name == NAME) { \ + AAM.registerFunctionAnalysis(); \ + continue; \ + } +#define MODULE_ALIAS_ANALYSIS(NAME, TYPE) \ + if (Name == NAME) { \ + AAM.registerModuleAnalysis(); \ + continue; \ + } +#include "PassRegistry.def" + + // If none match, return an error. + return false; + } + return true; +} + bool PassBuilder::parseModulePassName(ModulePassManager &MPM, StringRef Name) { #define MODULE_PASS(NAME, CREATE_PASS) \ if (Name == NAME) { \ @@ -154,11 +186,13 @@ } #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ if (Name == "require<" NAME ">") { \ - MPM.addPass(RequireAnalysisPass()); \ + MPM.addPass(RequireAnalysisPass< \ + std::remove_reference::type>()); \ return true; \ } \ if (Name == "invalidate<" NAME ">") { \ - MPM.addPass(InvalidateAnalysisPass()); \ + MPM.addPass(InvalidateAnalysisPass< \ + std::remove_reference::type>()); \ return true; \ } #include "PassRegistry.def" @@ -174,11 +208,13 @@ } #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ if (Name == "require<" NAME ">") { \ - CGPM.addPass(RequireAnalysisPass()); \ + CGPM.addPass(RequireAnalysisPass< \ + std::remove_reference::type>()); \ return true; \ } \ if (Name == "invalidate<" NAME ">") { \ - CGPM.addPass(InvalidateAnalysisPass()); \ + CGPM.addPass(InvalidateAnalysisPass< \ + std::remove_reference::type>()); \ return true; \ } #include "PassRegistry.def" @@ -188,6 +224,11 @@ bool PassBuilder::parseFunctionPassName(FunctionPassManager &FPM, StringRef Name) { + // A no-op variable to allow decltype to resolve below, inside of the macro + // when referenced via the .def file's CREATE_PASS, for function analyses + // the way the parameter to \c registerFunctionAnalyses does. + AAManager AAM; + #define FUNCTION_PASS(NAME, CREATE_PASS) \ if (Name == NAME) { \ FPM.addPass(CREATE_PASS); \ @@ -195,11 +236,13 @@ } #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ if (Name == "require<" NAME ">") { \ - FPM.addPass(RequireAnalysisPass()); \ + FPM.addPass(RequireAnalysisPass< \ + std::remove_reference::type>()); \ return true; \ } \ if (Name == "invalidate<" NAME ">") { \ - FPM.addPass(InvalidateAnalysisPass()); \ + FPM.addPass(InvalidateAnalysisPass< \ + std::remove_reference::type>()); \ return true; \ } #include "PassRegistry.def" Index: lib/Passes/PassRegistry.def =================================================================== --- lib/Passes/PassRegistry.def +++ lib/Passes/PassRegistry.def @@ -19,6 +19,7 @@ #ifndef MODULE_ANALYSIS #define MODULE_ANALYSIS(NAME, CREATE_PASS) #endif +MODULE_ANALYSIS("globals-aa", GlobalsAA()) MODULE_ANALYSIS("lcg", LazyCallGraphAnalysis()) MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis()) MODULE_ANALYSIS("targetlibinfo", TargetLibraryAnalysis()) @@ -50,19 +51,26 @@ #ifndef FUNCTION_ANALYSIS #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) #endif +FUNCTION_ANALYSIS("aa-manager", std::move(AAM)) FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis()) +FUNCTION_ANALYSIS("basic-aa", BasicAA()) +FUNCTION_ANALYSIS("cfl-aa", CFLAA()) FUNCTION_ANALYSIS("domtree", DominatorTreeAnalysis()) FUNCTION_ANALYSIS("loops", LoopAnalysis()) FUNCTION_ANALYSIS("no-op-function", NoOpFunctionAnalysis()) FUNCTION_ANALYSIS("scalar-evolution", ScalarEvolutionAnalysis()) +FUNCTION_ANALYSIS("scev-aa", SCEVAA()) +FUNCTION_ANALYSIS("scoped-noalias-aa", ScopedNoAliasAA()) FUNCTION_ANALYSIS("targetlibinfo", TargetLibraryAnalysis()) FUNCTION_ANALYSIS("targetir", TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()) +FUNCTION_ANALYSIS("type-based-aa", TypeBasedAA()) #undef FUNCTION_ANALYSIS #ifndef FUNCTION_PASS #define FUNCTION_PASS(NAME, CREATE_PASS) #endif +FUNCTION_PASS("aa-eval", AAEvaluator()) FUNCTION_PASS("early-cse", EarlyCSEPass()) FUNCTION_PASS("instcombine", InstCombinePass()) FUNCTION_PASS("invalidate", InvalidateAllAnalysesPass()) @@ -77,3 +85,19 @@ FUNCTION_PASS("verify", VerifierPass()) FUNCTION_PASS("verify", DominatorTreeVerifierPass()) #undef FUNCTION_PASS + +#ifndef FUNCTION_ALIAS_ANALYSIS +#define FUNCTION_ALIAS_ANALYSIS(NAME, TYPE) +#endif +FUNCTION_ALIAS_ANALYSIS("basic", BasicAA) +FUNCTION_ALIAS_ANALYSIS("cfl", CFLAA) +FUNCTION_ALIAS_ANALYSIS("scev", SCEVAA) +FUNCTION_ALIAS_ANALYSIS("scoped-noalias", ScopedNoAliasAA) +FUNCTION_ALIAS_ANALYSIS("type-based", TypeBasedAA) +#undef FUNCTION_ALIAS_ANALYSIS + +#ifndef MODULE_ALIAS_ANALYSIS +#define MODULE_ALIAS_ANALYSIS(NAME, TYPE) +#endif +MODULE_ALIAS_ANALYSIS("globals", GlobalsAA) +#undef MODULE_ALIAS_ANALYSIS Index: test/Analysis/BasicAA/phi-aa.ll =================================================================== --- test/Analysis/BasicAA/phi-aa.ll +++ test/Analysis/BasicAA/phi-aa.ll @@ -1,4 +1,5 @@ ; RUN: opt < %s -basicaa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s +; RUN: opt < %s -aa=basic -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" Index: test/Analysis/CFLAliasAnalysis/basic-interproc.ll =================================================================== --- test/Analysis/CFLAliasAnalysis/basic-interproc.ll +++ test/Analysis/CFLAliasAnalysis/basic-interproc.ll @@ -2,6 +2,7 @@ ; that involve arguments. ; RUN: opt < %s -disable-basicaa -cfl-aa -aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s +; RUN: opt < %s -aa=cfl -passes=aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s ; CHECK: Function: test ; CHECK: 2 Total Alias Queries Performed Index: test/Analysis/ScopedNoAliasAA/basic.ll =================================================================== --- test/Analysis/ScopedNoAliasAA/basic.ll +++ test/Analysis/ScopedNoAliasAA/basic.ll @@ -1,4 +1,5 @@ ; RUN: opt < %s -basicaa -scoped-noalias -aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s +; RUN: opt < %s -aa=basic,scoped-noalias -passes=aa-eval -evaluate-aa-metadata -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" Index: test/Analysis/TypeBasedAliasAnalysis/placement-tbaa.ll =================================================================== --- test/Analysis/TypeBasedAliasAnalysis/placement-tbaa.ll +++ test/Analysis/TypeBasedAliasAnalysis/placement-tbaa.ll @@ -1,4 +1,5 @@ ; RUN: opt < %s -tbaa -basicaa -aa-eval -evaluate-aa-metadata -print-no-aliases -print-may-aliases -disable-output 2>&1 | FileCheck %s +; RUN: opt < %s -aa=type-based,basic -passes=aa-eval -evaluate-aa-metadata -print-no-aliases -print-may-aliases -disable-output 2>&1 | FileCheck %s ; Generated with "clang -cc1 -disable-llvm-optzns -O1 -emit-llvm" ; #include Index: tools/opt/NewPMDriver.cpp =================================================================== --- tools/opt/NewPMDriver.cpp +++ tools/opt/NewPMDriver.cpp @@ -15,6 +15,7 @@ #include "NewPMDriver.h" #include "llvm/ADT/StringRef.h" +#include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Analysis/CGSCCPassManager.h" #include "llvm/Bitcode/BitcodeWriterPass.h" #include "llvm/IR/Dominators.h" @@ -36,6 +37,13 @@ DebugPM("debug-pass-manager", cl::Hidden, cl::desc("Print pass management debugging information")); +// This flag specifies a textual description of the alias analysis chain which +// should be used. +static cl::opt + AliasAnalyses("aa", + cl::desc("A textual description of the alias analysis chain"), + cl::Hidden); + bool llvm::runPassPipeline(StringRef Arg0, LLVMContext &Context, Module &M, TargetMachine *TM, tool_output_file *Out, StringRef PassPipeline, OutputKind OK, @@ -48,10 +56,18 @@ CGSCCAnalysisManager CGAM(DebugPM); ModuleAnalysisManager MAM(DebugPM); + // Parse the alias analysis chain into the AA manager. + AAManager AAM; + if (AliasAnalyses.getNumOccurrences() > 0) + if (!PB.parseAliasAnalyses(AAM, AliasAnalyses)) { + errs() << Arg0 << ": unable to parse alias analysis chain description.\n"; + return false; + } + // Register all the basic analyses with the managers. PB.registerModuleAnalyses(MAM); PB.registerCGSCCAnalyses(CGAM); - PB.registerFunctionAnalyses(FAM); + PB.registerFunctionAnalyses(FAM, std::move(AAM)); // Cross register the analysis managers through their proxies. MAM.registerPass(FunctionAnalysisManagerModuleProxy(FAM)); Index: unittests/Analysis/MixedTBAATest.cpp =================================================================== --- unittests/Analysis/MixedTBAATest.cpp +++ unittests/Analysis/MixedTBAATest.cpp @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include "llvm/Analysis/TypeBasedAliasAnalysis.h" +#include "llvm/Analysis/AliasAnalysisEvaluator.h" #include "llvm/Analysis/Passes.h" #include "llvm/IR/Constants.h" #include "llvm/IR/Instructions.h"