Members/tobaru/cbc/CbC_llvm: include/llvm/Analysis/BasicAliasAnalysis.h comparison

comparison include/llvm/Analysis/BasicAliasAnalysis.h @ 121:803732b1fca8

LLVM 5.0

author	kono
date	Fri, 27 Oct 2017 17:07:41 +0900
parents	1172e4bd9c6f
children

comparison

equal deleted inserted replaced

-:1172e4bd9c6f
+:803732b1fca8
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_ANALYSIS_BASICALIASANALYSIS_H
 #define LLVM_ANALYSIS_BASICALIASANALYSIS_H
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
-#include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/Analysis/MemoryLocation.h"
-#include "llvm/IR/Function.h"
+#include "llvm/IR/CallSite.h"
-#include "llvm/IR/GetElementPtrTypeIterator.h"
-#include "llvm/IR/Instruction.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Pass.h"
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <utility>
 namespace llvm {
+struct AAMDNodes;
+class APInt;
 class AssumptionCache;
+class BasicBlock;
+class DataLayout;
 class DominatorTree;
+class Function;
+class GEPOperator;
 class LoopInfo;
+class PHINode;
+class SelectInst;
+class TargetLibraryInfo;
+class Value;
 /// This is the AA result object for the basic, local, and stateless alias
 /// analysis. It implements the AA query interface in an entirely stateless
-/// manner. As one consequence, it is never invalidated. While it does retain
+/// manner. As one consequence, it is never invalidated due to IR changes.
-/// some storage, that is used as an optimization and not to preserve
+/// While it does retain some storage, that is used as an optimization and not
-/// information from query to query.
+/// to preserve information from query to query. However it does retain handles
+/// to various other analyses and must be recomputed when those analyses are.
 class BasicAAResult : public AAResultBase<BasicAAResult> {
 friend AAResultBase<BasicAAResult>;
 const DataLayout &DL;
 const TargetLibraryInfo &TLI;
 LI(Arg.LI) {}
 BasicAAResult(BasicAAResult &&Arg)
 : AAResultBase(std::move(Arg)), DL(Arg.DL), TLI(Arg.TLI), AC(Arg.AC),
 DT(Arg.DT), LI(Arg.LI) {}
+/// Handle invalidation events in the new pass manager.
+bool invalidate(Function &F, const PreservedAnalyses &PA,
+FunctionAnalysisManager::Invalidator &Inv);
 AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
 ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc);
 ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2);
 private:
 // A linear transformation of a Value; this class represents ZExt(SExt(V,
 // SExtBits), ZExtBits) * Scale + Offset.
 struct VariableGEPIndex {
 // An opaque Value - we can't decompose this further.
 const Value *V;
 // We need to track what extensions we've done as we consider the same Value
 // with different extensions as different variables in a GEP's linear
 // Scaled variable (non-constant) indices.
 SmallVector<VariableGEPIndex, 4> VarIndices;
 };
 /// Track alias queries to guard against recursion.
-typedef std::pair<MemoryLocation, MemoryLocation> LocPair;
+using LocPair = std::pair<MemoryLocation, MemoryLocation>;
-typedef SmallDenseMap<LocPair, AliasResult, 8> AliasCacheTy;
+using AliasCacheTy = SmallDenseMap<LocPair, AliasResult, 8>;
 AliasCacheTy AliasCache;
 /// Tracks phi nodes we have visited.
 ///
 /// When interpret "Value" pointer equality as value equality we need to make
 };
 /// Analysis pass providing a never-invalidated alias analysis result.
 class BasicAA : public AnalysisInfoMixin<BasicAA> {
 friend AnalysisInfoMixin<BasicAA>;
 static AnalysisKey Key;
 public:
-typedef BasicAAResult Result;
+using Result = BasicAAResult;
 BasicAAResult run(Function &F, FunctionAnalysisManager &AM);
 };
 /// Legacy wrapper pass to provide the BasicAAResult object.
 /// A helper for the legacy pass manager to create a \c BasicAAResult object
 /// populated to the best of our ability for a particular function when inside
 /// of a \c ModulePass or a \c CallGraphSCCPass.
 BasicAAResult createLegacyPMBasicAAResult(Pass &P, Function &F);
-}
+/// This class is a functor to be used in legacy module or SCC passes for
-#endif
+/// computing AA results for a function. We store the results in fields so that
+/// they live long enough to be queried, but we re-use them each time.
+class LegacyAARGetter {
+Pass &P;
+Optional<BasicAAResult> BAR;
+Optional<AAResults> AAR;
+public:
+LegacyAARGetter(Pass &P) : P(P) {}
+AAResults &operator()(Function &F) {
+BAR.emplace(createLegacyPMBasicAAResult(P, F));
+AAR.emplace(createLegacyPMAAResults(P, F, *BAR));
+return *AAR;
+}
+};
+} // end namespace llvm
+#endif // LLVM_ANALYSIS_BASICALIASANALYSIS_H

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison include/llvm/Analysis/BasicAliasAnalysis.h @ 121:803732b1fca8