From 8b0b8749875cd20fc694f7550a62ed517fe2cd9c Mon Sep 17 00:00:00 2001 From: Evan Cheng Date: Tue, 16 Oct 2007 08:04:24 +0000 Subject: [PATCH] Code clean up. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@43026 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../llvm/CodeGen/SimpleRegisterCoalescing.h | 5 +-- lib/CodeGen/SimpleRegisterCoalescing.cpp | 40 +++++++++++++------ 2 files changed, 29 insertions(+), 16 deletions(-) diff --git a/include/llvm/CodeGen/SimpleRegisterCoalescing.h b/include/llvm/CodeGen/SimpleRegisterCoalescing.h index 00095dd1761..93d3e1da219 100644 --- a/include/llvm/CodeGen/SimpleRegisterCoalescing.h +++ b/include/llvm/CodeGen/SimpleRegisterCoalescing.h @@ -100,7 +100,7 @@ namespace llvm { /// CopyCoalesceInMBB - Coalesce copies in the specified MBB, putting /// copies that cannot yet be coalesced into the "TryAgain" list. void CopyCoalesceInMBB(MachineBasicBlock *MBB, - std::vector *TryAgain, bool PhysOnly = false); + std::vector &TryAgain); /// JoinCopy - Attempt to join intervals corresponding to SrcReg/DstReg, /// which are the src/dst of the copy instruction CopyMI. This returns true @@ -108,8 +108,7 @@ namespace llvm { /// to coalesce these this copy, due to register constraints. It returns /// false if it is not currently possible to coalesce this interval, but /// it may be possible if other things get coalesced. - bool JoinCopy(MachineInstr *CopyMI, unsigned SrcReg, unsigned DstReg, - bool PhysOnly = false); + bool JoinCopy(MachineInstr *CopyMI, unsigned SrcReg, unsigned DstReg); /// JoinIntervals - Attempt to join these two intervals. On failure, this /// returns false. Otherwise, if one of the intervals being joined is a diff --git a/lib/CodeGen/SimpleRegisterCoalescing.cpp b/lib/CodeGen/SimpleRegisterCoalescing.cpp index 4a4df913a19..0c1db899d3b 100644 --- a/lib/CodeGen/SimpleRegisterCoalescing.cpp +++ b/lib/CodeGen/SimpleRegisterCoalescing.cpp @@ -192,7 +192,7 @@ bool SimpleRegisterCoalescing::AdjustCopiesBackFrom(LiveInterval &IntA, LiveInte /// false if it is not currently possible to coalesce this interval, but /// it may be possible if other things get coalesced. bool SimpleRegisterCoalescing::JoinCopy(MachineInstr *CopyMI, - unsigned SrcReg, unsigned DstReg, bool PhysOnly) { + unsigned SrcReg, unsigned DstReg) { DOUT << li_->getInstructionIndex(CopyMI) << '\t' << *CopyMI; // Get representative registers. @@ -207,9 +207,6 @@ bool SimpleRegisterCoalescing::JoinCopy(MachineInstr *CopyMI, bool SrcIsPhys = MRegisterInfo::isPhysicalRegister(repSrcReg); bool DstIsPhys = MRegisterInfo::isPhysicalRegister(repDstReg); - if (PhysOnly && !SrcIsPhys && !DstIsPhys) - // Only joining physical registers with virtual registers in this round. - return true; // If they are both physical registers, we cannot join them. if (SrcIsPhys && DstIsPhys) { @@ -932,9 +929,11 @@ namespace { } void SimpleRegisterCoalescing::CopyCoalesceInMBB(MachineBasicBlock *MBB, - std::vector *TryAgain, bool PhysOnly) { + std::vector &TryAgain) { DOUT << ((Value*)MBB->getBasicBlock())->getName() << ":\n"; + std::vector VirtCopies; + std::vector PhysCopies; for (MachineBasicBlock::iterator MII = MBB->begin(), E = MBB->end(); MII != E;) { MachineInstr *Inst = MII++; @@ -946,10 +945,27 @@ void SimpleRegisterCoalescing::CopyCoalesceInMBB(MachineBasicBlock *MBB, SrcReg = Inst->getOperand(1).getReg(); } else if (!tii_->isMoveInstr(*Inst, SrcReg, DstReg)) continue; - - bool Done = JoinCopy(Inst, SrcReg, DstReg, PhysOnly); - if (TryAgain && !Done) - TryAgain->push_back(getCopyRec(Inst, SrcReg, DstReg)); + + unsigned repSrcReg = rep(SrcReg); + unsigned repDstReg = rep(DstReg); + bool SrcIsPhys = MRegisterInfo::isPhysicalRegister(repSrcReg); + bool DstIsPhys = MRegisterInfo::isPhysicalRegister(repDstReg); + if (SrcIsPhys || DstIsPhys) + PhysCopies.push_back(getCopyRec(Inst, SrcReg, DstReg)); + else + VirtCopies.push_back(getCopyRec(Inst, SrcReg, DstReg)); + } + + // Try coalescing physical register + virtual register first. + for (unsigned i = 0, e = PhysCopies.size(); i != e; ++i) { + CopyRec &TheCopy = PhysCopies[i]; + if (!JoinCopy(TheCopy.MI, TheCopy.SrcReg, TheCopy.DstReg)) + TryAgain.push_back(TheCopy); + } + for (unsigned i = 0, e = VirtCopies.size(); i != e; ++i) { + CopyRec &TheCopy = VirtCopies[i]; + if (!JoinCopy(TheCopy.MI, TheCopy.SrcReg, TheCopy.DstReg)) + TryAgain.push_back(TheCopy); } } @@ -965,7 +981,7 @@ void SimpleRegisterCoalescing::joinIntervals() { // If there are no loops in the function, join intervals in function order. for (MachineFunction::iterator I = mf_->begin(), E = mf_->end(); I != E; ++I) - CopyCoalesceInMBB(I, &TryAgainList); + CopyCoalesceInMBB(I, TryAgainList); } else { // Otherwise, join intervals in inner loops before other intervals. // Unfortunately we can't just iterate over loop hierarchy here because @@ -982,9 +998,7 @@ void SimpleRegisterCoalescing::joinIntervals() { // Finally, join intervals in loop nest order. for (unsigned i = 0, e = MBBs.size(); i != e; ++i) - CopyCoalesceInMBB(MBBs[i].second, NULL, true); - for (unsigned i = 0, e = MBBs.size(); i != e; ++i) - CopyCoalesceInMBB(MBBs[i].second, &TryAgainList, false); + CopyCoalesceInMBB(MBBs[i].second, TryAgainList); } // Joining intervals can allow other intervals to be joined. Iteratively join