maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

remove the AllowAggressive argument to FoldOpIntoPhi. It is forced to false in the 

first line of the function because it isn't a good idea, even for compares.

llvm-svn: 123566
This commit is contained in:
Chris Lattner 2011-01-16 05:14:26 +00:00
parent ff2e737714
commit ea7131a062
3 changed files with 6 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
llvm/lib/Transforms/InstCombine/InstCombine.h
View File

@ -319,10 +319,7 @@ private:
// into the PHI (which is only possible if all operands to the PHI are
// constants).
//
// If AllowAggressive is true, FoldOpIntoPhi will allow certain transforms
// that would normally be unprofitable because they strongly encourage jump
// threading.
Instruction *FoldOpIntoPhi(Instruction &I, bool AllowAggressive = false);
Instruction *FoldOpIntoPhi(Instruction &I);
// FoldPHIArgOpIntoPHI - If all operands to a PHI node are the same "unary"
// operator and they all are only used by the PHI, PHI together their

4
llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp
View File

@ -2125,7 +2125,7 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
// block. If in the same block, we're encouraging jump threading. If
// not, we are just pessimizing the code by making an i1 phi.
if (LHSI->getParent() == I.getParent())
if (Instruction *NV = FoldOpIntoPhi(I, true))
if (Instruction *NV = FoldOpIntoPhi(I))
return NV;
break;
case Instruction::Select: {
@ -2648,7 +2648,7 @@ Instruction *InstCombiner::visitFCmpInst(FCmpInst &I) {
// block. If in the same block, we're encouraging jump threading. If
// not, we are just pessimizing the code by making an i1 phi.
if (LHSI->getParent() == I.getParent())
if (Instruction *NV = FoldOpIntoPhi(I, true))
if (Instruction *NV = FoldOpIntoPhi(I))
return NV;
break;
case Instruction::SIToFP:

11
llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
View File

@ -512,12 +512,7 @@ Instruction *InstCombiner::FoldOpIntoSelect(Instruction &Op, SelectInst *SI) {
/// has a PHI node as operand #0, see if we can fold the instruction into the
/// PHI (which is only possible if all operands to the PHI are constants).
///
/// If AllowAggressive is true, FoldOpIntoPhi will allow certain transforms
/// that would normally be unprofitable because they strongly encourage jump
/// threading.
Instruction *InstCombiner::FoldOpIntoPhi(Instruction &I,
bool AllowAggressive) {
AllowAggressive = false;
Instruction *InstCombiner::FoldOpIntoPhi(Instruction &I) {
PHINode *PN = cast<PHINode>(I.getOperand(0));
unsigned NumPHIValues = PN->getNumIncomingValues();
if (NumPHIValues == 0)
@ -525,7 +520,7 @@ Instruction *InstCombiner::FoldOpIntoPhi(Instruction &I,
// We normally only transform phis with a single use, unless we're trying
// hard to make jump threading happen.
if (!PN->hasOneUse() && !AllowAggressive)
if (!PN->hasOneUse())
return 0;
// Check to see if all of the operands of the PHI are simple constants
@ -560,7 +555,7 @@ Instruction *InstCombiner::FoldOpIntoPhi(Instruction &I,
// operation in that block. However, if this is a critical edge, we would be
// inserting the computation one some other paths (e.g. inside a loop). Only
// do this if the pred block is unconditionally branching into the phi block.
if (NonConstBB != 0 && !AllowAggressive) {
if (NonConstBB != 0) {
BranchInst *BI = dyn_cast<BranchInst>(NonConstBB->getTerminator());
if (!BI || !BI->isUnconditional()) return 0;
}