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

When coalescing an EXTRACT_SUBREG and the dst register is a physical register,

Browse Source 
the source register will be coalesced to the super register of the LHS. Properly
merge in the live ranges of the resulting coalesced interval that were part of
the original source interval to the live interval of the super-register.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@42961 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng 2007-10-14 10:08:34 +00:00
parent 347d39f1fd
commit 34729256e8
3 changed files with 29 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/CodeGen/LiveInterval.h
View File

@ -253,7 +253,7 @@ namespace llvm {
/// current interval, but only if the overlapping LiveRanges have the
/// specified value number.
void MergeValueInAsValue(const LiveInterval &RHS,
VNInfo *RHSValNo, VNInfo *LHSValNo);
const VNInfo *RHSValNo, VNInfo *LHSValNo);
/// Copy - Copy the specified live interval. This copies all the fields
/// except for the register of the interval.

2
lib/CodeGen/LiveInterval.cpp
View File

@ -389,7 +389,7 @@ void LiveInterval::MergeRangesInAsValue(const LiveInterval &RHS,
/// current interval, but only if the overlapping LiveRanges have the
/// specified value number.
void LiveInterval::MergeValueInAsValue(const LiveInterval &RHS,
VNInfo *RHSValNo, VNInfo *LHSValNo) {
const VNInfo *RHSValNo, VNInfo *LHSValNo) {
// TODO: Make this more efficient.
iterator InsertPos = begin();
for (const_iterator I = RHS.begin(), E = RHS.end(); I != E; ++I) {

52
lib/CodeGen/SimpleRegisterCoalescing.cpp
View File

@ -421,14 +421,16 @@ bool SimpleRegisterCoalescing::JoinCopy(MachineInstr *CopyMI,
// cl = EXTRACT_SUBREG reg1024, 1
// then create and update the actual physical register allocated to RHS.
if (RealDstReg) {
unsigned CopyIdx = li_->getInstructionIndex(CopyMI);
VNInfo *DstValNo =
ResDstInt->getLiveRangeContaining(li_->getUseIndex(CopyIdx))->valno;
LiveInterval &RealDstInt = li_->getOrCreateInterval(RealDstReg);
VNInfo *ValNo = RealDstInt.getNextValue(DstValNo->def, DstValNo->reg,
li_->getVNInfoAllocator());
RealDstInt.addKills(ValNo, DstValNo->kills);
RealDstInt.MergeValueInAsValue(*ResDstInt, DstValNo, ValNo);
for (unsigned i = 0, e = ResSrcInt->getNumValNums(); i != e; ++i) {
const VNInfo *SrcValNo = ResSrcInt->getValNumInfo(i);
const VNInfo *DstValNo =
ResDstInt->FindLiveRangeContaining(SrcValNo->def)->valno;
VNInfo *ValNo = RealDstInt.getNextValue(DstValNo->def, DstValNo->reg,
li_->getVNInfoAllocator());
RealDstInt.addKills(ValNo, DstValNo->kills);
RealDstInt.MergeValueInAsValue(*ResDstInt, DstValNo, ValNo);
}
repDstReg = RealDstReg;
}
@ -879,32 +881,32 @@ bool SimpleRegisterCoalescing::JoinIntervals(LiveInterval &LHS,
}
}
// Update kill info. Some live ranges are extended due to copy coalescing.
for (DenseMap<VNInfo*, VNInfo*>::iterator I = LHSValsDefinedFromRHS.begin(),
E = LHSValsDefinedFromRHS.end(); I != E; ++I) {
VNInfo *VNI = I->first;
unsigned LHSValID = LHSValNoAssignments[VNI->id];
LiveInterval::removeKill(NewVNInfo[LHSValID], VNI->def);
RHS.addKills(NewVNInfo[LHSValID], VNI->kills);
}
// Update kill info. Some live ranges are extended due to copy coalescing.
for (DenseMap<VNInfo*, VNInfo*>::iterator I = RHSValsDefinedFromLHS.begin(),
E = RHSValsDefinedFromLHS.end(); I != E; ++I) {
VNInfo *VNI = I->first;
unsigned RHSValID = RHSValNoAssignments[VNI->id];
LiveInterval::removeKill(NewVNInfo[RHSValID], VNI->def);
LHS.addKills(NewVNInfo[RHSValID], VNI->kills);
}
// If we get here, we know that we can coalesce the live ranges. Ask the
// intervals to coalesce themselves now.
if ((RHS.ranges.size() > LHS.ranges.size() &&
MRegisterInfo::isVirtualRegister(LHS.reg)) ||
MRegisterInfo::isPhysicalRegister(RHS.reg)) {
// Update kill info. Some live ranges are extended due to copy coalescing.
for (DenseMap<VNInfo*, VNInfo*>::iterator I = LHSValsDefinedFromRHS.begin(),
E = LHSValsDefinedFromRHS.end(); I != E; ++I) {
VNInfo *VNI = I->first;
unsigned LHSValID = LHSValNoAssignments[VNI->id];
LiveInterval::removeKill(NewVNInfo[LHSValID], VNI->def);
RHS.addKills(NewVNInfo[LHSValID], VNI->kills);
}
RHS.join(LHS, &RHSValNoAssignments[0], &LHSValNoAssignments[0], NewVNInfo);
Swapped = true;
} else {
// Update kill info. Some live ranges are extended due to copy coalescing.
for (DenseMap<VNInfo*, VNInfo*>::iterator I = RHSValsDefinedFromLHS.begin(),
E = RHSValsDefinedFromLHS.end(); I != E; ++I) {
VNInfo *VNI = I->first;
unsigned RHSValID = RHSValNoAssignments[VNI->id];
LiveInterval::removeKill(NewVNInfo[RHSValID], VNI->def);
LHS.addKills(NewVNInfo[RHSValID], VNI->kills);
}
LHS.join(RHS, &LHSValNoAssignments[0], &RHSValNoAssignments[0], NewVNInfo);
Swapped = false;
}