6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-08-14 15:28:20 +00:00
Code Issues Projects Releases Wiki Activity

Fix some really nasty dominance bugs that were exposed by my patch to

Browse Source 
make the verifier more strict.  This fixes building zlib


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@13002 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2004-04-16 18:08:07 +00:00
parent ea51deb18a
commit 657253119e
1 changed files with 12 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@@ -397,30 +397,6 @@ Instruction *AssociativeOpt(BinaryOperator &Root, const Functor &F) {
// reassociate the expression from ((? op A) op B) to (? op (A op B)) // reassociate the expression from ((? op A) op B) to (? op (A op B))
if (ShouldApply) { if (ShouldApply) {
BasicBlock *BB = Root.getParent(); BasicBlock *BB = Root.getParent();
// All of the instructions have a single use and have no side-effects,
// because of this, we can pull them all into the current basic block.
if (LHSI->getParent() != BB) {
// Move all of the instructions from root to LHSI into the current
// block.
Instruction *TmpLHSI = cast<Instruction>(Root.getOperand(0));
Instruction *LastUse = &Root;
while (TmpLHSI->getParent() == BB) {
LastUse = TmpLHSI;
TmpLHSI = cast<Instruction>(TmpLHSI->getOperand(0));
}
// Loop over all of the instructions in other blocks, moving them into
// the current one.
Value *TmpLHS = TmpLHSI;
do {
TmpLHSI = cast<Instruction>(TmpLHS);
// Remove from current block...
TmpLHSI->getParent()->getInstList().remove(TmpLHSI);
// Insert before the last instruction...
BB->getInstList().insert(LastUse, TmpLHSI);
TmpLHS = TmpLHSI->getOperand(0);
} while (TmpLHSI != LHSI);
}
// Now all of the instructions are in the current basic block, go ahead // Now all of the instructions are in the current basic block, go ahead
// and perform the reassociation. // and perform the reassociation.
@@ -431,20 +407,27 @@ Instruction *AssociativeOpt(BinaryOperator &Root, const Functor &F) {
// Make what used to be the LHS of the root be the user of the root... // Make what used to be the LHS of the root be the user of the root...
Value *ExtraOperand = TmpLHSI->getOperand(1); Value *ExtraOperand = TmpLHSI->getOperand(1);
if (&Root != TmpLHSI) if (&Root == TmpLHSI) {
Root.replaceAllUsesWith(TmpLHSI); // Users now use TmpLHSI
else {
Root.replaceAllUsesWith(Constant::getNullValue(TmpLHSI->getType())); Root.replaceAllUsesWith(Constant::getNullValue(TmpLHSI->getType()));
return 0; return 0;
} }
Root.replaceAllUsesWith(TmpLHSI); // Users now use TmpLHSI
TmpLHSI->setOperand(1, &Root); // TmpLHSI now uses the root TmpLHSI->setOperand(1, &Root); // TmpLHSI now uses the root
BB->getInstList().remove(&Root); // Remove root from the BB TmpLHSI->getParent()->getInstList().remove(TmpLHSI);
BB->getInstList().insert(TmpLHSI, &Root); // Insert root before TmpLHSI BasicBlock::iterator ARI = &Root; ++ARI;
BB->getInstList().insert(ARI, TmpLHSI); // Move TmpLHSI to after Root
ARI = Root;
// Now propagate the ExtraOperand down the chain of instructions until we // Now propagate the ExtraOperand down the chain of instructions until we
// get to LHSI. // get to LHSI.
while (TmpLHSI != LHSI) { while (TmpLHSI != LHSI) {
Instruction *NextLHSI = cast<Instruction>(TmpLHSI->getOperand(0)); Instruction *NextLHSI = cast<Instruction>(TmpLHSI->getOperand(0));
// Move the instruction to immediately before the chain we are
// constructing to avoid breaking dominance properties.
NextLHSI->getParent()->getInstList().remove(NextLHSI);
BB->getInstList().insert(ARI, NextLHSI);
ARI = NextLHSI;
Value *NextOp = NextLHSI->getOperand(1); Value *NextOp = NextLHSI->getOperand(1);
NextLHSI->setOperand(1, ExtraOperand); NextLHSI->setOperand(1, ExtraOperand);
TmpLHSI = NextLHSI; TmpLHSI = NextLHSI;