From 572c77066808fc0e9ee1d212dab227f28bf5e28a Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Mon, 12 May 2003 14:28:28 +0000 Subject: [PATCH] * Keep LiveVariable information more up-to-date and consistent * *** Finally mark values that are inputs to PHIs as killed when appropriate. This should make the generated code quite a bit better. For example, the local-ra will not have to spill PHI inputs at the end of predecessor BB's anymore. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6117 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/PHIElimination.cpp | 94 +++++++++++++++++++++++++++++++--- 1 file changed, 87 insertions(+), 7 deletions(-) diff --git a/lib/CodeGen/PHIElimination.cpp b/lib/CodeGen/PHIElimination.cpp index e7f4c9f5411..4a23eb257d5 100644 --- a/lib/CodeGen/PHIElimination.cpp +++ b/lib/CodeGen/PHIElimination.cpp @@ -12,6 +12,7 @@ #include "llvm/CodeGen/LiveVariables.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetMachine.h" +#include "llvm/Support/CFG.h" namespace { struct PNE : public MachineFunctionPass { @@ -91,7 +92,7 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) { // is defined in multiple entry blocks. Instead, we pretend that this // instruction defined it and killed it at the same time. // - LV->addVirtualRegisterDead(IncomingReg, PHICopy); + LV->addVirtualRegisterDead(IncomingReg, &MBB, PHICopy); // Since we are going to be deleting the PHI node, if it is the last use // of any registers, or if the value itself is dead, we need to move this @@ -99,17 +100,26 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) { // std::pair RKs = LV->killed_range(MI); + std::vector > Range; if (RKs.first != RKs.second) { - for (LiveVariables::killed_iterator I = RKs.first; I != RKs.second; ++I) - LV->addVirtualRegisterKilled(I->second, PHICopy); + // Copy the range into a vector... + Range.assign(RKs.first, RKs.second); + + // Delete the range... LV->removeVirtualRegistersKilled(RKs.first, RKs.second); + + // Add all of the kills back, which will update the appropriate info... + for (unsigned i = 0, e = Range.size(); i != e; ++i) + LV->addVirtualRegisterKilled(Range[i].second, &MBB, PHICopy); } RKs = LV->dead_range(MI); if (RKs.first != RKs.second) { - for (LiveVariables::killed_iterator I = RKs.first; I != RKs.second; ++I) - LV->addVirtualRegisterDead(I->second, PHICopy); + // Works as above... + Range.assign(RKs.first, RKs.second); LV->removeVirtualRegistersDead(RKs.first, RKs.second); + for (unsigned i = 0, e = Range.size(); i != e; ++i) + LV->addVirtualRegisterDead(Range[i].second, &MBB, PHICopy); } } @@ -163,10 +173,80 @@ bool PNE::EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB) { } } - if (HaveNotEmitted) { + if (HaveNotEmitted) { // If the copy has not already been emitted, do it. assert(opVal.isVirtualRegister() && "Machine PHI Operands must all be virtual registers!"); - RegInfo->copyRegToReg(opBlock, I, IncomingReg, opVal.getReg(), RC); + unsigned SrcReg = opVal.getReg(); + RegInfo->copyRegToReg(opBlock, I, IncomingReg, SrcReg, RC); + + // Now update live variable information if we have it. + if (LV) { + // We want to be able to insert a kill of the register if this PHI + // (aka, the copy we just inserted) is the last use of the source + // value. Live variable analysis conservatively handles this by + // saying that the value is live until the end of the block the PHI + // entry lives in. If the value really is dead at the PHI copy, there + // will be no successor blocks which have the value live-in. + // + // Check to see if the copy is the last use, and if so, update the + // live variables information so that it knows the copy source + // instruction kills the incoming value. + // + LiveVariables::VarInfo &InRegVI = LV->getVarInfo(SrcReg); + + // Loop over all of the successors of the basic block, checking to + // see if the value is either live in the block, or if it is killed + // in the block. + // + bool ValueIsLive = false; + BasicBlock *BB = opBlock.getBasicBlock(); + for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); + SI != E; ++SI) { + const std::pair & + SuccInfo = LV->getBasicBlockInfo(*SI); + + // Is it alive in this successor? + unsigned SuccIdx = SuccInfo.second; + if (SuccIdx < InRegVI.AliveBlocks.size() && + InRegVI.AliveBlocks[SuccIdx]) { + ValueIsLive = true; + break; + } + + // Is it killed in this successor? + MachineBasicBlock *MBB = SuccInfo.first; + for (unsigned i = 0, e = InRegVI.Kills.size(); i != e; ++i) + if (InRegVI.Kills[i].first == MBB) { + ValueIsLive = true; + break; + } + } + + // Okay, if we now know that the value is not live out of the block, + // we can add a kill marker to the copy we inserted saying that it + // kills the incoming value! + // + if (!ValueIsLive) { + // One more complication to worry about. There may actually be + // multiple PHI nodes using this value on this branch. If we aren't + // careful, the first PHI node will end up killing the value, not + // letting it get the to the copy for the final PHI node in the + // block. Therefore we have to check to see if there is already a + // kill in this block, and if so, extend the lifetime to our new + // copy. + // + for (unsigned i = 0, e = InRegVI.Kills.size(); i != e; ++i) + if (InRegVI.Kills[i].first == &opBlock) { + std::pair Range + = LV->killed_range(InRegVI.Kills[i].second); + LV->removeVirtualRegistersKilled(Range.first, Range.second); + break; + } + + LV->addVirtualRegisterKilled(SrcReg, &opBlock, *(I-1)); + } + } } }