6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-13 04:38:24 +00:00
Code Issues Projects Releases Wiki Activity

Create a more targeted fix for not sinking instructions into a range where it

Browse Source 
will conflict with another live range. The place which creates this scenerio is
the code in X86 that lowers a select instruction by splitting the MBBs. This
eliminates the need to check from the bottom up in an MBB for live pregs.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@106066 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling
2010-06-15 23:46:31 +00:00
parent 6102549737
commit d361a77f14
3 changed files with 30 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
lib/CodeGen/MachineSink.cpp
View File

@ -25,7 +25,6 @@
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
@ -62,7 +61,6 @@ namespace {
bool ProcessBlock(MachineBasicBlock &MBB);
bool SinkInstruction(MachineInstr *MI, bool &SawStore);
bool AllUsesDominatedByBlock(unsigned Reg, MachineBasicBlock *MBB) const;
bool LiveOutOfBasicBlock(const MachineInstr *MI, unsigned Reg) const;
};
} // end anonymous namespace
@ -168,44 +166,6 @@ bool MachineSinking::ProcessBlock(MachineBasicBlock &MBB) {
return MadeChange;
}
/// LiveOutOfBasicBlock - Determine if the physical register, defined and dead
/// in MI, is live on exit from the basic block.
bool MachineSinking::LiveOutOfBasicBlock(const MachineInstr *MI,
unsigned Reg) const {
assert(TargetRegisterInfo::isPhysicalRegister(Reg) &&
"Only want to determine if a physical register is live out of a BB!");
const MachineBasicBlock *MBB = MI->getParent();
SmallSet<unsigned, 8> KilledRegs;
MachineBasicBlock::const_iterator I = MBB->end();
MachineBasicBlock::const_iterator E = MBB->begin();
assert(I != E && "How can there be an empty block at this point?!");
// Loop through the instructions bottom-up. If we see a kill of the preg
// first, then it's not live out of the BB. If we see a use or def first, then
// we assume that it is live out of the BB.
do {
const MachineInstr &CurMI = *--I;
for (unsigned i = 0, e = CurMI.getNumOperands(); i != e; ++i) {
const MachineOperand &MO = CurMI.getOperand(i);
if (!MO.isReg()) continue; // Ignore non-register operands.
unsigned MOReg = MO.getReg();
if (MOReg == 0) continue;
if (MOReg == Reg) {
if (MO.isKill())
return false;
if (MO.isUse() || MO.isDef())
return true;
}
}
} while (I != E);
return false;
}
/// SinkInstruction - Determine whether it is safe to sink the specified machine
/// instruction out of its current block into a successor.
bool MachineSinking::SinkInstruction(MachineInstr *MI, bool &SawStore) {
@ -228,7 +188,6 @@ bool MachineSinking::SinkInstruction(MachineInstr *MI, bool &SawStore) {
// SuccToSinkTo - This is the successor to sink this instruction to, once we
// decide.
MachineBasicBlock *SuccToSinkTo = 0;
SmallVector<unsigned, 4> PhysRegs;
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
const MachineOperand &MO = MI->getOperand(i);
@ -257,12 +216,9 @@ bool MachineSinking::SinkInstruction(MachineInstr *MI, bool &SawStore) {
if (AllocatableSet.test(AliasReg))
return false;
}
} else {
if (!MO.isDead())
// A def that isn't dead. We can't move it.
return false;
else
PhysRegs.push_back(Reg);
} else if (!MO.isDead()) {
// A def that isn't dead. We can't move it.
return false;
}
} else {
// Virtual register uses are always safe to sink.
@ -329,10 +285,14 @@ bool MachineSinking::SinkInstruction(MachineInstr *MI, bool &SawStore) {
// If the instruction to move defines a dead physical register which is live
// when leaving the basic block, don't move it because it could turn into a
// "zombie" define of that preg. E.g., EFLAGS. (<rdar://problem/8030636>)
for (SmallVectorImpl<unsigned>::const_iterator
I = PhysRegs.begin(), E = PhysRegs.end(); I != E; ++I)
if (LiveOutOfBasicBlock(MI, *I))
for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {
const MachineOperand &MO = MI->getOperand(I);
if (!MO.isReg()) continue;
unsigned Reg = MO.getReg();
if (Reg == 0 || !TargetRegisterInfo::isPhysicalRegister(Reg)) continue;
if (SuccToSinkTo->isLiveIn(Reg))
return false;
}
DEBUG(dbgs() << "Sink instr " << *MI << "\tinto block " << *SuccToSinkTo);