RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-02-10 04:24:23 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Re-apply r112539, being more careful to respect the return values of the constant folding methods. Additionally,

Browse Source 
use the ConstantExpr::get*() methods to simplify some constant folding.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@112550 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2010-08-30 23:22:36 +00:00
parent 6d1e29d2f2
commit 327ca7bec2
1 changed files with 25 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
lib/Transforms/Scalar/JumpThreading.cpp
View File

@ -16,6 +16,7 @@
#include "llvm/IntrinsicInst.h" #include "llvm/IntrinsicInst.h"
#include "llvm/LLVMContext.h" #include "llvm/LLVMContext.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Analysis/InstructionSimplify.h" #include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Analysis/LazyValueInfo.h" #include "llvm/Analysis/LazyValueInfo.h"
#include "llvm/Analysis/Loads.h" #include "llvm/Analysis/Loads.h"
@ -325,9 +326,10 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,PredValueInfo &Result){
} else if (LVI) { } else if (LVI) {
Constant *CI = LVI->getConstantOnEdge(InVal, Constant *CI = LVI->getConstantOnEdge(InVal,
PN->getIncomingBlock(i), BB); PN->getIncomingBlock(i), BB);
ConstantInt *CInt = dyn_cast_or_null<ConstantInt>(CI); // LVI returns null is no value could be determined.
if (CInt) if (!CI) continue;
Result.push_back(std::make_pair(CInt, PN->getIncomingBlock(i))); ConstantInt *CInt = dyn_cast<ConstantInt>(CI);
Result.push_back(std::make_pair(CInt, PN->getIncomingBlock(i)));
} }
} }
return !Result.empty(); return !Result.empty();
@ -373,10 +375,6 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,PredValueInfo &Result){
} }
} }
return !Result.empty(); return !Result.empty();
// Try to process a few other binary operator patterns.
} else if (isa<BinaryOperator>(I)) {
} }
// Handle the NOT form of XOR. // Handle the NOT form of XOR.
@ -400,12 +398,19 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,PredValueInfo &Result){
// AND or OR of a value with itself is that value. // AND or OR of a value with itself is that value.
ConstantInt *CI = dyn_cast<ConstantInt>(BO->getOperand(1)); ConstantInt *CI = dyn_cast<ConstantInt>(BO->getOperand(1));
if (CI && (BO->getOpcode() == Instruction::And || if (CI && (BO->getOpcode() == Instruction::And ||
BO->getOpcode() == Instruction::Or)) { BO->getOpcode() == Instruction::Or)) {
SmallVector<std::pair<ConstantInt*, BasicBlock*>, 8> LHSVals; SmallVector<std::pair<ConstantInt*, BasicBlock*>, 8> LHSVals;
ComputeValueKnownInPredecessors(BO->getOperand(0), BB, LHSVals); ComputeValueKnownInPredecessors(BO->getOperand(0), BB, LHSVals);
for (unsigned i = 0, e = LHSVals.size(); i != e; ++i) for (unsigned i = 0, e = LHSVals.size(); i != e; ++i)
if (LHSVals[i].first == CI) if (LHSVals[i].first == 0) {
Result.push_back(std::make_pair(CI, LHSVals[i].second)); ConstantInt *Zero =
cast<ConstantInt>(ConstantInt::get(BO->getType(), 0));
Result.push_back(std::make_pair(Zero, LHSVals[i].second));
} else if (Constant *Folded = ConstantExpr::get(BO->getOpcode(),
LHSVals[i].first, CI)) {
Result.push_back(std::make_pair(cast<ConstantInt>(Folded),
LHSVals[i].second));
}
return !Result.empty(); return !Result.empty();
} }
@ -450,7 +455,7 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,PredValueInfo &Result){
if (LVI && isa<Constant>(Cmp->getOperand(1)) && if (LVI && isa<Constant>(Cmp->getOperand(1)) &&
Cmp->getType()->isIntegerTy()) { Cmp->getType()->isIntegerTy()) {
if (!isa<Instruction>(Cmp->getOperand(0)) || if (!isa<Instruction>(Cmp->getOperand(0)) ||
cast<Instruction>(Cmp->getOperand(0))->getParent() != BB) { cast<Instruction>(Cmp->getOperand(0))->getParent() != BB) {
Constant *RHSCst = cast<Constant>(Cmp->getOperand(1)); Constant *RHSCst = cast<Constant>(Cmp->getOperand(1));
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB);PI != E; ++PI){ for (pred_iterator PI = pred_begin(BB), E = pred_end(BB);PI != E; ++PI){
@ -472,20 +477,18 @@ ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,PredValueInfo &Result){
// Try to find a constant value for the LHS of an equality comparison, // Try to find a constant value for the LHS of an equality comparison,
// and evaluate it statically if we can. // and evaluate it statically if we can.
if (Cmp->getPredicate() == CmpInst::ICMP_EQ || if (Constant *CmpConst = dyn_cast<Constant>(Cmp->getOperand(1))) {
Cmp->getPredicate() == CmpInst::ICMP_NE) {
SmallVector<std::pair<ConstantInt*, BasicBlock*>, 8> LHSVals; SmallVector<std::pair<ConstantInt*, BasicBlock*>, 8> LHSVals;
ComputeValueKnownInPredecessors(I->getOperand(0), BB, LHSVals); ComputeValueKnownInPredecessors(I->getOperand(0), BB, LHSVals);
ConstantInt *True = ConstantInt::getTrue(I->getContext());
ConstantInt *False = ConstantInt::getFalse(I->getContext());
if (Cmp->getPredicate() == CmpInst::ICMP_NE) std::swap(True, False);
for (unsigned i = 0, e = LHSVals.size(); i != e; ++i) { for (unsigned i = 0, e = LHSVals.size(); i != e; ++i) {
if (LHSVals[i].first == Cmp->getOperand(1)) if (LHSVals[i].first == 0)
Result.push_back(std::make_pair(True, LHSVals[i].second)); Result.push_back(std::make_pair((ConstantInt*)0,
else LHSVals[i].second));
Result.push_back(std::make_pair(False, LHSVals[i].second)); else if (Constant *Folded = ConstantExpr::getCompare(
Cmp->getPredicate(), LHSVals[i].first, CmpConst))
Result.push_back(std::make_pair(cast<ConstantInt>(Folded),
LHSVals[i].second));
} }
return !Result.empty(); return !Result.empty();