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

Bring HMEditor into line with LLVM coding standards.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@150851 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Lang Hames
2012-02-17 23:43:40 +00:00
parent 9b5d6b860c
commit ecb50624d1
1 changed files with 161 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

319
lib/CodeGen/LiveIntervalAnalysis.cpp
View File

@@ -1028,254 +1028,257 @@ bool LiveIntervals::checkRegMaskInterference(LiveInterval &LI,
/// HMEditor is a toolkit used by handleMove to trim or extend live intervals. /// HMEditor is a toolkit used by handleMove to trim or extend live intervals.
class LiveIntervals::HMEditor { class LiveIntervals::HMEditor {
private: private:
LiveIntervals& lis; LiveIntervals& LIS;
SlotIndex newIdx; const MachineRegisterInfo& MRI;
const TargetRegisterInfo& TRI;
SlotIndex NewIdx;
public: public:
HMEditor(LiveIntervals& lis, SlotIndex newIdx) HMEditor(LiveIntervals& LIS, const MachineRegisterInfo& MRI,
: lis(lis), newIdx(newIdx) {} const TargetRegisterInfo& TRI, SlotIndex NewIdx)
: LIS(LIS), MRI(MRI), TRI(TRI), NewIdx(NewIdx) {}
// Update lr to be defined at newIdx. Preserves lr. // Update lr to be defined at NewIdx. Preserves lr.
void moveDef(LiveRange& lr, LiveInterval& li) { void moveDef(LiveRange& LR, LiveInterval& LI) {
lr.start = newIdx.getRegSlot(); LR.start = NewIdx.getRegSlot();
lr.valno->def = newIdx.getRegSlot(); LR.valno->def = NewIdx.getRegSlot();
assert(intervalRangesSane(li) && "Broke live interval moving def."); assert(intervalRangesSane(LI) && "Broke live interval moving def.");
} }
// Removes lr from li, inserting a new dead-def range starting at newIdx. // Removes lr from li, inserting a new dead-def range starting at NewIdx.
void moveDeadDefOrEC(LiveRange& lr, LiveInterval& li, bool isEC) { void moveDeadDefOrEC(LiveRange& LR, LiveInterval& LI, bool isEC) {
LiveRange t(lr); LiveRange T(LR);
t.start = newIdx.getRegSlot(isEC); T.start = NewIdx.getRegSlot(isEC);
t.valno->def = newIdx.getRegSlot(isEC); T.valno->def = NewIdx.getRegSlot(isEC);
t.end = isEC ? newIdx.getRegSlot() : newIdx.getDeadSlot(); T.end = isEC ? NewIdx.getRegSlot() : NewIdx.getDeadSlot();
li.removeRange(lr); LI.removeRange(LR);
li.addRange(t); LI.addRange(T);
assert(intervalRangesSane(li) && "Broke live interval moving dead def."); assert(intervalRangesSane(LI) && "Broke live interval moving dead def.");
} }
void moveUseDown(SlotIndex oldIdx, LiveRange& lr, LiveInterval& li, void moveUseDown(SlotIndex OldIdx, LiveRange& LR, LiveInterval& LI,
const MachineBasicBlock* mbb) { const MachineBasicBlock* MBB) {
bool liveThrough = lr.end > oldIdx.getRegSlot(); bool LiveThrough = LR.end > OldIdx.getRegSlot();
if (!liveThrough) { if (!LiveThrough) {
// Easy fix - just update the range endpoint. // Easy fix - just update the range endpoint.
lr.end = newIdx.getRegSlot(); LR.end = NewIdx.getRegSlot();
} else { } else {
bool liveOut = lr.end >= lis.getSlotIndexes()->getMBBEndIdx(mbb); bool LiveOut = LR.end >= LIS.getSlotIndexes()->getMBBEndIdx(MBB);
if (!liveOut) { if (!LiveOut) {
moveKillFlags(li.reg, lr.end, newIdx); moveKillFlags(LI.reg, LR.end, NewIdx);
lr.end = newIdx.getRegSlot(); LR.end = NewIdx.getRegSlot();
} }
} }
assert(intervalRangesSane(li) && "Broke live interval moving use."); assert(intervalRangesSane(LI) && "Broke live interval moving use.");
} }
void moveUseUp(SlotIndex oldIdx, LiveRange& lr, LiveInterval& li) { void moveUseUp(SlotIndex OldIdx, LiveRange& LR, LiveInterval& LI) {
bool liveThrough = lr.end > oldIdx.getRegSlot(); bool LiveThrough = LR.end > OldIdx.getRegSlot();
if (liveThrough) if (LiveThrough)
return; // If we moving up and live through there's nothing to do. return; // If we moving up and live through there's nothing to do.
SlotIndex lastUseInRange = newIdx.getRegSlot(); SlotIndex LastUseInRange = NewIdx.getRegSlot();
for (MachineRegisterInfo::use_nodbg_iterator for (MachineRegisterInfo::use_nodbg_iterator
useI = lis.mri_->use_nodbg_begin(li.reg), UI = MRI.use_nodbg_begin(LI.reg),
useE = lis.mri_->use_nodbg_end(); UE = MRI.use_nodbg_end();
useI != useE; ++useI) { UI != UE; ++UI) {
const MachineInstr* mopI = &*useI; const MachineInstr* MI = &*UI;
const MachineOperand& mop = useI.getOperand(); const MachineOperand& MO = UI.getOperand();
SlotIndex instSlot = lis.getSlotIndexes()->getInstructionIndex(mopI); SlotIndex InstSlot = LIS.getSlotIndexes()->getInstructionIndex(MI);
SlotIndex opSlot = instSlot.getRegSlot(mop.isEarlyClobber()); SlotIndex OpSlot = InstSlot.getRegSlot(MO.isEarlyClobber());
if (opSlot > lastUseInRange && opSlot < oldIdx) if (OpSlot > LastUseInRange && OpSlot < OldIdx)
lastUseInRange = opSlot; LastUseInRange = OpSlot;
} }
// If we found a new instr endpoint update the kill flags. // If we found a new instr endpoint update the kill flags.
if (lastUseInRange != newIdx.getRegSlot()) if (LastUseInRange != NewIdx.getRegSlot())
moveKillFlags(li.reg, newIdx, lastUseInRange); moveKillFlags(LI.reg, NewIdx, LastUseInRange);
// Fix up the range end. // Fix up the range end.
lr.end = lastUseInRange; LR.end = LastUseInRange;
assert(intervalRangesSane(li) && "Broke live interval moving use."); assert(intervalRangesSane(LI) && "Broke live interval moving use.");
} }
// Update intervals for all operands of mi from oldIndex to newIndex. // Update intervals for all operands of mi from oldIndex to newIndex.
void moveAllOperandsFrom(MachineInstr* mi, SlotIndex oldIdx) { void moveAllOperandsFrom(MachineInstr* MI, SlotIndex OldIdx) {
// Figure out the direction we're moving. // Figure out the direction we're moving.
bool movingUp = newIdx < oldIdx; bool MovingUp = NewIdx < OldIdx;
// Collect the operands. // Collect the operands.
DenseSet<unsigned> uses, defs, deadDefs, ecs; DenseSet<unsigned> Uses, Defs, DeadDefs, ECs;
for (MachineInstr::mop_iterator mopItr = mi->operands_begin(), for (MachineInstr::mop_iterator MOI = MI->operands_begin(),
mopEnd = mi->operands_end(); MOE = MI->operands_end();
mopItr != mopEnd; ++mopItr) { MOI != MOE; ++MOI) {
const MachineOperand& mop = *mopItr; const MachineOperand& MO = *MOI;
if (mop.isRegMask()) { if (MO.isRegMask()) {
updateRegMaskSlots(oldIdx); updateRegMaskSlots(OldIdx);
continue; continue;
} }
if (!mop.isReg() || mop.getReg() == 0) if (!MO.isReg() || MO.getReg() == 0)
continue; continue;
unsigned reg = mop.getReg(); unsigned Reg = MO.getReg();
// TODO: Currently we're skipping uses that are reserved or have no // TODO: Currently we're skipping uses that are reserved or have no
// interval, but we're not updating their kills. This should be // interval, but we're not updating their kills. This should be
// fixed. // fixed.
if (!lis.hasInterval(reg) || if (!LIS.hasInterval(Reg) ||
(TargetRegisterInfo::isPhysicalRegister(reg) && lis.isReserved(reg))) (TargetRegisterInfo::isPhysicalRegister(Reg) && LIS.isReserved(Reg)))
continue; continue;
if (mop.readsReg() && !ecs.count(reg)) { if (MO.readsReg() && !ECs.count(Reg)) {
uses.insert(reg); Uses.insert(Reg);
} }
if (mop.isDef()) { if (MO.isDef()) {
if (mop.isDead()) { if (MO.isDead()) {
assert(!defs.count(reg) && "Can't mix defs with dead-defs."); assert(!Defs.count(Reg) && "Can't mix defs with dead-defs.");
deadDefs.insert(reg); DeadDefs.insert(Reg);
} else if (mop.isEarlyClobber()) { } else if (MO.isEarlyClobber()) {
uses.erase(reg); Uses.erase(Reg);
ecs.insert(reg); ECs.insert(Reg);
} else { } else {
assert(!deadDefs.count(reg) && "Can't mix defs with dead-defs."); assert(!DeadDefs.count(Reg) && "Can't mix defs with dead-defs.");
defs.insert(reg); Defs.insert(Reg);
} }
} }
} }
if (movingUp) { if (MovingUp) {
moveUsesUp(oldIdx, uses); moveUsesUp(OldIdx, Uses);
moveECs(oldIdx, ecs); moveECs(OldIdx, ECs);
moveDeadDefs(oldIdx, deadDefs); moveDeadDefs(OldIdx, DeadDefs);
moveDefs(oldIdx, defs); moveDefs(OldIdx, Defs);
} else { } else {
moveDefs(oldIdx, defs); moveDefs(OldIdx, Defs);
moveDeadDefs(oldIdx, deadDefs); moveDeadDefs(OldIdx, DeadDefs);
moveECs(oldIdx, ecs); moveECs(OldIdx, ECs);
moveUsesDown(oldIdx, uses, mi->getParent()); moveUsesDown(OldIdx, Uses, MI->getParent());
} }
} }
private: private:
#ifndef NDEBUG #ifndef NDEBUG
bool intervalRangesSane(const LiveInterval& li) { bool intervalRangesSane(const LiveInterval& LI) {
if (li.empty()) { if (LI.empty()) {
return true; return true;
} }
SlotIndex lastEnd = li.begin()->start; SlotIndex LastEnd = LI.begin()->start;
for (LiveInterval::const_iterator lrItr = li.begin(), lrEnd = li.end(); for (LiveInterval::const_iterator LRI = LI.begin(), LRE = LI.end();
lrItr != lrEnd; ++lrItr) { LRI != LRE; ++LRI) {
const LiveRange& lr = *lrItr; const LiveRange& LR = *LRI;
if (lastEnd > lr.start || lr.start >= lr.end) if (LastEnd > LR.start || LR.start >= LR.end)
return false; return false;
lastEnd = lr.end; LastEnd = LR.end;
} }
return true; return true;
} }
#endif #endif
void moveKillFlags(unsigned reg, SlotIndex oldIdx, SlotIndex newKillIdx) { void moveKillFlags(unsigned reg, SlotIndex OldIdx, SlotIndex newKillIdx) {
MachineInstr* oldKillMI = lis.getInstructionFromIndex(oldIdx); MachineInstr* OldKillMI = LIS.getInstructionFromIndex(OldIdx);
if (!oldKillMI->killsRegister(reg)) if (!OldKillMI->killsRegister(reg))
return; // Bail out if we don't have kill flags on the old register. return; // Bail out if we don't have kill flags on the old register.
MachineInstr* newKillMI = lis.getInstructionFromIndex(newKillIdx); MachineInstr* NewKillMI = LIS.getInstructionFromIndex(newKillIdx);
assert(oldKillMI->killsRegister(reg) && "Old 'kill' instr isn't a kill."); assert(OldKillMI->killsRegister(reg) && "Old 'kill' instr isn't a kill.");
assert(!newKillMI->killsRegister(reg) && "New kill instr is already a kill."); assert(!NewKillMI->killsRegister(reg) && "New kill instr is already a kill.");
oldKillMI->clearRegisterKills(reg, lis.tri_); OldKillMI->clearRegisterKills(reg, &TRI);
newKillMI->addRegisterKilled(reg, lis.tri_); NewKillMI->addRegisterKilled(reg, &TRI);
} }
template <typename DefSetT> template <typename DefSetT>
void moveDefs(SlotIndex oldIdx, const DefSetT& defs) { void moveDefs(SlotIndex OldIdx, const DefSetT& Defs) {
typedef typename DefSetT::const_iterator DefItr; typedef typename DefSetT::const_iterator DefItr;
for (DefItr di = defs.begin(), de = defs.end(); di != de; ++di) { for (DefItr DI = Defs.begin(), DE = Defs.end(); DI != DE; ++DI) {
unsigned def = *di; unsigned Def = *DI;
LiveInterval& li = lis.getInterval(def); LiveInterval& LI = LIS.getInterval(Def);
LiveRange* lr = li.getLiveRangeContaining(oldIdx.getRegSlot()); LiveRange* LR = LI.getLiveRangeContaining(OldIdx.getRegSlot());
assert(lr != 0 && "No range?"); assert(LR != 0 && "No range?");
moveDef(*lr, li); moveDef(*LR, LI);
} }
} }
template <typename DeadDefSetT> template <typename DeadDefSetT>
void moveDeadDefs(SlotIndex oldIdx, const DeadDefSetT& deadDefs) { void moveDeadDefs(SlotIndex OldIdx, const DeadDefSetT& DeadDefs) {
typedef typename DeadDefSetT::const_iterator DeadDefItr; typedef typename DeadDefSetT::const_iterator DeadDefItr;
for (DeadDefItr di = deadDefs.begin(),de = deadDefs.end(); di != de; ++di) { for (DeadDefItr DI = DeadDefs.begin(),DE = DeadDefs.end(); DI != DE; ++DI) {
unsigned deadDef = *di; unsigned DeadDef = *DI;
LiveInterval& li = lis.getInterval(deadDef); LiveInterval& LI = LIS.getInterval(DeadDef);
LiveRange* lr = li.getLiveRangeContaining(oldIdx.getRegSlot()); LiveRange* LR = LI.getLiveRangeContaining(OldIdx.getRegSlot());
assert(lr != 0 && "No range for dead def?"); assert(LR != 0 && "No range for dead def?");
assert(lr->start == oldIdx.getRegSlot() && "Bad dead range start?"); assert(LR->start == OldIdx.getRegSlot() && "Bad dead range start?");
assert(lr->end == oldIdx.getDeadSlot() && "Bad dead range end?"); assert(LR->end == OldIdx.getDeadSlot() && "Bad dead range end?");
assert(lr->valno->def == oldIdx.getRegSlot() && "Bad dead valno def."); assert(LR->valno->def == OldIdx.getRegSlot() && "Bad dead valno def.");
moveDeadDefOrEC(*lr, li, false); moveDeadDefOrEC(*LR, LI, false);
} }
} }
template <typename ECSetT> template <typename ECSetT>
void moveECs(SlotIndex oldIdx, const ECSetT& ecs) { void moveECs(SlotIndex OldIdx, const ECSetT& ECs) {
typedef typename ECSetT::const_iterator ECItr; typedef typename ECSetT::const_iterator ECItr;
for (ECItr eci = ecs.begin(), ece = ecs.end(); eci != ece; ++eci) { for (ECItr EI = ECs.begin(), EE = ECs.end(); EI != EE; ++EI) {
unsigned ec = *eci; unsigned EC = *EI;
LiveInterval& li = lis.getInterval(ec); LiveInterval& LI = LIS.getInterval(EC);
LiveRange* lr = li.getLiveRangeContaining(oldIdx.getRegSlot(true)); LiveRange* LR = LI.getLiveRangeContaining(OldIdx.getRegSlot(true));
assert(lr != 0 && "No range for early clobber?"); assert(LR != 0 && "No range for early clobber?");
assert(lr->start == oldIdx.getRegSlot(true) && "Bad EC range start?"); assert(LR->start == OldIdx.getRegSlot(true) && "Bad EC range start?");
assert(lr->end == oldIdx.getRegSlot() && "Bad EC range end."); assert(LR->end == OldIdx.getRegSlot() && "Bad EC range end.");
assert(lr->valno->def == oldIdx.getRegSlot(true) && "Bad EC valno def."); assert(LR->valno->def == OldIdx.getRegSlot(true) && "Bad EC valno def.");
moveDeadDefOrEC(*lr, li, true); moveDeadDefOrEC(*LR, LI, true);
} }
} }
template <typename UseSetT> template <typename UsesetT>
void moveUsesUp(SlotIndex oldIdx, const UseSetT &uses) { void moveUsesUp(SlotIndex OldIdx, const UsesetT &Uses) {
typedef typename UseSetT::const_iterator UseItr; typedef typename UsesetT::const_iterator UseItr;
for (UseItr ui = uses.begin(), ue = uses.end(); ui != ue; ++ui) { for (UseItr UI = Uses.begin(), UE = Uses.end(); UI != UE; ++UI) {
unsigned use = *ui; unsigned Use = *UI;
LiveInterval& li = lis.getInterval(use); LiveInterval& LI = LIS.getInterval(Use);
LiveRange* lr = li.getLiveRangeBefore(oldIdx.getRegSlot()); LiveRange* LR = LI.getLiveRangeBefore(OldIdx.getRegSlot());
assert(lr != 0 && "No range for use?"); assert(LR != 0 && "No range for use?");
moveUseUp(oldIdx, *lr, li); moveUseUp(OldIdx, *LR, LI);
} }
} }
template <typename UseSetT> template <typename UsesetT>
void moveUsesDown(SlotIndex oldIdx, const UseSetT &uses, void moveUsesDown(SlotIndex OldIdx, const UsesetT &Uses,
const MachineBasicBlock* mbb) { const MachineBasicBlock* MBB) {
typedef typename UseSetT::const_iterator UseItr; typedef typename UsesetT::const_iterator UseItr;
for (UseItr ui = uses.begin(), ue = uses.end(); ui != ue; ++ui) { for (UseItr UI = Uses.begin(), UE = Uses.end(); UI != UE; ++UI) {
unsigned use = *ui; unsigned Use = *UI;
LiveInterval& li = lis.getInterval(use); LiveInterval& LI = LIS.getInterval(Use);
LiveRange* lr = li.getLiveRangeBefore(oldIdx.getRegSlot()); LiveRange* LR = LI.getLiveRangeBefore(OldIdx.getRegSlot());
assert(lr != 0 && "No range for use?"); assert(LR != 0 && "No range for use?");
moveUseDown(oldIdx, *lr, li, mbb); moveUseDown(OldIdx, *LR, LI, MBB);
} }
} }
void updateRegMaskSlots(SlotIndex oldIdx) { void updateRegMaskSlots(SlotIndex OldIdx) {
SmallVectorImpl<SlotIndex>::iterator rmItr = SmallVectorImpl<SlotIndex>::iterator RI =
std::lower_bound(lis.RegMaskSlots.begin(), lis.RegMaskSlots.end(), std::lower_bound(LIS.RegMaskSlots.begin(), LIS.RegMaskSlots.end(),
oldIdx); OldIdx);
assert(*rmItr == oldIdx && "No RegMask at oldIdx."); assert(*RI == OldIdx && "No RegMask at OldIdx.");
*rmItr = newIdx; *RI = NewIdx;
assert(*prior(rmItr) < *rmItr && *rmItr < *next(rmItr) && assert(*prior(RI) < *RI && *RI < *next(RI) &&
"RegSlots out of order. Did you move one call across another?"); "RegSlots out of order. Did you move one call across another?");
} }
}; };
void LiveIntervals::handleMove(MachineInstr* mi) { void LiveIntervals::handleMove(MachineInstr* MI) {
SlotIndex oldIndex = indexes_->getInstructionIndex(mi); SlotIndex OldIndex = indexes_->getInstructionIndex(MI);
indexes_->removeMachineInstrFromMaps(mi); indexes_->removeMachineInstrFromMaps(MI);
SlotIndex newIndex = mi->isInsideBundle() ? SlotIndex NewIndex = MI->isInsideBundle() ?
indexes_->getInstructionIndex(mi->getBundleStart()) : indexes_->getInstructionIndex(MI->getBundleStart()) :
indexes_->insertMachineInstrInMaps(mi); indexes_->insertMachineInstrInMaps(MI);
assert(getMBBStartIdx(mi->getParent()) <= oldIndex && assert(getMBBStartIdx(MI->getParent()) <= OldIndex &&
oldIndex < getMBBEndIdx(mi->getParent()) && OldIndex < getMBBEndIdx(MI->getParent()) &&
"Cannot handle moves across basic block boundaries."); "Cannot handle moves across basic block boundaries.");
assert(!mi->isBundled() && "Can't handle bundled instructions yet."); assert(!MI->isBundled() && "Can't handle bundled instructions yet.");
HMEditor hme(*this, newIndex); HMEditor HME(*this, *mri_, *tri_, NewIndex);
hme.moveAllOperandsFrom(mi, oldIndex); HME.moveAllOperandsFrom(MI, OldIndex);
} }