[llvm] r289755 - Make processing @llvm.assume more efficient by using operand bundles
Yung, Douglas via llvm-commits
llvm-commits at lists.llvm.org
Sun Dec 18 23:21:31 PST 2016
Hi,
I just wanted to add that one of our tests hit this problem as well. The test is an auto-generated test, so may be a bit pathological, but when compiling with –O2 or –O3, the compile time went from about a minute to about 33 minutes following this change. I have attached the test case.
Douglas Yung
From: llvm-commits [mailto:llvm-commits-bounces at lists.llvm.org] On Behalf Of Daniel Jasper via llvm-commits
Sent: Sunday, December 18, 2016 0:40
To: Hal Finkel
Cc: llvm-commits
Subject: Re: [llvm] r289755 - Make processing @llvm.assume more efficient by using operand bundles
As discussed on IRC, this makes some compiles slow/endless, e.g. of this project:
https://github.com/gdslang/gdsl-toolkit
I attached the preprocessed file that's problematic and I can reproduce the issue with:
$ clang -O2 -xc gdsl-x86-rreil.ii
On Thu, Dec 15, 2016 at 5:32 AM, Hal Finkel via llvm-commits <llvm-commits at lists.llvm.org<mailto:llvm-commits at lists.llvm.org>> wrote:
FYI: The iterator-invalidation issue is fixed; there is also a problem being triggered during self-hosting with bundle operands and AA. Working on that now...
-Hal
----- Original Message -----
> From: "Hal Finkel" <hfinkel at anl.gov<mailto:hfinkel at anl.gov>>
> To: "Hal Finkel" <hfinkel at anl.gov<mailto:hfinkel at anl.gov>>
> Cc: llvm-commits at lists.llvm.org<mailto:llvm-commits at lists.llvm.org>
> Sent: Wednesday, December 14, 2016 9:22:50 PM
> Subject: Re: [llvm] r289755 - Make processing @llvm.assume more efficient by using operand bundles
>
> This is causing some bots to fail, for example:
>
> opt:
> /home/buildbot/Buildbot/Slave/llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast/llvm.src/include/llvm/ADT/DenseMap.h:1074:
> pointer llvm::DenseMapIterator<const llvm::SCEV *,
> llvm::SetVector<llvm::Value *, std::vector<llvm::Value *,
> std::allocator<llvm::Value *> >, llvm::DenseSet<llvm::Value *,
> llvm::DenseMapInfo<llvm::Value *> > >, llvm::DenseMapInfo<const
> llvm::SCEV *>, llvm::detail::DenseMapPair<const llvm::SCEV *,
> llvm::SetVector<llvm::Value *, std::vector<llvm::Value *,
> std::allocator<llvm::Value *> >, llvm::DenseSet<llvm::Value *,
> llvm::DenseMapInfo<llvm::Value *> > > >, false>::operator->() const
> [KeyT = const llvm::SCEV *, ValueT = llvm::SetVector<llvm::Value *,
> std::vector<llvm::Value *, std::allocator<llvm::Value *> >,
> llvm::DenseSet<llvm::Value *, llvm::DenseMapInfo<llvm::Value *> > >,
> KeyInfoT = llvm::DenseMapInfo<const llvm::SCEV *>, Bucket =
> llvm::detail::DenseMapPair<const llvm::SCEV *,
> llvm::SetVector<llvm::Value *, std::vector<llvm::Value *,
> std::allocator<llvm::Value *> >, llvm::DenseSet<llvm::Value *,
> llvm::DenseMapInfo<llvm::Value *> > > >, IsConst = false]: Assertion
> `isHandleInSync() && "invalid iterator access!"' failed.
>
> I'm looking at it now...
>
> -Hal
>
> ----- Original Message -----
> > From: "Hal Finkel via llvm-commits" <llvm-commits at lists.llvm.org<mailto:llvm-commits at lists.llvm.org>>
> > To: llvm-commits at lists.llvm.org<mailto:llvm-commits at lists.llvm.org>
> > Sent: Wednesday, December 14, 2016 8:53:43 PM
> > Subject: [llvm] r289755 - Make processing @llvm.assume more
> > efficient by using operand bundles
> >
> > Author: hfinkel
> > Date: Wed Dec 14 20:53:42 2016
> > New Revision: 289755
> >
> > URL: http://llvm.org/viewvc/llvm-project?rev=289755&view=rev
> > Log:
> > Make processing @llvm.assume more efficient by using operand
> > bundles
> >
> > There was an efficiency problem with how we processed @llvm.assume
> > in
> > ValueTracking (and other places). The AssumptionCache tracked all
> > of
> > the
> > assumptions in a given function. In order to find assumptions
> > relevant to
> > computing known bits, etc. we searched every assumption in the
> > function. For
> > ValueTracking, that means that we did O(#assumes * #values) work in
> > InstCombine
> > and other passes (with a constant factor that can be quite large
> > because we'd
> > repeat this search at every level of recursion of the analysis).
> >
> > Several of us discussed this situation at the last developers'
> > meeting, and
> > this implements the discussed solution: Make the values that an
> > assume might
> > affect operands of the assume itself. To avoid exposing this detail
> > to
> > frontends and passes that need not worry about it, I've used the
> > new
> > operand-bundle feature to add these extra call "operands" in a way
> > that does
> > not affect the intrinsic's signature. I think this solution is
> > relatively
> > clean. InstCombine adds these extra operands based on what
> > ValueTracking, LVI,
> > etc. will need and then those passes need only search the users of
> > the values
> > under consideration. This should fix the computational-complexity
> > problem.
> >
> > At this point, no passes depend on the AssumptionCache, and so I'll
> > remove
> > that as a follow-up change.
> >
> > Differential Revision: https://reviews.llvm.org/D27259
> >
> > Modified:
> > llvm/trunk/docs/LangRef.rst
> > llvm/trunk/include/llvm/Analysis/ScalarEvolution.h
> > llvm/trunk/lib/Analysis/CodeMetrics.cpp
> > llvm/trunk/lib/Analysis/LazyValueInfo.cpp
> > llvm/trunk/lib/Analysis/ScalarEvolution.cpp
> > llvm/trunk/lib/Analysis/ValueTracking.cpp
> > llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> > llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp
> > llvm/trunk/test/Analysis/ScalarEvolution/no-wrap-unknown-becount.ll
> > llvm/trunk/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
> > llvm/trunk/test/Transforms/CorrelatedValuePropagation/conflict.ll
> > llvm/trunk/test/Transforms/InstCombine/assume-redundant.ll
> > llvm/trunk/test/Transforms/InstCombine/assume.ll
> > llvm/trunk/test/Transforms/InstCombine/assume2.ll
> > llvm/trunk/test/Transforms/InstSimplify/add-mask.ll
> > llvm/trunk/test/Transforms/JumpThreading/assume-edge-dom.ll
> > llvm/trunk/test/Transforms/JumpThreading/assume.ll
> > llvm/trunk/test/Transforms/NaryReassociate/NVPTX/nary-gep.ll
> > llvm/trunk/test/Transforms/SimplifyCFG/switch-dead-default.ll
> >
> > Modified: llvm/trunk/docs/LangRef.rst
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/LangRef.rst?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/docs/LangRef.rst (original)
> > +++ llvm/trunk/docs/LangRef.rst Wed Dec 14 20:53:42 2016
> > @@ -1753,6 +1753,15 @@ site, these bundles may contain any valu
> > generated code. For more details, see :ref:`GC Transitions
> > <gc_transition_args>`.
> >
> > +Affected Operand Bundles
> > +^^^^^^^^^^^^^^^^^^^^^^^^
> > +
> > +Affected operand bundles are characterized by the ``"affected"``
> > operand bundle
> > +tag. These operand bundles indicate that a call, specifically a
> > call
> > to an
> > +intrinsic like ``llvm.assume``, implies some additional knowledge
> > about the
> > +values within the bundle. This enables the optimizer to
> > efficiently
> > find these
> > +relationships. The optimizer will add these automatically.
> > +
> > .. _moduleasm:
> >
> > Module-Level Inline Assembly
> >
> > Modified: llvm/trunk/include/llvm/Analysis/ScalarEvolution.h
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ScalarEvolution.h?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/ScalarEvolution.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/ScalarEvolution.h Wed Dec 14
> > 20:53:42 2016
> > @@ -532,6 +532,10 @@ private:
> > ///
> > ValueExprMapType ValueExprMap;
> >
> > + /// This is a map of SCEVs to intrinsics (e.g. assumptions) that
> > might affect
> > + /// (i.e. imply something about) them.
> > + DenseMap<const SCEV *, SetVector<Value *>> AffectedMap;
> > +
> > /// Mark predicate values currently being processed by
> > isImpliedCond.
> > SmallPtrSet<Value *, 6> PendingLoopPredicates;
> >
> > @@ -800,6 +804,9 @@ private:
> > ConstantRange getRangeViaFactoring(const SCEV *Start, const SCEV
> > *Stop,
> > const SCEV *MaxBECount,
> > unsigned BitWidth);
> >
> > + /// Add to the AffectedMap this SCEV if its operands are in the
> > AffectedMap.
> > + void addAffectedFromOperands(const SCEV *S);
> > +
> > /// We know that there is no SCEV for the specified value.
> > Analyze the
> > /// expression.
> > const SCEV *createSCEV(Value *V);
> >
> > Modified: llvm/trunk/lib/Analysis/CodeMetrics.cpp
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/CodeMetrics.cpp?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/lib/Analysis/CodeMetrics.cpp (original)
> > +++ llvm/trunk/lib/Analysis/CodeMetrics.cpp Wed Dec 14 20:53:42
> > 2016
> > @@ -76,20 +76,12 @@ void CodeMetrics::collectEphemeralValues
> > SmallPtrSet<const Value *, 32> Visited;
> > SmallVector<const Value *, 16> Worklist;
> >
> > - 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 do 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).
> > - if (!L->contains(I->getParent()))
> > - continue;
> > -
> > - if (EphValues.insert(I).second)
> > - appendSpeculatableOperands(I, Visited, Worklist);
> > - }
> > + for (auto &B : L->blocks())
> > + for (auto &I : *B)
> > + if (auto *II = dyn_cast<IntrinsicInst>(&I))
> > + if (II->getIntrinsicID() == Intrinsic::assume &&
> > + EphValues.insert(II).second)
> > + appendSpeculatableOperands(II, Visited, Worklist);
> >
> > completeEphemeralValues(Visited, Worklist, EphValues);
> > }
> > @@ -100,16 +92,12 @@ void CodeMetrics::collectEphemeralValues
> > SmallPtrSet<const Value *, 32> Visited;
> > SmallVector<const Value *, 16> Worklist;
> >
> > - for (auto &AssumeVH : AC->assumptions()) {
> > - if (!AssumeVH)
> > - continue;
> > - Instruction *I = cast<Instruction>(AssumeVH);
> > - assert(I->getParent()->getParent() == F &&
> > - "Found assumption for the wrong function!");
> > -
> > - if (EphValues.insert(I).second)
> > - appendSpeculatableOperands(I, Visited, Worklist);
> > - }
> > + for (auto &B : *F)
> > + for (auto &I : B)
> > + if (auto *II = dyn_cast<IntrinsicInst>(&I))
> > + if (II->getIntrinsicID() == Intrinsic::assume &&
> > + EphValues.insert(II).second)
> > + appendSpeculatableOperands(II, Visited, Worklist);
> >
> > completeEphemeralValues(Visited, Worklist, EphValues);
> > }
> >
> > Modified: llvm/trunk/lib/Analysis/LazyValueInfo.cpp
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/LazyValueInfo.cpp?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/lib/Analysis/LazyValueInfo.cpp (original)
> > +++ llvm/trunk/lib/Analysis/LazyValueInfo.cpp Wed Dec 14 20:53:42
> > 2016
> > @@ -924,14 +924,16 @@ void LazyValueInfoImpl::intersectAssumeO
> > if (!BBI)
> > return;
> >
> > - for (auto &AssumeVH : AC->assumptions()) {
> > - if (!AssumeVH)
> > + for (auto *U : Val->users()) {
> > + auto *II = dyn_cast<IntrinsicInst>(U);
> > + if (!II)
> > continue;
> > - auto *I = cast<CallInst>(AssumeVH);
> > - if (!isValidAssumeForContext(I, BBI, DT))
> > + if (II->getIntrinsicID() != Intrinsic::assume)
> > + continue;
> > + if (!isValidAssumeForContext(II, BBI, DT))
> > continue;
> >
> > - BBLV = intersect(BBLV, getValueFromCondition(Val,
> > I->getArgOperand(0)));
> > + BBLV = intersect(BBLV, getValueFromCondition(Val,
> > II->getArgOperand(0)));
> > }
> >
> > // If guards are not used in the module, don't spend time
> > looking
> > for them
> >
> > Modified: llvm/trunk/lib/Analysis/ScalarEvolution.cpp
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ScalarEvolution.cpp?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/lib/Analysis/ScalarEvolution.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ScalarEvolution.cpp Wed Dec 14 20:53:42
> > 2016
> > @@ -1212,6 +1212,7 @@ const SCEV *ScalarEvolution::getTruncate
> > SCEV *S = new (SCEVAllocator)
> > SCEVTruncateExpr(ID.Intern(SCEVAllocator),
> > Op, Ty);
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > return S;
> > }
> >
> > @@ -1598,7 +1599,7 @@ const SCEV *ScalarEvolution::getZeroExte
> > // these to prove lack of overflow. Use this fact to avoid
> > // doing extra work that may not pay off.
> > if (!isa<SCEVCouldNotCompute>(MaxBECount) || HasGuards ||
> > - !AC.assumptions().empty()) {
> > + !AffectedMap.empty()) {
> > // If the backedge is guarded by a comparison with the
> > pre-inc
> > // value the addrec is safe. Also, if the entry is guarded
> > by
> > // a comparison with the start value and the backedge is
> > @@ -1664,6 +1665,7 @@ const SCEV *ScalarEvolution::getZeroExte
> > SCEV *S = new (SCEVAllocator)
> > SCEVZeroExtendExpr(ID.Intern(SCEVAllocator),
> > Op, Ty);
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > return S;
> > }
> >
> > @@ -1833,7 +1835,7 @@ const SCEV *ScalarEvolution::getSignExte
> > // doing extra work that may not pay off.
> >
> > if (!isa<SCEVCouldNotCompute>(MaxBECount) || HasGuards ||
> > - !AC.assumptions().empty()) {
> > + !AffectedMap.empty()) {
> > // If the backedge is guarded by a comparison with the
> > pre-inc
> > // value the addrec is safe. Also, if the entry is guarded
> > by
> > // a comparison with the start value and the backedge is
> > @@ -1891,6 +1893,7 @@ const SCEV *ScalarEvolution::getSignExte
> > SCEV *S = new (SCEVAllocator)
> > SCEVSignExtendExpr(ID.Intern(SCEVAllocator),
> > Op, Ty);
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > return S;
> > }
> >
> > @@ -2444,6 +2447,7 @@ const SCEV *ScalarEvolution::getAddExpr(
> > S = new (SCEVAllocator) SCEVAddExpr(ID.Intern(SCEVAllocator),
> > O, Ops.size());
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > }
> > S->setNoWrapFlags(Flags);
> > return S;
> > @@ -2736,6 +2740,7 @@ const SCEV *ScalarEvolution::getMulExpr(
> > S = new (SCEVAllocator) SCEVMulExpr(ID.Intern(SCEVAllocator),
> > O, Ops.size());
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > }
> > S->setNoWrapFlags(Flags);
> > return S;
> > @@ -2856,6 +2861,7 @@ const SCEV *ScalarEvolution::getUDivExpr
> > SCEV *S = new (SCEVAllocator)
> > SCEVUDivExpr(ID.Intern(SCEVAllocator),
> > LHS, RHS);
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > return S;
> > }
> >
> > @@ -3036,6 +3042,7 @@ ScalarEvolution::getAddRecExpr(SmallVect
> > S = new (SCEVAllocator)
> > SCEVAddRecExpr(ID.Intern(SCEVAllocator),
> > O, Operands.size(), L);
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > }
> > S->setNoWrapFlags(Flags);
> > return S;
> > @@ -3191,6 +3198,7 @@ ScalarEvolution::getSMaxExpr(SmallVector
> > SCEV *S = new (SCEVAllocator)
> > SCEVSMaxExpr(ID.Intern(SCEVAllocator),
> > O, Ops.size());
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > return S;
> > }
> >
> > @@ -3292,6 +3300,7 @@ ScalarEvolution::getUMaxExpr(SmallVector
> > SCEV *S = new (SCEVAllocator)
> > SCEVUMaxExpr(ID.Intern(SCEVAllocator),
> > O, Ops.size());
> > UniqueSCEVs.InsertNode(S, IP);
> > + addAffectedFromOperands(S);
> > return S;
> > }
> >
> > @@ -3492,9 +3501,38 @@ const SCEV *ScalarEvolution::getSCEV(Val
> > ExprValueMap[Stripped].insert({V, Offset});
> > }
> > }
> > +
> > + // If this value is an instruction or an argument, and might be
> > affected by
> > + // an assumption, and its SCEV to the AffectedMap.
> > + if (isa<Instruction>(V) || isa<Argument>(V)) {
> > + for (auto *U : V->users()) {
> > + auto *II = dyn_cast<IntrinsicInst>(U);
> > + if (!II)
> > + continue;
> > + if (II->getIntrinsicID() != Intrinsic::assume)
> > + continue;
> > +
> > + AffectedMap[S].insert(II);
> > + }
> > + }
> > +
> > return S;
> > }
> >
> > +// If one of this SCEV's operands is in the AffectedMap (meaning
> > that it might
> > +// be affected by an assumption), then this SCEV might be affected
> > by the same
> > +// assumption.
> > +void ScalarEvolution::addAffectedFromOperands(const SCEV *S) {
> > + if (auto *NS = dyn_cast<SCEVNAryExpr>(S))
> > + for (auto *Op : NS->operands()) {
> > + auto AMI = AffectedMap.find(Op);
> > + if (AMI == AffectedMap.end())
> > + continue;
> > +
> > + AffectedMap[S].insert(AMI->second.begin(),
> > AMI->second.end());
> > + }
> > +}
> > +
> > const SCEV *ScalarEvolution::getExistingSCEV(Value *V) {
> > assert(isSCEVable(V->getType()) && "Value is not SCEVable!");
> >
> > @@ -7926,16 +7964,23 @@ ScalarEvolution::isLoopBackedgeGuardedBy
> > }
> >
> > // Check conditions due to any @llvm.assume intrinsics.
> > - for (auto &AssumeVH : AC.assumptions()) {
> > - if (!AssumeVH)
> > - continue;
> > - auto *CI = cast<CallInst>(AssumeVH);
> > - if (!DT.dominates(CI, Latch->getTerminator()))
> > - continue;
> > + auto CheckAssumptions = [&](const SCEV *S) {
> > + auto AMI = AffectedMap.find(S);
> > + if (AMI != AffectedMap.end())
> > + for (auto *Assume : AMI->second) {
> > + auto *CI = cast<CallInst>(Assume);
> > + if (!DT.dominates(CI, Latch->getTerminator()))
> > + continue;
> >
> > - if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0),
> > false))
> > - return true;
> > - }
> > + if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0),
> > false))
> > + return true;
> > + }
> > +
> > + return false;
> > + };
> > +
> > + if (CheckAssumptions(LHS) || CheckAssumptions(RHS))
> > + return true;
> >
> > // If the loop is not reachable from the entry block, we risk
> > running into an
> > // infinite loop as we walk up into the dom tree. These loops
> > do
> > not matter
> > @@ -8020,16 +8065,23 @@ ScalarEvolution::isLoopEntryGuardedByCon
> > }
> >
> > // Check conditions due to any @llvm.assume intrinsics.
> > - for (auto &AssumeVH : AC.assumptions()) {
> > - if (!AssumeVH)
> > - continue;
> > - auto *CI = cast<CallInst>(AssumeVH);
> > - if (!DT.dominates(CI, L->getHeader()))
> > - continue;
> > + auto CheckAssumptions = [&](const SCEV *S) {
> > + auto AMI = AffectedMap.find(S);
> > + if (AMI != AffectedMap.end())
> > + for (auto *Assume : AMI->second) {
> > + auto *CI = cast<CallInst>(Assume);
> > + if (!DT.dominates(CI, L->getHeader()))
> > + continue;
> >
> > - if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0),
> > false))
> > - return true;
> > - }
> > + if (isImpliedCond(Pred, LHS, RHS, CI->getArgOperand(0),
> > false))
> > + return true;
> > + }
> > +
> > + return false;
> > + };
> > +
> > + if (CheckAssumptions(LHS) || CheckAssumptions(RHS))
> > + return true;
> >
> > return false;
> > }
> >
> > Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ValueTracking.cpp Wed Dec 14 20:53:42
> > 2016
> > @@ -526,31 +526,28 @@ static void computeKnownBitsFromAssume(c
> >
> > unsigned BitWidth = KnownZero.getBitWidth();
> >
> > - for (auto &AssumeVH : Q.AC->assumptions()) {
> > - if (!AssumeVH)
> > + for (auto *U : V->users()) {
> > + auto *II = dyn_cast<IntrinsicInst>(U);
> > + if (!II)
> > continue;
> > - CallInst *I = cast<CallInst>(AssumeVH);
> > - assert(I->getParent()->getParent() ==
> > Q.CxtI->getParent()->getParent() &&
> > - "Got assumption for the wrong function!");
> > - if (Q.isExcluded(I))
> > + if (II->getIntrinsicID() != Intrinsic::assume)
> > + continue;
> > + if (Q.isExcluded(II))
> > continue;
> >
> > - // Warning: This loop can end up being somewhat performance
> > sensetive.
> > - // We're running this loop for once for each value queried
> > resulting in a
> > - // runtime of ~O(#assumes * #values).
> > -
> > - assert(I->getCalledFunction()->getIntrinsicID() ==
> > Intrinsic::assume &&
> > - "must be an assume intrinsic");
> > -
> > - Value *Arg = I->getArgOperand(0);
> > + Value *Arg = II->getArgOperand(0);
> >
> > - if (Arg == V && isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + if (Arg == V && isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > assert(BitWidth == 1 && "assume operand is not i1?");
> > KnownZero.clearAllBits();
> > KnownOne.setAllBits();
> > return;
> > }
> >
> > + // Note that the patterns below need to be kept in sync with
> > the
> > code
> > + // in InstCombiner::visitCallInst that adds relevant values to
> > each
> > + // assume's operand bundles.
> > +
> > // The remaining tests are all recursive, so bail out if we
> > hit
> > the limit.
> > if (Depth == MaxDepth)
> > continue;
> > @@ -564,20 +561,20 @@ static void computeKnownBitsFromAssume(c
> > ConstantInt *C;
> > // assume(v = a)
> > if (match(Arg, m_c_ICmp(Pred, m_V, m_Value(A))) &&
> > - Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I,
> > Q.CxtI, Q.DT)) {
> > + Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(II,
> > Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > KnownZero |= RHSKnownZero;
> > KnownOne |= RHSKnownOne;
> > // assume(v & b = a)
> > } else if (match(Arg,
> > m_c_ICmp(Pred, m_c_And(m_V, m_Value(B)),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
> > - computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1,
> > Query(Q, II));
> >
> > // For those bits in the mask that are known to be one, we
> > can
> > propagate
> > // known bits from the RHS to V.
> > @@ -587,11 +584,11 @@ static void computeKnownBitsFromAssume(c
> > } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_And(m_V,
> > m_Value(B))),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
> > - computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1,
> > Query(Q, II));
> >
> > // For those bits in the mask that are known to be one, we
> > can
> > propagate
> > // inverted known bits from the RHS to V.
> > @@ -601,11 +598,11 @@ static void computeKnownBitsFromAssume(c
> > } else if (match(Arg,
> > m_c_ICmp(Pred, m_c_Or(m_V, m_Value(B)),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
> > - computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q,
> > I));
> > + computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q,
> > II));
> >
> > // For those bits in B that are known to be zero, we can
> > propagate known
> > // bits from the RHS to V.
> > @@ -615,11 +612,11 @@ static void computeKnownBitsFromAssume(c
> > } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Or(m_V,
> > m_Value(B))),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
> > - computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q,
> > I));
> > + computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q,
> > II));
> >
> > // For those bits in B that are known to be zero, we can
> > propagate
> > // inverted known bits from the RHS to V.
> > @@ -629,11 +626,11 @@ static void computeKnownBitsFromAssume(c
> > } else if (match(Arg,
> > m_c_ICmp(Pred, m_c_Xor(m_V, m_Value(B)),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
> > - computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q,
> > I));
> > + computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q,
> > II));
> >
> > // For those bits in B that are known to be zero, we can
> > propagate known
> > // bits from the RHS to V. For those bits in B that are
> > known
> > to be one,
> > @@ -646,11 +643,11 @@ static void computeKnownBitsFromAssume(c
> > } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Xor(m_V,
> > m_Value(B))),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
> > - computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q,
> > I));
> > + computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q,
> > II));
> >
> > // For those bits in B that are known to be zero, we can
> > propagate
> > // inverted known bits from the RHS to V. For those bits in
> > B
> > that are
> > @@ -663,9 +660,9 @@ static void computeKnownBitsFromAssume(c
> > } else if (match(Arg, m_c_ICmp(Pred, m_Shl(m_V,
> > m_ConstantInt(C)),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > // For those bits in RHS that are known, we can propagate
> > them
> > to known
> > // bits in V shifted to the right by C.
> > KnownZero |= RHSKnownZero.lshr(C->getZExtValue());
> > @@ -674,9 +671,9 @@ static void computeKnownBitsFromAssume(c
> > } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_Shl(m_V,
> > m_ConstantInt(C))),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > // For those bits in RHS that are known, we can propagate
> > them
> > inverted
> > // to known bits in V shifted to the right by C.
> > KnownZero |= RHSKnownOne.lshr(C->getZExtValue());
> > @@ -687,9 +684,9 @@ static void computeKnownBitsFromAssume(c
> > m_AShr(m_V,
> > m_ConstantInt(C))),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > // For those bits in RHS that are known, we can propagate
> > them
> > to known
> > // bits in V shifted to the right by C.
> > KnownZero |= RHSKnownZero << C->getZExtValue();
> > @@ -700,9 +697,9 @@ static void computeKnownBitsFromAssume(c
> > m_AShr(m_V,
> > m_ConstantInt(C)))),
> > m_Value(A))) &&
> > Pred == ICmpInst::ICMP_EQ &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> > // For those bits in RHS that are known, we can propagate
> > them
> > inverted
> > // to known bits in V shifted to the right by C.
> > KnownZero |= RHSKnownOne << C->getZExtValue();
> > @@ -710,9 +707,9 @@ static void computeKnownBitsFromAssume(c
> > // assume(v >=_s c) where c is non-negative
> > } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> > Pred == ICmpInst::ICMP_SGE &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> >
> > if (RHSKnownZero.isNegative()) {
> > // We know that the sign bit is zero.
> > @@ -721,9 +718,9 @@ static void computeKnownBitsFromAssume(c
> > // assume(v >_s c) where c is at least -1.
> > } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> > Pred == ICmpInst::ICMP_SGT &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> >
> > if (RHSKnownOne.isAllOnesValue() ||
> > RHSKnownZero.isNegative())
> > {
> > // We know that the sign bit is zero.
> > @@ -732,9 +729,9 @@ static void computeKnownBitsFromAssume(c
> > // assume(v <=_s c) where c is negative
> > } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> > Pred == ICmpInst::ICMP_SLE &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> >
> > if (RHSKnownOne.isNegative()) {
> > // We know that the sign bit is one.
> > @@ -743,9 +740,9 @@ static void computeKnownBitsFromAssume(c
> > // assume(v <_s c) where c is non-positive
> > } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> > Pred == ICmpInst::ICMP_SLT &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> >
> > if (RHSKnownZero.isAllOnesValue() ||
> > RHSKnownOne.isNegative())
> > {
> > // We know that the sign bit is one.
> > @@ -754,9 +751,9 @@ static void computeKnownBitsFromAssume(c
> > // assume(v <=_u c)
> > } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> > Pred == ICmpInst::ICMP_ULE &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> >
> > // Whatever high bits in c are zero are known to be zero.
> > KnownZero |=
> > @@ -764,13 +761,13 @@ static void computeKnownBitsFromAssume(c
> > // assume(v <_u c)
> > } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
> > Pred == ICmpInst::ICMP_ULT &&
> > - isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
> > + isValidAssumeForContext(II, Q.CxtI, Q.DT)) {
> > APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
> > - computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, I));
> > + computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1,
> > Query(Q, II));
> >
> > // Whatever high bits in c are zero are known to be zero (if
> > c
> > is a power
> > // of 2, then one more).
> > - if (isKnownToBeAPowerOfTwo(A, false, Depth + 1, Query(Q,
> > I)))
> > + if (isKnownToBeAPowerOfTwo(A, false, Depth + 1, Query(Q,
> > II)))
> > KnownZero |=
> > APInt::getHighBitsSet(BitWidth,
> > RHSKnownZero.countLeadingOnes()+1);
> > else
> >
> > Modified:
> > llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp
> > (original)
> > +++ llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp Wed
> > Dec 14 20:53:42 2016
> > @@ -2518,6 +2518,78 @@ Instruction *InstCombiner::visitCallInst
> > if (KnownOne.isAllOnesValue())
> > return eraseInstFromFunction(*II);
> >
> > + // For assumptions, add to the associated operand bundle the
> > values to which
> > + // the assumption might apply.
> > + // Note: This code must be kept in-sync with the code in
> > + // computeKnownBitsFromAssume in ValueTracking.
> > + SmallVector<Value *, 16> Affected;
> > + auto AddAffected = [&Affected](Value *V) {
> > + if (isa<Argument>(V)) {
> > + Affected.push_back(V);
> > + } else if (auto *I = dyn_cast<Instruction>(V)) {
> > + Affected.push_back(I);
> > +
> > + if (I->getOpcode() == Instruction::BitCast ||
> > + I->getOpcode() == Instruction::PtrToInt) {
> > + V = I->getOperand(0);
> > + if (isa<Instruction>(V) || isa<Argument>(V))
> > + Affected.push_back(V);
> > + }
> > + }
> > + };
> > +
> > + CmpInst::Predicate Pred;
> > + if (match(IIOperand, m_ICmp(Pred, m_Value(A), m_Value(B)))) {
> > + AddAffected(A);
> > + AddAffected(B);
> > +
> > + if (Pred == ICmpInst::ICMP_EQ) {
> > + // For equality comparisons, we handle the case of bit
> > inversion.
> > + auto AddAffectedFromEq = [&AddAffected](Value *V) {
> > + Value *A;
> > + if (match(V, m_Not(m_Value(A)))) {
> > + AddAffected(A);
> > + V = A;
> > + }
> > +
> > + Value *B;
> > + ConstantInt *C;
> > + if (match(V,
> > + m_CombineOr(m_And(m_Value(A), m_Value(B)),
> > + m_CombineOr(m_Or(m_Value(A), m_Value(B)),
> > + m_Xor(m_Value(A),
> > m_Value(B))))))
> > {
> > + AddAffected(A);
> > + AddAffected(B);
> > + } else if (match(V,
> > + m_CombineOr(m_Shl(m_Value(A),
> > m_ConstantInt(C)),
> > + m_CombineOr(m_LShr(m_Value(A),
> > m_ConstantInt(C)),
> > + m_AShr(m_Value(A),
> > +
> > m_ConstantInt(C))))))
> > {
> > + AddAffected(A);
> > + }
> > + };
> > +
> > + AddAffectedFromEq(A);
> > + AddAffectedFromEq(B);
> > + }
> > + }
> > +
> > + // If the list of affected values is the same as the existing
> > list then
> > + // there's nothing more to do here.
> > + if (!Affected.empty())
> > + if (auto OB = CI.getOperandBundle("affected"))
> > + if (Affected.size() == OB.getValue().Inputs.size() &&
> > + std::equal(Affected.begin(), Affected.end(),
> > + OB.getValue().Inputs.begin()))
> > + Affected.clear();
> > +
> > + if (!Affected.empty()) {
> > + Builder->CreateCall(AssumeIntrinsic, IIOperand,
> > + OperandBundleDef("affected", Affected),
> > + II->getName());
> > + return eraseInstFromFunction(*II);
> > + }
> > +
> > break;
> > }
> > case Intrinsic::experimental_gc_relocate: {
> >
> > Modified:
> > llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp
> > (original)
> > +++ llvm/trunk/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp
> > Wed
> > Dec 14 20:53:42 2016
> > @@ -425,9 +425,12 @@ bool AlignmentFromAssumptionsPass::runIm
> > NewSrcAlignments.clear();
> >
> > bool Changed = false;
> > - for (auto &AssumeVH : AC.assumptions())
> > - if (AssumeVH)
> > - Changed |= processAssumption(cast<CallInst>(AssumeVH));
> > +
> > + for (auto &B : F)
> > + for (auto &I : B)
> > + if (auto *II = dyn_cast<IntrinsicInst>(&I))
> > + if (II->getIntrinsicID() == Intrinsic::assume)
> > + Changed |= processAssumption(II);
> >
> > return Changed;
> > }
> >
> > Modified:
> > llvm/trunk/test/Analysis/ScalarEvolution/no-wrap-unknown-becount.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/ScalarEvolution/no-wrap-unknown-becount.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > ---
> > llvm/trunk/test/Analysis/ScalarEvolution/no-wrap-unknown-becount.ll
> > (original)
> > +++
> > llvm/trunk/test/Analysis/ScalarEvolution/no-wrap-unknown-becount.ll
> > Wed Dec 14 20:53:42 2016
> > @@ -55,7 +55,7 @@ loop:
> > %cmp = icmp slt i32 %iv, 10000
> > ; CHECK: %iv.sext = sext i32 %iv to i64
> > ; CHECK-NEXT: --> {0,+,3}<nuw><nsw><%loop>
> > - call void @llvm.assume(i1 %cmp)
> > + call void @llvm.assume(i1 %cmp) [ "affected"(i32 %iv) ]
> > %c = load volatile i1, i1* %cond
> > br i1 %c, label %loop, label %leave
> >
> > @@ -159,7 +159,7 @@ loop:
> > %cmp = icmp ugt i32 %iv.inc, -10000
> > ; CHECK: %iv.zext = zext i32 %iv to i64
> > ; CHECK-NEXT: --> {30000,+,-2}<nw><%loop>
> > - call void @llvm.assume(i1 %cmp)
> > + call void @llvm.assume(i1 %cmp) [ "affected"(i32 %iv.inc) ]
> > %c = load volatile i1, i1* %cond
> > br i1 %c, label %loop, label %leave
> >
> >
> > Modified:
> > llvm/trunk/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/ScalarEvolution/nsw-offset-assume.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
> > (original)
> > +++ llvm/trunk/test/Analysis/ScalarEvolution/nsw-offset-assume.ll
> > Wed
> > Dec 14 20:53:42 2016
> > @@ -11,7 +11,7 @@ define void @foo(i32 %no, double* nocapt
> > entry:
> > %n = and i32 %no, 4294967294
> > %0 = icmp sgt i32 %n, 0 ; <i1> [#uses=1]
> > - tail call void @llvm.assume(i1 %0)
> > + tail call void @llvm.assume(i1 %0) [ "affected"(i32 %n) ]
> > br label %bb.nph
> >
> > bb.nph: ; preds = %entry
> >
> > Modified:
> > llvm/trunk/test/Transforms/CorrelatedValuePropagation/conflict.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/CorrelatedValuePropagation/conflict.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > ---
> > llvm/trunk/test/Transforms/CorrelatedValuePropagation/conflict.ll
> > (original)
> > +++
> > llvm/trunk/test/Transforms/CorrelatedValuePropagation/conflict.ll
> > Wed Dec 14 20:53:42 2016
> > @@ -26,7 +26,7 @@ declare void @llvm.assume(i1)
> > define i8 @test2(i8 %a) {
> > ; CHECK-LABEL: @test2
> > %cmp1 = icmp eq i8 %a, 5
> > - call void @llvm.assume(i1 %cmp1)
> > + call void @llvm.assume(i1 %cmp1) [ "affected"(i8 %a) ]
> > %cmp2 = icmp eq i8 %a, 3
> > ; CHECK: br i1 false, label %dead, label %exit
> > br i1 %cmp2, label %dead, label %exit
> > @@ -43,7 +43,7 @@ define i8 @test3(i8 %a) {
> > dead:
> > %cmp2 = icmp eq i8 %a, 3
> > ; CHECK: call void @llvm.assume(i1 false)
> > - call void @llvm.assume(i1 %cmp2)
> > + call void @llvm.assume(i1 %cmp2) [ "affected"(i8 %a) ]
> > ret i8 %a
> > exit:
> > ret i8 0
> >
> > Modified:
> > llvm/trunk/test/Transforms/InstCombine/assume-redundant.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/assume-redundant.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Transforms/InstCombine/assume-redundant.ll
> > (original)
> > +++ llvm/trunk/test/Transforms/InstCombine/assume-redundant.ll Wed
> > Dec 14 20:53:42 2016
> > @@ -11,7 +11,7 @@ target triple = "x86_64-unknown-linux-gn
> > define void @_Z3fooR1s(%struct.s* nocapture readonly
> > dereferenceable(8) %x) #0 {
> >
> > ; CHECK-LABEL: @_Z3fooR1s
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %maskcond) [ "affected"(i64
> > %maskedptr, i64 %ptrint, double* %{{.*}}) ]
> > ; CHECK-NOT: call void @llvm.assume
> >
> > entry:
> >
> > Modified: llvm/trunk/test/Transforms/InstCombine/assume.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/assume.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Transforms/InstCombine/assume.ll (original)
> > +++ llvm/trunk/test/Transforms/InstCombine/assume.ll Wed Dec 14
> > 20:53:42 2016
> > @@ -11,7 +11,7 @@ entry:
> > ; been removed:
> > ; CHECK-LABEL: @foo1
> > ; CHECK-DAG: load i32, i32* %a, align 32
> > -; CHECK-DAG: call void @llvm.assume
> > +; CHECK-DAG: call void @llvm.assume(i1 %maskcond) [ "affected"(i64
> > %maskedptr, i64 %ptrint, i32* %a) ]
> > ; CHECK: ret i32
> >
> > %ptrint = ptrtoint i32* %a to i64
> > @@ -28,7 +28,7 @@ entry:
> > ; Same check as in @foo1, but make sure it works if the assume is
> > first too.
> > ; CHECK-LABEL: @foo2
> > ; CHECK-DAG: load i32, i32* %a, align 32
> > -; CHECK-DAG: call void @llvm.assume
> > +; CHECK-DAG: call void @llvm.assume(i1 %maskcond) [ "affected"(i64
> > %maskedptr, i64 %ptrint, i32* %a) ]
> > ; CHECK: ret i32
> >
> > %ptrint = ptrtoint i32* %a to i64
> > @@ -51,7 +51,7 @@ entry:
> > ; CHECK: ret i32 4
> >
> > %cmp = icmp eq i32 %a, 4
> > - tail call void @llvm.assume(i1 %cmp)
> > + tail call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > ret i32 %a
> > }
> >
> > @@ -93,7 +93,7 @@ entry:
> > %and1 = and i32 %a, 3
> >
> > ; CHECK-LABEL: @bar1
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %and,
> > i32
> > %a) ]
> > ; CHECK: ret i32 1
> >
> > %and = and i32 %a, 7
> > @@ -107,7 +107,7 @@ entry:
> > define i32 @bar2(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @bar2
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %and,
> > i32
> > %a) ]
> > ; CHECK: ret i32 1
> >
> > %and = and i32 %a, 7
> > @@ -125,7 +125,7 @@ entry:
> >
> > ; Don't be fooled by other assumes around.
> > ; CHECK-LABEL: @bar3
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %and,
> > i32
> > %a) ]
> > ; CHECK: ret i32 1
> >
> > tail call void @llvm.assume(i1 %x)
> > @@ -145,8 +145,8 @@ entry:
> > %and1 = and i32 %b, 3
> >
> > ; CHECK-LABEL: @bar4
> > -; CHECK: call void @llvm.assume
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %and,
> > i32
> > %a) ]
> > +; CHECK: call void @llvm.assume(i1 %cmp2) [ "affected"(i32 %a, i32
> > %b) ]
> > ; CHECK: ret i32 1
> >
> > %and = and i32 %a, 7
> > @@ -167,7 +167,7 @@ entry:
> > ret i32 %conv
> >
> > ; CHECK-LABEL: @icmp1
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > ; CHECK: ret i32 1
> >
> > }
> > @@ -182,7 +182,7 @@ entry:
> > ret i32 %lnot.ext
> >
> > ; CHECK-LABEL: @icmp2
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > ; CHECK: ret i32 0
> > }
> >
> > @@ -217,7 +217,7 @@ entry:
> >
> > ; CHECK-LABEL: @nonnull2
> > ; CHECK-NOT: !nonnull
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %load) ]
> > }
> >
> > ; Make sure the above canonicalization does not trigger
> > @@ -236,7 +236,7 @@ not_taken:
> >
> > ; CHECK-LABEL: @nonnull3
> > ; CHECK-NOT: !nonnull
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32* %load)
> > ]
> > }
> >
> > ; Make sure the above canonicalization does not trigger
> > @@ -254,7 +254,7 @@ entry:
> >
> > ; CHECK-LABEL: @nonnull4
> > ; CHECK-NOT: !nonnull
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32* %load)
> > ]
> > }
> >
> >
> >
> > Modified: llvm/trunk/test/Transforms/InstCombine/assume2.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/assume2.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Transforms/InstCombine/assume2.ll (original)
> > +++ llvm/trunk/test/Transforms/InstCombine/assume2.ll Wed Dec 14
> > 20:53:42 2016
> > @@ -9,7 +9,7 @@ declare void @llvm.assume(i1) #1
> > define i32 @test1(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test1
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %and,
> > i32
> > %a) ]
> > ; CHECK: ret i32 5
> >
> > %and = and i32 %a, 15
> > @@ -24,7 +24,7 @@ entry:
> > define i32 @test2(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test2
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a.not,
> > i32 %a) ]
> > ; CHECK: ret i32 2
> >
> > %and = and i32 %a, 15
> > @@ -40,7 +40,7 @@ entry:
> > define i32 @test3(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test3
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %v, i32
> > %a) ]
> > ; CHECK: ret i32 5
> >
> > %v = or i32 %a, 4294967280
> > @@ -55,7 +55,7 @@ entry:
> > define i32 @test4(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test4
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a.not,
> > i32 %a) ]
> > ; CHECK: ret i32 2
> >
> > %v = or i32 %a, 4294967280
> > @@ -71,7 +71,7 @@ entry:
> > define i32 @test5(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test5
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > ; CHECK: ret i32 4
> >
> > %v = xor i32 %a, 1
> > @@ -86,7 +86,7 @@ entry:
> > define i32 @test6(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test6
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %v.mask,
> > i32 %a) ]
> > ; CHECK: ret i32 5
> >
> > %v = shl i32 %a, 2
> > @@ -101,7 +101,7 @@ entry:
> > define i32 @test7(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test7
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %v.mask,
> > i32 %a) ]
> > ; CHECK: ret i32 20
> >
> > %v = lshr i32 %a, 2
> > @@ -116,7 +116,7 @@ entry:
> > define i32 @test8(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test8
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %v.mask,
> > i32 %a) ]
> > ; CHECK: ret i32 20
> >
> > %v = lshr i32 %a, 2
> > @@ -131,7 +131,7 @@ entry:
> > define i32 @test9(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test9
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > ; CHECK: ret i32 0
> >
> > %cmp = icmp sgt i32 %a, 5
> > @@ -145,7 +145,7 @@ entry:
> > define i32 @test10(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test10
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > ; CHECK: ret i32 -2147483648
> >
> > %cmp = icmp sle i32 %a, -2
> > @@ -159,7 +159,7 @@ entry:
> > define i32 @test11(i32 %a) #0 {
> > entry:
> > ; CHECK-LABEL: @test11
> > -; CHECK: call void @llvm.assume
> > +; CHECK: call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > ; CHECK: ret i32 0
> >
> > %cmp = icmp ule i32 %a, 256
> >
> > Modified: llvm/trunk/test/Transforms/InstSimplify/add-mask.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstSimplify/add-mask.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Transforms/InstSimplify/add-mask.ll (original)
> > +++ llvm/trunk/test/Transforms/InstSimplify/add-mask.ll Wed Dec 14
> > 20:53:42 2016
> > @@ -46,7 +46,7 @@ define i1 @test4(i32 %a) {
> > %b = load i32, i32* @B
> > %b.and = and i32 %b, 1
> > %b.cnd = icmp eq i32 %b.and, 1
> > - call void @llvm.assume(i1 %b.cnd)
> > + call void @llvm.assume(i1 %b.cnd) [ "affected"(i32 %b.and, i32
> > %b)
> > ]
> >
> > %rhs = add i32 %a, %b
> > %and = and i32 %a, %rhs
> >
> > Modified:
> > llvm/trunk/test/Transforms/JumpThreading/assume-edge-dom.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/JumpThreading/assume-edge-dom.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Transforms/JumpThreading/assume-edge-dom.ll
> > (original)
> > +++ llvm/trunk/test/Transforms/JumpThreading/assume-edge-dom.ll Wed
> > Dec 14 20:53:42 2016
> > @@ -14,12 +14,12 @@ entry:
> > taken:
> > %res1 = call i8* @escape()
> > %a = icmp eq i8* %res1, null
> > - tail call void @llvm.assume(i1 %a)
> > + tail call void @llvm.assume(i1 %a) [ "affected"(i8* %res1) ]
> > br label %done
> > not_taken:
> > %res2 = call i8* @escape()
> > %b = icmp ne i8* %res2, null
> > - tail call void @llvm.assume(i1 %b)
> > + tail call void @llvm.assume(i1 %b) [ "affected"(i8* %res2) ]
> > br label %done
> >
> > ; An assume that can be used to simplify this comparison dominates
> > each
> >
> > Modified: llvm/trunk/test/Transforms/JumpThreading/assume.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/JumpThreading/assume.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Transforms/JumpThreading/assume.ll (original)
> > +++ llvm/trunk/test/Transforms/JumpThreading/assume.ll Wed Dec 14
> > 20:53:42 2016
> > @@ -6,7 +6,7 @@ target triple = "x86_64-unknown-linux-gn
> > define i32 @test1(i32 %a, i32 %b) #0 {
> > entry:
> > %cmp = icmp sgt i32 %a, 5
> > - tail call void @llvm.assume(i1 %cmp)
> > + tail call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > %cmp1 = icmp sgt i32 %b, 1234
> > br i1 %cmp1, label %if.then, label %if.else
> >
> > @@ -36,7 +36,7 @@ return:
> > define i32 @test2(i32 %a) #0 {
> > entry:
> > %cmp = icmp sgt i32 %a, 5
> > - tail call void @llvm.assume(i1 %cmp)
> > + tail call void @llvm.assume(i1 %cmp) [ "affected"(i32 %a) ]
> > %cmp1 = icmp sgt i32 %a, 3
> > br i1 %cmp1, label %if.then, label %return
> >
> >
> > Modified:
> > llvm/trunk/test/Transforms/NaryReassociate/NVPTX/nary-gep.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/NaryReassociate/NVPTX/nary-gep.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Transforms/NaryReassociate/NVPTX/nary-gep.ll
> > (original)
> > +++ llvm/trunk/test/Transforms/NaryReassociate/NVPTX/nary-gep.ll
> > Wed
> > Dec 14 20:53:42 2016
> > @@ -75,10 +75,10 @@ define void @reassociate_gep_assume(floa
> > ; CHECK-LABEL: @reassociate_gep_assume(
> > ; assume(j >= 0)
> > %cmp = icmp sgt i32 %j, -1
> > - call void @llvm.assume(i1 %cmp)
> > + call void @llvm.assume(i1 %cmp) [ "affected"(i32 %j) ]
> > %1 = add i32 %i, %j
> > %cmp2 = icmp sgt i32 %1, -1
> > - call void @llvm.assume(i1 %cmp2)
> > + call void @llvm.assume(i1 %cmp2) [ "affected"(i32 %1) ]
> >
> > %idxprom.j = zext i32 %j to i64
> > %2 = getelementptr float, float* %a, i64 %idxprom.j
> >
> > Modified:
> > llvm/trunk/test/Transforms/SimplifyCFG/switch-dead-default.ll
> > URL:
> > http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/SimplifyCFG/switch-dead-default.ll?rev=289755&r1=289754&r2=289755&view=diff
> > ==============================================================================
> > --- llvm/trunk/test/Transforms/SimplifyCFG/switch-dead-default.ll
> > (original)
> > +++ llvm/trunk/test/Transforms/SimplifyCFG/switch-dead-default.ll
> > Wed
> > Dec 14 20:53:42 2016
> > @@ -91,7 +91,7 @@ define void @test5(i8 %a) {
> > ; CHECK-LABEL: @test5
> > ; CHECK: br i1 [[IGNORE:%.*]], label %true, label %false
> > %cmp = icmp ult i8 %a, 2
> > - call void @llvm.assume(i1 %cmp)
> > + call void @llvm.assume(i1 %cmp) [ "affected"(i8 %a) ]
> > switch i8 %a, label %default [i8 1, label %true
> > i8 0, label %false]
> > true:
> > @@ -112,7 +112,7 @@ define void @test6(i8 %a) {
> > ; CHECK: br i1 [[IGNORE:%.*]], label %true, label %false
> > %and = and i8 %a, 254
> > %cmp = icmp eq i8 %and, 254
> > - call void @llvm.assume(i1 %cmp)
> > + call void @llvm.assume(i1 %cmp) [ "affected"(i8 %and, i8 %a) ]
> > switch i8 %a, label %default [i8 255, label %true
> > i8 254, label %false]
> > true:
> > @@ -134,7 +134,7 @@ define void @test7(i8 %a) {
> > ; CHECK: br i1 [[IGNORE:%.*]], label %true, label %false
> > %and = and i8 %a, 254
> > %cmp = icmp eq i8 %and, 254
> > - call void @llvm.assume(i1 %cmp)
> > + call void @llvm.assume(i1 %cmp) [ "affected"(i8 %and, i8 %a) ]
> > switch i8 %a, label %default [i8 255, label %true
> > i8 254, label %false
> > i8 0, label %also_dead]
> > @@ -162,7 +162,7 @@ define void @test8(i8 %a) {
> > ; CHECK: switch i8
> > %and = and i8 %a, 254
> > %cmp = icmp eq i8 %and, undef
> > - call void @llvm.assume(i1 %cmp)
> > + call void @llvm.assume(i1 %cmp) [ "affected"(i8 %and, i8 %a) ]
> > switch i8 %a, label %default [i8 255, label %true
> > i8 254, label %false]
> > true:
> >
> >
> > _______________________________________________
> > llvm-commits mailing list
> > llvm-commits at lists.llvm.org<mailto:llvm-commits at lists.llvm.org>
> > http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
> >
>
> --
> Hal Finkel
> Lead, Compiler Technology and Programming Languages
> Leadership Computing Facility
> Argonne National Laboratory
>
--
Hal Finkel
Lead, Compiler Technology and Programming Languages
Leadership Computing Facility
Argonne National Laboratory
_______________________________________________
llvm-commits mailing list
llvm-commits at lists.llvm.org<mailto:llvm-commits at lists.llvm.org>
http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20161219/227aee81/attachment-0001.html>
-------------- next part --------------
An embedded and charset-unspecified text was scrubbed...
Name: repro.cpp
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20161219/227aee81/attachment-0001.ksh>
More information about the llvm-commits
mailing list