6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-11-01 00:17:01 +00:00
Code Issues Projects Releases Wiki Activity

Remove threading of Xor over selects and phis, with an explanation

Browse Source 
of why such threading is pointless.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@119798 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands
2010-11-19 09:20:39 +00:00
parent 3b0aed19f0
commit 87689cfc54
1 changed files with 18 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
lib/Analysis/InstructionSimplify.cpp
View File

@@ -250,6 +250,16 @@ Value *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
} }
// FIXME: Could pull several more out of instcombine. // FIXME: Could pull several more out of instcombine.
// Threading Add over selects and phi nodes is pointless, so don't bother.
// Threading over the select in "A + select(cond, B, C)" means evaluating
// "A+B" and "A+C" and seeing if they are equal; but they are equal if and
// only if B and C are equal. If B and C are equal then (since we assume
// that operands have already been simplified) "select(cond, B, C)" should
// have been simplified to the common value of B and C already. Analysing
// "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly
// for threading over phi nodes.
return 0; return 0;
} }
@@ -454,19 +464,14 @@ static Value *SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD,
(A == Op0 || B == Op0)) (A == Op0 || B == Op0))
return A == Op0 ? B : A; return A == Op0 ? B : A;
// If the operation is with the result of a select instruction, check whether // Threading Xor over selects and phi nodes is pointless, so don't bother.
// operating on either branch of the select always yields the same value. // Threading over the select in "A ^ select(cond, B, C)" means evaluating
if (MaxRecurse && (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))) // "A^B" and "A^C" and seeing if they are equal; but they are equal if and
if (Value *V = ThreadBinOpOverSelect(Instruction::Xor, Op0, Op1, TD, DT, // only if B and C are equal. If B and C are equal then (since we assume
MaxRecurse-1)) // that operands have already been simplified) "select(cond, B, C)" should
return V; // have been simplified to the common value of B and C already. Analysing
// "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly
// If the operation is with the result of a phi instruction, check whether // for threading over phi nodes.
// operating on all incoming values of the phi always yields the same value.
if (MaxRecurse && (isa<PHINode>(Op0) || isa<PHINode>(Op1)))
if (Value *V = ThreadBinOpOverPHI(Instruction::Xor, Op0, Op1, TD, DT,
MaxRecurse-1))
return V;
return 0; return 0;
} }