[llvm] r263605 - Revert "[JumpThreading] Simplify Instructions first in ComputeValueKnownInPredecessors()"
Haicheng Wu via llvm-commits
llvm-commits at lists.llvm.org
Tue Mar 15 16:38:47 PDT 2016
Author: haicheng
Date: Tue Mar 15 18:38:47 2016
New Revision: 263605
URL: http://llvm.org/viewvc/llvm-project?rev=263605&view=rev
Log:
Revert "[JumpThreading] Simplify Instructions first in ComputeValueKnownInPredecessors()"
Not sure it handles undef properly.
Modified:
llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp
llvm/trunk/test/Transforms/JumpThreading/basic.ll
Modified: llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp?rev=263605&r1=263604&r2=263605&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/JumpThreading.cpp Tue Mar 15 18:38:47 2016
@@ -152,7 +152,6 @@ namespace {
bool ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,
PredValueInfo &Result,
ConstantPreference Preference,
- bool &Changed,
Instruction *CxtI = nullptr);
bool ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
ConstantPreference Preference,
@@ -396,9 +395,10 @@ static Constant *getKnownConstant(Value
///
/// This returns true if there were any known values.
///
-bool JumpThreading::ComputeValueKnownInPredecessors(
- Value *V, BasicBlock *BB, PredValueInfo &Result,
- ConstantPreference Preference, bool &Changed, Instruction *CxtI) {
+bool JumpThreading::
+ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB, PredValueInfo &Result,
+ ConstantPreference Preference,
+ Instruction *CxtI) {
// This method walks up use-def chains recursively. Because of this, we could
// get into an infinite loop going around loops in the use-def chain. To
// prevent this, keep track of what (value, block) pairs we've already visited
@@ -410,16 +410,6 @@ bool JumpThreading::ComputeValueKnownInP
// stack pops back out again.
RecursionSetRemover remover(RecursionSet, std::make_pair(V, BB));
- // Simplify the instruction before inferring the value.
- Instruction *I = dyn_cast<Instruction>(V);
- if (I && !isa<PHINode>(I))
- if (auto *NewV = SimplifyInstruction(I, BB->getModule()->getDataLayout())) {
- I->replaceAllUsesWith(NewV);
- I->eraseFromParent();
- V = NewV;
- Changed = true;
- }
-
// If V is a constant, then it is known in all predecessors.
if (Constant *KC = getKnownConstant(V, Preference)) {
for (BasicBlock *Pred : predecessors(BB))
@@ -430,7 +420,7 @@ bool JumpThreading::ComputeValueKnownInP
// If V is a non-instruction value, or an instruction in a different block,
// then it can't be derived from a PHI.
- I = dyn_cast<Instruction>(V);
+ Instruction *I = dyn_cast<Instruction>(V);
if (!I || I->getParent() != BB) {
// Okay, if this is a live-in value, see if it has a known value at the end
@@ -485,9 +475,9 @@ bool JumpThreading::ComputeValueKnownInP
if (I->getOpcode() == Instruction::Or ||
I->getOpcode() == Instruction::And) {
ComputeValueKnownInPredecessors(I->getOperand(0), BB, LHSVals,
- WantInteger, Changed, CxtI);
+ WantInteger, CxtI);
ComputeValueKnownInPredecessors(I->getOperand(1), BB, RHSVals,
- WantInteger, Changed, CxtI);
+ WantInteger, CxtI);
if (LHSVals.empty() && RHSVals.empty())
return false;
@@ -522,8 +512,8 @@ bool JumpThreading::ComputeValueKnownInP
if (I->getOpcode() == Instruction::Xor &&
isa<ConstantInt>(I->getOperand(1)) &&
cast<ConstantInt>(I->getOperand(1))->isOne()) {
- ComputeValueKnownInPredecessors(I->getOperand(0), BB, Result, WantInteger,
- Changed, CxtI);
+ ComputeValueKnownInPredecessors(I->getOperand(0), BB, Result,
+ WantInteger, CxtI);
if (Result.empty())
return false;
@@ -541,7 +531,7 @@ bool JumpThreading::ComputeValueKnownInP
if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->getOperand(1))) {
PredValueInfoTy LHSVals;
ComputeValueKnownInPredecessors(BO->getOperand(0), BB, LHSVals,
- WantInteger, Changed, CxtI);
+ WantInteger, CxtI);
// Try to use constant folding to simplify the binary operator.
for (const auto &LHSVal : LHSVals) {
@@ -618,7 +608,7 @@ bool JumpThreading::ComputeValueKnownInP
if (Constant *CmpConst = dyn_cast<Constant>(Cmp->getOperand(1))) {
PredValueInfoTy LHSVals;
ComputeValueKnownInPredecessors(I->getOperand(0), BB, LHSVals,
- WantInteger, Changed, CxtI);
+ WantInteger, CxtI);
for (const auto &LHSVal : LHSVals) {
Constant *V = LHSVal.first;
@@ -641,7 +631,7 @@ bool JumpThreading::ComputeValueKnownInP
PredValueInfoTy Conds;
if ((TrueVal || FalseVal) &&
ComputeValueKnownInPredecessors(SI->getCondition(), BB, Conds,
- WantInteger, Changed, CxtI)) {
+ WantInteger, CxtI)) {
for (auto &C : Conds) {
Constant *Cond = C.first;
@@ -1190,10 +1180,8 @@ bool JumpThreading::ProcessThreadableEdg
return false;
PredValueInfoTy PredValues;
- bool Changed = false;
- if (!ComputeValueKnownInPredecessors(Cond, BB, PredValues, Preference,
- Changed, CxtI))
- return Changed;
+ if (!ComputeValueKnownInPredecessors(Cond, BB, PredValues, Preference, CxtI))
+ return false;
assert(!PredValues.empty() &&
"ComputeValueKnownInPredecessors returned true with no values");
@@ -1251,7 +1239,7 @@ bool JumpThreading::ProcessThreadableEdg
// If all edges were unthreadable, we fail.
if (PredToDestList.empty())
- return Changed;
+ return false;
// Determine which is the most common successor. If we have many inputs and
// this block is a switch, we want to start by threading the batch that goes
@@ -1284,8 +1272,7 @@ bool JumpThreading::ProcessThreadableEdg
getSuccessor(GetBestDestForJumpOnUndef(BB));
// Ok, try to thread it!
- Changed |= ThreadEdge(BB, PredsToFactor, MostPopularDest);
- return Changed;
+ return ThreadEdge(BB, PredsToFactor, MostPopularDest);
}
/// ProcessBranchOnPHI - We have an otherwise unthreadable conditional branch on
@@ -1356,13 +1343,12 @@ bool JumpThreading::ProcessBranchOnXOR(B
PredValueInfoTy XorOpValues;
bool isLHS = true;
- bool Changed = false;
if (!ComputeValueKnownInPredecessors(BO->getOperand(0), BB, XorOpValues,
- WantInteger, Changed, BO)) {
+ WantInteger, BO)) {
assert(XorOpValues.empty());
if (!ComputeValueKnownInPredecessors(BO->getOperand(1), BB, XorOpValues,
- WantInteger, Changed, BO))
- return Changed;
+ WantInteger, BO))
+ return false;
isLHS = false;
}
@@ -1420,8 +1406,7 @@ bool JumpThreading::ProcessBranchOnXOR(B
}
// Try to duplicate BB into PredBB.
- Changed |= DuplicateCondBranchOnPHIIntoPred(BB, BlocksToFoldInto);
- return Changed;
+ return DuplicateCondBranchOnPHIIntoPred(BB, BlocksToFoldInto);
}
Modified: llvm/trunk/test/Transforms/JumpThreading/basic.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/JumpThreading/basic.ll?rev=263605&r1=263604&r2=263605&view=diff
==============================================================================
--- llvm/trunk/test/Transforms/JumpThreading/basic.ll (original)
+++ llvm/trunk/test/Transforms/JumpThreading/basic.ll Tue Mar 15 18:38:47 2016
@@ -476,56 +476,6 @@ exit1:
; CHECK: }
}
-
-;;; Verify that we can handle constraint propagation through cast.
-define i32 @test16(i1 %cond) {
-Entry:
-; CHECK-LABEL: @test16(
- br i1 %cond, label %Merge, label %F1
-
-; CHECK: Entry:
-; CHECK-NEXT: br i1 %cond, label %F2, label %Merge
-
-F1:
- %v1 = call i32 @f1()
- br label %Merge
-
-Merge:
- %B = phi i32 [1, %Entry], [%v1, %F1]
- %M = icmp eq i32 %B, 0
- %M1 = zext i1 %M to i32
- %N = icmp eq i32 %M1, 1
- br i1 %N, label %T2, label %F2
-
-; CHECK: Merge:
-; CHECK-NOT: phi
-; CHECK-NEXT: %v1 = call i32 @f1()
-
-T2:
- %Q = zext i1 %M to i32
- ret i32 %Q
-
-F2:
- ret i32 %B
-; CHECK: F2:
-; CHECK-NEXT: phi i32
-}
-
-;;; Just check that ComputeValueKnownInPredecessors() does not return true with
-;;; no values and triggers the assert in ProcessThreadableEdges().
-define i32 @test17() {
-entry:
- %A = add i32 0, 1
- %B = icmp eq i32 %A, 0
- br i1 %B, label %T, label %F
-T:
- %v1 = call i32 @f1()
- ret i32 %v1
-F:
- %v2 = call i32 @f2()
- ret i32 %v2
-}
-
; In this test we check that block duplication is inhibited by the presence
; of a function with the 'noduplicate' attribute.
More information about the llvm-commits
mailing list