RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-30 23:20:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

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


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123566 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2011-01-16 05:14:26 +00:00
parent 7dfe8fd96c
commit 9922ccf4b4
3 changed files with 6 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
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
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
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;
}