diff options
author | Dale Johannesen <dalej@apple.com> | 2008-09-19 01:02:35 +0000 |
---|---|---|
committer | Dale Johannesen <dalej@apple.com> | 2008-09-19 01:02:35 +0000 |
commit | fa48f941304f29f967e0a7fc6807d7026ba99b7b (patch) | |
tree | a8f9875394aebdba26f7d1b2f886ead96f181e1f /lib/CodeGen | |
parent | 4fe0fe8b493437e91f8510b81462ff39f0d889ca (diff) | |
download | external_llvm-fa48f941304f29f967e0a7fc6807d7026ba99b7b.zip external_llvm-fa48f941304f29f967e0a7fc6807d7026ba99b7b.tar.gz external_llvm-fa48f941304f29f967e0a7fc6807d7026ba99b7b.tar.bz2 |
Remove AsmThatEarlyClobber etc. from LiveIntervalAnalysis
and redo as linked list walk. Logic moved into RA.
Per review feedback.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@56326 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/CodeGen')
-rw-r--r-- | lib/CodeGen/LiveInterval.cpp | 4 | ||||
-rw-r--r-- | lib/CodeGen/LiveIntervalAnalysis.cpp | 75 | ||||
-rw-r--r-- | lib/CodeGen/RegAllocLinearScan.cpp | 73 |
3 files changed, 79 insertions, 73 deletions
diff --git a/lib/CodeGen/LiveInterval.cpp b/lib/CodeGen/LiveInterval.cpp index ff430d7..06e9722 100644 --- a/lib/CodeGen/LiveInterval.cpp +++ b/lib/CodeGen/LiveInterval.cpp @@ -686,6 +686,10 @@ void LiveInterval::print(std::ostream &OS, OS << "%reg" << reg; OS << ',' << weight; + if (isEarlyClobber) + OS << ",earlyclobber"; + if (overlapsEarlyClobber) + OS << ",overlapsearly"; if (empty()) OS << " EMPTY"; diff --git a/lib/CodeGen/LiveIntervalAnalysis.cpp b/lib/CodeGen/LiveIntervalAnalysis.cpp index cb83194..2a23d49 100644 --- a/lib/CodeGen/LiveIntervalAnalysis.cpp +++ b/lib/CodeGen/LiveIntervalAnalysis.cpp @@ -674,8 +674,6 @@ exit: /// live interval is an interval [i, j) where 1 <= i <= j < N for /// which a variable is live void LiveIntervals::computeIntervals() { - AsmsThatEarlyClobber.clear(); - AsmsWithEarlyClobberConflict.clear(); DOUT << "********** COMPUTING LIVE INTERVALS **********\n" << "********** Function: " @@ -716,13 +714,15 @@ void LiveIntervals::computeIntervals() { if (MO.isRegister() && MO.getReg() && MO.isDef()) { handleRegisterDef(MBB, MI, MIIndex, MO, i); if (MO.isEarlyClobber()) { - AsmsThatEarlyClobber.insert(std::make_pair(MO.getReg(), MI)); + LiveInterval &interval = getOrCreateInterval(MO.getReg()); + interval.isEarlyClobber = true; } } if (MO.isRegister() && !MO.isDef() && MO.getReg() && TargetRegisterInfo::isVirtualRegister(MO.getReg()) && MO.overlapsEarlyClobber()) { - AsmsWithEarlyClobberConflict.insert(std::make_pair(MO.getReg(), MI)); + LiveInterval &interval = getOrCreateInterval(MO.getReg()); + interval.overlapsEarlyClobber = true; } } @@ -752,73 +752,6 @@ bool LiveIntervals::findLiveInMBBs(const LiveRange &LR, return ResVal; } -/// noEarlyclobberConflict - see whether virtual reg VReg has a conflict with -/// hard reg HReg because of earlyclobbers. -/// -/// Earlyclobber operands may not be assigned the same register as -/// each other, or as earlyclobber-conflict operands (i.e. those that -/// are non-earlyclobbered inputs to an asm that also has earlyclobbers). -/// -/// Thus there are two cases to check for: -/// 1. VReg is an earlyclobber-conflict register and HReg is an earlyclobber -/// register in some asm that also has VReg as an input. -/// 2. VReg is an earlyclobber register and HReg is an earlyclobber-conflict -/// input elsewhere in some asm. -/// In both cases HReg can be assigned by the user, or assigned early in -/// register allocation. -/// -/// Dropping the distinction between earlyclobber and earlyclobber-conflict, -/// keeping only one multimap, looks promising, but two earlyclobber-conflict -/// operands may be assigned the same register if they happen to contain the -/// same value, and that implementation would prevent this. -/// -bool LiveIntervals::noEarlyclobberConflict(unsigned VReg, VirtRegMap &vrm, - unsigned HReg) { - typedef std::multimap<unsigned, MachineInstr*>::iterator It; - - // Short circuit the most common case. - if (AsmsWithEarlyClobberConflict.size()!=0) { - std::pair<It, It> x = AsmsWithEarlyClobberConflict.equal_range(VReg); - for (It I = x.first; I!=x.second; I++) { - MachineInstr* MI = I->second; - for (int i = MI->getNumOperands() - 1; i >= 0; --i) { - MachineOperand &MO = MI->getOperand(i); - if (MO.isRegister() && MO.isEarlyClobber()) { - unsigned PhysReg = MO.getReg(); - if (PhysReg && TargetRegisterInfo::isVirtualRegister(PhysReg)) { - if (!vrm.hasPhys(PhysReg)) - continue; - PhysReg = vrm.getPhys(PhysReg); - } - if (PhysReg==HReg) - return false; - } - } - } - } - // Short circuit the most common case. - if (AsmsThatEarlyClobber.size()!=0) { - std::pair<It, It> x = AsmsThatEarlyClobber.equal_range(VReg); - for (It I = x.first; I!=x.second; I++) { - MachineInstr* MI = I->second; - for (int i = MI->getNumOperands() - 1; i >= 0; --i) { - MachineOperand &MO = MI->getOperand(i); - if (MO.isRegister() && MO.overlapsEarlyClobber()) { - unsigned PhysReg = MO.getReg(); - if (PhysReg && TargetRegisterInfo::isVirtualRegister(PhysReg)) { - if (!vrm.hasPhys(PhysReg)) - continue; - PhysReg = vrm.getPhys(PhysReg); - } - if (PhysReg==HReg) - return false; - } - } - } - } - return true; -} - LiveInterval* LiveIntervals::createInterval(unsigned reg) { float Weight = TargetRegisterInfo::isPhysicalRegister(reg) ? HUGE_VALF : 0.0F; diff --git a/lib/CodeGen/RegAllocLinearScan.cpp b/lib/CodeGen/RegAllocLinearScan.cpp index 0279db6..af70db8 100644 --- a/lib/CodeGen/RegAllocLinearScan.cpp +++ b/lib/CodeGen/RegAllocLinearScan.cpp @@ -173,6 +173,8 @@ namespace { void ComputeRelatedRegClasses(); + bool noEarlyClobberConflict(LiveInterval *cur, unsigned RegNo); + template <typename ItTy> void printIntervals(const char* const str, ItTy i, ItTy e) const { if (str) DOUT << str << " intervals:\n"; @@ -1001,6 +1003,73 @@ void RALinScan::assignRegOrStackSlotAtInterval(LiveInterval* cur) unhandled_.push(added[i]); } +/// noEarlyClobberConflict - see whether LiveInternal cur has a conflict with +/// hard reg HReg because of earlyclobbers. +/// +/// Earlyclobber operands may not be assigned the same register as +/// each other, or as earlyclobber-conflict operands (i.e. those that +/// are non-earlyclobbered inputs to an asm that also has earlyclobbers). +/// +/// Thus there are two cases to check for: +/// 1. cur->reg is an earlyclobber-conflict register and HReg is an +/// earlyclobber register in some asm that also has cur->reg as an input. +/// 2. cur->reg is an earlyclobber register and HReg is an +/// earlyclobber-conflict input, or a different earlyclobber register, +/// elsewhere in some asm. +/// In both cases HReg can be assigned by the user, or assigned early in +/// register allocation. +/// +/// Dropping the distinction between earlyclobber and earlyclobber-conflict, +/// keeping only one bit, looks promising, but two earlyclobber-conflict +/// operands may be assigned the same register if they happen to contain the +/// same value, and that implementation would prevent this. +/// +bool RALinScan::noEarlyClobberConflict(LiveInterval *cur, unsigned HReg) { + if (cur->overlapsEarlyClobber) { + for (MachineRegisterInfo::use_iterator I = mri_->use_begin(cur->reg), + E = mri_->use_end(); I!=E; ++I) { + MachineInstr *MI = I.getOperand().getParent(); + if (MI->getOpcode()==TargetInstrInfo::INLINEASM) { + for (int i = MI->getNumOperands()-1; i>=0; --i) { + MachineOperand &MO = MI->getOperand(i); + if (MO.isRegister() && MO.getReg() && MO.isEarlyClobber() && + HReg==MO.getReg()) { + DOUT << " earlyclobber conflict: " << + "%reg" << cur->reg << ", " << tri_->getName(HReg) << "\n\t"; + return false; + } + } + } + } + } + if (cur->isEarlyClobber) { + for (MachineRegisterInfo::def_iterator I = mri_->def_begin(cur->reg), + E = mri_->def_end(); I!=E; ++I) { + MachineInstr *MI = I.getOperand().getParent(); + if (MI->getOpcode()==TargetInstrInfo::INLINEASM) { + // make sure cur->reg is really clobbered in this instruction. + bool earlyClobberFound = false, overlapFound = false; + for (int i = MI->getNumOperands()-1; i>=0; --i) { + MachineOperand &MO = MI->getOperand(i); + if (MO.isRegister() && MO.getReg()) { + if ((MO.overlapsEarlyClobber() || MO.isEarlyClobber()) && + HReg==MO.getReg()) + overlapFound = true; + if (MO.isEarlyClobber() && cur->reg==MO.getReg()) + earlyClobberFound = true; + } + } + if (earlyClobberFound && overlapFound) { + DOUT << " earlyclobber conflict: " << + "%reg" << cur->reg << ", " << tri_->getName(HReg) << "\n\t"; + return false; + } + } + } + } + return true; +} + /// getFreePhysReg - return a free physical register for this virtual register /// interval if we have one, otherwise return 0. unsigned RALinScan::getFreePhysReg(LiveInterval *cur) { @@ -1049,7 +1118,7 @@ unsigned RALinScan::getFreePhysReg(LiveInterval *cur) { assert(I != E && "No allocatable register in this register class!"); for (; I != E; ++I) if (prt_->isRegAvail(*I) && - li_->noEarlyclobberConflict(cur->reg, *vrm_, *I)) { + noEarlyClobberConflict(cur, *I)) { FreeReg = *I; if (FreeReg < inactiveCounts.size()) FreeRegInactiveCount = inactiveCounts[FreeReg]; @@ -1070,7 +1139,7 @@ unsigned RALinScan::getFreePhysReg(LiveInterval *cur) { unsigned Reg = *I; if (prt_->isRegAvail(Reg) && Reg < inactiveCounts.size() && FreeRegInactiveCount < inactiveCounts[Reg] && - li_->noEarlyclobberConflict(cur->reg, *vrm_, Reg)) { + noEarlyClobberConflict(cur, *I)) { FreeReg = Reg; FreeRegInactiveCount = inactiveCounts[Reg]; if (FreeRegInactiveCount == MaxInactiveCount) |