[llvm] r225131 - [PM] Split the AssumptionTracker immutable pass into two separate APIs:
Philip Reames
listmail at philipreames.com
Sun Jan 4 16:56:07 PST 2015
On 01/04/2015 04:03 AM, Chandler Carruth wrote:
> Author: chandlerc
> Date: Sun Jan 4 06:03:27 2015
> New Revision: 225131
>
> URL: http://llvm.org/viewvc/llvm-project?rev=225131&view=rev
> Log:
> [PM] Split the AssumptionTracker immutable pass into two separate APIs:
> a cache of assumptions for a single function, and an immutable pass that
> manages those caches.
>
> The motivation for this change is two fold. Immutable analyses are
> really hacks around the current pass manager design and don't exist in
> the new design. This is usually OK, but it requires that the core logic
> of an immutable pass be reasonably partitioned off from the pass logic.
> This change does precisely that. As a consequence it also paves the way
> for the *many* utility functions that deal in the assumptions to live in
> both pass manager worlds by creating an separate non-pass object with
> its own independent API that they all rely on. Now, the only bits of the
> system that deal with the actual pass mechanics are those that actually
> need to deal with the pass mechanics.
>
> Once this separation is made, several simplifications become pretty
> obvious in the assumption cache itself. Rather than using a set and
> callback value handles, it can just be a vector of weak value handles.
> The callers can easily skip the handles that are null, and eventually we
> can wrap all of this up behind a filter iterator.
>
> For now, this adds boiler plate to the various passes, but this kind of
> boiler plate will end up making it possible to port these passes to the
> new pass manager, and so it will end up factored away pretty reasonably.
Chandler, this is large enough it really should have gone for review.
At minimum, a chance for everyone involved to process the ownership
changes. I'm not asking you to revert, just making the point.
A couple of comments inline.
>
> Added:
> llvm/trunk/include/llvm/Analysis/AssumptionCache.h
> llvm/trunk/lib/Analysis/AssumptionCache.cpp
> Removed:
> llvm/trunk/include/llvm/Analysis/AssumptionTracker.h
> llvm/trunk/lib/Analysis/AssumptionTracker.cpp
> Modified:
> llvm/trunk/include/llvm/Analysis/CodeMetrics.h
> llvm/trunk/include/llvm/Analysis/InlineCost.h
> llvm/trunk/include/llvm/Analysis/InstructionSimplify.h
> llvm/trunk/include/llvm/Analysis/LazyValueInfo.h
> llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h
> llvm/trunk/include/llvm/Analysis/PHITransAddr.h
> llvm/trunk/include/llvm/Analysis/ScalarEvolution.h
> llvm/trunk/include/llvm/Analysis/ValueTracking.h
> llvm/trunk/include/llvm/InitializePasses.h
> llvm/trunk/include/llvm/Transforms/Utils/Cloning.h
> llvm/trunk/include/llvm/Transforms/Utils/Local.h
> llvm/trunk/include/llvm/Transforms/Utils/LoopUtils.h
> llvm/trunk/include/llvm/Transforms/Utils/PromoteMemToReg.h
> llvm/trunk/include/llvm/Transforms/Utils/UnrollLoop.h
> llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
> llvm/trunk/lib/Analysis/CMakeLists.txt
> llvm/trunk/lib/Analysis/CodeMetrics.cpp
> llvm/trunk/lib/Analysis/IPA/InlineCost.cpp
> llvm/trunk/lib/Analysis/InstructionSimplify.cpp
> llvm/trunk/lib/Analysis/LazyValueInfo.cpp
> llvm/trunk/lib/Analysis/Lint.cpp
> llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
> llvm/trunk/lib/Analysis/PHITransAddr.cpp
> llvm/trunk/lib/Analysis/ScalarEvolution.cpp
> llvm/trunk/lib/Analysis/ScalarEvolutionExpander.cpp
> llvm/trunk/lib/Analysis/ValueTracking.cpp
> llvm/trunk/lib/Transforms/IPO/InlineAlways.cpp
> llvm/trunk/lib/Transforms/IPO/InlineSimple.cpp
> llvm/trunk/lib/Transforms/IPO/Inliner.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombine.h
> llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombinePHI.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp
> llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp
> llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp
> llvm/trunk/lib/Transforms/Scalar/EarlyCSE.cpp
> llvm/trunk/lib/Transforms/Scalar/GVN.cpp
> llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp
> llvm/trunk/lib/Transforms/Scalar/LoopRotation.cpp
> llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp
> llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp
> llvm/trunk/lib/Transforms/Scalar/MemCpyOptimizer.cpp
> llvm/trunk/lib/Transforms/Scalar/SROA.cpp
> llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp
> llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp
> llvm/trunk/lib/Transforms/Utils/InlineFunction.cpp
> llvm/trunk/lib/Transforms/Utils/Local.cpp
> llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp
> llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp
> llvm/trunk/lib/Transforms/Utils/Mem2Reg.cpp
> llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
> llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp
> llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp
> llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
> llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp
>
> Added: llvm/trunk/include/llvm/Analysis/AssumptionCache.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/AssumptionCache.h?rev=225131&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/AssumptionCache.h (added)
> +++ llvm/trunk/include/llvm/Analysis/AssumptionCache.h Sun Jan 4 06:03:27 2015
> @@ -0,0 +1,142 @@
> +//===- llvm/Analysis/AssumptionCache.h - Track @llvm.assume ---*- C++ -*-===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// This file contains a pass that keeps track of @llvm.assume intrinsics in
> +// the functions of a module (allowing assumptions within any function to be
> +// found cheaply by other parts of the optimizer).
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_ANALYSIS_ASSUMPTIONTRACKER_H
> +#define LLVM_ANALYSIS_ASSUMPTIONTRACKER_H
This needs updated.
> +
> +#include "llvm/ADT/ArrayRef.h"
> +#include "llvm/ADT/DenseMap.h"
> +#include "llvm/ADT/SmallSet.h"
> +#include "llvm/IR/Function.h"
> +#include "llvm/IR/Instructions.h"
> +#include "llvm/IR/ValueHandle.h"
> +#include "llvm/Pass.h"
> +#include <memory>
> +
> +namespace llvm {
> +
> +/// \brief A cache of @llvm.assume calls within a function.
> +///
> +/// This cache provides fast lookup of assumptions within a function by caching
> +/// them and amortizing the cost of scanning for them across all queries. The
> +/// cache is also conservatively self-updating so that it will never return
> +/// incorrect results about a function even as the function is being mutated.
> +/// However, flushing the cache and rebuilding it (or explicitly updating it)
> +/// may allow it to discover new assumptions.
> +class AssumptionCache {
> + /// \brief The function for which this cache is handling assumptions.
> + ///
> + /// We track this to lazily populate our assumptions.
> + Function &F;
> +
> + /// \brief Vector of weak value handles to calls of the @llvm.assume
> + /// intrinsic.
> + SmallVector<WeakVH, 4> AssumeHandles;
Why 4? Given that an assumption cache only exists if a function has
assumes, why not make this slightly larger?
> +
> + /// \brief Flag tracking whether we have scanned the function yet.
> + ///
> + /// We want to be as lazy about this as possible, and so we scan the function
> + /// at the last moment.
> + bool Scanned;
> +
> + /// \brief Scan the function for assumptions and add them to the cache.
> + void scanFunction();
> +
> +public:
> + /// \brief Construct an AssumptionCache from a function by scanning all of
> + /// its instructions.
> + AssumptionCache(Function &F) : F(F), Scanned(false) {}
> +
> + /// \brief Add an @llvm.assume intrinsic to this function's cache.
> + ///
> + /// The call passed in must be an instruction within this fuction and must
> + /// not already be in the cache.
> + void registerAssumption(CallInst *CI);
> +
> + /// \brief Clear the cache of @llvm.assume intrinsics for a function.
> + ///
> + /// It will be re-scanned the next time it is requested.
> + void clear() {
> + AssumeHandles.clear();
> + Scanned = false;
> + }
> +
> + /// \brief Access the list of assumption handles currently tracked for this
> + /// fuction.
> + ///
> + /// Note that these produce weak handles that may be null. The caller must
> + /// handle that case.
> + /// FIXME: We should replace this with pointee_iterator<filter_iterator<...>>
> + /// when we can write that to filter out the null values. Then caller code
> + /// will become simpler.
> + MutableArrayRef<WeakVH> assumptions() {
> + if (!Scanned)
> + scanFunction();
> + return AssumeHandles;
> + }
> +};
> +
> +/// \brief An immutable pass that tracks lazily created \c AssumptionCache
> +/// objects.
> +///
> +/// This is essentially a workaround for the legacy pass manager's weaknesses
> +/// which associates each assumption cache with Function and clears it if the
> +/// function is deleted. The nature of the AssumptionCache is that it is not
> +/// invalidated by any changes to the function body and so this is sufficient
> +/// to be conservatively correct.
> +class AssumptionCacheTracker : public ImmutablePass {
> + /// A callback value handle applied to function objects, which we use to
> + /// delete our cache of intrinsics for a function when it is deleted.
> + class FunctionCallbackVH : public CallbackVH {
> + AssumptionCacheTracker *ACT;
> + void deleted() override;
> +
> + public:
> + typedef DenseMapInfo<Value *> DMI;
> +
> + FunctionCallbackVH(Value *V, AssumptionCacheTracker *ACT = nullptr)
> + : CallbackVH(V), ACT(ACT) {}
> + };
> +
> + friend FunctionCallbackVH;
> +
> + typedef DenseMap<FunctionCallbackVH, std::unique_ptr<AssumptionCache>,
> + FunctionCallbackVH::DMI> FunctionCallsMap;
> + FunctionCallsMap AssumptionCaches;
> +
> +public:
> + /// \brief Get the cached assumptions for a function.
> + ///
> + /// If no assumptions are cached, this will scan the function. Otherwise, the
> + /// existing cache will be returned.
> + AssumptionCache &getAssumptionCache(Function &F);
> +
> + AssumptionCacheTracker();
> + ~AssumptionCacheTracker();
> +
> + void releaseMemory() override { AssumptionCaches.shrink_and_clear(); }
> +
> + void verifyAnalysis() const override;
> + bool doFinalization(Module &) override {
> + verifyAnalysis();
> + return false;
> + }
> +
> + static char ID; // Pass identification, replacement for typeid
> +};
> +
> +} // end namespace llvm
> +
> +#endif
>
> Removed: llvm/trunk/include/llvm/Analysis/AssumptionTracker.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/AssumptionTracker.h?rev=225130&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/AssumptionTracker.h (original)
> +++ llvm/trunk/include/llvm/Analysis/AssumptionTracker.h (removed)
> @@ -1,128 +0,0 @@
> -//===- llvm/Analysis/AssumptionTracker.h - Track @llvm.assume ---*- C++ -*-===//
> -//
> -// The LLVM Compiler Infrastructure
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
> -//===----------------------------------------------------------------------===//
> -//
> -// This file contains a pass that keeps track of @llvm.assume intrinsics in
> -// the functions of a module (allowing assumptions within any function to be
> -// found cheaply by other parts of the optimizer).
> -//
> -//===----------------------------------------------------------------------===//
> -
> -#ifndef LLVM_ANALYSIS_ASSUMPTIONTRACKER_H
> -#define LLVM_ANALYSIS_ASSUMPTIONTRACKER_H
> -
> -#include "llvm/ADT/DenseMap.h"
> -#include "llvm/ADT/DenseSet.h"
> -#include "llvm/ADT/SmallSet.h"
> -#include "llvm/IR/Function.h"
> -#include "llvm/IR/Instructions.h"
> -#include "llvm/IR/ValueHandle.h"
> -#include "llvm/Pass.h"
> -#include <memory>
> -
> -namespace llvm {
> -
> -/// An immutable pass that tracks @llvm.assume intrinsics in a module.
> -class AssumptionTracker : public ImmutablePass {
> - /// A callback value handle applied to function objects, which we use to
> - /// delete our cache of intrinsics for a function when it is deleted.
> - class FunctionCallbackVH : public CallbackVH {
> - AssumptionTracker *AT;
> - void deleted() override;
> -
> - public:
> - typedef DenseMapInfo<Value *> DMI;
> -
> - FunctionCallbackVH(Value *V, AssumptionTracker *AT = nullptr)
> - : CallbackVH(V), AT(AT) {}
> - };
> -
> - /// A callback value handle applied to call instructions, which keeps
> - /// track of the call's parent function so that we can remove a
> - /// assumption intrinsic call from our cache when the instruction is
> - /// deleted.
> - class CallCallbackVH : public CallbackVH {
> - AssumptionTracker *AT;
> - void deleted() override;
> -
> - // We store the function here because we need it to lookup the set
> - // containing this handle when the underlying CallInst is being deleted.
> - Function *F;
> -
> - public:
> - typedef DenseMapInfo<Instruction *> DMI;
> -
> - CallCallbackVH(Instruction *I, AssumptionTracker *AT = nullptr)
> - : CallbackVH(I), AT(AT), F(nullptr) {
> - if (I != DMI::getEmptyKey() && I != DMI::getTombstoneKey())
> - F = I->getParent()->getParent();
> - }
> -
> - operator CallInst*() const {
> - Value *V = getValPtr();
> - if (V == DMI::getEmptyKey() || V == DMI::getTombstoneKey())
> - return reinterpret_cast<CallInst*>(V);
> -
> - return cast<CallInst>(V);
> - }
> -
> - CallInst *operator->() const { return cast<CallInst>(getValPtr()); }
> - CallInst &operator*() const { return *cast<CallInst>(getValPtr()); }
> - };
> -
> - friend FunctionCallbackVH;
> - friend CallCallbackVH;
> -
> - // FIXME: SmallSet might be better here, but it currently has no iterators.
> - typedef DenseSet<CallCallbackVH, CallCallbackVH::DMI> CallHandleSet;
> - typedef DenseMap<FunctionCallbackVH, std::unique_ptr<CallHandleSet>,
> - FunctionCallbackVH::DMI> FunctionCallsMap;
> - FunctionCallsMap CachedAssumeCalls;
> -
> - /// Scan the provided function for @llvm.assume intrinsic calls. Returns an
> - /// iterator to the set for this function in the CachedAssumeCalls map.
> - FunctionCallsMap::iterator scanFunction(Function *F);
> -
> -public:
> - /// Remove the cache of @llvm.assume intrinsics for the given function.
> - void forgetCachedAssumptions(Function *F);
> -
> - /// Add an @llvm.assume intrinsic to the cache for its parent function.
> - void registerAssumption(CallInst *CI);
> -
> - typedef CallHandleSet::iterator assumption_iterator;
> - typedef iterator_range<assumption_iterator> assumption_range;
> -
> - inline assumption_range assumptions(Function *F) {
> - FunctionCallsMap::iterator I = CachedAssumeCalls.find_as(F);
> - if (I == CachedAssumeCalls.end()) {
> - I = scanFunction(F);
> - }
> -
> - return assumption_range(I->second->begin(), I->second->end());
> - }
> -
> - AssumptionTracker();
> - ~AssumptionTracker();
> -
> - void releaseMemory() override {
> - CachedAssumeCalls.shrink_and_clear();
> - }
> -
> - void verifyAnalysis() const override;
> - bool doFinalization(Module &) override {
> - verifyAnalysis();
> - return false;
> - }
> -
> - static char ID; // Pass identification, replacement for typeid
> -};
> -
> -} // end namespace llvm
> -
> -#endif
>
> Modified: llvm/trunk/include/llvm/Analysis/CodeMetrics.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/CodeMetrics.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/CodeMetrics.h (original)
> +++ llvm/trunk/include/llvm/Analysis/CodeMetrics.h Sun Jan 4 06:03:27 2015
> @@ -20,7 +20,7 @@
> #include "llvm/IR/CallSite.h"
>
> namespace llvm {
> -class AssumptionTracker;
> +class AssumptionCache;
> class BasicBlock;
> class Loop;
> class Function;
> @@ -93,13 +93,13 @@ struct CodeMetrics {
>
> /// \brief Collect a loop's ephemeral values (those used only by an assume
> /// or similar intrinsics in the loop).
> - static void collectEphemeralValues(const Loop *L, AssumptionTracker *AT,
> - SmallPtrSetImpl<const Value*> &EphValues);
> + static void collectEphemeralValues(const Loop *L, AssumptionCache *AC,
> + SmallPtrSetImpl<const Value *> &EphValues);
Formatting changes (and arguably the rename involved in the API split
itself) should have been separated.
>
> /// \brief Collect a functions's ephemeral values (those used only by an
> /// assume or similar intrinsics in the function).
> - static void collectEphemeralValues(const Function *L, AssumptionTracker *AT,
> - SmallPtrSetImpl<const Value*> &EphValues);
> + static void collectEphemeralValues(const Function *L, AssumptionCache *AC,
> + SmallPtrSetImpl<const Value *> &EphValues);
> };
>
> }
>
> Modified: llvm/trunk/include/llvm/Analysis/InlineCost.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/InlineCost.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/InlineCost.h (original)
> +++ llvm/trunk/include/llvm/Analysis/InlineCost.h Sun Jan 4 06:03:27 2015
> @@ -19,7 +19,7 @@
> #include <climits>
>
> namespace llvm {
> -class AssumptionTracker;
> +class AssumptionCacheTracker;
> class CallSite;
> class DataLayout;
> class Function;
> @@ -101,7 +101,7 @@ public:
> /// \brief Cost analyzer used by inliner.
> class InlineCostAnalysis : public CallGraphSCCPass {
> const TargetTransformInfo *TTI;
> - AssumptionTracker *AT;
> + AssumptionCacheTracker *ACT;
>
> public:
> static char ID;
>
> Modified: llvm/trunk/include/llvm/Analysis/InstructionSimplify.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/InstructionSimplify.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/InstructionSimplify.h (original)
> +++ llvm/trunk/include/llvm/Analysis/InstructionSimplify.h Sun Jan 4 06:03:27 2015
> @@ -37,7 +37,7 @@
> namespace llvm {
> template<typename T>
> class ArrayRef;
> - class AssumptionTracker;
> + class AssumptionCache;
> class DominatorTree;
> class Instruction;
> class DataLayout;
> @@ -52,7 +52,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifySubInst - Given operands for a Sub, see if we can
> @@ -61,35 +61,34 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// Given operands for an FAdd, see if we can fold the result. If not, this
> /// returns null.
> Value *SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF,
> - const DataLayout *TD = nullptr,
> - const TargetLibraryInfo *TLI = nullptr,
> - const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> - const Instruction *CxtI = nullptr);
> + const DataLayout *TD = nullptr,
> + const TargetLibraryInfo *TLI = nullptr,
> + const DominatorTree *DT = nullptr,
> + AssumptionCache *AC = nullptr,
> + const Instruction *CxtI = nullptr);
>
> /// Given operands for an FSub, see if we can fold the result. If not, this
> /// returns null.
> Value *SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF,
> - const DataLayout *TD = nullptr,
> - const TargetLibraryInfo *TLI = nullptr,
> - const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> - const Instruction *CxtI = nullptr);
> + const DataLayout *TD = nullptr,
> + const TargetLibraryInfo *TLI = nullptr,
> + const DominatorTree *DT = nullptr,
> + AssumptionCache *AC = nullptr,
> + const Instruction *CxtI = nullptr);
>
> /// Given operands for an FMul, see if we can fold the result. If not, this
> /// returns null.
> - Value *SimplifyFMulInst(Value *LHS, Value *RHS,
> - FastMathFlags FMF,
> + Value *SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF,
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyMulInst - Given operands for a Mul, see if we can
> @@ -97,7 +96,7 @@ namespace llvm {
> Value *SimplifyMulInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifySDivInst - Given operands for an SDiv, see if we can
> @@ -106,7 +105,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyUDivInst - Given operands for a UDiv, see if we can
> @@ -115,7 +114,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyFDivInst - Given operands for an FDiv, see if we can
> @@ -124,7 +123,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifySRemInst - Given operands for an SRem, see if we can
> @@ -133,7 +132,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyURemInst - Given operands for a URem, see if we can
> @@ -142,7 +141,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyFRemInst - Given operands for an FRem, see if we can
> @@ -151,7 +150,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyShlInst - Given operands for a Shl, see if we can
> @@ -160,7 +159,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyLShrInst - Given operands for a LShr, see if we can
> @@ -169,7 +168,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyAShrInst - Given operands for a AShr, see if we can
> @@ -178,7 +177,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyAndInst - Given operands for an And, see if we can
> @@ -186,7 +185,7 @@ namespace llvm {
> Value *SimplifyAndInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyOrInst - Given operands for an Or, see if we can
> @@ -194,7 +193,7 @@ namespace llvm {
> Value *SimplifyOrInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyXorInst - Given operands for a Xor, see if we can
> @@ -202,7 +201,7 @@ namespace llvm {
> Value *SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
> @@ -211,7 +210,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> Instruction *CxtI = nullptr);
>
> /// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
> @@ -220,7 +219,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifySelectInst - Given operands for a SelectInst, see if we can fold
> @@ -229,7 +228,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
> @@ -237,7 +236,7 @@ namespace llvm {
> Value *SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we
> @@ -247,7 +246,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyTruncInst - Given operands for an TruncInst, see if we can fold
> @@ -255,7 +254,7 @@ namespace llvm {
> Value *SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> //=== Helper functions for higher up the class hierarchy.
> @@ -267,7 +266,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
> @@ -276,7 +275,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// \brief Given a function and iterators over arguments, see if we can fold
> @@ -287,7 +286,7 @@ namespace llvm {
> User::op_iterator ArgEnd, const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// \brief Given a function and set of arguments, see if we can fold the
> @@ -298,7 +297,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr);
>
> /// SimplifyInstruction - See if we can compute a simplified version of this
> @@ -306,8 +305,7 @@ namespace llvm {
> Value *SimplifyInstruction(Instruction *I, const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr);
> -
> + AssumptionCache *AC = nullptr);
>
> /// \brief Replace all uses of 'I' with 'SimpleV' and simplify the uses
> /// recursively.
> @@ -321,7 +319,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr);
> + AssumptionCache *AC = nullptr);
>
> /// \brief Recursively attempt to simplify an instruction.
> ///
> @@ -333,7 +331,7 @@ namespace llvm {
> const DataLayout *TD = nullptr,
> const TargetLibraryInfo *TLI = nullptr,
> const DominatorTree *DT = nullptr,
> - AssumptionTracker *AT = nullptr);
> + AssumptionCache *AC = nullptr);
> } // end namespace llvm
>
> #endif
>
> Modified: llvm/trunk/include/llvm/Analysis/LazyValueInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/LazyValueInfo.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/LazyValueInfo.h (original)
> +++ llvm/trunk/include/llvm/Analysis/LazyValueInfo.h Sun Jan 4 06:03:27 2015
> @@ -18,7 +18,7 @@
> #include "llvm/Pass.h"
>
> namespace llvm {
> - class AssumptionTracker;
> + class AssumptionCache;
> class Constant;
> class DataLayout;
> class DominatorTree;
> @@ -29,7 +29,7 @@ namespace llvm {
> /// LazyValueInfo - This pass computes, caches, and vends lazy value constraint
> /// information.
> class LazyValueInfo : public FunctionPass {
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> const DataLayout *DL;
> class TargetLibraryInfo *TLI;
> DominatorTree *DT;
>
> Modified: llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h (original)
> +++ llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h Sun Jan 4 06:03:27 2015
> @@ -28,7 +28,7 @@ namespace llvm {
> class Instruction;
> class CallSite;
> class AliasAnalysis;
> - class AssumptionTracker;
> + class AssumptionCache;
> class DataLayout;
> class MemoryDependenceAnalysis;
> class PredIteratorCache;
> @@ -326,7 +326,7 @@ namespace llvm {
> AliasAnalysis *AA;
> const DataLayout *DL;
> DominatorTree *DT;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> std::unique_ptr<PredIteratorCache> PredCache;
>
> public:
>
> Modified: llvm/trunk/include/llvm/Analysis/PHITransAddr.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/PHITransAddr.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/PHITransAddr.h (original)
> +++ llvm/trunk/include/llvm/Analysis/PHITransAddr.h Sun Jan 4 06:03:27 2015
> @@ -18,7 +18,7 @@
> #include "llvm/IR/Instruction.h"
>
> namespace llvm {
> - class AssumptionTracker;
> + class AssumptionCache;
> class DominatorTree;
> class DataLayout;
> class TargetLibraryInfo;
> @@ -44,13 +44,13 @@ class PHITransAddr {
> const TargetLibraryInfo *TLI;
>
> /// A cache of @llvm.assume calls used by SimplifyInstruction.
> - AssumptionTracker *AT;
> -
> + AssumptionCache *AC;
> +
> /// InstInputs - The inputs for our symbolic address.
> SmallVector<Instruction*, 4> InstInputs;
> public:
> - PHITransAddr(Value *addr, const DataLayout *DL, AssumptionTracker *AT)
> - : Addr(addr), DL(DL), TLI(nullptr), AT(AT) {
> + PHITransAddr(Value *addr, const DataLayout *DL, AssumptionCache *AC)
> + : Addr(addr), DL(DL), TLI(nullptr), AC(AC) {
> // If the address is an instruction, the whole thing is considered an input.
> if (Instruction *I = dyn_cast<Instruction>(Addr))
> InstInputs.push_back(I);
>
> Modified: llvm/trunk/include/llvm/Analysis/ScalarEvolution.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ScalarEvolution.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/ScalarEvolution.h (original)
> +++ llvm/trunk/include/llvm/Analysis/ScalarEvolution.h Sun Jan 4 06:03:27 2015
> @@ -35,7 +35,7 @@
>
> namespace llvm {
> class APInt;
> - class AssumptionTracker;
> + class AssumptionCache;
> class Constant;
> class ConstantInt;
> class DominatorTree;
> @@ -225,7 +225,7 @@ namespace llvm {
> Function *F;
>
> /// The tracker for @llvm.assume intrinsics in this function.
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
>
> /// LI - The loop information for the function we are currently analyzing.
> ///
>
> Modified: llvm/trunk/include/llvm/Analysis/ValueTracking.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ValueTracking.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Analysis/ValueTracking.h (original)
> +++ llvm/trunk/include/llvm/Analysis/ValueTracking.h Sun Jan 4 06:03:27 2015
> @@ -25,7 +25,7 @@ namespace llvm {
> class DataLayout;
> class StringRef;
> class MDNode;
> - class AssumptionTracker;
> + class AssumptionCache;
> class DominatorTree;
> class TargetLibraryInfo;
>
> @@ -37,9 +37,9 @@ namespace llvm {
> /// where V is a vector, the known zero and known one values are the
> /// same width as the vector element, and the bit is set only if it is true
> /// for all of the elements in the vector.
> - void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
> + void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
> const DataLayout *TD = nullptr, unsigned Depth = 0,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr);
> /// Compute known bits from the range metadata.
> @@ -51,7 +51,7 @@ namespace llvm {
> /// one. Convenience wrapper around computeKnownBits.
> void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
> const DataLayout *TD = nullptr, unsigned Depth = 0,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr);
>
> @@ -61,7 +61,7 @@ namespace llvm {
> /// integer or pointer type and vectors of integers. If 'OrZero' is set then
> /// returns true if the given value is either a power of two or zero.
> bool isKnownToBeAPowerOfTwo(Value *V, bool OrZero = false, unsigned Depth = 0,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr);
>
> @@ -70,7 +70,7 @@ namespace llvm {
> /// non-zero when defined. Supports values with integer or pointer type and
> /// vectors of integers.
> bool isKnownNonZero(Value *V, const DataLayout *TD = nullptr,
> - unsigned Depth = 0, AssumptionTracker *AT = nullptr,
> + unsigned Depth = 0, AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr);
>
> @@ -83,13 +83,12 @@ namespace llvm {
> /// where V is a vector, the mask, known zero, and known one values are the
> /// same width as the vector element, and the bit is set only if it is true
> /// for all of the elements in the vector.
> - bool MaskedValueIsZero(Value *V, const APInt &Mask,
> + bool MaskedValueIsZero(Value *V, const APInt &Mask,
> const DataLayout *TD = nullptr, unsigned Depth = 0,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr);
>
> -
> /// ComputeNumSignBits - Return the number of times the sign bit of the
> /// register is replicated into the other bits. We know that at least 1 bit
> /// is always equal to the sign bit (itself), but other cases can give us
> @@ -99,8 +98,7 @@ namespace llvm {
> /// 'Op' must have a scalar integer type.
> ///
> unsigned ComputeNumSignBits(Value *Op, const DataLayout *TD = nullptr,
> - unsigned Depth = 0,
> - AssumptionTracker *AT = nullptr,
> + unsigned Depth = 0, AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr);
>
> @@ -220,7 +218,7 @@ namespace llvm {
> enum class OverflowResult { AlwaysOverflows, MayOverflow, NeverOverflows };
> OverflowResult computeOverflowForUnsignedMul(Value *LHS, Value *RHS,
> const DataLayout *DL,
> - AssumptionTracker *AT,
> + AssumptionCache *AC,
> const Instruction *CxtI,
> const DominatorTree *DT);
> } // end namespace llvm
>
> Modified: llvm/trunk/include/llvm/InitializePasses.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/InitializePasses.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/InitializePasses.h (original)
> +++ llvm/trunk/include/llvm/InitializePasses.h Sun Jan 4 06:03:27 2015
> @@ -266,7 +266,7 @@ void initializeTargetTransformInfoAnalys
> void initializeFunctionTargetTransformInfoPass(PassRegistry &);
> void initializeNoTTIPass(PassRegistry&);
> void initializeTargetLibraryInfoPass(PassRegistry&);
> -void initializeAssumptionTrackerPass(PassRegistry &);
> +void initializeAssumptionCacheTrackerPass(PassRegistry &);
> void initializeTwoAddressInstructionPassPass(PassRegistry&);
> void initializeTypeBasedAliasAnalysisPass(PassRegistry&);
> void initializeScopedNoAliasAAPass(PassRegistry&);
>
> Modified: llvm/trunk/include/llvm/Transforms/Utils/Cloning.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/Cloning.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Transforms/Utils/Cloning.h (original)
> +++ llvm/trunk/include/llvm/Transforms/Utils/Cloning.h Sun Jan 4 06:03:27 2015
> @@ -44,7 +44,7 @@ class Loop;
> class LoopInfo;
> class AllocaInst;
> class AliasAnalysis;
> -class AssumptionTracker;
> +class AssumptionCacheTracker;
>
> /// CloneModule - Return an exact copy of the specified module
> ///
> @@ -162,15 +162,15 @@ public:
> explicit InlineFunctionInfo(CallGraph *cg = nullptr,
> const DataLayout *DL = nullptr,
> AliasAnalysis *AA = nullptr,
> - AssumptionTracker *AT = nullptr)
> - : CG(cg), DL(DL), AA(AA), AT(AT) {}
> + AssumptionCacheTracker *ACT = nullptr)
> + : CG(cg), DL(DL), AA(AA), ACT(ACT) {}
>
> /// CG - If non-null, InlineFunction will update the callgraph to reflect the
> /// changes it makes.
> CallGraph *CG;
> const DataLayout *DL;
> AliasAnalysis *AA;
> - AssumptionTracker *AT;
> + AssumptionCacheTracker *ACT;
>
> /// StaticAllocas - InlineFunction fills this in with all static allocas that
> /// get copied into the caller.
>
> Modified: llvm/trunk/include/llvm/Transforms/Utils/Local.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/Local.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Transforms/Utils/Local.h (original)
> +++ llvm/trunk/include/llvm/Transforms/Utils/Local.h Sun Jan 4 06:03:27 2015
> @@ -34,7 +34,7 @@ class Value;
> class Pass;
> class PHINode;
> class AllocaInst;
> -class AssumptionTracker;
> +class AssumptionCache;
> class ConstantExpr;
> class DataLayout;
> class TargetLibraryInfo;
> @@ -138,9 +138,8 @@ bool EliminateDuplicatePHINodes(BasicBlo
> /// the basic block that was pointed to.
> ///
> bool SimplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI,
> - unsigned BonusInstThreshold,
> - const DataLayout *TD = nullptr,
> - AssumptionTracker *AT = nullptr);
> + unsigned BonusInstThreshold, const DataLayout *TD = nullptr,
> + AssumptionCache *AC = nullptr);
>
> /// FlatternCFG - This function is used to flatten a CFG. For
> /// example, it uses parallel-and and parallel-or mode to collapse
> @@ -176,17 +175,17 @@ AllocaInst *DemotePHIToStack(PHINode *P,
> /// increase the alignment of the ultimate object, making this check succeed.
> unsigned getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign,
> const DataLayout *TD = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr);
>
> /// getKnownAlignment - Try to infer an alignment for the specified pointer.
> static inline unsigned getKnownAlignment(Value *V,
> const DataLayout *TD = nullptr,
> - AssumptionTracker *AT = nullptr,
> + AssumptionCache *AC = nullptr,
> const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr) {
> - return getOrEnforceKnownAlignment(V, 0, TD, AT, CxtI, DT);
> + return getOrEnforceKnownAlignment(V, 0, TD, AC, CxtI, DT);
> }
>
> /// EmitGEPOffset - Given a getelementptr instruction/constantexpr, emit the
>
> Modified: llvm/trunk/include/llvm/Transforms/Utils/LoopUtils.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/LoopUtils.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Transforms/Utils/LoopUtils.h (original)
> +++ llvm/trunk/include/llvm/Transforms/Utils/LoopUtils.h Sun Jan 4 06:03:27 2015
> @@ -16,7 +16,7 @@
>
> namespace llvm {
> class AliasAnalysis;
> -class AssumptionTracker;
> +class AssumptionCache;
> class BasicBlock;
> class DataLayout;
> class DominatorTree;
> @@ -36,7 +36,7 @@ BasicBlock *InsertPreheaderForLoop(Loop
> bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, Pass *PP,
> AliasAnalysis *AA = nullptr, ScalarEvolution *SE = nullptr,
> const DataLayout *DL = nullptr,
> - AssumptionTracker *AT = nullptr);
> + AssumptionCache *AC = nullptr);
>
> /// \brief Put loop into LCSSA form.
> ///
>
> Modified: llvm/trunk/include/llvm/Transforms/Utils/PromoteMemToReg.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/PromoteMemToReg.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Transforms/Utils/PromoteMemToReg.h (original)
> +++ llvm/trunk/include/llvm/Transforms/Utils/PromoteMemToReg.h Sun Jan 4 06:03:27 2015
> @@ -22,7 +22,7 @@ namespace llvm {
> class AllocaInst;
> class DominatorTree;
> class AliasSetTracker;
> -class AssumptionTracker;
> +class AssumptionCache;
>
> /// \brief Return true if this alloca is legal for promotion.
> ///
> @@ -43,7 +43,7 @@ bool isAllocaPromotable(const AllocaInst
> /// made to the IR.
> void PromoteMemToReg(ArrayRef<AllocaInst *> Allocas, DominatorTree &DT,
> AliasSetTracker *AST = nullptr,
> - AssumptionTracker *AT = nullptr);
> + AssumptionCache *AC = nullptr);
>
> } // End llvm namespace
>
>
> Modified: llvm/trunk/include/llvm/Transforms/Utils/UnrollLoop.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Utils/UnrollLoop.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Transforms/Utils/UnrollLoop.h (original)
> +++ llvm/trunk/include/llvm/Transforms/Utils/UnrollLoop.h Sun Jan 4 06:03:27 2015
> @@ -18,7 +18,7 @@
>
> namespace llvm {
>
> -class AssumptionTracker;
> +class AssumptionCache;
> class Loop;
> class LoopInfo;
> class LPPassManager;
> @@ -26,7 +26,7 @@ class Pass;
>
> bool UnrollLoop(Loop *L, unsigned Count, unsigned TripCount, bool AllowRuntime,
> unsigned TripMultiple, LoopInfo *LI, Pass *PP,
> - LPPassManager *LPM, AssumptionTracker *AT);
> + LPPassManager *LPM, AssumptionCache *AC);
>
> bool UnrollRuntimeLoopProlog(Loop *L, unsigned Count, LoopInfo *LI,
> LPPassManager* LPM);
>
> Added: llvm/trunk/lib/Analysis/AssumptionCache.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/AssumptionCache.cpp?rev=225131&view=auto
> ==============================================================================
> --- llvm/trunk/lib/Analysis/AssumptionCache.cpp (added)
> +++ llvm/trunk/lib/Analysis/AssumptionCache.cpp Sun Jan 4 06:03:27 2015
> @@ -0,0 +1,125 @@
> +//===- AssumptionCache.cpp - Cache finding @llvm.assume calls -------------===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// This file contains a pass that keeps track of @llvm.assume intrinsics in
> +// the functions of a module.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "llvm/Analysis/AssumptionCache.h"
> +#include "llvm/IR/CallSite.h"
> +#include "llvm/IR/Dominators.h"
> +#include "llvm/IR/Function.h"
> +#include "llvm/IR/Instructions.h"
> +#include "llvm/IR/IntrinsicInst.h"
> +#include "llvm/IR/PatternMatch.h"
> +#include "llvm/Support/Debug.h"
> +using namespace llvm;
> +using namespace llvm::PatternMatch;
> +
> +void AssumptionCache::scanFunction() {
> + assert(!Scanned && "Tried to scan the function twice!");
> + assert(AssumeHandles.empty() && "Already have assumes when scanning!");
> +
> + // Go through all instructions in all blocks, add all calls to @llvm.assume
> + // to this cache.
> + for (BasicBlock &B : F)
> + for (Instruction &II : B)
Why not use inst_iterator? (Which we really need a range form of btw.)
> + if (match(&II, m_Intrinsic<Intrinsic::assume>()))
> + AssumeHandles.push_back(&II);
> +
> + // Mark the scan as complete.
> + Scanned = true;
> +}
> +
> +void AssumptionCache::registerAssumption(CallInst *CI) {
> + assert(match(CI, m_Intrinsic<Intrinsic::assume>()) &&
> + "Registered call does not call @llvm.assume");
> +
> + // If we haven't scanned the function yet, just drop this assumption. It will
> + // be found when we scan later.
> + if (!Scanned)
> + return;
> +
> + AssumeHandles.push_back(CI);
> +
> +#ifndef NDEBUG
> + assert(CI->getParent() &&
> + "Cannot register @llvm.assume call not in a basic block");
> + assert(&F == CI->getParent()->getParent() &&
> + "Cannot register @llvm.assume call not in this function");
> +
> + // We expect the number of assumptions to be small, so in an asserts build
> + // check that we don't accumulate duplicates and that all assumptions point
> + // to the same function.
> + SmallPtrSet<Value *, 16> AssumptionSet;
> + for (auto &VH : AssumeHandles) {
> + if (!VH)
> + continue;
> +
> + assert(&F == cast<Instruction>(VH)->getParent()->getParent() &&
> + "Cached assumption not inside this function!");
> + assert(match(cast<CallInst>(VH), m_Intrinsic<Intrinsic::assume>()) &&
> + "Cached something other than a call to @llvm.assume!");
> + assert(AssumptionSet.insert(VH).second &&
> + "Cache contains multiple copies of a call!");
> + }
This seems like an odd place for this logic. Arguably it should be in
the getter? Or at least called from the scanFunction code too?
> +#endif
> +}
> +
> +void AssumptionCacheTracker::FunctionCallbackVH::deleted() {
> + auto I = ACT->AssumptionCaches.find_as(cast<Function>(getValPtr()));
> + if (I != ACT->AssumptionCaches.end())
> + ACT->AssumptionCaches.erase(I);
> + // 'this' now dangles!
> +}
> +
> +AssumptionCache &AssumptionCacheTracker::getAssumptionCache(Function &F) {
> + // We probe the function map twice to try and avoid creating a value handle
> + // around the function in common cases. This makes insertion a bit slower,
> + // but if we have to insert we're going to scan the whole function so that
> + // shouldn't matter.
> + auto I = AssumptionCaches.find_as(&F);
> + if (I != AssumptionCaches.end())
> + return *I->second;
> +
> + // Ok, build a new cache by scanning the function, insert it and the value
> + // handle into our map, and return the newly populated cache.
> + auto IP = AssumptionCaches.insert(std::make_pair(
> + FunctionCallbackVH(&F, this), llvm::make_unique<AssumptionCache>(F)));
Why does creating a new AssumptionCache imply populating it?
> + assert(IP.second && "Scanning function already in the map?");
> + return *IP.first->second;
> +}
> +
> +void AssumptionCacheTracker::verifyAnalysis() const {
> +#ifndef NDEBUG
> + SmallPtrSet<const CallInst *, 4> AssumptionSet;
> + for (const auto &I : AssumptionCaches) {
> + for (auto &VH : I.second->assumptions())
> + if (VH)
> + AssumptionSet.insert(cast<CallInst>(VH));
> +
> + for (const BasicBlock &B : cast<Function>(*I.first))
> + for (const Instruction &II : B)
> + if (match(&II, m_Intrinsic<Intrinsic::assume>()))
> + assert(AssumptionSet.count(cast<CallInst>(&II)) &&
> + "Assumption in scanned function not in cache");
> + }
> +#endif
> +}
> +
> +AssumptionCacheTracker::AssumptionCacheTracker() : ImmutablePass(ID) {
> + initializeAssumptionCacheTrackerPass(*PassRegistry::getPassRegistry());
> +}
> +
> +AssumptionCacheTracker::~AssumptionCacheTracker() {}
> +
> +INITIALIZE_PASS(AssumptionCacheTracker, "assumption-cache-tracker",
> + "Assumption Cache Tracker", false, true)
> +char AssumptionCacheTracker::ID = 0;
>
> Removed: llvm/trunk/lib/Analysis/AssumptionTracker.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/AssumptionTracker.cpp?rev=225130&view=auto
> ==============================================================================
> --- llvm/trunk/lib/Analysis/AssumptionTracker.cpp (original)
> +++ llvm/trunk/lib/Analysis/AssumptionTracker.cpp (removed)
> @@ -1,110 +0,0 @@
> -//===- AssumptionTracker.cpp - Track @llvm.assume -------------------------===//
> -//
> -// The LLVM Compiler Infrastructure
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
> -//===----------------------------------------------------------------------===//
> -//
> -// This file contains a pass that keeps track of @llvm.assume intrinsics in
> -// the functions of a module.
> -//
> -//===----------------------------------------------------------------------===//
> -
> -#include "llvm/Analysis/AssumptionTracker.h"
> -#include "llvm/IR/CallSite.h"
> -#include "llvm/IR/Dominators.h"
> -#include "llvm/IR/Function.h"
> -#include "llvm/IR/Instructions.h"
> -#include "llvm/IR/IntrinsicInst.h"
> -#include "llvm/IR/PatternMatch.h"
> -#include "llvm/Support/Debug.h"
> -using namespace llvm;
> -using namespace llvm::PatternMatch;
> -
> -void AssumptionTracker::FunctionCallbackVH::deleted() {
> - AT->forgetCachedAssumptions(cast<Function>(getValPtr()));
> - // 'this' now dangles!
> -}
> -
> -void AssumptionTracker::forgetCachedAssumptions(Function *F) {
> - auto I = CachedAssumeCalls.find_as(F);
> - if (I != CachedAssumeCalls.end())
> - CachedAssumeCalls.erase(I);
> -}
> -
> -void AssumptionTracker::CallCallbackVH::deleted() {
> - assert(F && "delete callback called on dummy handle");
> - FunctionCallsMap::iterator I = AT->CachedAssumeCalls.find_as(F);
> - assert(I != AT->CachedAssumeCalls.end() &&
> - "Function cleared from the map without removing the values?");
> -
> - I->second->erase(*this);
> - // 'this' now dangles!
> -}
> -
> -AssumptionTracker::FunctionCallsMap::iterator
> -AssumptionTracker::scanFunction(Function *F) {
> - auto IP = CachedAssumeCalls.insert(std::make_pair(
> - FunctionCallbackVH(F, this), llvm::make_unique<CallHandleSet>()));
> - assert(IP.second && "Scanning function already in the map?");
> -
> - FunctionCallsMap::iterator I = IP.first;
> -
> - // Go through all instructions in all blocks, add all calls to @llvm.assume
> - // to our cache.
> - for (BasicBlock &B : *F)
> - for (Instruction &II : B)
> - if (match(&II, m_Intrinsic<Intrinsic::assume>()))
> - I->second->insert(CallCallbackVH(&II, this));
> -
> - return I;
> -}
> -
> -void AssumptionTracker::verifyAnalysis() const {
> -#ifndef NDEBUG
> - for (const auto &I : CachedAssumeCalls) {
> - for (const BasicBlock &B : cast<Function>(*I.first))
> - for (const Instruction &II : B) {
> - if (match(&II, m_Intrinsic<Intrinsic::assume>())) {
> - assert(I.second->find_as(&II) != I.second->end() &&
> - "Assumption in scanned function not in cache");
> - }
> - }
> - }
> -#endif
> -}
> -
> -void AssumptionTracker::registerAssumption(CallInst *CI) {
> - assert(match(CI, m_Intrinsic<Intrinsic::assume>()) &&
> - "Registered call does not call @llvm.assume");
> - assert(CI->getParent() &&
> - "Cannot register @llvm.assume call not in a basic block");
> -
> - Function *F = CI->getParent()->getParent();
> - assert(F && "Cannot register @llvm.assume call not in a function");
> -
> - FunctionCallsMap::iterator I = CachedAssumeCalls.find_as(F);
> - if (I == CachedAssumeCalls.end()) {
> - // If this function has not already been scanned, then don't do anything
> - // here. This intrinsic will be found, if it still exists, if the list of
> - // assumptions in this function is requested at some later point. This
> - // maintains the following invariant: if a function is present in the
> - // cache, then its list of assumption intrinsic calls is complete.
> - return;
> - }
> -
> - I->second->insert(CallCallbackVH(CI, this));
> -}
> -
> -AssumptionTracker::AssumptionTracker() : ImmutablePass(ID) {
> - initializeAssumptionTrackerPass(*PassRegistry::getPassRegistry());
> -}
> -
> -AssumptionTracker::~AssumptionTracker() {}
> -
> -INITIALIZE_PASS(AssumptionTracker, "assumption-tracker", "Assumption Tracker",
> - false, true)
> -char AssumptionTracker::ID = 0;
> -
>
> Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
> +++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Sun Jan 4 06:03:27 2015
> @@ -17,7 +17,7 @@
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CFG.h"
> #include "llvm/Analysis/CaptureTracking.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> @@ -196,8 +196,7 @@ namespace {
> static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
> ExtensionKind &Extension,
> const DataLayout &DL, unsigned Depth,
> - AssumptionTracker *AT,
> - DominatorTree *DT) {
> + AssumptionCache *AC, DominatorTree *DT) {
> assert(V->getType()->isIntegerTy() && "Not an integer value");
>
> // Limit our recursion depth.
> @@ -222,24 +221,24 @@ static Value *GetLinearExpression(Value
> case Instruction::Or:
> // X|C == X+C if all the bits in C are unset in X. Otherwise we can't
> // analyze it.
> - if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), &DL, 0,
> - AT, BOp, DT))
> + if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), &DL, 0, AC,
> + BOp, DT))
> break;
> // FALL THROUGH.
> case Instruction::Add:
> V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, Extension,
> - DL, Depth+1, AT, DT);
> + DL, Depth + 1, AC, DT);
> Offset += RHSC->getValue();
> return V;
> case Instruction::Mul:
> V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, Extension,
> - DL, Depth+1, AT, DT);
> + DL, Depth + 1, AC, DT);
> Offset *= RHSC->getValue();
> Scale *= RHSC->getValue();
> return V;
> case Instruction::Shl:
> V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, Extension,
> - DL, Depth+1, AT, DT);
> + DL, Depth + 1, AC, DT);
> Offset <<= RHSC->getValue().getLimitedValue();
> Scale <<= RHSC->getValue().getLimitedValue();
> return V;
> @@ -259,8 +258,8 @@ static Value *GetLinearExpression(Value
> Offset = Offset.trunc(SmallWidth);
> Extension = isa<SExtInst>(V) ? EK_SignExt : EK_ZeroExt;
>
> - Value *Result = GetLinearExpression(CastOp, Scale, Offset, Extension,
> - DL, Depth+1, AT, DT);
> + Value *Result = GetLinearExpression(CastOp, Scale, Offset, Extension, DL,
> + Depth + 1, AC, DT);
> Scale = Scale.zext(OldWidth);
>
> // We have to sign-extend even if Extension == EK_ZeroExt as we can't
> @@ -294,7 +293,7 @@ static const Value *
> DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
> SmallVectorImpl<VariableGEPIndex> &VarIndices,
> bool &MaxLookupReached, const DataLayout *DL,
> - AssumptionTracker *AT, DominatorTree *DT) {
> + AssumptionCache *AC, DominatorTree *DT) {
> // Limit recursion depth to limit compile time in crazy cases.
> unsigned MaxLookup = MaxLookupSearchDepth;
> MaxLookupReached = false;
> @@ -325,7 +324,7 @@ DecomposeGEPExpression(const Value *V, i
> // If it's not a GEP, hand it off to SimplifyInstruction to see if it
> // can come up with something. This matches what GetUnderlyingObject does.
> if (const Instruction *I = dyn_cast<Instruction>(V))
> - // TODO: Get a DominatorTree and AssumptionTracker and use them here
> + // TODO: Get a DominatorTree and AssumptionCache and use them here
> // (these are both now available in this function, but this should be
> // updated when GetUnderlyingObject is updated). TLI should be
> // provided also.
> @@ -387,7 +386,7 @@ DecomposeGEPExpression(const Value *V, i
> // Use GetLinearExpression to decompose the index into a C1*V+C2 form.
> APInt IndexScale(Width, 0), IndexOffset(Width, 0);
> Index = GetLinearExpression(Index, IndexScale, IndexOffset, Extension,
> - *DL, 0, AT, DT);
> + *DL, 0, AC, DT);
>
> // The GEP index scale ("Scale") scales C1*V+C2, yielding (C1*V+C2)*Scale.
> // This gives us an aggregate computation of (C1*Scale)*V + C2*Scale.
> @@ -468,7 +467,7 @@ namespace {
>
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> AU.addRequired<AliasAnalysis>();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<TargetLibraryInfo>();
> }
>
> @@ -591,7 +590,7 @@ char BasicAliasAnalysis::ID = 0;
> INITIALIZE_AG_PASS_BEGIN(BasicAliasAnalysis, AliasAnalysis, "basicaa",
> "Basic Alias Analysis (stateless AA impl)",
> false, true, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> INITIALIZE_AG_PASS_END(BasicAliasAnalysis, AliasAnalysis, "basicaa",
> "Basic Alias Analysis (stateless AA impl)",
> @@ -905,7 +904,22 @@ BasicAliasAnalysis::aliasGEP(const GEPOp
> bool GEP1MaxLookupReached;
> SmallVector<VariableGEPIndex, 4> GEP1VariableIndices;
>
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + // We have to get two AssumptionCaches here because GEP1 and V2 may be from
> + // different functions.
> + // FIXME: This really doesn't make any sense. We get a dominator tree below
> + // that can only refer to a single function. But this function (aliasGEP) is
> + // a method on an immutable pass that can be called when there *isn't*
> + // a single function. The old pass management layer makes this "work", but
> + // this isn't really a clean solution.
> + AssumptionCacheTracker &ACT = getAnalysis<AssumptionCacheTracker>();
> + AssumptionCache *AC1 = nullptr, *AC2 = nullptr;
> + if (auto *GEP1I = dyn_cast<Instruction>(GEP1))
> + AC1 = &ACT.getAssumptionCache(
> + const_cast<Function &>(*GEP1I->getParent()->getParent()));
> + if (auto *I2 = dyn_cast<Instruction>(V2))
> + AC2 = &ACT.getAssumptionCache(
> + const_cast<Function &>(*I2->getParent()->getParent()));
> +
> DominatorTreeWrapperPass *DTWP =
> getAnalysisIfAvailable<DominatorTreeWrapperPass>();
> DominatorTree *DT = DTWP ? &DTWP->getDomTree() : nullptr;
> @@ -932,11 +946,11 @@ BasicAliasAnalysis::aliasGEP(const GEPOp
> bool GEP2MaxLookupReached;
> SmallVector<VariableGEPIndex, 4> GEP2VariableIndices;
> const Value *GEP2BasePtr =
> - DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices,
> - GEP2MaxLookupReached, DL, AT, DT);
> + DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices,
> + GEP2MaxLookupReached, DL, AC2, DT);
> const Value *GEP1BasePtr =
> - DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
> - GEP1MaxLookupReached, DL, AT, DT);
> + DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
> + GEP1MaxLookupReached, DL, AC1, DT);
> // DecomposeGEPExpression and GetUnderlyingObject should return the
> // same result except when DecomposeGEPExpression has no DataLayout.
> if (GEP1BasePtr != UnderlyingV1 || GEP2BasePtr != UnderlyingV2) {
> @@ -964,15 +978,15 @@ BasicAliasAnalysis::aliasGEP(const GEPOp
> // exactly, see if the computed offset from the common pointer tells us
> // about the relation of the resulting pointer.
> const Value *GEP1BasePtr =
> - DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
> - GEP1MaxLookupReached, DL, AT, DT);
> + DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
> + GEP1MaxLookupReached, DL, AC1, DT);
>
> int64_t GEP2BaseOffset;
> bool GEP2MaxLookupReached;
> SmallVector<VariableGEPIndex, 4> GEP2VariableIndices;
> const Value *GEP2BasePtr =
> - DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices,
> - GEP2MaxLookupReached, DL, AT, DT);
> + DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices,
> + GEP2MaxLookupReached, DL, AC2, DT);
>
> // DecomposeGEPExpression and GetUnderlyingObject should return the
> // same result except when DecomposeGEPExpression has no DataLayout.
> @@ -1010,8 +1024,8 @@ BasicAliasAnalysis::aliasGEP(const GEPOp
> return R;
>
> const Value *GEP1BasePtr =
> - DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
> - GEP1MaxLookupReached, DL, AT, DT);
> + DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
> + GEP1MaxLookupReached, DL, AC1, DT);
>
> // DecomposeGEPExpression and GetUnderlyingObject should return the
> // same result except when DecomposeGEPExpression has no DataLayout.
> @@ -1080,10 +1094,8 @@ BasicAliasAnalysis::aliasGEP(const GEPOp
> const Value *V = GEP1VariableIndices[i].V;
>
> bool SignKnownZero, SignKnownOne;
> - ComputeSignBit(
> - const_cast<Value *>(V),
> - SignKnownZero, SignKnownOne,
> - DL, 0, AT, nullptr, DT);
> + ComputeSignBit(const_cast<Value *>(V), SignKnownZero, SignKnownOne, DL,
> + 0, AC1, nullptr, DT);
>
> // Zero-extension widens the variable, and so forces the sign
> // bit to zero.
>
> Modified: llvm/trunk/lib/Analysis/CMakeLists.txt
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/CMakeLists.txt?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/CMakeLists.txt (original)
> +++ llvm/trunk/lib/Analysis/CMakeLists.txt Sun Jan 4 06:03:27 2015
> @@ -5,7 +5,7 @@ add_llvm_library(LLVMAnalysis
> AliasDebugger.cpp
> AliasSetTracker.cpp
> Analysis.cpp
> - AssumptionTracker.cpp
> + AssumptionCache.cpp
> BasicAliasAnalysis.cpp
> BlockFrequencyInfo.cpp
> BlockFrequencyInfoImpl.cpp
>
> Modified: llvm/trunk/lib/Analysis/CodeMetrics.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/CodeMetrics.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/CodeMetrics.cpp (original)
> +++ llvm/trunk/lib/Analysis/CodeMetrics.cpp Sun Jan 4 06:03:27 2015
> @@ -11,7 +11,7 @@
> //
> //===----------------------------------------------------------------------===//
>
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CodeMetrics.h"
> #include "llvm/Analysis/LoopInfo.h"
> #include "llvm/Analysis/TargetTransformInfo.h"
> @@ -66,11 +66,16 @@ static void completeEphemeralValues(Smal
> }
>
> // Find all ephemeral values.
> -void CodeMetrics::collectEphemeralValues(const Loop *L, AssumptionTracker *AT,
> - SmallPtrSetImpl<const Value*> &EphValues) {
> +void CodeMetrics::collectEphemeralValues(
> + const Loop *L, AssumptionCache *AC,
> + SmallPtrSetImpl<const Value *> &EphValues) {
> SmallVector<const Value *, 16> WorkSet;
>
> - for (auto &I : AT->assumptions(L->getHeader()->getParent())) {
> + for (auto &AssumeVH : AC->assumptions()) {
> + if (!AssumeVH)
> + continue;
> + Instruction *I = cast<Instruction>(AssumeVH);
> +
> // Filter out call sites outside of the loop so we don't to a function's
> // worth of work for each of its loops (and, in the common case, ephemeral
> // values in the loop are likely due to @llvm.assume calls in the loop).
> @@ -83,12 +88,19 @@ void CodeMetrics::collectEphemeralValues
> completeEphemeralValues(WorkSet, EphValues);
> }
>
> -void CodeMetrics::collectEphemeralValues(const Function *F, AssumptionTracker *AT,
> - SmallPtrSetImpl<const Value*> &EphValues) {
> +void CodeMetrics::collectEphemeralValues(
> + const Function *F, AssumptionCache *AC,
> + SmallPtrSetImpl<const Value *> &EphValues) {
> SmallVector<const Value *, 16> WorkSet;
>
> - for (auto &I : AT->assumptions(const_cast<Function*>(F)))
> + for (auto &AssumeVH : AC->assumptions()) {
> + if (!AssumeVH)
> + continue;
> + Instruction *I = cast<Instruction>(AssumeVH);
> + assert(I->getParent()->getParent() == F &&
> + "Found assumption for the wrong function!");
> WorkSet.push_back(I);
> + }
>
> completeEphemeralValues(WorkSet, EphValues);
> }
>
> Modified: llvm/trunk/lib/Analysis/IPA/InlineCost.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/IPA/InlineCost.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/IPA/InlineCost.cpp (original)
> +++ llvm/trunk/lib/Analysis/IPA/InlineCost.cpp Sun Jan 4 06:03:27 2015
> @@ -17,7 +17,7 @@
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/ConstantFolding.h"
> #include "llvm/Analysis/CodeMetrics.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> @@ -52,7 +52,7 @@ class CallAnalyzer : public InstVisitor<
> const TargetTransformInfo &TTI;
>
> /// The cache of @llvm.assume intrinsics.
> - AssumptionTracker *AT;
> + AssumptionCache &AC;
>
> // The called function.
> Function &F;
> @@ -146,8 +146,8 @@ class CallAnalyzer : public InstVisitor<
>
> public:
> CallAnalyzer(const DataLayout *DL, const TargetTransformInfo &TTI,
> - AssumptionTracker *AT, Function &Callee, int Threshold)
> - : DL(DL), TTI(TTI), AT(AT), F(Callee), Threshold(Threshold), Cost(0),
> + AssumptionCache &AC, Function &Callee, int Threshold)
> + : DL(DL), TTI(TTI), AC(AC), F(Callee), Threshold(Threshold), Cost(0),
> IsCallerRecursive(false), IsRecursiveCall(false),
> ExposesReturnsTwice(false), HasDynamicAlloca(false),
> ContainsNoDuplicateCall(false), HasReturn(false), HasIndirectBr(false),
> @@ -783,7 +783,7 @@ bool CallAnalyzer::visitCallSite(CallSit
> // during devirtualization and so we want to give it a hefty bonus for
> // inlining, but cap that bonus in the event that inlining wouldn't pan
> // out. Pretend to inline the function, with a custom threshold.
> - CallAnalyzer CA(DL, TTI, AT, *F, InlineConstants::IndirectCallThreshold);
> + CallAnalyzer CA(DL, TTI, AC, *F, InlineConstants::IndirectCallThreshold);
> if (CA.analyzeCall(CS)) {
> // We were able to inline the indirect call! Subtract the cost from the
> // bonus we want to apply, but don't go below zero.
> @@ -1110,7 +1110,7 @@ bool CallAnalyzer::analyzeCall(CallSite
> // the ephemeral values multiple times (and they're completely determined by
> // the callee, so this is purely duplicate work).
> SmallPtrSet<const Value *, 32> EphValues;
> - CodeMetrics::collectEphemeralValues(&F, AT, EphValues);
> + CodeMetrics::collectEphemeralValues(&F, &AC, EphValues);
>
> // The worklist of live basic blocks in the callee *after* inlining. We avoid
> // adding basic blocks of the callee which can be proven to be dead for this
> @@ -1233,7 +1233,7 @@ void CallAnalyzer::dump() {
> INITIALIZE_PASS_BEGIN(InlineCostAnalysis, "inline-cost", "Inline Cost Analysis",
> true, true)
> INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_END(InlineCostAnalysis, "inline-cost", "Inline Cost Analysis",
> true, true)
>
> @@ -1245,14 +1245,14 @@ InlineCostAnalysis::~InlineCostAnalysis(
>
> void InlineCostAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
> AU.setPreservesAll();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<TargetTransformInfo>();
> CallGraphSCCPass::getAnalysisUsage(AU);
> }
>
> bool InlineCostAnalysis::runOnSCC(CallGraphSCC &SCC) {
> TTI = &getAnalysis<TargetTransformInfo>();
> - AT = &getAnalysis<AssumptionTracker>();
> + ACT = &getAnalysis<AssumptionCacheTracker>();
> return false;
> }
>
> @@ -1309,7 +1309,8 @@ InlineCost InlineCostAnalysis::getInline
> DEBUG(llvm::dbgs() << " Analyzing call of " << Callee->getName()
> << "...\n");
>
> - CallAnalyzer CA(Callee->getDataLayout(), *TTI, AT, *Callee, Threshold);
> + CallAnalyzer CA(Callee->getDataLayout(), *TTI,
> + ACT->getAssumptionCache(*Callee), *Callee, Threshold);
> bool ShouldInline = CA.analyzeCall(CS);
>
> DEBUG(CA.dump());
>
> Modified: llvm/trunk/lib/Analysis/InstructionSimplify.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/InstructionSimplify.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/InstructionSimplify.cpp (original)
> +++ llvm/trunk/lib/Analysis/InstructionSimplify.cpp Sun Jan 4 06:03:27 2015
> @@ -48,13 +48,13 @@ struct Query {
> const DataLayout *DL;
> const TargetLibraryInfo *TLI;
> const DominatorTree *DT;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> const Instruction *CxtI;
>
> Query(const DataLayout *DL, const TargetLibraryInfo *tli,
> - const DominatorTree *dt, AssumptionTracker *at = nullptr,
> + const DominatorTree *dt, AssumptionCache *ac = nullptr,
> const Instruction *cxti = nullptr)
> - : DL(DL), TLI(tli), DT(dt), AT(at), CxtI(cxti) {}
> + : DL(DL), TLI(tli), DT(dt), AC(ac), CxtI(cxti) {}
> };
> } // end anonymous namespace
>
> @@ -583,10 +583,10 @@ static Value *SimplifyAddInst(Value *Op0
>
> Value *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
> const DataLayout *DL, const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW,
> - Query (DL, TLI, DT, AT, CxtI), RecursionLimit);
> + return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
> + RecursionLimit);
> }
>
> /// \brief Compute the base pointer and cumulative constant offsets for V.
> @@ -782,10 +782,10 @@ static Value *SimplifySubInst(Value *Op0
>
> Value *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
> const DataLayout *DL, const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifySubInst(Op0, Op1, isNSW, isNUW,
> - Query (DL, TLI, DT, AT, CxtI), RecursionLimit);
> + return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
> + RecursionLimit);
> }
>
> /// Given operands for an FAdd, see if we can fold the result. If not, this
> @@ -960,37 +960,37 @@ static Value *SimplifyMulInst(Value *Op0
> }
>
> Value *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
> - const DataLayout *DL, const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> - const Instruction *CxtI) {
> - return ::SimplifyFAddInst(Op0, Op1, FMF, Query (DL, TLI, DT, AT, CxtI),
> + const DataLayout *DL,
> + const TargetLibraryInfo *TLI,
> + const DominatorTree *DT, AssumptionCache *AC,
> + const Instruction *CxtI) {
> + return ::SimplifyFAddInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> Value *llvm::SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
> - const DataLayout *DL, const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> - const Instruction *CxtI) {
> - return ::SimplifyFSubInst(Op0, Op1, FMF, Query (DL, TLI, DT, AT, CxtI),
> + const DataLayout *DL,
> + const TargetLibraryInfo *TLI,
> + const DominatorTree *DT, AssumptionCache *AC,
> + const Instruction *CxtI) {
> + return ::SimplifyFSubInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> -Value *llvm::SimplifyFMulInst(Value *Op0, Value *Op1,
> - FastMathFlags FMF,
> +Value *llvm::SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
> const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyFMulInst(Op0, Op1, FMF, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyFMulInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> Value *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyMulInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyMulInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1092,10 +1092,9 @@ static Value *SimplifySDivInst(Value *Op
>
> Value *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifySDivInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifySDivInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1111,10 +1110,9 @@ static Value *SimplifyUDivInst(Value *Op
>
> Value *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyUDivInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyUDivInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1133,10 +1131,9 @@ static Value *SimplifyFDivInst(Value *Op
>
> Value *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyFDivInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyFDivInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1213,10 +1210,9 @@ static Value *SimplifySRemInst(Value *Op
>
> Value *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifySRemInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifySRemInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1232,10 +1228,9 @@ static Value *SimplifyURemInst(Value *Op
>
> Value *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyURemInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyURemInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1254,10 +1249,9 @@ static Value *SimplifyFRemInst(Value *Op
>
> Value *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyFRemInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyFRemInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1348,8 +1342,8 @@ static Value *SimplifyRightShift(unsigne
> unsigned BitWidth = Op0->getType()->getScalarSizeInBits();
> APInt Op0KnownZero(BitWidth, 0);
> APInt Op0KnownOne(BitWidth, 0);
> - computeKnownBits(Op0, Op0KnownZero, Op0KnownOne, Q.DL, /*Depth=*/0, Q.AT, Q.CxtI,
> - Q.DT);
> + computeKnownBits(Op0, Op0KnownZero, Op0KnownOne, Q.DL, /*Depth=*/0, Q.AC,
> + Q.CxtI, Q.DT);
> if (Op0KnownOne[0])
> return Op0;
> }
> @@ -1378,9 +1372,9 @@ static Value *SimplifyShlInst(Value *Op0
>
> Value *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
> const DataLayout *DL, const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1403,10 +1397,9 @@ static Value *SimplifyLShrInst(Value *Op
> Value *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
> const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyLShrInst(Op0, Op1, isExact, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyLShrInst(Op0, Op1, isExact, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1428,7 +1421,7 @@ static Value *SimplifyAShrInst(Value *Op
> return X;
>
> // Arithmetic shifting an all-sign-bit value is a no-op.
> - unsigned NumSignBits = ComputeNumSignBits(Op0, Q.DL, 0, Q.AT, Q.CxtI, Q.DT);
> + unsigned NumSignBits = ComputeNumSignBits(Op0, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
> if (NumSignBits == Op0->getType()->getScalarSizeInBits())
> return Op0;
>
> @@ -1438,10 +1431,9 @@ static Value *SimplifyAShrInst(Value *Op
> Value *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
> const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyAShrInst(Op0, Op1, isExact, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyAShrInst(Op0, Op1, isExact, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1588,9 +1580,9 @@ static Value *SimplifyAndInst(Value *Op0
> // A & (-A) = A if A is a power of two or zero.
> if (match(Op0, m_Neg(m_Specific(Op1))) ||
> match(Op1, m_Neg(m_Specific(Op0)))) {
> - if (isKnownToBeAPowerOfTwo(Op0, /*OrZero*/true, 0, Q.AT, Q.CxtI, Q.DT))
> + if (isKnownToBeAPowerOfTwo(Op0, /*OrZero*/ true, 0, Q.AC, Q.CxtI, Q.DT))
> return Op0;
> - if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/true, 0, Q.AT, Q.CxtI, Q.DT))
> + if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, Q.AC, Q.CxtI, Q.DT))
> return Op1;
> }
>
> @@ -1637,9 +1629,9 @@ static Value *SimplifyAndInst(Value *Op0
>
> Value *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyAndInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyAndInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1793,22 +1785,22 @@ static Value *SimplifyOrInst(Value *Op0,
> if ((C2->getValue() & (C2->getValue() + 1)) == 0 && // C2 == 0+1+
> match(A, m_Add(m_Value(V1), m_Value(V2)))) {
> // Add commutes, try both ways.
> - if (V1 == B && MaskedValueIsZero(V2, C2->getValue(), Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT))
> + if (V1 == B &&
> + MaskedValueIsZero(V2, C2->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
> return A;
> - if (V2 == B && MaskedValueIsZero(V1, C2->getValue(), Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT))
> + if (V2 == B &&
> + MaskedValueIsZero(V1, C2->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
> return A;
> }
> // Or commutes, try both ways.
> if ((C1->getValue() & (C1->getValue() + 1)) == 0 &&
> match(B, m_Add(m_Value(V1), m_Value(V2)))) {
> // Add commutes, try both ways.
> - if (V1 == A && MaskedValueIsZero(V2, C1->getValue(), Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT))
> + if (V1 == A &&
> + MaskedValueIsZero(V2, C1->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
> return B;
> - if (V2 == A && MaskedValueIsZero(V1, C1->getValue(), Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT))
> + if (V2 == A &&
> + MaskedValueIsZero(V1, C1->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
> return B;
> }
> }
> @@ -1825,9 +1817,9 @@ static Value *SimplifyOrInst(Value *Op0,
>
> Value *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyOrInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyOrInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -1882,9 +1874,9 @@ static Value *SimplifyXorInst(Value *Op0
>
> Value *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyXorInst(Op0, Op1, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyXorInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -2183,46 +2175,46 @@ static Value *SimplifyICmpInst(unsigned
> return getTrue(ITy);
> case ICmpInst::ICMP_EQ:
> case ICmpInst::ICMP_ULE:
> - if (isKnownNonZero(LHS, Q.DL, 0, Q.AT, Q.CxtI, Q.DT))
> + if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
> return getFalse(ITy);
> break;
> case ICmpInst::ICMP_NE:
> case ICmpInst::ICMP_UGT:
> - if (isKnownNonZero(LHS, Q.DL, 0, Q.AT, Q.CxtI, Q.DT))
> + if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
> return getTrue(ITy);
> break;
> case ICmpInst::ICMP_SLT:
> - ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT);
> + ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
> + Q.CxtI, Q.DT);
> if (LHSKnownNegative)
> return getTrue(ITy);
> if (LHSKnownNonNegative)
> return getFalse(ITy);
> break;
> case ICmpInst::ICMP_SLE:
> - ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT);
> + ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
> + Q.CxtI, Q.DT);
> if (LHSKnownNegative)
> return getTrue(ITy);
> - if (LHSKnownNonNegative && isKnownNonZero(LHS, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT))
> + if (LHSKnownNonNegative &&
> + isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
> return getFalse(ITy);
> break;
> case ICmpInst::ICMP_SGE:
> - ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT);
> + ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
> + Q.CxtI, Q.DT);
> if (LHSKnownNegative)
> return getFalse(ITy);
> if (LHSKnownNonNegative)
> return getTrue(ITy);
> break;
> case ICmpInst::ICMP_SGT:
> - ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT);
> + ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
> + Q.CxtI, Q.DT);
> if (LHSKnownNegative)
> return getFalse(ITy);
> - if (LHSKnownNonNegative && isKnownNonZero(LHS, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT))
> + if (LHSKnownNonNegative &&
> + isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
> return getTrue(ITy);
> break;
> }
> @@ -2638,8 +2630,8 @@ static Value *SimplifyICmpInst(unsigned
> break;
> case ICmpInst::ICMP_SGT:
> case ICmpInst::ICMP_SGE:
> - ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT);
> + ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
> + Q.CxtI, Q.DT);
> if (!KnownNonNegative)
> break;
> // fall-through
> @@ -2649,8 +2641,8 @@ static Value *SimplifyICmpInst(unsigned
> return getFalse(ITy);
> case ICmpInst::ICMP_SLT:
> case ICmpInst::ICMP_SLE:
> - ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT);
> + ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
> + Q.CxtI, Q.DT);
> if (!KnownNonNegative)
> break;
> // fall-through
> @@ -2669,8 +2661,8 @@ static Value *SimplifyICmpInst(unsigned
> break;
> case ICmpInst::ICMP_SGT:
> case ICmpInst::ICMP_SGE:
> - ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT);
> + ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
> + Q.CxtI, Q.DT);
> if (!KnownNonNegative)
> break;
> // fall-through
> @@ -2680,8 +2672,8 @@ static Value *SimplifyICmpInst(unsigned
> return getTrue(ITy);
> case ICmpInst::ICMP_SLT:
> case ICmpInst::ICMP_SLE:
> - ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL,
> - 0, Q.AT, Q.CxtI, Q.DT);
> + ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
> + Q.CxtI, Q.DT);
> if (!KnownNonNegative)
> break;
> // fall-through
> @@ -2990,7 +2982,7 @@ static Value *SimplifyICmpInst(unsigned
> uint32_t BitWidth = CI->getBitWidth();
> APInt LHSKnownZero(BitWidth, 0);
> APInt LHSKnownOne(BitWidth, 0);
> - computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, Q.DL, /*Depth=*/0, Q.AT,
> + computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, Q.DL, /*Depth=*/0, Q.AC,
> Q.CxtI, Q.DT);
> const APInt &RHSVal = CI->getValue();
> if (((LHSKnownZero & RHSVal) != 0) || ((LHSKnownOne & ~RHSVal) != 0))
> @@ -3018,10 +3010,9 @@ static Value *SimplifyICmpInst(unsigned
> Value *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
> const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> Instruction *CxtI) {
> - return ::SimplifyICmpInst(Predicate, LHS, RHS, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyICmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -3117,10 +3108,9 @@ static Value *SimplifyFCmpInst(unsigned
> Value *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
> const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyFCmpInst(Predicate, LHS, RHS, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyFCmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -3213,11 +3203,10 @@ static Value *SimplifySelectInst(Value *
> Value *llvm::SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
> const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> return ::SimplifySelectInst(Cond, TrueVal, FalseVal,
> - Query (DL, TLI, DT, AT, CxtI), RecursionLimit);
> + Query(DL, TLI, DT, AC, CxtI), RecursionLimit);
> }
>
> /// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
> @@ -3304,9 +3293,9 @@ static Value *SimplifyGEPInst(ArrayRef<V
>
> Value *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyGEPInst(Ops, Query (DL, TLI, DT, AT, CxtI), RecursionLimit);
> + return ::SimplifyGEPInst(Ops, Query(DL, TLI, DT, AC, CxtI), RecursionLimit);
> }
>
> /// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we
> @@ -3338,15 +3327,11 @@ static Value *SimplifyInsertValueInst(Va
> return nullptr;
> }
>
> -Value *llvm::SimplifyInsertValueInst(Value *Agg, Value *Val,
> - ArrayRef<unsigned> Idxs,
> - const DataLayout *DL,
> - const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> - const Instruction *CxtI) {
> - return ::SimplifyInsertValueInst(Agg, Val, Idxs,
> - Query (DL, TLI, DT, AT, CxtI),
> +Value *llvm::SimplifyInsertValueInst(
> + Value *Agg, Value *Val, ArrayRef<unsigned> Idxs, const DataLayout *DL,
> + const TargetLibraryInfo *TLI, const DominatorTree *DT, AssumptionCache *AC,
> + const Instruction *CxtI) {
> + return ::SimplifyInsertValueInst(Agg, Val, Idxs, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -3393,10 +3378,9 @@ static Value *SimplifyTruncInst(Value *O
>
> Value *llvm::SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyTruncInst(Op, Ty, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyTruncInst(Op, Ty, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -3469,9 +3453,9 @@ static Value *SimplifyBinOp(unsigned Opc
>
> Value *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
> const DataLayout *DL, const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyBinOp(Opcode, LHS, RHS, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyBinOp(Opcode, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -3486,9 +3470,9 @@ static Value *SimplifyCmpInst(unsigned P
>
> Value *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
> const DataLayout *DL, const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> - return ::SimplifyCmpInst(Predicate, LHS, RHS, Query (DL, TLI, DT, AT, CxtI),
> + return ::SimplifyCmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> @@ -3562,27 +3546,25 @@ static Value *SimplifyCall(Value *V, Ite
>
> Value *llvm::SimplifyCall(Value *V, User::op_iterator ArgBegin,
> User::op_iterator ArgEnd, const DataLayout *DL,
> - const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> - const Instruction *CxtI) {
> - return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(DL, TLI, DT, AT, CxtI),
> + const TargetLibraryInfo *TLI, const DominatorTree *DT,
> + AssumptionCache *AC, const Instruction *CxtI) {
> + return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(DL, TLI, DT, AC, CxtI),
> RecursionLimit);
> }
>
> Value *llvm::SimplifyCall(Value *V, ArrayRef<Value *> Args,
> const DataLayout *DL, const TargetLibraryInfo *TLI,
> - const DominatorTree *DT, AssumptionTracker *AT,
> + const DominatorTree *DT, AssumptionCache *AC,
> const Instruction *CxtI) {
> return ::SimplifyCall(V, Args.begin(), Args.end(),
> - Query(DL, TLI, DT, AT, CxtI), RecursionLimit);
> + Query(DL, TLI, DT, AC, CxtI), RecursionLimit);
> }
>
> /// SimplifyInstruction - See if we can compute a simplified version of this
> /// instruction. If not, this returns null.
> Value *llvm::SimplifyInstruction(Instruction *I, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> - const DominatorTree *DT,
> - AssumptionTracker *AT) {
> + const DominatorTree *DT, AssumptionCache *AC) {
> Value *Result;
>
> switch (I->getOpcode()) {
> @@ -3591,122 +3573,122 @@ Value *llvm::SimplifyInstruction(Instruc
> break;
> case Instruction::FAdd:
> Result = SimplifyFAddInst(I->getOperand(0), I->getOperand(1),
> - I->getFastMathFlags(), DL, TLI, DT, AT, I);
> + I->getFastMathFlags(), DL, TLI, DT, AC, I);
> break;
> case Instruction::Add:
> Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1),
> cast<BinaryOperator>(I)->hasNoSignedWrap(),
> - cast<BinaryOperator>(I)->hasNoUnsignedWrap(),
> - DL, TLI, DT, AT, I);
> + cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL,
> + TLI, DT, AC, I);
> break;
> case Instruction::FSub:
> Result = SimplifyFSubInst(I->getOperand(0), I->getOperand(1),
> - I->getFastMathFlags(), DL, TLI, DT, AT, I);
> + I->getFastMathFlags(), DL, TLI, DT, AC, I);
> break;
> case Instruction::Sub:
> Result = SimplifySubInst(I->getOperand(0), I->getOperand(1),
> cast<BinaryOperator>(I)->hasNoSignedWrap(),
> - cast<BinaryOperator>(I)->hasNoUnsignedWrap(),
> - DL, TLI, DT, AT, I);
> + cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL,
> + TLI, DT, AC, I);
> break;
> case Instruction::FMul:
> Result = SimplifyFMulInst(I->getOperand(0), I->getOperand(1),
> - I->getFastMathFlags(), DL, TLI, DT, AT, I);
> + I->getFastMathFlags(), DL, TLI, DT, AC, I);
> break;
> case Instruction::Mul:
> - Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result =
> + SimplifyMulInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I);
> break;
> case Instruction::SDiv:
> - Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
> + AC, I);
> break;
> case Instruction::UDiv:
> - Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
> + AC, I);
> break;
> case Instruction::FDiv:
> - Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
> + AC, I);
> break;
> case Instruction::SRem:
> - Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
> + AC, I);
> break;
> case Instruction::URem:
> - Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
> + AC, I);
> break;
> case Instruction::FRem:
> - Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
> + AC, I);
> break;
> case Instruction::Shl:
> Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1),
> cast<BinaryOperator>(I)->hasNoSignedWrap(),
> - cast<BinaryOperator>(I)->hasNoUnsignedWrap(),
> - DL, TLI, DT, AT, I);
> + cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL,
> + TLI, DT, AC, I);
> break;
> case Instruction::LShr:
> Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1),
> - cast<BinaryOperator>(I)->isExact(),
> - DL, TLI, DT, AT, I);
> + cast<BinaryOperator>(I)->isExact(), DL, TLI, DT,
> + AC, I);
> break;
> case Instruction::AShr:
> Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1),
> - cast<BinaryOperator>(I)->isExact(),
> - DL, TLI, DT, AT, I);
> + cast<BinaryOperator>(I)->isExact(), DL, TLI, DT,
> + AC, I);
> break;
> case Instruction::And:
> - Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result =
> + SimplifyAndInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I);
> break;
> case Instruction::Or:
> - Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
> - AT, I);
> + Result =
> + SimplifyOrInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I);
> break;
> case Instruction::Xor:
> - Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result =
> + SimplifyXorInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I);
> break;
> case Instruction::ICmp:
> - Result = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(),
> - I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result =
> + SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), I->getOperand(0),
> + I->getOperand(1), DL, TLI, DT, AC, I);
> break;
> case Instruction::FCmp:
> - Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(),
> - I->getOperand(0), I->getOperand(1),
> - DL, TLI, DT, AT, I);
> + Result =
> + SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), I->getOperand(0),
> + I->getOperand(1), DL, TLI, DT, AC, I);
> break;
> case Instruction::Select:
> Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1),
> - I->getOperand(2), DL, TLI, DT, AT, I);
> + I->getOperand(2), DL, TLI, DT, AC, I);
> break;
> case Instruction::GetElementPtr: {
> SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end());
> - Result = SimplifyGEPInst(Ops, DL, TLI, DT, AT, I);
> + Result = SimplifyGEPInst(Ops, DL, TLI, DT, AC, I);
> break;
> }
> case Instruction::InsertValue: {
> InsertValueInst *IV = cast<InsertValueInst>(I);
> Result = SimplifyInsertValueInst(IV->getAggregateOperand(),
> IV->getInsertedValueOperand(),
> - IV->getIndices(), DL, TLI, DT, AT, I);
> + IV->getIndices(), DL, TLI, DT, AC, I);
> break;
> }
> case Instruction::PHI:
> - Result = SimplifyPHINode(cast<PHINode>(I), Query (DL, TLI, DT, AT, I));
> + Result = SimplifyPHINode(cast<PHINode>(I), Query(DL, TLI, DT, AC, I));
> break;
> case Instruction::Call: {
> CallSite CS(cast<CallInst>(I));
> - Result = SimplifyCall(CS.getCalledValue(), CS.arg_begin(), CS.arg_end(),
> - DL, TLI, DT, AT, I);
> + Result = SimplifyCall(CS.getCalledValue(), CS.arg_begin(), CS.arg_end(), DL,
> + TLI, DT, AC, I);
> break;
> }
> case Instruction::Trunc:
> - Result = SimplifyTruncInst(I->getOperand(0), I->getType(), DL, TLI, DT,
> - AT, I);
> + Result =
> + SimplifyTruncInst(I->getOperand(0), I->getType(), DL, TLI, DT, AC, I);
> break;
> }
>
> @@ -3731,7 +3713,7 @@ static bool replaceAndRecursivelySimplif
> const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> const DominatorTree *DT,
> - AssumptionTracker *AT) {
> + AssumptionCache *AC) {
> bool Simplified = false;
> SmallSetVector<Instruction *, 8> Worklist;
>
> @@ -3758,7 +3740,7 @@ static bool replaceAndRecursivelySimplif
> I = Worklist[Idx];
>
> // See if this instruction simplifies.
> - SimpleV = SimplifyInstruction(I, DL, TLI, DT, AT);
> + SimpleV = SimplifyInstruction(I, DL, TLI, DT, AC);
> if (!SimpleV)
> continue;
>
> @@ -3781,20 +3763,19 @@ static bool replaceAndRecursivelySimplif
> return Simplified;
> }
>
> -bool llvm::recursivelySimplifyInstruction(Instruction *I,
> - const DataLayout *DL,
> +bool llvm::recursivelySimplifyInstruction(Instruction *I, const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> const DominatorTree *DT,
> - AssumptionTracker *AT) {
> - return replaceAndRecursivelySimplifyImpl(I, nullptr, DL, TLI, DT, AT);
> + AssumptionCache *AC) {
> + return replaceAndRecursivelySimplifyImpl(I, nullptr, DL, TLI, DT, AC);
> }
>
> bool llvm::replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV,
> const DataLayout *DL,
> const TargetLibraryInfo *TLI,
> const DominatorTree *DT,
> - AssumptionTracker *AT) {
> + AssumptionCache *AC) {
> assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!");
> assert(SimpleV && "Must provide a simplified value.");
> - return replaceAndRecursivelySimplifyImpl(I, SimpleV, DL, TLI, DT, AT);
> + return replaceAndRecursivelySimplifyImpl(I, SimpleV, DL, TLI, DT, AC);
> }
>
> Modified: llvm/trunk/lib/Analysis/LazyValueInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/LazyValueInfo.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/LazyValueInfo.cpp (original)
> +++ llvm/trunk/lib/Analysis/LazyValueInfo.cpp Sun Jan 4 06:03:27 2015
> @@ -15,7 +15,7 @@
> #include "llvm/Analysis/LazyValueInfo.h"
> #include "llvm/ADT/DenseSet.h"
> #include "llvm/ADT/STLExtras.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/ConstantFolding.h"
> #include "llvm/Analysis/ValueTracking.h"
> #include "llvm/IR/CFG.h"
> @@ -40,7 +40,7 @@ using namespace PatternMatch;
> char LazyValueInfo::ID = 0;
> INITIALIZE_PASS_BEGIN(LazyValueInfo, "lazy-value-info",
> "Lazy Value Information Analysis", false, true)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> INITIALIZE_PASS_END(LazyValueInfo, "lazy-value-info",
> "Lazy Value Information Analysis", false, true)
> @@ -358,7 +358,7 @@ namespace {
> }
>
> /// A pointer to the cache of @llvm.assume calls.
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> /// An optional DL pointer.
> const DataLayout *DL;
> /// An optional DT pointer.
> @@ -430,9 +430,9 @@ namespace {
> OverDefinedCache.clear();
> }
>
> - LazyValueInfoCache(AssumptionTracker *AT,
> - const DataLayout *DL = nullptr,
> - DominatorTree *DT = nullptr) : AT(AT), DL(DL), DT(DT) {}
> + LazyValueInfoCache(AssumptionCache *AC, const DataLayout *DL = nullptr,
> + DominatorTree *DT = nullptr)
> + : AC(AC), DL(DL), DT(DT) {}
> };
> } // end anonymous namespace
>
> @@ -735,7 +735,10 @@ void LazyValueInfoCache::mergeAssumeBloc
> if (!BBI)
> return;
>
> - for (auto &I : AT->assumptions(BBI->getParent()->getParent())) {
> + for (auto &AssumeVH : AC->assumptions()) {
> + if (!AssumeVH)
> + continue;
> + auto *I = cast<CallInst>(AssumeVH);
> if (!isValidAssumeForContext(I, BBI, DL, DT))
> continue;
>
> @@ -1104,17 +1107,16 @@ void LazyValueInfoCache::threadEdge(Basi
> //===----------------------------------------------------------------------===//
>
> /// getCache - This lazily constructs the LazyValueInfoCache.
> -static LazyValueInfoCache &getCache(void *&PImpl,
> - AssumptionTracker *AT,
> +static LazyValueInfoCache &getCache(void *&PImpl, AssumptionCache *AC,
> const DataLayout *DL = nullptr,
> DominatorTree *DT = nullptr) {
> if (!PImpl)
> - PImpl = new LazyValueInfoCache(AT, DL, DT);
> + PImpl = new LazyValueInfoCache(AC, DL, DT);
> return *static_cast<LazyValueInfoCache*>(PImpl);
> }
>
> bool LazyValueInfo::runOnFunction(Function &F) {
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
>
> DominatorTreeWrapperPass *DTWP =
> getAnalysisIfAvailable<DominatorTreeWrapperPass>();
> @@ -1126,7 +1128,7 @@ bool LazyValueInfo::runOnFunction(Functi
> TLI = &getAnalysis<TargetLibraryInfo>();
>
> if (PImpl)
> - getCache(PImpl, AT, DL, DT).clear();
> + getCache(PImpl, AC, DL, DT).clear();
>
> // Fully lazy.
> return false;
> @@ -1134,14 +1136,14 @@ bool LazyValueInfo::runOnFunction(Functi
>
> void LazyValueInfo::getAnalysisUsage(AnalysisUsage &AU) const {
> AU.setPreservesAll();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<TargetLibraryInfo>();
> }
>
> void LazyValueInfo::releaseMemory() {
> // If the cache was allocated, free it.
> if (PImpl) {
> - delete &getCache(PImpl, AT);
> + delete &getCache(PImpl, AC);
> PImpl = nullptr;
> }
> }
> @@ -1149,8 +1151,8 @@ void LazyValueInfo::releaseMemory() {
> Constant *LazyValueInfo::getConstant(Value *V, BasicBlock *BB,
> Instruction *CxtI) {
> LVILatticeVal Result =
> - getCache(PImpl, AT, DL, DT).getValueInBlock(V, BB, CxtI);
> -
> + getCache(PImpl, AC, DL, DT).getValueInBlock(V, BB, CxtI);
> +
> if (Result.isConstant())
> return Result.getConstant();
> if (Result.isConstantRange()) {
> @@ -1167,8 +1169,8 @@ Constant *LazyValueInfo::getConstantOnEd
> BasicBlock *ToBB,
> Instruction *CxtI) {
> LVILatticeVal Result =
> - getCache(PImpl, AT, DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
> -
> + getCache(PImpl, AC, DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
> +
> if (Result.isConstant())
> return Result.getConstant();
> if (Result.isConstantRange()) {
> @@ -1254,7 +1256,7 @@ LazyValueInfo::getPredicateOnEdge(unsign
> BasicBlock *FromBB, BasicBlock *ToBB,
> Instruction *CxtI) {
> LVILatticeVal Result =
> - getCache(PImpl, AT, DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
> + getCache(PImpl, AC, DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
>
> return getPredicateResult(Pred, C, Result, DL, TLI);
> }
> @@ -1262,17 +1264,18 @@ LazyValueInfo::getPredicateOnEdge(unsign
> LazyValueInfo::Tristate
> LazyValueInfo::getPredicateAt(unsigned Pred, Value *V, Constant *C,
> Instruction *CxtI) {
> - LVILatticeVal Result =
> - getCache(PImpl, AT, DL, DT).getValueAt(V, CxtI);
> + LVILatticeVal Result = getCache(PImpl, AC, DL, DT).getValueAt(V, CxtI);
>
> return getPredicateResult(Pred, C, Result, DL, TLI);
> }
>
> void LazyValueInfo::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
> BasicBlock *NewSucc) {
> - if (PImpl) getCache(PImpl, AT, DL, DT).threadEdge(PredBB, OldSucc, NewSucc);
> + if (PImpl)
> + getCache(PImpl, AC, DL, DT).threadEdge(PredBB, OldSucc, NewSucc);
> }
>
> void LazyValueInfo::eraseBlock(BasicBlock *BB) {
> - if (PImpl) getCache(PImpl, AT, DL, DT).eraseBlock(BB);
> + if (PImpl)
> + getCache(PImpl, AC, DL, DT).eraseBlock(BB);
> }
>
> Modified: llvm/trunk/lib/Analysis/Lint.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/Lint.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/Lint.cpp (original)
> +++ llvm/trunk/lib/Analysis/Lint.cpp Sun Jan 4 06:03:27 2015
> @@ -37,7 +37,7 @@
> #include "llvm/Analysis/Lint.h"
> #include "llvm/ADT/STLExtras.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/ConstantFolding.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/Loads.h"
> @@ -102,7 +102,7 @@ namespace {
> public:
> Module *Mod;
> AliasAnalysis *AA;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> DominatorTree *DT;
> const DataLayout *DL;
> TargetLibraryInfo *TLI;
> @@ -120,7 +120,7 @@ namespace {
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> AU.setPreservesAll();
> AU.addRequired<AliasAnalysis>();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<TargetLibraryInfo>();
> AU.addRequired<DominatorTreeWrapperPass>();
> }
> @@ -154,7 +154,7 @@ namespace {
> char Lint::ID = 0;
> INITIALIZE_PASS_BEGIN(Lint, "lint", "Statically lint-checks LLVM IR",
> false, true)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
> @@ -179,7 +179,7 @@ INITIALIZE_PASS_END(Lint, "lint", "Stati
> bool Lint::runOnFunction(Function &F) {
> Mod = F.getParent();
> AA = &getAnalysis<AliasAnalysis>();
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
> DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> DL = DLP ? &DLP->getDataLayout() : nullptr;
> @@ -510,7 +510,7 @@ void Lint::visitShl(BinaryOperator &I) {
> }
>
> static bool isZero(Value *V, const DataLayout *DL, DominatorTree *DT,
> - AssumptionTracker *AT) {
> + AssumptionCache *AC) {
> // Assume undef could be zero.
> if (isa<UndefValue>(V))
> return true;
> @@ -519,8 +519,8 @@ static bool isZero(Value *V, const DataL
> if (!VecTy) {
> unsigned BitWidth = V->getType()->getIntegerBitWidth();
> APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(V, KnownZero, KnownOne, DL,
> - 0, AT, dyn_cast<Instruction>(V), DT);
> + computeKnownBits(V, KnownZero, KnownOne, DL, 0, AC,
> + dyn_cast<Instruction>(V), DT);
> return KnownZero.isAllOnesValue();
> }
>
> @@ -550,22 +550,22 @@ static bool isZero(Value *V, const DataL
> }
>
> void Lint::visitSDiv(BinaryOperator &I) {
> - Assert1(!isZero(I.getOperand(1), DL, DT, AT),
> + Assert1(!isZero(I.getOperand(1), DL, DT, AC),
> "Undefined behavior: Division by zero", &I);
> }
>
> void Lint::visitUDiv(BinaryOperator &I) {
> - Assert1(!isZero(I.getOperand(1), DL, DT, AT),
> + Assert1(!isZero(I.getOperand(1), DL, DT, AC),
> "Undefined behavior: Division by zero", &I);
> }
>
> void Lint::visitSRem(BinaryOperator &I) {
> - Assert1(!isZero(I.getOperand(1), DL, DT, AT),
> + Assert1(!isZero(I.getOperand(1), DL, DT, AC),
> "Undefined behavior: Division by zero", &I);
> }
>
> void Lint::visitURem(BinaryOperator &I) {
> - Assert1(!isZero(I.getOperand(1), DL, DT, AT),
> + Assert1(!isZero(I.getOperand(1), DL, DT, AC),
> "Undefined behavior: Division by zero", &I);
> }
>
> @@ -686,7 +686,7 @@ Value *Lint::findValueImpl(Value *V, boo
>
> // As a last resort, try SimplifyInstruction or constant folding.
> if (Instruction *Inst = dyn_cast<Instruction>(V)) {
> - if (Value *W = SimplifyInstruction(Inst, DL, TLI, DT, AT))
> + if (Value *W = SimplifyInstruction(Inst, DL, TLI, DT, AC))
> return findValueImpl(W, OffsetOk, Visited);
> } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
> if (Value *W = ConstantFoldConstantExpression(CE, DL, TLI))
>
> Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
> +++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Sun Jan 4 06:03:27 2015
> @@ -18,7 +18,7 @@
> #include "llvm/ADT/STLExtras.h"
> #include "llvm/ADT/Statistic.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/MemoryBuiltins.h"
> #include "llvm/Analysis/PHITransAddr.h"
> @@ -59,7 +59,7 @@ char MemoryDependenceAnalysis::ID = 0;
> // Register this pass...
> INITIALIZE_PASS_BEGIN(MemoryDependenceAnalysis, "memdep",
> "Memory Dependence Analysis", false, true)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
> INITIALIZE_PASS_END(MemoryDependenceAnalysis, "memdep",
> "Memory Dependence Analysis", false, true)
> @@ -88,13 +88,13 @@ void MemoryDependenceAnalysis::releaseMe
> ///
> void MemoryDependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
> AU.setPreservesAll();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequiredTransitive<AliasAnalysis>();
> }
>
> -bool MemoryDependenceAnalysis::runOnFunction(Function &) {
> +bool MemoryDependenceAnalysis::runOnFunction(Function &F) {
> AA = &getAnalysis<AliasAnalysis>();
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> DL = DLP ? &DLP->getDataLayout() : nullptr;
> DominatorTreeWrapperPass *DTWP =
> @@ -866,7 +866,7 @@ getNonLocalPointerDependency(const Alias
> "Can't get pointer deps of a non-pointer!");
> Result.clear();
>
> - PHITransAddr Address(const_cast<Value *>(Loc.Ptr), DL, AT);
> + PHITransAddr Address(const_cast<Value *>(Loc.Ptr), DL, AC);
>
> // This is the set of blocks we've inspected, and the pointer we consider in
> // each block. Because of critical edges, we currently bail out if querying
>
> Modified: llvm/trunk/lib/Analysis/PHITransAddr.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/PHITransAddr.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/PHITransAddr.cpp (original)
> +++ llvm/trunk/lib/Analysis/PHITransAddr.cpp Sun Jan 4 06:03:27 2015
> @@ -228,7 +228,7 @@ Value *PHITransAddr::PHITranslateSubExpr
> return GEP;
>
> // Simplify the GEP to handle 'gep x, 0' -> x etc.
> - if (Value *V = SimplifyGEPInst(GEPOps, DL, TLI, DT, AT)) {
> + if (Value *V = SimplifyGEPInst(GEPOps, DL, TLI, DT, AC)) {
> for (unsigned i = 0, e = GEPOps.size(); i != e; ++i)
> RemoveInstInputs(GEPOps[i], InstInputs);
>
> @@ -283,7 +283,7 @@ Value *PHITransAddr::PHITranslateSubExpr
> }
>
> // See if the add simplifies away.
> - if (Value *Res = SimplifyAddInst(LHS, RHS, isNSW, isNUW, DL, TLI, DT, AT)) {
> + if (Value *Res = SimplifyAddInst(LHS, RHS, isNSW, isNUW, DL, TLI, DT, AC)) {
> // If we simplified the operands, the LHS is no longer an input, but Res
> // is.
> RemoveInstInputs(LHS, InstInputs);
> @@ -369,7 +369,7 @@ InsertPHITranslatedSubExpr(Value *InVal,
> SmallVectorImpl<Instruction*> &NewInsts) {
> // See if we have a version of this value already available and dominating
> // PredBB. If so, there is no need to insert a new instance of it.
> - PHITransAddr Tmp(InVal, DL, AT);
> + PHITransAddr Tmp(InVal, DL, AC);
> if (!Tmp.PHITranslateValue(CurBB, PredBB, &DT))
> return Tmp.getAddr();
>
>
> Modified: llvm/trunk/lib/Analysis/ScalarEvolution.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolution.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/ScalarEvolution.cpp (original)
> +++ llvm/trunk/lib/Analysis/ScalarEvolution.cpp Sun Jan 4 06:03:27 2015
> @@ -63,7 +63,7 @@
> #include "llvm/ADT/STLExtras.h"
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/ConstantFolding.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/LoopInfo.h"
> @@ -116,7 +116,7 @@ VerifySCEV("verify-scev",
>
> INITIALIZE_PASS_BEGIN(ScalarEvolution, "scalar-evolution",
> "Scalar Evolution Analysis", false, true)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(LoopInfo)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> @@ -3531,7 +3531,7 @@ const SCEV *ScalarEvolution::createNodeF
> // PHI's incoming blocks are in a different loop, in which case doing so
> // risks breaking LCSSA form. Instcombine would normally zap these, but
> // it doesn't have DominatorTree information, so it may miss cases.
> - if (Value *V = SimplifyInstruction(PN, DL, TLI, DT, AT))
> + if (Value *V = SimplifyInstruction(PN, DL, TLI, DT, AC))
> if (LI->replacementPreservesLCSSAForm(PN, V))
> return getSCEV(V);
>
> @@ -3663,7 +3663,7 @@ ScalarEvolution::GetMinTrailingZeros(con
> // For a SCEVUnknown, ask ValueTracking.
> unsigned BitWidth = getTypeSizeInBits(U->getType());
> APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
> - computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, AT, nullptr, DT);
> + computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, AC, nullptr, DT);
> return Zeros.countTrailingOnes();
> }
>
> @@ -3834,7 +3834,7 @@ ScalarEvolution::getUnsignedRange(const
>
> // For a SCEVUnknown, ask ValueTracking.
> APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
> - computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, AT, nullptr, DT);
> + computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, AC, nullptr, DT);
> if (Ones == ~Zeros + 1)
> return setUnsignedRange(U, ConservativeResult);
> return setUnsignedRange(U,
> @@ -3991,7 +3991,7 @@ ScalarEvolution::getSignedRange(const SC
> // For a SCEVUnknown, ask ValueTracking.
> if (!U->getValue()->getType()->isIntegerTy() && !DL)
> return setSignedRange(U, ConservativeResult);
> - unsigned NS = ComputeNumSignBits(U->getValue(), DL, 0, AT, nullptr, DT);
> + unsigned NS = ComputeNumSignBits(U->getValue(), DL, 0, AC, nullptr, DT);
> if (NS <= 1)
> return setSignedRange(U, ConservativeResult);
> return setSignedRange(U, ConservativeResult.intersectWith(
> @@ -4098,8 +4098,8 @@ const SCEV *ScalarEvolution::createSCEV(
> unsigned TZ = A.countTrailingZeros();
> unsigned BitWidth = A.getBitWidth();
> APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(U->getOperand(0), KnownZero, KnownOne, DL,
> - 0, AT, nullptr, DT);
> + computeKnownBits(U->getOperand(0), KnownZero, KnownOne, DL, 0, AC,
> + nullptr, DT);
>
> APInt EffectiveMask =
> APInt::getLowBitsSet(BitWidth, BitWidth - LZ - TZ).shl(TZ);
> @@ -6630,7 +6630,10 @@ ScalarEvolution::isLoopBackedgeGuardedBy
> return true;
>
> // Check conditions due to any @llvm.assume intrinsics.
> - for (auto &CI : AT->assumptions(F)) {
> + for (auto &AssumeVH : AC->assumptions()) {
> + if (!AssumeVH)
> + continue;
> + auto *CI = cast<CallInst>(AssumeVH);
> if (!DT->dominates(CI, Latch->getTerminator()))
> continue;
>
> @@ -6675,7 +6678,10 @@ ScalarEvolution::isLoopEntryGuardedByCon
> }
>
> // Check conditions due to any @llvm.assume intrinsics.
> - for (auto &CI : AT->assumptions(F)) {
> + for (auto &AssumeVH : AC->assumptions()) {
> + if (!AssumeVH)
> + continue;
> + auto *CI = cast<CallInst>(AssumeVH);
> if (!DT->dominates(CI, L->getHeader()))
> continue;
>
> @@ -7869,7 +7875,7 @@ ScalarEvolution::ScalarEvolution()
>
> bool ScalarEvolution::runOnFunction(Function &F) {
> this->F = &F;
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
> LI = &getAnalysis<LoopInfo>();
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> DL = DLP ? &DLP->getDataLayout() : nullptr;
> @@ -7910,7 +7916,7 @@ void ScalarEvolution::releaseMemory() {
>
> void ScalarEvolution::getAnalysisUsage(AnalysisUsage &AU) const {
> AU.setPreservesAll();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequiredTransitive<LoopInfo>();
> AU.addRequiredTransitive<DominatorTreeWrapperPass>();
> AU.addRequired<TargetLibraryInfo>();
>
> Modified: llvm/trunk/lib/Analysis/ScalarEvolutionExpander.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolutionExpander.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/ScalarEvolutionExpander.cpp (original)
> +++ llvm/trunk/lib/Analysis/ScalarEvolutionExpander.cpp Sun Jan 4 06:03:27 2015
> @@ -1711,7 +1711,7 @@ unsigned SCEVExpander::replaceCongruentI
>
> // Fold constant phis. They may be congruent to other constant phis and
> // would confuse the logic below that expects proper IVs.
> - if (Value *V = SimplifyInstruction(Phi, SE.DL, SE.TLI, SE.DT, SE.AT)) {
> + if (Value *V = SimplifyInstruction(Phi, SE.DL, SE.TLI, SE.DT, SE.AC)) {
> Phi->replaceAllUsesWith(V);
> DeadInsts.push_back(Phi);
> ++NumElim;
>
> Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
> +++ llvm/trunk/lib/Analysis/ValueTracking.cpp Sun Jan 4 06:03:27 2015
> @@ -13,7 +13,7 @@
> //===----------------------------------------------------------------------===//
>
> #include "llvm/Analysis/ValueTracking.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/MemoryBuiltins.h"
> @@ -65,16 +65,16 @@ namespace {
> // figuring out if we can use it.
> struct Query {
> ExclInvsSet ExclInvs;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> const Instruction *CxtI;
> const DominatorTree *DT;
>
> - Query(AssumptionTracker *AT = nullptr, const Instruction *CxtI = nullptr,
> + Query(AssumptionCache *AC = nullptr, const Instruction *CxtI = nullptr,
> const DominatorTree *DT = nullptr)
> - : AT(AT), CxtI(CxtI), DT(DT) {}
> + : AC(AC), CxtI(CxtI), DT(DT) {}
>
> Query(const Query &Q, const Value *NewExcl)
> - : ExclInvs(Q.ExclInvs), AT(Q.AT), CxtI(Q.CxtI), DT(Q.DT) {
> + : ExclInvs(Q.ExclInvs), AC(Q.AC), CxtI(Q.CxtI), DT(Q.DT) {
> ExclInvs.insert(NewExcl);
> }
> };
> @@ -102,10 +102,10 @@ static void computeKnownBits(Value *V, A
>
> void llvm::computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
> const DataLayout *TD, unsigned Depth,
> - AssumptionTracker *AT, const Instruction *CxtI,
> + AssumptionCache *AC, const Instruction *CxtI,
> const DominatorTree *DT) {
> ::computeKnownBits(V, KnownZero, KnownOne, TD, Depth,
> - Query(AT, safeCxtI(V, CxtI), DT));
> + Query(AC, safeCxtI(V, CxtI), DT));
> }
>
> static void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
> @@ -114,52 +114,50 @@ static void ComputeSignBit(Value *V, boo
>
> void llvm::ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
> const DataLayout *TD, unsigned Depth,
> - AssumptionTracker *AT, const Instruction *CxtI,
> + AssumptionCache *AC, const Instruction *CxtI,
> const DominatorTree *DT) {
> ::ComputeSignBit(V, KnownZero, KnownOne, TD, Depth,
> - Query(AT, safeCxtI(V, CxtI), DT));
> + Query(AC, safeCxtI(V, CxtI), DT));
> }
>
> static bool isKnownToBeAPowerOfTwo(Value *V, bool OrZero, unsigned Depth,
> const Query &Q);
>
> bool llvm::isKnownToBeAPowerOfTwo(Value *V, bool OrZero, unsigned Depth,
> - AssumptionTracker *AT,
> - const Instruction *CxtI,
> + AssumptionCache *AC, const Instruction *CxtI,
> const DominatorTree *DT) {
> return ::isKnownToBeAPowerOfTwo(V, OrZero, Depth,
> - Query(AT, safeCxtI(V, CxtI), DT));
> + Query(AC, safeCxtI(V, CxtI), DT));
> }
>
> static bool isKnownNonZero(Value *V, const DataLayout *TD, unsigned Depth,
> const Query &Q);
>
> bool llvm::isKnownNonZero(Value *V, const DataLayout *TD, unsigned Depth,
> - AssumptionTracker *AT, const Instruction *CxtI,
> + AssumptionCache *AC, const Instruction *CxtI,
> const DominatorTree *DT) {
> - return ::isKnownNonZero(V, TD, Depth, Query(AT, safeCxtI(V, CxtI), DT));
> + return ::isKnownNonZero(V, TD, Depth, Query(AC, safeCxtI(V, CxtI), DT));
> }
>
> static bool MaskedValueIsZero(Value *V, const APInt &Mask,
> const DataLayout *TD, unsigned Depth,
> const Query &Q);
>
> -bool llvm::MaskedValueIsZero(Value *V, const APInt &Mask,
> - const DataLayout *TD, unsigned Depth,
> - AssumptionTracker *AT, const Instruction *CxtI,
> - const DominatorTree *DT) {
> +bool llvm::MaskedValueIsZero(Value *V, const APInt &Mask, const DataLayout *TD,
> + unsigned Depth, AssumptionCache *AC,
> + const Instruction *CxtI, const DominatorTree *DT) {
> return ::MaskedValueIsZero(V, Mask, TD, Depth,
> - Query(AT, safeCxtI(V, CxtI), DT));
> + Query(AC, safeCxtI(V, CxtI), DT));
> }
>
> static unsigned ComputeNumSignBits(Value *V, const DataLayout *TD,
> unsigned Depth, const Query &Q);
>
> unsigned llvm::ComputeNumSignBits(Value *V, const DataLayout *TD,
> - unsigned Depth, AssumptionTracker *AT,
> + unsigned Depth, AssumptionCache *AC,
> const Instruction *CxtI,
> const DominatorTree *DT) {
> - return ::ComputeNumSignBits(V, TD, Depth, Query(AT, safeCxtI(V, CxtI), DT));
> + return ::ComputeNumSignBits(V, TD, Depth, Query(AC, safeCxtI(V, CxtI), DT));
> }
>
> static void computeKnownBitsAddSub(bool Add, Value *Op0, Value *Op1, bool NSW,
> @@ -482,14 +480,18 @@ static void computeKnownBitsFromAssume(V
> unsigned Depth, const Query &Q) {
> // Use of assumptions is context-sensitive. If we don't have a context, we
> // cannot use them!
> - if (!Q.AT || !Q.CxtI)
> + if (!Q.AC || !Q.CxtI)
> return;
>
> unsigned BitWidth = KnownZero.getBitWidth();
>
> Function *F = const_cast<Function*>(Q.CxtI->getParent()->getParent());
> - for (auto &CI : Q.AT->assumptions(F)) {
> - CallInst *I = CI;
> + for (auto &AssumeVH : Q.AC->assumptions()) {
> + if (!AssumeVH)
> + continue;
> + CallInst *I = cast<CallInst>(AssumeVH);
> + assert(I->getParent()->getParent() == F &&
> + "Got assumption for the wrong function!");
> if (Q.ExclInvs.count(I))
> continue;
>
> @@ -2484,7 +2486,7 @@ llvm::GetUnderlyingObject(Value *V, cons
> } else {
> // See if InstructionSimplify knows any relevant tricks.
> if (Instruction *I = dyn_cast<Instruction>(V))
> - // TODO: Acquire a DominatorTree and AssumptionTracker and use them.
> + // TODO: Acquire a DominatorTree and AssumptionCache and use them.
> if (Value *Simplified = SimplifyInstruction(I, TD, nullptr)) {
> V = Simplified;
> continue;
> @@ -2681,7 +2683,7 @@ bool llvm::isKnownNonNull(const Value *V
>
> OverflowResult llvm::computeOverflowForUnsignedMul(Value *LHS, Value *RHS,
> const DataLayout *DL,
> - AssumptionTracker *AT,
> + AssumptionCache *AC,
> const Instruction *CxtI,
> const DominatorTree *DT) {
> // Multiplying n * m significant bits yields a result of n + m significant
> @@ -2695,8 +2697,10 @@ OverflowResult llvm::computeOverflowForU
> APInt LHSKnownOne(BitWidth, 0);
> APInt RHSKnownZero(BitWidth, 0);
> APInt RHSKnownOne(BitWidth, 0);
> - computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, DL, /*Depth=*/0, AT, CxtI, DT);
> - computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, DL, /*Depth=*/0, AT, CxtI, DT);
> + computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, DL, /*Depth=*/0, AC, CxtI,
> + DT);
> + computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, DL, /*Depth=*/0, AC, CxtI,
> + DT);
> // Note that underestimating the number of zero bits gives a more
> // conservative answer.
> unsigned ZeroBits = LHSKnownZero.countLeadingOnes() +
>
> Modified: llvm/trunk/lib/Transforms/IPO/InlineAlways.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/InlineAlways.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/IPO/InlineAlways.cpp (original)
> +++ llvm/trunk/lib/Transforms/IPO/InlineAlways.cpp Sun Jan 4 06:03:27 2015
> @@ -15,7 +15,7 @@
> #include "llvm/Transforms/IPO.h"
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CallGraph.h"
> #include "llvm/Analysis/InlineCost.h"
> #include "llvm/IR/CallSite.h"
> @@ -68,7 +68,7 @@ char AlwaysInliner::ID = 0;
> INITIALIZE_PASS_BEGIN(AlwaysInliner, "always-inline",
> "Inliner for always_inline functions", false, false)
> INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(InlineCostAnalysis)
> INITIALIZE_PASS_END(AlwaysInliner, "always-inline",
>
> Modified: llvm/trunk/lib/Transforms/IPO/InlineSimple.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/InlineSimple.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/IPO/InlineSimple.cpp (original)
> +++ llvm/trunk/lib/Transforms/IPO/InlineSimple.cpp Sun Jan 4 06:03:27 2015
> @@ -13,7 +13,7 @@
>
> #include "llvm/Transforms/IPO.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CallGraph.h"
> #include "llvm/Analysis/InlineCost.h"
> #include "llvm/IR/CallSite.h"
> @@ -76,7 +76,7 @@ char SimpleInliner::ID = 0;
> INITIALIZE_PASS_BEGIN(SimpleInliner, "inline",
> "Function Integration/Inlining", false, false)
> INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(InlineCostAnalysis)
> INITIALIZE_PASS_END(SimpleInliner, "inline",
>
> Modified: llvm/trunk/lib/Transforms/IPO/Inliner.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/Inliner.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/IPO/Inliner.cpp (original)
> +++ llvm/trunk/lib/Transforms/IPO/Inliner.cpp Sun Jan 4 06:03:27 2015
> @@ -17,7 +17,7 @@
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/Statistic.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CallGraph.h"
> #include "llvm/Analysis/InlineCost.h"
> #include "llvm/IR/CallSite.h"
> @@ -77,7 +77,7 @@ Inliner::Inliner(char &ID, int Threshold
> /// always explicitly call the implementation here.
> void Inliner::getAnalysisUsage(AnalysisUsage &AU) const {
> AU.addRequired<AliasAnalysis>();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> CallGraphSCCPass::getAnalysisUsage(AU);
> }
>
> @@ -443,7 +443,7 @@ static bool InlineHistoryIncludes(Functi
>
> bool Inliner::runOnSCC(CallGraphSCC &SCC) {
> CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + AssumptionCacheTracker *ACT = &getAnalysis<AssumptionCacheTracker>();
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> const DataLayout *DL = DLP ? &DLP->getDataLayout() : nullptr;
> const TargetLibraryInfo *TLI = getAnalysisIfAvailable<TargetLibraryInfo>();
> @@ -506,8 +506,8 @@ bool Inliner::runOnSCC(CallGraphSCC &SCC
>
>
> InlinedArrayAllocasTy InlinedArrayAllocas;
> - InlineFunctionInfo InlineInfo(&CG, DL, AA, AT);
> -
> + InlineFunctionInfo InlineInfo(&CG, DL, AA, ACT);
> +
> // Now that we have all of the call sites, loop over them and inline them if
> // it looks profitable to do so.
> bool Changed = false;
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombine.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombine.h?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombine.h (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombine.h Sun Jan 4 06:03:27 2015
> @@ -11,7 +11,7 @@
> #define LLVM_LIB_TRANSFORMS_INSTCOMBINE_INSTCOMBINE_H
>
> #include "InstCombineWorklist.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/TargetFolder.h"
> #include "llvm/Analysis/ValueTracking.h"
> #include "llvm/IR/Dominators.h"
> @@ -75,11 +75,11 @@ static inline Constant *SubOne(Constant
> class LLVM_LIBRARY_VISIBILITY InstCombineIRInserter
> : public IRBuilderDefaultInserter<true> {
> InstCombineWorklist &Worklist;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
>
> public:
> - InstCombineIRInserter(InstCombineWorklist &WL, AssumptionTracker *AT)
> - : Worklist(WL), AT(AT) {}
> + InstCombineIRInserter(InstCombineWorklist &WL, AssumptionCache *AC)
> + : Worklist(WL), AC(AC) {}
>
> void InsertHelper(Instruction *I, const Twine &Name, BasicBlock *BB,
> BasicBlock::iterator InsertPt) const {
> @@ -88,7 +88,7 @@ public:
>
> using namespace llvm::PatternMatch;
> if (match(I, m_Intrinsic<Intrinsic::assume>()))
> - AT->registerAssumption(cast<CallInst>(I));
> + AC->registerAssumption(cast<CallInst>(I));
> }
> };
>
> @@ -96,7 +96,7 @@ public:
> class LLVM_LIBRARY_VISIBILITY InstCombiner
> : public FunctionPass,
> public InstVisitor<InstCombiner, Instruction *> {
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> const DataLayout *DL;
> TargetLibraryInfo *TLI;
> DominatorTree *DT;
> @@ -127,7 +127,7 @@ public:
>
> void getAnalysisUsage(AnalysisUsage &AU) const override;
>
> - AssumptionTracker *getAssumptionTracker() const { return AT; }
> + AssumptionCache *getAssumptionCache() const { return AC; }
>
> const DataLayout *getDataLayout() const { return DL; }
>
> @@ -369,27 +369,27 @@ public:
>
> void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
> unsigned Depth = 0, Instruction *CxtI = nullptr) const {
> - return llvm::computeKnownBits(V, KnownZero, KnownOne, DL, Depth,
> - AT, CxtI, DT);
> + return llvm::computeKnownBits(V, KnownZero, KnownOne, DL, Depth, AC, CxtI,
> + DT);
> }
>
> bool MaskedValueIsZero(Value *V, const APInt &Mask,
> unsigned Depth = 0,
> Instruction *CxtI = nullptr) const {
> - return llvm::MaskedValueIsZero(V, Mask, DL, Depth, AT, CxtI, DT);
> + return llvm::MaskedValueIsZero(V, Mask, DL, Depth, AC, CxtI, DT);
> }
> unsigned ComputeNumSignBits(Value *Op, unsigned Depth = 0,
> Instruction *CxtI = nullptr) const {
> - return llvm::ComputeNumSignBits(Op, DL, Depth, AT, CxtI, DT);
> + return llvm::ComputeNumSignBits(Op, DL, Depth, AC, CxtI, DT);
> }
> void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
> unsigned Depth = 0, Instruction *CxtI = nullptr) const {
> - return llvm::ComputeSignBit(V, KnownZero, KnownOne, DL, Depth, AT, CxtI,
> + return llvm::ComputeSignBit(V, KnownZero, KnownOne, DL, Depth, AC, CxtI,
> DT);
> }
> OverflowResult computeOverflowForUnsignedMul(Value *LHS, Value *RHS,
> const Instruction *CxtI) {
> - return llvm::computeOverflowForUnsignedMul(LHS, RHS, DL, AT, CxtI, DT);
> + return llvm::computeOverflowForUnsignedMul(LHS, RHS, DL, AC, CxtI, DT);
> }
>
> private:
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineAddSub.cpp Sun Jan 4 06:03:27 2015
> @@ -1069,7 +1069,7 @@ Instruction *InstCombiner::visitAdd(Bina
> return ReplaceInstUsesWith(I, V);
>
> if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(),
> - I.hasNoUnsignedWrap(), DL, TLI, DT, AT))
> + I.hasNoUnsignedWrap(), DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // (A*B)+(A*C) -> A*(B+C) etc
> @@ -1342,8 +1342,8 @@ Instruction *InstCombiner::visitFAdd(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyFAddInst(LHS, RHS, I.getFastMathFlags(), DL,
> - TLI, DT, AT))
> + if (Value *V =
> + SimplifyFAddInst(LHS, RHS, I.getFastMathFlags(), DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> if (isa<Constant>(RHS)) {
> @@ -1521,7 +1521,7 @@ Instruction *InstCombiner::visitSub(Bina
> return ReplaceInstUsesWith(I, V);
>
> if (Value *V = SimplifySubInst(Op0, Op1, I.hasNoSignedWrap(),
> - I.hasNoUnsignedWrap(), DL, TLI, DT, AT))
> + I.hasNoUnsignedWrap(), DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // (A*B)-(A*C) -> A*(B-C) etc
> @@ -1709,8 +1709,8 @@ Instruction *InstCombiner::visitFSub(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyFSubInst(Op0, Op1, I.getFastMathFlags(), DL,
> - TLI, DT, AT))
> + if (Value *V =
> + SimplifyFSubInst(Op0, Op1, I.getFastMathFlags(), DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // fsub nsz 0, X ==> fsub nsz -0.0, X
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp Sun Jan 4 06:03:27 2015
> @@ -1227,7 +1227,7 @@ Instruction *InstCombiner::visitAnd(Bina
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyAndInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyAndInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // (A|B)&(A|C) -> A|(B&C) etc
> @@ -1727,15 +1727,15 @@ Value *InstCombiner::FoldOrOfICmps(ICmpI
> Value *Mask = nullptr;
> Value *Masked = nullptr;
> if (LAnd->getOperand(0) == RAnd->getOperand(0) &&
> - isKnownToBeAPowerOfTwo(LAnd->getOperand(1), false, 0, AT, CxtI, DT) &&
> - isKnownToBeAPowerOfTwo(RAnd->getOperand(1), false, 0, AT, CxtI, DT)) {
> + isKnownToBeAPowerOfTwo(LAnd->getOperand(1), false, 0, AC, CxtI, DT) &&
> + isKnownToBeAPowerOfTwo(RAnd->getOperand(1), false, 0, AC, CxtI, DT)) {
> Mask = Builder->CreateOr(LAnd->getOperand(1), RAnd->getOperand(1));
> Masked = Builder->CreateAnd(LAnd->getOperand(0), Mask);
> } else if (LAnd->getOperand(1) == RAnd->getOperand(1) &&
> - isKnownToBeAPowerOfTwo(LAnd->getOperand(0),
> - false, 0, AT, CxtI, DT) &&
> - isKnownToBeAPowerOfTwo(RAnd->getOperand(0),
> - false, 0, AT, CxtI, DT)) {
> + isKnownToBeAPowerOfTwo(LAnd->getOperand(0), false, 0, AC, CxtI,
> + DT) &&
> + isKnownToBeAPowerOfTwo(RAnd->getOperand(0), false, 0, AC, CxtI,
> + DT)) {
> Mask = Builder->CreateOr(LAnd->getOperand(0), RAnd->getOperand(0));
> Masked = Builder->CreateAnd(LAnd->getOperand(1), Mask);
> }
> @@ -2163,7 +2163,7 @@ Instruction *InstCombiner::visitOr(Binar
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyOrInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyOrInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // (A&B)|(A&C) -> A&(B|C) etc
> @@ -2550,7 +2550,7 @@ Instruction *InstCombiner::visitXor(Bina
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyXorInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyXorInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // (A&B)^(A&C) -> A&(B^C) etc
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp Sun Jan 4 06:03:27 2015
> @@ -60,8 +60,8 @@ static Type *reduceToSingleValueType(Typ
> }
>
> Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) {
> - unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), DL, AT, MI, DT);
> - unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), DL, AT, MI, DT);
> + unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), DL, AC, MI, DT);
> + unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), DL, AC, MI, DT);
> unsigned MinAlign = std::min(DstAlign, SrcAlign);
> unsigned CopyAlign = MI->getAlignment();
>
> @@ -155,7 +155,7 @@ Instruction *InstCombiner::SimplifyMemTr
> }
>
> Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) {
> - unsigned Alignment = getKnownAlignment(MI->getDest(), DL, AT, MI, DT);
> + unsigned Alignment = getKnownAlignment(MI->getDest(), DL, AC, MI, DT);
> if (MI->getAlignment() < Alignment) {
> MI->setAlignment(ConstantInt::get(MI->getAlignmentType(),
> Alignment, false));
> @@ -566,8 +566,8 @@ Instruction *InstCombiner::visitCallInst
> case Intrinsic::ppc_altivec_lvx:
> case Intrinsic::ppc_altivec_lvxl:
> // Turn PPC lvx -> load if the pointer is known aligned.
> - if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16,
> - DL, AT, II, DT) >= 16) {
> + if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, AC, II, DT) >=
> + 16) {
> Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
> PointerType::getUnqual(II->getType()));
> return new LoadInst(Ptr);
> @@ -583,8 +583,8 @@ Instruction *InstCombiner::visitCallInst
> case Intrinsic::ppc_altivec_stvx:
> case Intrinsic::ppc_altivec_stvxl:
> // Turn stvx -> store if the pointer is known aligned.
> - if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16,
> - DL, AT, II, DT) >= 16) {
> + if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, DL, AC, II, DT) >=
> + 16) {
> Type *OpPtrTy =
> PointerType::getUnqual(II->getArgOperand(0)->getType());
> Value *Ptr = Builder->CreateBitCast(II->getArgOperand(1), OpPtrTy);
> @@ -602,8 +602,8 @@ Instruction *InstCombiner::visitCallInst
> case Intrinsic::x86_sse2_storeu_pd:
> case Intrinsic::x86_sse2_storeu_dq:
> // Turn X86 storeu -> store if the pointer is known aligned.
> - if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16,
> - DL, AT, II, DT) >= 16) {
> + if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, AC, II, DT) >=
> + 16) {
> Type *OpPtrTy =
> PointerType::getUnqual(II->getArgOperand(1)->getType());
> Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), OpPtrTy);
> @@ -963,7 +963,7 @@ Instruction *InstCombiner::visitCallInst
> case Intrinsic::arm_neon_vst2lane:
> case Intrinsic::arm_neon_vst3lane:
> case Intrinsic::arm_neon_vst4lane: {
> - unsigned MemAlign = getKnownAlignment(II->getArgOperand(0), DL, AT, II, DT);
> + unsigned MemAlign = getKnownAlignment(II->getArgOperand(0), DL, AC, II, DT);
> unsigned AlignArg = II->getNumArgOperands() - 1;
> ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg));
> if (IntrAlign && IntrAlign->getZExtValue() < MemAlign) {
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCompares.cpp Sun Jan 4 06:03:27 2015
> @@ -2588,7 +2588,7 @@ Instruction *InstCombiner::visitICmpInst
> Changed = true;
> }
>
> - if (Value *V = SimplifyICmpInst(I.getPredicate(), Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyICmpInst(I.getPredicate(), Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // comparing -val or val with non-zero is the same as just comparing val
> @@ -3421,9 +3421,8 @@ Instruction *InstCombiner::visitICmpInst
> // and (A & ~B) != 0 --> (A & B) == 0
> // if A is a power of 2.
> if (match(Op0, m_And(m_Value(A), m_Not(m_Value(B)))) &&
> - match(Op1, m_Zero()) && isKnownToBeAPowerOfTwo(A, false,
> - 0, AT, &I, DT) &&
> - I.isEquality())
> + match(Op1, m_Zero()) &&
> + isKnownToBeAPowerOfTwo(A, false, 0, AC, &I, DT) && I.isEquality())
> return new ICmpInst(I.getInversePredicate(),
> Builder->CreateAnd(A, B),
> Op1);
> @@ -3828,7 +3827,7 @@ Instruction *InstCombiner::visitFCmpInst
>
> Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
>
> - if (Value *V = SimplifyFCmpInst(I.getPredicate(), Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyFCmpInst(I.getPredicate(), Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // Simplify 'fcmp pred X, X'
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp Sun Jan 4 06:03:27 2015
> @@ -268,9 +268,8 @@ Instruction *InstCombiner::visitAllocaIn
> // is only subsequently read.
> SmallVector<Instruction *, 4> ToDelete;
> if (MemTransferInst *Copy = isOnlyCopiedFromConstantGlobal(&AI, ToDelete)) {
> - unsigned SourceAlign = getOrEnforceKnownAlignment(Copy->getSource(),
> - AI.getAlignment(),
> - DL, AT, &AI, DT);
> + unsigned SourceAlign = getOrEnforceKnownAlignment(
> + Copy->getSource(), AI.getAlignment(), DL, AC, &AI, DT);
> if (AI.getAlignment() <= SourceAlign) {
> DEBUG(dbgs() << "Found alloca equal to global: " << AI << '\n');
> DEBUG(dbgs() << " memcpy = " << *Copy << '\n');
> @@ -395,9 +394,8 @@ Instruction *InstCombiner::visitLoadInst
>
> // Attempt to improve the alignment.
> if (DL) {
> - unsigned KnownAlign =
> - getOrEnforceKnownAlignment(Op, DL->getPrefTypeAlignment(LI.getType()),
> - DL, AT, &LI, DT);
> + unsigned KnownAlign = getOrEnforceKnownAlignment(
> + Op, DL->getPrefTypeAlignment(LI.getType()), DL, AC, &LI, DT);
> unsigned LoadAlign = LI.getAlignment();
> unsigned EffectiveLoadAlign = LoadAlign != 0 ? LoadAlign :
> DL->getABITypeAlignment(LI.getType());
> @@ -607,9 +605,8 @@ Instruction *InstCombiner::visitStoreIns
>
> // Attempt to improve the alignment.
> if (DL) {
> - unsigned KnownAlign =
> - getOrEnforceKnownAlignment(Ptr, DL->getPrefTypeAlignment(Val->getType()),
> - DL, AT, &SI, DT);
> + unsigned KnownAlign = getOrEnforceKnownAlignment(
> + Ptr, DL->getPrefTypeAlignment(Val->getType()), DL, AC, &SI, DT);
> unsigned StoreAlign = SI.getAlignment();
> unsigned EffectiveStoreAlign = StoreAlign != 0 ? StoreAlign :
> DL->getABITypeAlignment(Val->getType());
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp Sun Jan 4 06:03:27 2015
> @@ -46,10 +46,10 @@ static Value *simplifyValueKnownNonZero(
> // (PowerOfTwo >>u B) --> isExact since shifting out the result would make it
> // inexact. Similarly for <<.
> if (BinaryOperator *I = dyn_cast<BinaryOperator>(V))
> - if (I->isLogicalShift() && isKnownToBeAPowerOfTwo(I->getOperand(0), false,
> - 0, IC.getAssumptionTracker(),
> - CxtI,
> - IC.getDominatorTree())) {
> + if (I->isLogicalShift() &&
> + isKnownToBeAPowerOfTwo(I->getOperand(0), false, 0,
> + IC.getAssumptionCache(), CxtI,
> + IC.getDominatorTree())) {
> // We know that this is an exact/nuw shift and that the input is a
> // non-zero context as well.
> if (Value *V2 = simplifyValueKnownNonZero(I->getOperand(0), IC, CxtI)) {
> @@ -172,7 +172,7 @@ Instruction *InstCombiner::visitMul(Bina
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyMulInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyMulInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> if (Value *V = SimplifyUsingDistributiveLaws(I))
> @@ -530,8 +530,8 @@ Instruction *InstCombiner::visitFMul(Bin
> if (isa<Constant>(Op0))
> std::swap(Op0, Op1);
>
> - if (Value *V = SimplifyFMulInst(Op0, Op1, I.getFastMathFlags(), DL, TLI,
> - DT, AT))
> + if (Value *V =
> + SimplifyFMulInst(Op0, Op1, I.getFastMathFlags(), DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> bool AllowReassociate = I.hasUnsafeAlgebra();
> @@ -1035,7 +1035,7 @@ Instruction *InstCombiner::visitUDiv(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyUDivInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyUDivInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // Handle the integer div common cases
> @@ -1108,7 +1108,7 @@ Instruction *InstCombiner::visitSDiv(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifySDivInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifySDivInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // Handle the integer div common cases
> @@ -1155,7 +1155,7 @@ Instruction *InstCombiner::visitSDiv(Bin
> return BO;
> }
>
> - if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/true, 0, AT, &I, DT)) {
> + if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, AC, &I, DT)) {
> // X sdiv (1 << Y) -> X udiv (1 << Y) ( -> X u>> Y)
> // Safe because the only negative value (1 << Y) can take on is
> // INT_MIN, and X sdiv INT_MIN == X udiv INT_MIN == 0 if X doesn't have
> @@ -1206,7 +1206,7 @@ Instruction *InstCombiner::visitFDiv(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyFDivInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyFDivInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> if (isa<Constant>(Op0))
> @@ -1371,7 +1371,7 @@ Instruction *InstCombiner::visitURem(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyURemInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyURemInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> if (Instruction *common = commonIRemTransforms(I))
> @@ -1384,7 +1384,7 @@ Instruction *InstCombiner::visitURem(Bin
> I.getType());
>
> // X urem Y -> X and Y-1, where Y is a power of 2,
> - if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/true, 0, AT, &I, DT)) {
> + if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, AC, &I, DT)) {
> Constant *N1 = Constant::getAllOnesValue(I.getType());
> Value *Add = Builder->CreateAdd(Op1, N1);
> return BinaryOperator::CreateAnd(Op0, Add);
> @@ -1406,7 +1406,7 @@ Instruction *InstCombiner::visitSRem(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifySRemInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifySRemInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // Handle the integer rem common cases
> @@ -1481,7 +1481,7 @@ Instruction *InstCombiner::visitFRem(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyFRemInst(Op0, Op1, DL, TLI, DT, AT))
> + if (Value *V = SimplifyFRemInst(Op0, Op1, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> // Handle cases involving: rem X, (select Cond, Y, Z)
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombinePHI.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombinePHI.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombinePHI.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombinePHI.cpp Sun Jan 4 06:03:27 2015
> @@ -788,7 +788,7 @@ Instruction *InstCombiner::SliceUpIllega
> // PHINode simplification
> //
> Instruction *InstCombiner::visitPHINode(PHINode &PN) {
> - if (Value *V = SimplifyInstruction(&PN, DL, TLI, DT, AT))
> + if (Value *V = SimplifyInstruction(&PN, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(PN, V);
>
> // If all PHI operands are the same operation, pull them through the PHI,
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineSelect.cpp Sun Jan 4 06:03:27 2015
> @@ -314,8 +314,7 @@ Instruction *InstCombiner::FoldSelectInt
> static Value *SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
> const DataLayout *TD,
> const TargetLibraryInfo *TLI,
> - DominatorTree *DT,
> - AssumptionTracker *AT) {
> + DominatorTree *DT, AssumptionCache *AC) {
> // Trivial replacement.
> if (V == Op)
> return RepOp;
> @@ -336,10 +335,10 @@ static Value *SimplifyWithOpReplaced(Val
> if (CmpInst *C = dyn_cast<CmpInst>(I)) {
> if (C->getOperand(0) == Op)
> return SimplifyCmpInst(C->getPredicate(), RepOp, C->getOperand(1), TD,
> - TLI, DT, AT);
> + TLI, DT, AC);
> if (C->getOperand(1) == Op)
> return SimplifyCmpInst(C->getPredicate(), C->getOperand(0), RepOp, TD,
> - TLI, DT, AT);
> + TLI, DT, AC);
> }
>
> // TODO: We could hand off more cases to instsimplify here.
> @@ -580,26 +579,26 @@ Instruction *InstCombiner::visitSelectIn
> // arms of the select. See if substituting this value into the arm and
> // simplifying the result yields the same value as the other arm.
> if (Pred == ICmpInst::ICMP_EQ) {
> - if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, DL, TLI,
> - DT, AT) == TrueVal ||
> - SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, DL, TLI,
> - DT, AT) == TrueVal)
> + if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, DL, TLI, DT, AC) ==
> + TrueVal ||
> + SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, DL, TLI, DT, AC) ==
> + TrueVal)
> return ReplaceInstUsesWith(SI, FalseVal);
> - if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, DL, TLI,
> - DT, AT) == FalseVal ||
> - SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, DL, TLI,
> - DT, AT) == FalseVal)
> + if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, DL, TLI, DT, AC) ==
> + FalseVal ||
> + SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, DL, TLI, DT, AC) ==
> + FalseVal)
> return ReplaceInstUsesWith(SI, FalseVal);
> } else if (Pred == ICmpInst::ICMP_NE) {
> - if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, DL, TLI,
> - DT, AT) == FalseVal ||
> - SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, DL, TLI,
> - DT, AT) == FalseVal)
> + if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, DL, TLI, DT, AC) ==
> + FalseVal ||
> + SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, DL, TLI, DT, AC) ==
> + FalseVal)
> return ReplaceInstUsesWith(SI, TrueVal);
> - if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, DL, TLI,
> - DT, AT) == TrueVal ||
> - SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, DL, TLI,
> - DT, AT) == TrueVal)
> + if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, DL, TLI, DT, AC) ==
> + TrueVal ||
> + SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, DL, TLI, DT, AC) ==
> + TrueVal)
> return ReplaceInstUsesWith(SI, TrueVal);
> }
>
> @@ -854,8 +853,8 @@ Instruction *InstCombiner::visitSelectIn
> Value *TrueVal = SI.getTrueValue();
> Value *FalseVal = SI.getFalseValue();
>
> - if (Value *V = SimplifySelectInst(CondVal, TrueVal, FalseVal, DL, TLI,
> - DT, AT))
> + if (Value *V =
> + SimplifySelectInst(CondVal, TrueVal, FalseVal, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(SI, V);
>
> if (SI.getType()->isIntegerTy(1)) {
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineShifts.cpp Sun Jan 4 06:03:27 2015
> @@ -693,9 +693,9 @@ Instruction *InstCombiner::visitShl(Bina
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyShlInst(I.getOperand(0), I.getOperand(1),
> - I.hasNoSignedWrap(), I.hasNoUnsignedWrap(),
> - DL, TLI, DT, AT))
> + if (Value *V =
> + SimplifyShlInst(I.getOperand(0), I.getOperand(1), I.hasNoSignedWrap(),
> + I.hasNoUnsignedWrap(), DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> if (Instruction *V = commonShiftTransforms(I))
> @@ -735,8 +735,8 @@ Instruction *InstCombiner::visitLShr(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyLShrInst(I.getOperand(0), I.getOperand(1),
> - I.isExact(), DL, TLI, DT, AT))
> + if (Value *V = SimplifyLShrInst(I.getOperand(0), I.getOperand(1), I.isExact(),
> + DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> if (Instruction *R = commonShiftTransforms(I))
> @@ -779,8 +779,8 @@ Instruction *InstCombiner::visitAShr(Bin
> if (Value *V = SimplifyVectorOp(I))
> return ReplaceInstUsesWith(I, V);
>
> - if (Value *V = SimplifyAShrInst(I.getOperand(0), I.getOperand(1),
> - I.isExact(), DL, TLI, DT, AT))
> + if (Value *V = SimplifyAShrInst(I.getOperand(0), I.getOperand(1), I.isExact(),
> + DL, TLI, DT, AC))
> return ReplaceInstUsesWith(I, V);
>
> if (Instruction *R = commonShiftTransforms(I))
>
> Modified: llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp (original)
> +++ llvm/trunk/lib/Transforms/InstCombine/InstructionCombining.cpp Sun Jan 4 06:03:27 2015
> @@ -39,7 +39,7 @@
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/Statistic.h"
> #include "llvm/ADT/StringSwitch.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CFG.h"
> #include "llvm/Analysis/ConstantFolding.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> @@ -84,7 +84,7 @@ void LLVMInitializeInstCombine(LLVMPassR
> char InstCombiner::ID = 0;
> INITIALIZE_PASS_BEGIN(InstCombiner, "instcombine",
> "Combine redundant instructions", false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_END(InstCombiner, "instcombine",
> @@ -92,7 +92,7 @@ INITIALIZE_PASS_END(InstCombiner, "instc
>
> void InstCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
> AU.setPreservesCFG();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<TargetLibraryInfo>();
> AU.addRequired<DominatorTreeWrapperPass>();
> AU.addPreserved<DominatorTreeWrapperPass>();
> @@ -1319,7 +1319,7 @@ Value *InstCombiner::SimplifyVectorOp(Bi
> Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
> SmallVector<Value*, 8> Ops(GEP.op_begin(), GEP.op_end());
>
> - if (Value *V = SimplifyGEPInst(Ops, DL, TLI, DT, AT))
> + if (Value *V = SimplifyGEPInst(Ops, DL, TLI, DT, AC))
> return ReplaceInstUsesWith(GEP, V);
>
> Value *PtrOp = GEP.getOperand(0);
> @@ -2970,7 +2970,7 @@ bool InstCombiner::runOnFunction(Functio
> if (skipOptnoneFunction(F))
> return false;
>
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> DL = DLP ? &DLP->getDataLayout() : nullptr;
> DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> @@ -2982,9 +2982,8 @@ bool InstCombiner::runOnFunction(Functio
>
> /// Builder - This is an IRBuilder that automatically inserts new
> /// instructions into the worklist when they are created.
> - IRBuilder<true, TargetFolder, InstCombineIRInserter>
> - TheBuilder(F.getContext(), TargetFolder(DL),
> - InstCombineIRInserter(Worklist, AT));
> + IRBuilder<true, TargetFolder, InstCombineIRInserter> TheBuilder(
> + F.getContext(), TargetFolder(DL), InstCombineIRInserter(Worklist, AC));
> Builder = &TheBuilder;
>
> InstCombinerLibCallSimplifier TheSimplifier(DL, TLI, this);
>
> Modified: llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp Sun Jan 4 06:03:27 2015
> @@ -21,7 +21,7 @@
> #include "llvm/Transforms/Scalar.h"
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/LoopInfo.h"
> #include "llvm/Analysis/ValueTracking.h"
> #include "llvm/Analysis/ScalarEvolution.h"
> @@ -53,7 +53,7 @@ struct AlignmentFromAssumptions : public
> bool runOnFunction(Function &F);
>
> virtual void getAnalysisUsage(AnalysisUsage &AU) const {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<ScalarEvolution>();
> AU.addRequired<DominatorTreeWrapperPass>();
>
> @@ -69,7 +69,6 @@ struct AlignmentFromAssumptions : public
> // another assumption later, then we may change the alignment at that point.
> DenseMap<MemTransferInst *, unsigned> NewDestAlignments, NewSrcAlignments;
>
> - AssumptionTracker *AT;
> ScalarEvolution *SE;
> DominatorTree *DT;
> const DataLayout *DL;
> @@ -84,7 +83,7 @@ char AlignmentFromAssumptions::ID = 0;
> static const char aip_name[] = "Alignment from assumptions";
> INITIALIZE_PASS_BEGIN(AlignmentFromAssumptions, AA_NAME,
> aip_name, false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
> INITIALIZE_PASS_END(AlignmentFromAssumptions, AA_NAME,
> @@ -411,7 +410,7 @@ bool AlignmentFromAssumptions::processAs
>
> bool AlignmentFromAssumptions::runOnFunction(Function &F) {
> bool Changed = false;
> - AT = &getAnalysis<AssumptionTracker>();
> + auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
> SE = &getAnalysis<ScalarEvolution>();
> DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> @@ -420,8 +419,9 @@ bool AlignmentFromAssumptions::runOnFunc
> NewDestAlignments.clear();
> NewSrcAlignments.clear();
>
> - for (auto &I : AT->assumptions(&F))
> - Changed |= processAssumption(I);
> + for (auto &AssumeVH : AC.assumptions())
> + if (AssumeVH)
> + Changed |= processAssumption(cast<CallInst>(AssumeVH));
>
> return Changed;
> }
>
> Modified: llvm/trunk/lib/Transforms/Scalar/EarlyCSE.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/EarlyCSE.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/EarlyCSE.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/EarlyCSE.cpp Sun Jan 4 06:03:27 2015
> @@ -16,7 +16,7 @@
> #include "llvm/ADT/Hashing.h"
> #include "llvm/ADT/ScopedHashTable.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/IR/DataLayout.h"
> #include "llvm/IR/Dominators.h"
> @@ -270,7 +270,7 @@ public:
> const DataLayout *DL;
> const TargetLibraryInfo *TLI;
> DominatorTree *DT;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> typedef RecyclingAllocator<BumpPtrAllocator,
> ScopedHashTableVal<SimpleValue, Value*> > AllocatorTy;
> typedef ScopedHashTable<SimpleValue, Value*, DenseMapInfo<SimpleValue>,
> @@ -383,7 +383,7 @@ private:
>
> // This transformation requires dominator postdominator info
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<DominatorTreeWrapperPass>();
> AU.addRequired<TargetLibraryInfo>();
> AU.setPreservesCFG();
> @@ -399,7 +399,7 @@ FunctionPass *llvm::createEarlyCSEPass()
> }
>
> INITIALIZE_PASS_BEGIN(EarlyCSE, "early-cse", "Early CSE", false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> INITIALIZE_PASS_END(EarlyCSE, "early-cse", "Early CSE", false, false)
> @@ -449,7 +449,7 @@ bool EarlyCSE::processNode(DomTreeNode *
>
> // If the instruction can be simplified (e.g. X+0 = X) then replace it with
> // its simpler value.
> - if (Value *V = SimplifyInstruction(Inst, DL, TLI, DT, AT)) {
> + if (Value *V = SimplifyInstruction(Inst, DL, TLI, DT, AC)) {
> DEBUG(dbgs() << "EarlyCSE Simplify: " << *Inst << " to: " << *V << '\n');
> Inst->replaceAllUsesWith(V);
> Inst->eraseFromParent();
> @@ -582,7 +582,7 @@ bool EarlyCSE::runOnFunction(Function &F
> DL = DLP ? &DLP->getDataLayout() : nullptr;
> TLI = &getAnalysis<TargetLibraryInfo>();
> DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
>
> // Tables that the pass uses when walking the domtree.
> ScopedHTType AVTable;
>
> Modified: llvm/trunk/lib/Transforms/Scalar/GVN.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/GVN.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/GVN.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/GVN.cpp Sun Jan 4 06:03:27 2015
> @@ -24,7 +24,7 @@
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/Statistic.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CFG.h"
> #include "llvm/Analysis/ConstantFolding.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> @@ -592,7 +592,7 @@ namespace {
> DominatorTree *DT;
> const DataLayout *DL;
> const TargetLibraryInfo *TLI;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> SetVector<BasicBlock *> DeadBlocks;
>
> ValueTable VN;
> @@ -682,7 +682,7 @@ namespace {
>
> // This transformation requires dominator postdominator info
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<DominatorTreeWrapperPass>();
> AU.addRequired<TargetLibraryInfo>();
> if (!NoLoads)
> @@ -731,7 +731,7 @@ FunctionPass *llvm::createGVNPass(bool N
> }
>
> INITIALIZE_PASS_BEGIN(GVN, "gvn", "Global Value Numbering", false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> @@ -1621,7 +1621,7 @@ bool GVN::PerformLoadPRE(LoadInst *LI, A
> // If all preds have a single successor, then we know it is safe to insert
> // the load on the pred (?!?), so we can insert code to materialize the
> // pointer if it is not available.
> - PHITransAddr Address(LI->getPointerOperand(), DL, AT);
> + PHITransAddr Address(LI->getPointerOperand(), DL, AC);
> Value *LoadPtr = nullptr;
> LoadPtr = Address.PHITranslateWithInsertion(LoadBB, UnavailablePred,
> *DT, NewInsts);
> @@ -2214,7 +2214,7 @@ bool GVN::processInstruction(Instruction
> // to value numbering it. Value numbering often exposes redundancies, for
> // example if it determines that %y is equal to %x then the instruction
> // "%z = and i32 %x, %y" becomes "%z = and i32 %x, %x" which we now simplify.
> - if (Value *V = SimplifyInstruction(I, DL, TLI, DT, AT)) {
> + if (Value *V = SimplifyInstruction(I, DL, TLI, DT, AC)) {
> I->replaceAllUsesWith(V);
> if (MD && V->getType()->getScalarType()->isPointerTy())
> MD->invalidateCachedPointerInfo(V);
> @@ -2334,7 +2334,7 @@ bool GVN::runOnFunction(Function& F) {
> DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> DL = DLP ? &DLP->getDataLayout() : nullptr;
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
> TLI = &getAnalysis<TargetLibraryInfo>();
> VN.setAliasAnalysis(&getAnalysis<AliasAnalysis>());
> VN.setMemDep(MD);
>
> Modified: llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/LoopInstSimplify.cpp Sun Jan 4 06:03:27 2015
> @@ -14,7 +14,7 @@
> #include "llvm/Transforms/Scalar.h"
> #include "llvm/ADT/STLExtras.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/LoopInfo.h"
> #include "llvm/Analysis/LoopPass.h"
> @@ -42,7 +42,7 @@ namespace {
>
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> AU.setPreservesCFG();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<LoopInfo>();
> AU.addRequiredID(LoopSimplifyID);
> AU.addPreservedID(LoopSimplifyID);
> @@ -56,7 +56,7 @@ namespace {
> char LoopInstSimplify::ID = 0;
> INITIALIZE_PASS_BEGIN(LoopInstSimplify, "loop-instsimplify",
> "Simplify instructions in loops", false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(LoopInfo)
> @@ -79,7 +79,8 @@ bool LoopInstSimplify::runOnLoop(Loop *L
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> const DataLayout *DL = DLP ? &DLP->getDataLayout() : nullptr;
> const TargetLibraryInfo *TLI = &getAnalysis<TargetLibraryInfo>();
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
> + *L->getHeader()->getParent());
>
> SmallVector<BasicBlock*, 8> ExitBlocks;
> L->getUniqueExitBlocks(ExitBlocks);
> @@ -120,7 +121,7 @@ bool LoopInstSimplify::runOnLoop(Loop *L
>
> // Don't bother simplifying unused instructions.
> if (!I->use_empty()) {
> - Value *V = SimplifyInstruction(I, DL, TLI, DT, AT);
> + Value *V = SimplifyInstruction(I, DL, TLI, DT, &AC);
> if (V && LI->replacementPreservesLCSSAForm(I, V)) {
> // Mark all uses for resimplification next time round the loop.
> for (User *U : I->users())
>
> Modified: llvm/trunk/lib/Transforms/Scalar/LoopRotation.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopRotation.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/LoopRotation.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/LoopRotation.cpp Sun Jan 4 06:03:27 2015
> @@ -13,7 +13,7 @@
>
> #include "llvm/Transforms/Scalar.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CodeMetrics.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/LoopPass.h"
> @@ -54,7 +54,7 @@ namespace {
>
> // LCSSA form makes instruction renaming easier.
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addPreserved<DominatorTreeWrapperPass>();
> AU.addRequired<LoopInfo>();
> AU.addPreserved<LoopInfo>();
> @@ -74,14 +74,14 @@ namespace {
> unsigned MaxHeaderSize;
> LoopInfo *LI;
> const TargetTransformInfo *TTI;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> };
> }
>
> char LoopRotate::ID = 0;
> INITIALIZE_PASS_BEGIN(LoopRotate, "loop-rotate", "Rotate Loops", false, false)
> INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(LoopInfo)
> INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
> INITIALIZE_PASS_DEPENDENCY(LCSSA)
> @@ -102,7 +102,8 @@ bool LoopRotate::runOnLoop(Loop *L, LPPa
>
> LI = &getAnalysis<LoopInfo>();
> TTI = &getAnalysis<TargetTransformInfo>();
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
> + *L->getHeader()->getParent());
>
> // Simplify the loop latch before attempting to rotate the header
> // upward. Rotation may not be needed if the loop tail can be folded into the
> @@ -356,7 +357,7 @@ bool LoopRotate::rotateLoop(Loop *L, boo
> // duplicate blocks inside it.
> {
> SmallPtrSet<const Value *, 32> EphValues;
> - CodeMetrics::collectEphemeralValues(L, AT, EphValues);
> + CodeMetrics::collectEphemeralValues(L, AC, EphValues);
>
> CodeMetrics Metrics;
> Metrics.analyzeBasicBlock(OrigHeader, *TTI, EphValues);
> @@ -441,7 +442,7 @@ bool LoopRotate::rotateLoop(Loop *L, boo
> // With the operands remapped, see if the instruction constant folds or is
> // otherwise simplifyable. This commonly occurs because the entry from PHI
> // nodes allows icmps and other instructions to fold.
> - // FIXME: Provide DL, TLI, DT, AT to SimplifyInstruction.
> + // FIXME: Provide DL, TLI, DT, AC to SimplifyInstruction.
> Value *V = SimplifyInstruction(C);
> if (V && LI->replacementPreservesLCSSAForm(C, V)) {
> // If so, then delete the temporary instruction and stick the folded value
>
> Modified: llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/LoopUnrollPass.cpp Sun Jan 4 06:03:27 2015
> @@ -13,7 +13,7 @@
> //===----------------------------------------------------------------------===//
>
> #include "llvm/Transforms/Scalar.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CodeMetrics.h"
> #include "llvm/Analysis/FunctionTargetTransformInfo.h"
> #include "llvm/Analysis/LoopPass.h"
> @@ -104,7 +104,7 @@ namespace {
> /// loop preheaders be inserted into the CFG...
> ///
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<LoopInfo>();
> AU.addPreserved<LoopInfo>();
> AU.addRequiredID(LoopSimplifyID);
> @@ -186,7 +186,7 @@ namespace {
> char LoopUnroll::ID = 0;
> INITIALIZE_PASS_BEGIN(LoopUnroll, "loop-unroll", "Unroll loops", false, false)
> INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(FunctionTargetTransformInfo)
> INITIALIZE_PASS_DEPENDENCY(LoopInfo)
> INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
> @@ -207,9 +207,9 @@ Pass *llvm::createSimpleLoopUnrollPass()
> static unsigned ApproximateLoopSize(const Loop *L, unsigned &NumCalls,
> bool &NotDuplicatable,
> const TargetTransformInfo &TTI,
> - AssumptionTracker *AT) {
> + AssumptionCache *AC) {
> SmallPtrSet<const Value *, 32> EphValues;
> - CodeMetrics::collectEphemeralValues(L, AT, EphValues);
> + CodeMetrics::collectEphemeralValues(L, AC, EphValues);
>
> CodeMetrics Metrics;
> for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
> @@ -365,7 +365,8 @@ bool LoopUnroll::runOnLoop(Loop *L, LPPa
> const TargetTransformInfo &TTI = getAnalysis<TargetTransformInfo>();
> const FunctionTargetTransformInfo &FTTI =
> getAnalysis<FunctionTargetTransformInfo>();
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
> + *L->getHeader()->getParent());
>
> BasicBlock *Header = L->getHeader();
> DEBUG(dbgs() << "Loop Unroll: F[" << Header->getParent()->getName()
> @@ -404,7 +405,7 @@ bool LoopUnroll::runOnLoop(Loop *L, LPPa
> unsigned NumInlineCandidates;
> bool notDuplicatable;
> unsigned LoopSize =
> - ApproximateLoopSize(L, NumInlineCandidates, notDuplicatable, TTI, AT);
> + ApproximateLoopSize(L, NumInlineCandidates, notDuplicatable, TTI, &AC);
> DEBUG(dbgs() << " Loop Size = " << LoopSize << "\n");
> uint64_t UnrolledSize = (uint64_t)LoopSize * Count;
> if (notDuplicatable) {
> @@ -511,7 +512,7 @@ bool LoopUnroll::runOnLoop(Loop *L, LPPa
>
> // Unroll the loop.
> if (!UnrollLoop(L, Count, TripCount, AllowRuntime, TripMultiple, LI, this,
> - &LPM, AT))
> + &LPM, &AC))
> return false;
>
> return true;
>
> Modified: llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/LoopUnswitch.cpp Sun Jan 4 06:03:27 2015
> @@ -30,7 +30,7 @@
> #include "llvm/ADT/STLExtras.h"
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CodeMetrics.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/LoopInfo.h"
> @@ -105,7 +105,7 @@ namespace {
> // Analyze loop. Check its size, calculate is it possible to unswitch
> // it. Returns true if we can unswitch this loop.
> bool countLoop(const Loop *L, const TargetTransformInfo &TTI,
> - AssumptionTracker *AT);
> + AssumptionCache *AC);
>
> // Clean all data related to given loop.
> void forgetLoop(const Loop *L);
> @@ -128,7 +128,7 @@ namespace {
> class LoopUnswitch : public LoopPass {
> LoopInfo *LI; // Loop information
> LPPassManager *LPM;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
>
> // LoopProcessWorklist - Used to check if second loop needs processing
> // after RewriteLoopBodyWithConditionConstant rewrites first loop.
> @@ -167,7 +167,7 @@ namespace {
> /// loop preheaders be inserted into the CFG.
> ///
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequiredID(LoopSimplifyID);
> AU.addPreservedID(LoopSimplifyID);
> AU.addRequired<LoopInfo>();
> @@ -217,7 +217,7 @@ namespace {
> // Analyze loop. Check its size, calculate is it possible to unswitch
> // it. Returns true if we can unswitch this loop.
> bool LUAnalysisCache::countLoop(const Loop *L, const TargetTransformInfo &TTI,
> - AssumptionTracker *AT) {
> + AssumptionCache *AC) {
>
> LoopPropsMapIt PropsIt;
> bool Inserted;
> @@ -235,7 +235,7 @@ bool LUAnalysisCache::countLoop(const Lo
> // This is a very ad-hoc heuristic.
>
> SmallPtrSet<const Value *, 32> EphValues;
> - CodeMetrics::collectEphemeralValues(L, AT, EphValues);
> + CodeMetrics::collectEphemeralValues(L, AC, EphValues);
>
> // FIXME: This is overly conservative because it does not take into
> // consideration code simplification opportunities and code that can
> @@ -334,7 +334,7 @@ char LoopUnswitch::ID = 0;
> INITIALIZE_PASS_BEGIN(LoopUnswitch, "loop-unswitch", "Unswitch loops",
> false, false)
> INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
> INITIALIZE_PASS_DEPENDENCY(LoopInfo)
> INITIALIZE_PASS_DEPENDENCY(LCSSA)
> @@ -385,7 +385,8 @@ bool LoopUnswitch::runOnLoop(Loop *L, LP
> if (skipOptnoneFunction(L))
> return false;
>
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
> + *L->getHeader()->getParent());
> LI = &getAnalysis<LoopInfo>();
> LPM = &LPM_Ref;
> DominatorTreeWrapperPass *DTWP =
> @@ -432,7 +433,7 @@ bool LoopUnswitch::processCurrentLoop()
> // Probably we reach the quota of branches for this loop. If so
> // stop unswitching.
> if (!BranchesInfo.countLoop(currentLoop, getAnalysis<TargetTransformInfo>(),
> - AT))
> + AC))
> return false;
>
> // Loop over all of the basic blocks in the loop. If we find an interior
> @@ -836,7 +837,7 @@ void LoopUnswitch::UnswitchNontrivialCon
>
> // FIXME: We could register any cloned assumptions instead of clearing the
> // whole function's cache.
> - AT->forgetCachedAssumptions(F);
> + AC->clear();
>
> // Now we create the new Loop object for the versioned loop.
> Loop *NewLoop = CloneLoop(L, L->getParentLoop(), VMap, LI, LPM);
>
> Modified: llvm/trunk/lib/Transforms/Scalar/MemCpyOptimizer.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/MemCpyOptimizer.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/MemCpyOptimizer.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/MemCpyOptimizer.cpp Sun Jan 4 06:03:27 2015
> @@ -16,7 +16,7 @@
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/ADT/Statistic.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/MemoryDependenceAnalysis.h"
> #include "llvm/Analysis/ValueTracking.h"
> #include "llvm/IR/DataLayout.h"
> @@ -330,7 +330,7 @@ namespace {
> // This transformation requires dominator postdominator info
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> AU.setPreservesCFG();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<DominatorTreeWrapperPass>();
> AU.addRequired<MemoryDependenceAnalysis>();
> AU.addRequired<AliasAnalysis>();
> @@ -363,7 +363,7 @@ FunctionPass *llvm::createMemCpyOptPass(
>
> INITIALIZE_PASS_BEGIN(MemCpyOpt, "memcpyopt", "MemCpy Optimization",
> false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(MemoryDependenceAnalysis)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> @@ -982,11 +982,13 @@ bool MemCpyOpt::processByValArgument(Cal
>
> // If it is greater than the memcpy, then we check to see if we can force the
> // source of the memcpy to the alignment we need. If we fail, we bail out.
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + AssumptionCache &AC =
> + getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
> + *CS->getParent()->getParent());
> DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> if (MDep->getAlignment() < ByValAlign &&
> - getOrEnforceKnownAlignment(MDep->getSource(),ByValAlign,
> - DL, AT, CS.getInstruction(), &DT) < ByValAlign)
> + getOrEnforceKnownAlignment(MDep->getSource(), ByValAlign, DL, &AC,
> + CS.getInstruction(), &DT) < ByValAlign)
> return false;
>
> // Verify that the copied-from memory doesn't change in between the memcpy and
>
> Modified: llvm/trunk/lib/Transforms/Scalar/SROA.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/SROA.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/SROA.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/SROA.cpp Sun Jan 4 06:03:27 2015
> @@ -28,7 +28,7 @@
> #include "llvm/ADT/SetVector.h"
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/Loads.h"
> #include "llvm/Analysis/PtrUseVisitor.h"
> #include "llvm/Analysis/ValueTracking.h"
> @@ -1196,7 +1196,7 @@ class SROA : public FunctionPass {
> LLVMContext *C;
> const DataLayout *DL;
> DominatorTree *DT;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
>
> /// \brief Worklist of alloca instructions to simplify.
> ///
> @@ -1275,7 +1275,7 @@ FunctionPass *llvm::createSROAPass(bool
>
> INITIALIZE_PASS_BEGIN(SROA, "sroa", "Scalar Replacement Of Aggregates", false,
> false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_END(SROA, "sroa", "Scalar Replacement Of Aggregates", false,
> false)
> @@ -4254,7 +4254,7 @@ bool SROA::promoteAllocas(Function &F) {
>
> if (DT && !ForceSSAUpdater) {
> DEBUG(dbgs() << "Promoting allocas with mem2reg...\n");
> - PromoteMemToReg(PromotableAllocas, *DT, nullptr, AT);
> + PromoteMemToReg(PromotableAllocas, *DT, nullptr, AC);
> PromotableAllocas.clear();
> return true;
> }
> @@ -4336,7 +4336,7 @@ bool SROA::runOnFunction(Function &F) {
> DominatorTreeWrapperPass *DTWP =
> getAnalysisIfAvailable<DominatorTreeWrapperPass>();
> DT = DTWP ? &DTWP->getDomTree() : nullptr;
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
>
> BasicBlock &EntryBB = F.getEntryBlock();
> for (BasicBlock::iterator I = EntryBB.begin(), E = std::prev(EntryBB.end());
> @@ -4378,7 +4378,7 @@ bool SROA::runOnFunction(Function &F) {
> }
>
> void SROA::getAnalysisUsage(AnalysisUsage &AU) const {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> if (RequiresDomTree)
> AU.addRequired<DominatorTreeWrapperPass>();
> AU.setPreservesCFG();
>
> Modified: llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp Sun Jan 4 06:03:27 2015
> @@ -23,7 +23,7 @@
> #include "llvm/ADT/SetVector.h"
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/Loads.h"
> #include "llvm/Analysis/ValueTracking.h"
> #include "llvm/IR/CallSite.h"
> @@ -198,7 +198,7 @@ namespace {
> // getAnalysisUsage - This pass does not require any passes, but we know it
> // will not alter the CFG, so say so.
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<DominatorTreeWrapperPass>();
> AU.setPreservesCFG();
> }
> @@ -216,7 +216,7 @@ namespace {
> // getAnalysisUsage - This pass does not require any passes, but we know it
> // will not alter the CFG, so say so.
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.setPreservesCFG();
> }
> };
> @@ -228,14 +228,14 @@ char SROA_SSAUp::ID = 0;
>
> INITIALIZE_PASS_BEGIN(SROA_DT, "scalarrepl",
> "Scalar Replacement of Aggregates (DT)", false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_END(SROA_DT, "scalarrepl",
> "Scalar Replacement of Aggregates (DT)", false, false)
>
> INITIALIZE_PASS_BEGIN(SROA_SSAUp, "scalarrepl-ssa",
> "Scalar Replacement of Aggregates (SSAUp)", false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_END(SROA_SSAUp, "scalarrepl-ssa",
> "Scalar Replacement of Aggregates (SSAUp)", false, false)
>
> @@ -1419,7 +1419,8 @@ bool SROA::performPromotion(Function &F)
> DominatorTree *DT = nullptr;
> if (HasDomTree)
> DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + AssumptionCache &AC =
> + getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
>
> BasicBlock &BB = F.getEntryBlock(); // Get the entry node for the function
> DIBuilder DIB(*F.getParent(), /*AllowUnresolved*/ false);
> @@ -1438,7 +1439,7 @@ bool SROA::performPromotion(Function &F)
> if (Allocas.empty()) break;
>
> if (HasDomTree)
> - PromoteMemToReg(Allocas, *DT, nullptr, AT);
> + PromoteMemToReg(Allocas, *DT, nullptr, &AC);
> else {
> SSAUpdater SSA;
> for (unsigned i = 0, e = Allocas.size(); i != e; ++i) {
>
> Modified: llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp (original)
> +++ llvm/trunk/lib/Transforms/Scalar/SimplifyCFGPass.cpp Sun Jan 4 06:03:27 2015
> @@ -25,7 +25,7 @@
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/TargetTransformInfo.h"
> #include "llvm/IR/Attributes.h"
> #include "llvm/IR/CFG.h"
> @@ -58,7 +58,7 @@ struct CFGSimplifyPass : public Function
> bool runOnFunction(Function &F) override;
>
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<TargetTransformInfo>();
> }
> };
> @@ -68,7 +68,7 @@ char CFGSimplifyPass::ID = 0;
> INITIALIZE_PASS_BEGIN(CFGSimplifyPass, "simplifycfg", "Simplify the CFG", false,
> false)
> INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_END(CFGSimplifyPass, "simplifycfg", "Simplify the CFG", false,
> false)
>
> @@ -156,8 +156,7 @@ static bool mergeEmptyReturnBlocks(Funct
> /// iterativelySimplifyCFG - Call SimplifyCFG on all the blocks in the function,
> /// iterating until no more changes are made.
> static bool iterativelySimplifyCFG(Function &F, const TargetTransformInfo &TTI,
> - const DataLayout *DL,
> - AssumptionTracker *AT,
> + const DataLayout *DL, AssumptionCache *AC,
> unsigned BonusInstThreshold) {
> bool Changed = false;
> bool LocalChange = true;
> @@ -167,7 +166,7 @@ static bool iterativelySimplifyCFG(Funct
> // Loop over all of the basic blocks and remove them if they are unneeded...
> //
> for (Function::iterator BBIt = F.begin(); BBIt != F.end(); ) {
> - if (SimplifyCFG(BBIt++, TTI, BonusInstThreshold, DL, AT)) {
> + if (SimplifyCFG(BBIt++, TTI, BonusInstThreshold, DL, AC)) {
> LocalChange = true;
> ++NumSimpl;
> }
> @@ -184,13 +183,14 @@ bool CFGSimplifyPass::runOnFunction(Func
> if (skipOptnoneFunction(F))
> return false;
>
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + AssumptionCache *AC =
> + &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
> const TargetTransformInfo &TTI = getAnalysis<TargetTransformInfo>();
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> const DataLayout *DL = DLP ? &DLP->getDataLayout() : nullptr;
> bool EverChanged = removeUnreachableBlocks(F);
> EverChanged |= mergeEmptyReturnBlocks(F);
> - EverChanged |= iterativelySimplifyCFG(F, TTI, DL, AT, BonusInstThreshold);
> + EverChanged |= iterativelySimplifyCFG(F, TTI, DL, AC, BonusInstThreshold);
>
> // If neither pass changed anything, we're done.
> if (!EverChanged) return false;
> @@ -204,7 +204,7 @@ bool CFGSimplifyPass::runOnFunction(Func
> return true;
>
> do {
> - EverChanged = iterativelySimplifyCFG(F, TTI, DL, AT, BonusInstThreshold);
> + EverChanged = iterativelySimplifyCFG(F, TTI, DL, AC, BonusInstThreshold);
> EverChanged |= removeUnreachableBlocks(F);
> } while (EverChanged);
>
>
> Modified: llvm/trunk/lib/Transforms/Utils/InlineFunction.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/InlineFunction.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/InlineFunction.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/InlineFunction.cpp Sun Jan 4 06:03:27 2015
> @@ -18,7 +18,7 @@
> #include "llvm/ADT/SetVector.h"
> #include "llvm/ADT/StringExtras.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CallGraph.h"
> #include "llvm/Analysis/CaptureTracking.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> @@ -633,9 +633,10 @@ static void AddAlignmentAssumptions(Call
> DominatorTree DT;
> bool DTCalculated = false;
>
> - const Function *CalledFunc = CS.getCalledFunction();
> - for (Function::const_arg_iterator I = CalledFunc->arg_begin(),
> - E = CalledFunc->arg_end(); I != E; ++I) {
> + Function *CalledFunc = CS.getCalledFunction();
> + for (Function::arg_iterator I = CalledFunc->arg_begin(),
> + E = CalledFunc->arg_end();
> + I != E; ++I) {
> unsigned Align = I->getType()->isPointerTy() ? I->getParamAlignment() : 0;
> if (Align && !I->hasByValOrInAllocaAttr() && !I->hasNUses(0)) {
> if (!DTCalculated) {
> @@ -647,8 +648,9 @@ static void AddAlignmentAssumptions(Call
> // If we can already prove the asserted alignment in the context of the
> // caller, then don't bother inserting the assumption.
> Value *Arg = CS.getArgument(I->getArgNo());
> - if (getKnownAlignment(Arg, IFI.DL, IFI.AT, CS.getInstruction(),
> - &DT) >= Align)
> + if (getKnownAlignment(Arg, IFI.DL,
> + &IFI.ACT->getAssumptionCache(*CalledFunc),
> + CS.getInstruction(), &DT) >= Align)
> continue;
>
> IRBuilder<>(CS.getInstruction()).CreateAlignmentAssumption(*IFI.DL, Arg,
> @@ -748,6 +750,8 @@ static Value *HandleByValArgument(Value
> PointerType *ArgTy = cast<PointerType>(Arg->getType());
> Type *AggTy = ArgTy->getElementType();
>
> + Function *Caller = TheCall->getParent()->getParent();
> +
> // If the called function is readonly, then it could not mutate the caller's
> // copy of the byval'd memory. In this case, it is safe to elide the copy and
> // temporary.
> @@ -760,8 +764,9 @@ static Value *HandleByValArgument(Value
>
> // If the pointer is already known to be sufficiently aligned, or if we can
> // round it up to a larger alignment, then we don't need a temporary.
> - if (getOrEnforceKnownAlignment(Arg, ByValAlignment,
> - IFI.DL, IFI.AT, TheCall) >= ByValAlignment)
> + if (getOrEnforceKnownAlignment(Arg, ByValAlignment, IFI.DL,
> + &IFI.ACT->getAssumptionCache(*Caller),
> + TheCall) >= ByValAlignment)
> return Arg;
>
> // Otherwise, we have to make a memcpy to get a safe alignment. This is bad
> @@ -778,8 +783,6 @@ static Value *HandleByValArgument(Value
> // pointer inside the callee).
> Align = std::max(Align, ByValAlignment);
>
> - Function *Caller = TheCall->getParent()->getParent();
> -
> Value *NewAlloca = new AllocaInst(AggTy, nullptr, Align, Arg->getName(),
> &*Caller->begin()->begin());
> IFI.StaticAllocas.push_back(cast<AllocaInst>(NewAlloca));
> @@ -1033,8 +1036,8 @@ bool llvm::InlineFunction(CallSite CS, I
>
> // FIXME: We could register any cloned assumptions instead of clearing the
> // whole function's cache.
> - if (IFI.AT)
> - IFI.AT->forgetCachedAssumptions(Caller);
> + if (IFI.ACT)
> + IFI.ACT->getAssumptionCache(*Caller).clear();
> }
>
> // If there are any alloca instructions in the block that used to be the entry
> @@ -1405,7 +1408,8 @@ bool llvm::InlineFunction(CallSite CS, I
> // the entries are the same or undef). If so, remove the PHI so it doesn't
> // block other optimizations.
> if (PHI) {
> - if (Value *V = SimplifyInstruction(PHI, IFI.DL, nullptr, nullptr, IFI.AT)) {
> + if (Value *V = SimplifyInstruction(PHI, IFI.DL, nullptr, nullptr,
> + &IFI.ACT->getAssumptionCache(*Caller))) {
> PHI->replaceAllUsesWith(V);
> PHI->eraseFromParent();
> }
>
> Modified: llvm/trunk/lib/Transforms/Utils/Local.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/Local.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/Local.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/Local.cpp Sun Jan 4 06:03:27 2015
> @@ -943,7 +943,7 @@ static unsigned enforceKnownAlignment(Va
> /// increase the alignment of the ultimate object, making this check succeed.
> unsigned llvm::getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign,
> const DataLayout *DL,
> - AssumptionTracker *AT,
> + AssumptionCache *AC,
> const Instruction *CxtI,
> const DominatorTree *DT) {
> assert(V->getType()->isPointerTy() &&
> @@ -951,7 +951,7 @@ unsigned llvm::getOrEnforceKnownAlignmen
> unsigned BitWidth = DL ? DL->getPointerTypeSizeInBits(V->getType()) : 64;
>
> APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
> - computeKnownBits(V, KnownZero, KnownOne, DL, 0, AT, CxtI, DT);
> + computeKnownBits(V, KnownZero, KnownOne, DL, 0, AC, CxtI, DT);
> unsigned TrailZ = KnownZero.countTrailingOnes();
>
> // Avoid trouble with ridiculously large TrailZ values, such as
>
> Modified: llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/LoopSimplify.cpp Sun Jan 4 06:03:27 2015
> @@ -44,7 +44,7 @@
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/ADT/Statistic.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/DependenceAnalysis.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/LoopInfo.h"
> @@ -210,11 +210,11 @@ static void addBlockAndPredsToSet(BasicB
> /// us how to partition the loops.
> static PHINode *findPHIToPartitionLoops(Loop *L, AliasAnalysis *AA,
> DominatorTree *DT,
> - AssumptionTracker *AT) {
> + AssumptionCache *AC) {
> for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) {
> PHINode *PN = cast<PHINode>(I);
> ++I;
> - if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, DT, AT)) {
> + if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, DT, AC)) {
> // This is a degenerate PHI already, don't modify it!
> PN->replaceAllUsesWith(V);
> if (AA) AA->deleteValue(PN);
> @@ -254,7 +254,7 @@ static PHINode *findPHIToPartitionLoops(
> static Loop *separateNestedLoop(Loop *L, BasicBlock *Preheader,
> AliasAnalysis *AA, DominatorTree *DT,
> LoopInfo *LI, ScalarEvolution *SE, Pass *PP,
> - AssumptionTracker *AT) {
> + AssumptionCache *AC) {
> // Don't try to separate loops without a preheader.
> if (!Preheader)
> return nullptr;
> @@ -263,7 +263,7 @@ static Loop *separateNestedLoop(Loop *L,
> assert(!L->getHeader()->isLandingPad() &&
> "Can't insert backedge to landing pad");
>
> - PHINode *PN = findPHIToPartitionLoops(L, AA, DT, AT);
> + PHINode *PN = findPHIToPartitionLoops(L, AA, DT, AC);
> if (!PN) return nullptr; // No known way to partition.
>
> // Pull out all predecessors that have varying values in the loop. This
> @@ -476,8 +476,8 @@ static BasicBlock *insertUniqueBackedgeB
> /// explicit if they accepted the analysis directly and then updated it.
> static bool simplifyOneLoop(Loop *L, SmallVectorImpl<Loop *> &Worklist,
> AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI,
> - ScalarEvolution *SE, Pass *PP,
> - const DataLayout *DL, AssumptionTracker *AT) {
> + ScalarEvolution *SE, Pass *PP, const DataLayout *DL,
> + AssumptionCache *AC) {
> bool Changed = false;
> ReprocessLoop:
>
> @@ -583,8 +583,8 @@ ReprocessLoop:
> // this for loops with a giant number of backedges, just factor them into a
> // common backedge instead.
> if (L->getNumBackEdges() < 8) {
> - if (Loop *OuterL = separateNestedLoop(L, Preheader, AA, DT, LI, SE,
> - PP, AT)) {
> + if (Loop *OuterL =
> + separateNestedLoop(L, Preheader, AA, DT, LI, SE, PP, AC)) {
> ++NumNested;
> // Enqueue the outer loop as it should be processed next in our
> // depth-first nest walk.
> @@ -614,7 +614,7 @@ ReprocessLoop:
> PHINode *PN;
> for (BasicBlock::iterator I = L->getHeader()->begin();
> (PN = dyn_cast<PHINode>(I++)); )
> - if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, DT, AT)) {
> + if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, DT, AC)) {
> if (AA) AA->deleteValue(PN);
> if (SE) SE->forgetValue(PN);
> PN->replaceAllUsesWith(V);
> @@ -714,7 +714,7 @@ ReprocessLoop:
>
> bool llvm::simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, Pass *PP,
> AliasAnalysis *AA, ScalarEvolution *SE,
> - const DataLayout *DL, AssumptionTracker *AT) {
> + const DataLayout *DL, AssumptionCache *AC) {
> bool Changed = false;
>
> // Worklist maintains our depth-first queue of loops in this nest to process.
> @@ -732,7 +732,7 @@ bool llvm::simplifyLoop(Loop *L, Dominat
>
> while (!Worklist.empty())
> Changed |= simplifyOneLoop(Worklist.pop_back_val(), Worklist, AA, DT, LI,
> - SE, PP, DL, AT);
> + SE, PP, DL, AC);
>
> return Changed;
> }
> @@ -751,12 +751,12 @@ namespace {
> LoopInfo *LI;
> ScalarEvolution *SE;
> const DataLayout *DL;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
>
> bool runOnFunction(Function &F) override;
>
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
>
> // We need loop information to identify the loops...
> AU.addRequired<DominatorTreeWrapperPass>();
> @@ -779,7 +779,7 @@ namespace {
> char LoopSimplify::ID = 0;
> INITIALIZE_PASS_BEGIN(LoopSimplify, "loop-simplify",
> "Canonicalize natural loops", false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(LoopInfo)
> INITIALIZE_PASS_END(LoopSimplify, "loop-simplify",
> @@ -800,11 +800,11 @@ bool LoopSimplify::runOnFunction(Functio
> SE = getAnalysisIfAvailable<ScalarEvolution>();
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> DL = DLP ? &DLP->getDataLayout() : nullptr;
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
>
> // Simplify each loop nest in the function.
> for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
> - Changed |= simplifyLoop(*I, DT, LI, this, AA, SE, DL, AT);
> + Changed |= simplifyLoop(*I, DT, LI, this, AA, SE, DL, AC);
>
> return Changed;
> }
>
> Modified: llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/LoopUnroll.cpp Sun Jan 4 06:03:27 2015
> @@ -19,7 +19,7 @@
> #include "llvm/Transforms/Utils/UnrollLoop.h"
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/Analysis/LoopIterator.h"
> #include "llvm/Analysis/LoopPass.h"
> @@ -154,9 +154,8 @@ FoldBlockIntoPredecessor(BasicBlock *BB,
> /// This utility preserves LoopInfo. If DominatorTree or ScalarEvolution are
> /// available from the Pass it must also preserve those analyses.
> bool llvm::UnrollLoop(Loop *L, unsigned Count, unsigned TripCount,
> - bool AllowRuntime, unsigned TripMultiple,
> - LoopInfo *LI, Pass *PP, LPPassManager *LPM,
> - AssumptionTracker *AT) {
> + bool AllowRuntime, unsigned TripMultiple, LoopInfo *LI,
> + Pass *PP, LPPassManager *LPM, AssumptionCache *AC) {
> BasicBlock *Preheader = L->getLoopPreheader();
> if (!Preheader) {
> DEBUG(dbgs() << " Can't unroll; loop preheader-insertion failed.\n");
> @@ -473,7 +472,7 @@ bool llvm::UnrollLoop(Loop *L, unsigned
>
> // FIXME: We could register any cloned assumptions instead of clearing the
> // whole function's cache.
> - AT->forgetCachedAssumptions(F);
> + AC->clear();
>
> DominatorTree *DT = nullptr;
> if (PP) {
> @@ -534,7 +533,7 @@ bool llvm::UnrollLoop(Loop *L, unsigned
> if (OuterL) {
> DataLayoutPass *DLP = PP->getAnalysisIfAvailable<DataLayoutPass>();
> const DataLayout *DL = DLP ? &DLP->getDataLayout() : nullptr;
> - simplifyLoop(OuterL, DT, LI, PP, /*AliasAnalysis*/ nullptr, SE, DL, AT);
> + simplifyLoop(OuterL, DT, LI, PP, /*AliasAnalysis*/ nullptr, SE, DL, AC);
>
> // LCSSA must be performed on the outermost affected loop. The unrolled
> // loop's last loop latch is guaranteed to be in the outermost loop after
>
> Modified: llvm/trunk/lib/Transforms/Utils/Mem2Reg.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/Mem2Reg.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/Mem2Reg.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/Mem2Reg.cpp Sun Jan 4 06:03:27 2015
> @@ -14,7 +14,7 @@
>
> #include "llvm/Transforms/Scalar.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/IR/Dominators.h"
> #include "llvm/IR/Function.h"
> #include "llvm/IR/Instructions.h"
> @@ -39,7 +39,7 @@ namespace {
> bool runOnFunction(Function &F) override;
>
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<DominatorTreeWrapperPass>();
> AU.setPreservesCFG();
> // This is a cluster of orthogonal Transforms
> @@ -53,7 +53,7 @@ namespace {
> char PromotePass::ID = 0;
> INITIALIZE_PASS_BEGIN(PromotePass, "mem2reg", "Promote Memory to Register",
> false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_END(PromotePass, "mem2reg", "Promote Memory to Register",
> false, false)
> @@ -66,7 +66,8 @@ bool PromotePass::runOnFunction(Function
> bool Changed = false;
>
> DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + AssumptionCache &AC =
> + getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
>
> while (1) {
> Allocas.clear();
> @@ -80,7 +81,7 @@ bool PromotePass::runOnFunction(Function
>
> if (Allocas.empty()) break;
>
> - PromoteMemToReg(Allocas, DT, nullptr, AT);
> + PromoteMemToReg(Allocas, DT, nullptr, &AC);
> NumPromoted += Allocas.size();
> Changed = true;
> }
>
> Modified: llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/PromoteMemoryToRegister.cpp Sun Jan 4 06:03:27 2015
> @@ -239,7 +239,7 @@ struct PromoteMem2Reg {
> AliasSetTracker *AST;
>
> /// A cache of @llvm.assume intrinsics used by SimplifyInstruction.
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
>
> /// Reverse mapping of Allocas.
> DenseMap<AllocaInst *, unsigned> AllocaLookup;
> @@ -282,10 +282,10 @@ struct PromoteMem2Reg {
>
> public:
> PromoteMem2Reg(ArrayRef<AllocaInst *> Allocas, DominatorTree &DT,
> - AliasSetTracker *AST, AssumptionTracker *AT)
> + AliasSetTracker *AST, AssumptionCache *AC)
> : Allocas(Allocas.begin(), Allocas.end()), DT(DT),
> DIB(*DT.getRoot()->getParent()->getParent(), /*AllowUnresolved*/ false),
> - AST(AST), AT(AT) {}
> + AST(AST), AC(AC) {}
>
> void run();
>
> @@ -691,7 +691,7 @@ void PromoteMem2Reg::run() {
> PHINode *PN = I->second;
>
> // If this PHI node merges one value and/or undefs, get the value.
> - if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, &DT, AT)) {
> + if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, &DT, AC)) {
> if (AST && PN->getType()->isPointerTy())
> AST->deleteValue(PN);
> PN->replaceAllUsesWith(V);
> @@ -1071,10 +1071,10 @@ NextIteration:
> }
>
> void llvm::PromoteMemToReg(ArrayRef<AllocaInst *> Allocas, DominatorTree &DT,
> - AliasSetTracker *AST, AssumptionTracker *AT) {
> + AliasSetTracker *AST, AssumptionCache *AC) {
> // If there is nothing to do, bail out...
> if (Allocas.empty())
> return;
>
> - PromoteMem2Reg(Allocas, DT, AST, AT).run();
> + PromoteMem2Reg(Allocas, DT, AST, AC).run();
> }
>
> Modified: llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/SimplifyCFG.cpp Sun Jan 4 06:03:27 2015
> @@ -108,7 +108,7 @@ class SimplifyCFGOpt {
> const TargetTransformInfo &TTI;
> unsigned BonusInstThreshold;
> const DataLayout *const DL;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> Value *isValueEqualityComparison(TerminatorInst *TI);
> BasicBlock *GetValueEqualityComparisonCases(TerminatorInst *TI,
> std::vector<ValueEqualityComparisonCase> &Cases);
> @@ -128,8 +128,8 @@ class SimplifyCFGOpt {
>
> public:
> SimplifyCFGOpt(const TargetTransformInfo &TTI, unsigned BonusInstThreshold,
> - const DataLayout *DL, AssumptionTracker *AT)
> - : TTI(TTI), BonusInstThreshold(BonusInstThreshold), DL(DL), AT(AT) {}
> + const DataLayout *DL, AssumptionCache *AC)
> + : TTI(TTI), BonusInstThreshold(BonusInstThreshold), DL(DL), AC(AC) {}
> bool run(BasicBlock *BB);
> };
> }
> @@ -2720,7 +2720,7 @@ static bool SimplifyIndirectBrOnSelect(I
> /// the PHI, merging the third icmp into the switch.
> static bool TryToSimplifyUncondBranchWithICmpInIt(
> ICmpInst *ICI, IRBuilder<> &Builder, const TargetTransformInfo &TTI,
> - unsigned BonusInstThreshold, const DataLayout *DL, AssumptionTracker *AT) {
> + unsigned BonusInstThreshold, const DataLayout *DL, AssumptionCache *AC) {
> BasicBlock *BB = ICI->getParent();
>
> // If the block has any PHIs in it or the icmp has multiple uses, it is too
> @@ -2753,7 +2753,7 @@ static bool TryToSimplifyUncondBranchWit
> ICI->eraseFromParent();
> }
> // BB is now empty, so it is likely to simplify away.
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> }
>
> // Ok, the block is reachable from the default dest. If the constant we're
> @@ -2769,7 +2769,7 @@ static bool TryToSimplifyUncondBranchWit
> ICI->replaceAllUsesWith(V);
> ICI->eraseFromParent();
> // BB is now empty, so it is likely to simplify away.
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> }
>
> // The use of the icmp has to be in the 'end' block, by the only PHI node in
> @@ -3275,11 +3275,11 @@ static bool TurnSwitchRangeIntoICmp(Swit
> /// EliminateDeadSwitchCases - Compute masked bits for the condition of a switch
> /// and use it to remove dead cases.
> static bool EliminateDeadSwitchCases(SwitchInst *SI, const DataLayout *DL,
> - AssumptionTracker *AT) {
> + AssumptionCache *AC) {
> Value *Cond = SI->getCondition();
> unsigned Bits = Cond->getType()->getIntegerBitWidth();
> APInt KnownZero(Bits, 0), KnownOne(Bits, 0);
> - computeKnownBits(Cond, KnownZero, KnownOne, DL, 0, AT, SI);
> + computeKnownBits(Cond, KnownZero, KnownOne, DL, 0, AC, SI);
>
> // Gather dead cases.
> SmallVector<ConstantInt*, 8> DeadCases;
> @@ -3657,7 +3657,7 @@ static void RemoveSwitchAfterSelectConve
> /// phi nodes in a common successor block with only two different
> /// constant values, replace the switch with select.
> static bool SwitchToSelect(SwitchInst *SI, IRBuilder<> &Builder,
> - const DataLayout *DL, AssumptionTracker *AT) {
> + const DataLayout *DL, AssumptionCache *AC) {
> Value *const Cond = SI->getCondition();
> PHINode *PHI = nullptr;
> BasicBlock *CommonDest = nullptr;
> @@ -4308,12 +4308,12 @@ bool SimplifyCFGOpt::SimplifySwitch(Swit
> // see if that predecessor totally determines the outcome of this switch.
> if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
> if (SimplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred, Builder))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> Value *Cond = SI->getCondition();
> if (SelectInst *Select = dyn_cast<SelectInst>(Cond))
> if (SimplifySwitchOnSelect(SI, Select))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> // If the block only contains the switch, see if we can fold the block
> // away into any preds.
> @@ -4323,25 +4323,25 @@ bool SimplifyCFGOpt::SimplifySwitch(Swit
> ++BBI;
> if (SI == &*BBI)
> if (FoldValueComparisonIntoPredecessors(SI, Builder))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> }
>
> // Try to transform the switch into an icmp and a branch.
> if (TurnSwitchRangeIntoICmp(SI, Builder))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> // Remove unreachable cases.
> - if (EliminateDeadSwitchCases(SI, DL, AT))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + if (EliminateDeadSwitchCases(SI, DL, AC))
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> - if (SwitchToSelect(SI, Builder, DL, AT))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + if (SwitchToSelect(SI, Builder, DL, AC))
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> if (ForwardSwitchConditionToPHI(SI))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> if (SwitchToLookupTable(SI, Builder, TTI, DL))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> return false;
> }
> @@ -4378,7 +4378,7 @@ bool SimplifyCFGOpt::SimplifyIndirectBr(
>
> if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) {
> if (SimplifyIndirectBrOnSelect(IBI, SI))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> }
> return Changed;
> }
> @@ -4403,7 +4403,7 @@ bool SimplifyCFGOpt::SimplifyUncondBranc
> ;
> if (I->isTerminator() &&
> TryToSimplifyUncondBranchWithICmpInIt(ICI, Builder, TTI,
> - BonusInstThreshold, DL, AT))
> + BonusInstThreshold, DL, AC))
> return true;
> }
>
> @@ -4412,7 +4412,7 @@ bool SimplifyCFGOpt::SimplifyUncondBranc
> // predecessor and use logical operations to update the incoming value
> // for PHI nodes in common successor.
> if (FoldBranchToCommonDest(BI, DL, BonusInstThreshold))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> return false;
> }
>
> @@ -4427,7 +4427,7 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
> // switch.
> if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
> if (SimplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred, Builder))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> // This block must be empty, except for the setcond inst, if it exists.
> // Ignore dbg intrinsics.
> @@ -4437,14 +4437,14 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
> ++I;
> if (&*I == BI) {
> if (FoldValueComparisonIntoPredecessors(BI, Builder))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> } else if (&*I == cast<Instruction>(BI->getCondition())){
> ++I;
> // Ignore dbg intrinsics.
> while (isa<DbgInfoIntrinsic>(I))
> ++I;
> if (&*I == BI && FoldValueComparisonIntoPredecessors(BI, Builder))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> }
> }
>
> @@ -4456,7 +4456,7 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
> // branches to us and one of our successors, fold the comparison into the
> // predecessor and use logical operations to pick the right destination.
> if (FoldBranchToCommonDest(BI, DL, BonusInstThreshold))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> // We have a conditional branch to two blocks that are only reachable
> // from BI. We know that the condbr dominates the two blocks, so see if
> @@ -4465,7 +4465,7 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
> if (BI->getSuccessor(0)->getSinglePredecessor()) {
> if (BI->getSuccessor(1)->getSinglePredecessor()) {
> if (HoistThenElseCodeToIf(BI, DL))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> } else {
> // If Successor #1 has multiple preds, we may be able to conditionally
> // execute Successor #0 if it branches to Successor #1.
> @@ -4473,7 +4473,7 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
> if (Succ0TI->getNumSuccessors() == 1 &&
> Succ0TI->getSuccessor(0) == BI->getSuccessor(1))
> if (SpeculativelyExecuteBB(BI, BI->getSuccessor(0), DL))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> }
> } else if (BI->getSuccessor(1)->getSinglePredecessor()) {
> // If Successor #0 has multiple preds, we may be able to conditionally
> @@ -4482,7 +4482,7 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
> if (Succ1TI->getNumSuccessors() == 1 &&
> Succ1TI->getSuccessor(0) == BI->getSuccessor(0))
> if (SpeculativelyExecuteBB(BI, BI->getSuccessor(1), DL))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
> }
>
> // If this is a branch on a phi node in the current block, thread control
> @@ -4490,14 +4490,14 @@ bool SimplifyCFGOpt::SimplifyCondBranch(
> if (PHINode *PN = dyn_cast<PHINode>(BI->getCondition()))
> if (PN->getParent() == BI->getParent())
> if (FoldCondBranchOnPHI(BI, DL))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> // Scan predecessor blocks for conditional branches.
> for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
> if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator()))
> if (PBI != BI && PBI->isConditional())
> if (SimplifyCondBranchToCondBranch(PBI, BI))
> - return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AT) | true;
> + return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true;
>
> return false;
> }
> @@ -4641,7 +4641,7 @@ bool SimplifyCFGOpt::run(BasicBlock *BB)
> /// of the CFG. It returns true if a modification was made.
> ///
> bool llvm::SimplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI,
> - unsigned BonusInstThreshold,
> - const DataLayout *DL, AssumptionTracker *AT) {
> - return SimplifyCFGOpt(TTI, BonusInstThreshold, DL, AT).run(BB);
> + unsigned BonusInstThreshold, const DataLayout *DL,
> + AssumptionCache *AC) {
> + return SimplifyCFGOpt(TTI, BonusInstThreshold, DL, AC).run(BB);
> }
>
> Modified: llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp (original)
> +++ llvm/trunk/lib/Transforms/Utils/SimplifyInstructions.cpp Sun Jan 4 06:03:27 2015
> @@ -18,7 +18,7 @@
> #include "llvm/ADT/DepthFirstIterator.h"
> #include "llvm/ADT/SmallPtrSet.h"
> #include "llvm/ADT/Statistic.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/InstructionSimplify.h"
> #include "llvm/IR/DataLayout.h"
> #include "llvm/IR/Dominators.h"
> @@ -42,7 +42,7 @@ namespace {
>
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> AU.setPreservesCFG();
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<TargetLibraryInfo>();
> }
>
> @@ -54,7 +54,8 @@ namespace {
> DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
> const DataLayout *DL = DLP ? &DLP->getDataLayout() : nullptr;
> const TargetLibraryInfo *TLI = &getAnalysis<TargetLibraryInfo>();
> - AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
> + AssumptionCache *AC =
> + &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
> SmallPtrSet<const Instruction*, 8> S1, S2, *ToSimplify = &S1, *Next = &S2;
> bool Changed = false;
>
> @@ -71,7 +72,7 @@ namespace {
> continue;
> // Don't waste time simplifying unused instructions.
> if (!I->use_empty())
> - if (Value *V = SimplifyInstruction(I, DL, TLI, DT, AT)) {
> + if (Value *V = SimplifyInstruction(I, DL, TLI, DT, AC)) {
> // Mark all uses for resimplification next time round the loop.
> for (User *U : I->users())
> Next->insert(cast<Instruction>(U));
> @@ -104,7 +105,7 @@ namespace {
> char InstSimplifier::ID = 0;
> INITIALIZE_PASS_BEGIN(InstSimplifier, "instsimplify",
> "Remove redundant instructions", false, false)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
> INITIALIZE_PASS_END(InstSimplifier, "instsimplify",
> "Remove redundant instructions", false, false)
>
> Modified: llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp (original)
> +++ llvm/trunk/lib/Transforms/Vectorize/LoopVectorize.cpp Sun Jan 4 06:03:27 2015
> @@ -55,7 +55,7 @@
> #include "llvm/ADT/StringExtras.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> #include "llvm/Analysis/AliasSetTracker.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/BlockFrequencyInfo.h"
> #include "llvm/Analysis/CodeMetrics.h"
> #include "llvm/Analysis/LoopInfo.h"
> @@ -908,11 +908,11 @@ public:
> LoopVectorizationLegality *Legal,
> const TargetTransformInfo &TTI,
> const DataLayout *DL, const TargetLibraryInfo *TLI,
> - AssumptionTracker *AT, const Function *F,
> + AssumptionCache *AC, const Function *F,
> const LoopVectorizeHints *Hints)
> : TheLoop(L), SE(SE), LI(LI), Legal(Legal), TTI(TTI), DL(DL), TLI(TLI),
> TheFunction(F), Hints(Hints) {
> - CodeMetrics::collectEphemeralValues(L, AT, EphValues);
> + CodeMetrics::collectEphemeralValues(L, AC, EphValues);
> }
>
> /// Information about vectorization costs
> @@ -1267,7 +1267,7 @@ struct LoopVectorize : public FunctionPa
> BlockFrequencyInfo *BFI;
> TargetLibraryInfo *TLI;
> AliasAnalysis *AA;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
> bool DisableUnrolling;
> bool AlwaysVectorize;
>
> @@ -1283,7 +1283,7 @@ struct LoopVectorize : public FunctionPa
> BFI = &getAnalysis<BlockFrequencyInfo>();
> TLI = getAnalysisIfAvailable<TargetLibraryInfo>();
> AA = &getAnalysis<AliasAnalysis>();
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
>
> // Compute some weights outside of the loop over the loops. Compute this
> // using a BranchProbability to re-use its scaling math.
> @@ -1402,7 +1402,7 @@ struct LoopVectorize : public FunctionPa
> }
>
> // Use the cost model.
> - LoopVectorizationCostModel CM(L, SE, LI, &LVL, *TTI, DL, TLI, AT, F,
> + LoopVectorizationCostModel CM(L, SE, LI, &LVL, *TTI, DL, TLI, AC, F,
> &Hints);
>
> // Check the function attributes to find out if this function should be
> @@ -1490,7 +1490,7 @@ struct LoopVectorize : public FunctionPa
> }
>
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequiredID(LoopSimplifyID);
> AU.addRequiredID(LCSSAID);
> AU.addRequired<BlockFrequencyInfo>();
> @@ -6145,7 +6145,7 @@ static const char lv_name[] = "Loop Vect
> INITIALIZE_PASS_BEGIN(LoopVectorize, LV_NAME, lv_name, false, false)
> INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
> INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfo)
> INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
> INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
>
> Modified: llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp?rev=225131&r1=225130&r2=225131&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp (original)
> +++ llvm/trunk/lib/Transforms/Vectorize/SLPVectorizer.cpp Sun Jan 4 06:03:27 2015
> @@ -21,7 +21,7 @@
> #include "llvm/ADT/SetVector.h"
> #include "llvm/ADT/Statistic.h"
> #include "llvm/Analysis/AliasAnalysis.h"
> -#include "llvm/Analysis/AssumptionTracker.h"
> +#include "llvm/Analysis/AssumptionCache.h"
> #include "llvm/Analysis/CodeMetrics.h"
> #include "llvm/Analysis/LoopInfo.h"
> #include "llvm/Analysis/ScalarEvolution.h"
> @@ -398,11 +398,11 @@ public:
>
> BoUpSLP(Function *Func, ScalarEvolution *Se, const DataLayout *Dl,
> TargetTransformInfo *Tti, TargetLibraryInfo *TLi, AliasAnalysis *Aa,
> - LoopInfo *Li, DominatorTree *Dt, AssumptionTracker *AT)
> - : NumLoadsWantToKeepOrder(0), NumLoadsWantToChangeOrder(0),
> - F(Func), SE(Se), DL(Dl), TTI(Tti), TLI(TLi), AA(Aa), LI(Li), DT(Dt),
> + LoopInfo *Li, DominatorTree *Dt, AssumptionCache *AC)
> + : NumLoadsWantToKeepOrder(0), NumLoadsWantToChangeOrder(0), F(Func),
> + SE(Se), DL(Dl), TTI(Tti), TLI(TLi), AA(Aa), LI(Li), DT(Dt),
> Builder(Se->getContext()) {
> - CodeMetrics::collectEphemeralValues(F, AT, EphValues);
> + CodeMetrics::collectEphemeralValues(F, AC, EphValues);
> }
>
> /// \brief Vectorize the tree that starts with the elements in \p VL.
> @@ -2833,7 +2833,7 @@ struct SLPVectorizer : public FunctionPa
> AliasAnalysis *AA;
> LoopInfo *LI;
> DominatorTree *DT;
> - AssumptionTracker *AT;
> + AssumptionCache *AC;
>
> bool runOnFunction(Function &F) override {
> if (skipOptnoneFunction(F))
> @@ -2847,7 +2847,7 @@ struct SLPVectorizer : public FunctionPa
> AA = &getAnalysis<AliasAnalysis>();
> LI = &getAnalysis<LoopInfo>();
> DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
> - AT = &getAnalysis<AssumptionTracker>();
> + AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
>
> StoreRefs.clear();
> bool Changed = false;
> @@ -2870,7 +2870,7 @@ struct SLPVectorizer : public FunctionPa
>
> // Use the bottom up slp vectorizer to construct chains that start with
> // store instructions.
> - BoUpSLP R(&F, SE, DL, TTI, TLI, AA, LI, DT, AT);
> + BoUpSLP R(&F, SE, DL, TTI, TLI, AA, LI, DT, AC);
>
> // Scan the blocks in the function in post order.
> for (po_iterator<BasicBlock*> it = po_begin(&F.getEntryBlock()),
> @@ -2897,7 +2897,7 @@ struct SLPVectorizer : public FunctionPa
>
> void getAnalysisUsage(AnalysisUsage &AU) const override {
> FunctionPass::getAnalysisUsage(AU);
> - AU.addRequired<AssumptionTracker>();
> + AU.addRequired<AssumptionCacheTracker>();
> AU.addRequired<ScalarEvolution>();
> AU.addRequired<AliasAnalysis>();
> AU.addRequired<TargetTransformInfo>();
> @@ -3787,7 +3787,7 @@ static const char lv_name[] = "SLP Vecto
> INITIALIZE_PASS_BEGIN(SLPVectorizer, SV_NAME, lv_name, false, false)
> INITIALIZE_AG_DEPENDENCY(AliasAnalysis)
> INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
> -INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
> +INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
> INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
> INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
> INITIALIZE_PASS_END(SLPVectorizer, SV_NAME, lv_name, false, false)
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list