RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-01 17:28:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename SimplifyDistributed to the more meaningfull name SimplifyByFactorizing.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@120051 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands 2010-11-23 20:42:39 +00:00
parent c21a821e9f
commit 50f2625b22
4 changed files with 15 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/Transforms/InstCombine/InstCombine.h
View File

@ -290,11 +290,11 @@ private:
/// operators which are associative or commutative.
bool SimplifyAssociativeOrCommutative(BinaryOperator &I);
/// SimplifyDistributed - This tries to simplify binary operations which some
/// other binary operation distributes over (eg "A*B+A*C" -> "A*(B+C)" since
/// addition is distributed over by multiplication). Returns the result of
/// the simplification, or null if no simplification was performed.
Instruction *SimplifyDistributed(BinaryOperator &I);
/// SimplifyByFactorizing - This tries to simplify binary operations which
/// some other binary operation distributes over by factorizing out a common
/// term (eg "(A*B)+(A*C)" -> "A*(B+C)"). Returns the simplified value, or
/// null if no simplification was performed.
Instruction *SimplifyByFactorizing(BinaryOperator &I);
/// SimplifyDemandedUseBits - Attempts to replace V with a simpler value
/// based on the demanded bits.

4
lib/Transforms/InstCombine/InstCombineAddSub.cpp
View File

@ -91,7 +91,7 @@ Instruction *InstCombiner::visitAdd(BinaryOperator &I) {
I.hasNoUnsignedWrap(), TD))
return ReplaceInstUsesWith(I, V);
if (Instruction *NV = SimplifyDistributed(I)) // (A*B)+(A*C) -> A*(B+C)
if (Instruction *NV = SimplifyByFactorizing(I)) // (A*B)+(A*C) -> A*(B+C)
return NV;
if (Constant *RHSC = dyn_cast<Constant>(RHS)) {
@ -550,7 +550,7 @@ Instruction *InstCombiner::visitSub(BinaryOperator &I) {
if (Op0 == Op1) // sub X, X -> 0
return ReplaceInstUsesWith(I, Constant::getNullValue(I.getType()));
if (Instruction *NV = SimplifyDistributed(I)) // (A*B)-(A*C) -> A*(B-C)
if (Instruction *NV = SimplifyByFactorizing(I)) // (A*B)-(A*C) -> A*(B-C)
return NV;
// If this is a 'B = x-(-A)', change to B = x+A. This preserves NSW/NUW.

6
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
View File

@ -984,7 +984,7 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) {
if (Value *V = SimplifyAndInst(Op0, Op1, TD))
return ReplaceInstUsesWith(I, V);
if (Instruction *NV = SimplifyDistributed(I)) // (A|B)&(A|C) -> A|(B&C)
if (Instruction *NV = SimplifyByFactorizing(I)) // (A|B)&(A|C) -> A|(B&C)
return NV;
// See if we can simplify any instructions used by the instruction whose sole
@ -1695,7 +1695,7 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) {
if (Value *V = SimplifyOrInst(Op0, Op1, TD))
return ReplaceInstUsesWith(I, V);
if (Instruction *NV = SimplifyDistributed(I)) // (A&B)|(A&C) -> A&(B|C)
if (Instruction *NV = SimplifyByFactorizing(I)) // (A&B)|(A&C) -> A&(B|C)
return NV;
// See if we can simplify any instructions used by the instruction whose sole
@ -1966,7 +1966,7 @@ Instruction *InstCombiner::visitXor(BinaryOperator &I) {
if (Value *V = SimplifyXorInst(Op0, Op1, TD))
return ReplaceInstUsesWith(I, V);
if (Instruction *NV = SimplifyDistributed(I)) // (A&B)^(A&C) -> A&(B^C)
if (Instruction *NV = SimplifyByFactorizing(I)) // (A&B)^(A&C) -> A&(B^C)
return NV;
// See if we can simplify any instructions used by the instruction whose sole

10
lib/Transforms/InstCombine/InstructionCombining.cpp
View File

@ -288,11 +288,11 @@ static bool RightDistributesOverLeft(Instruction::BinaryOps LOp,
return false;
}
/// SimplifyDistributed - This tries to simplify binary operations which some
/// other binary operation distributes over (eg "A*B+A*C" -> "A*(B+C)" since
/// addition is distributed over by multiplication). Returns the result of
/// the simplification, or null if no simplification was performed.
Instruction *InstCombiner::SimplifyDistributed(BinaryOperator &I) {
/// SimplifyByFactorizing - This tries to simplify binary operations which
/// some other binary operation distributes over by factorizing out a common
/// term (eg "(A*B)+(A*C)" -> "A*(B+C)"). Returns the simplified value, or
/// null if no simplification was performed.
Instruction *InstCombiner::SimplifyByFactorizing(BinaryOperator &I) {
BinaryOperator *Op0 = dyn_cast<BinaryOperator>(I.getOperand(0));
BinaryOperator *Op1 = dyn_cast<BinaryOperator>(I.getOperand(1));
if (!Op0 || !Op1 || Op0->getOpcode() != Op1->getOpcode())