6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-11-01 00:11:00 +00:00
Code Issues Projects Releases Wiki Activity

Fix PR3486. Fix a bug in code that manually patch physical register live interval after its sub-register is coalesced with a virtual register.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@64082 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng 2009-02-08 11:04:35 +00:00
parent 86fb9fdb20
commit 0a1fcce092
4 changed files with 60 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/CodeGen/LiveIntervalAnalysis.h
View File

@ -283,6 +283,10 @@ namespace llvm {
return *I->second;
}
/// dupInterval - Duplicate a live interval. The caller is responsible for
/// managing the allocated memory.
LiveInterval *dupInterval(LiveInterval *li);
/// addLiveRangeToEndOfBlock - Given a register and an instruction,
/// adds a live range from that instruction to the end of its MBB.
LiveRange addLiveRangeToEndOfBlock(unsigned reg,

11
lib/CodeGen/LiveIntervalAnalysis.cpp
View File

@ -824,11 +824,18 @@ bool LiveIntervals::findReachableMBBs(unsigned Start, unsigned End,
}
LiveInterval* LiveIntervals::createInterval(unsigned reg) {
float Weight = TargetRegisterInfo::isPhysicalRegister(reg) ?
HUGE_VALF : 0.0F;
float Weight = TargetRegisterInfo::isPhysicalRegister(reg) ? HUGE_VALF : 0.0F;
return new LiveInterval(reg, Weight);
}
/// dupInterval - Duplicate a live interval. The caller is responsible for
/// managing the allocated memory.
LiveInterval* LiveIntervals::dupInterval(LiveInterval *li) {
LiveInterval *NewLI = createInterval(li->reg);
NewLI->Copy(*li, getVNInfoAllocator());
return NewLI;
}
/// getVNInfoSourceReg - Helper function that parses the specified VNInfo
/// copy field and returns the source register that defines it.
unsigned LiveIntervals::getVNInfoSourceReg(const VNInfo *VNI) const {

39
lib/CodeGen/SimpleRegisterCoalescing.cpp
View File

@ -1354,6 +1354,15 @@ bool SimpleRegisterCoalescing::JoinCopy(CopyRec &TheCopy, bool &Again) {
DOUT << " and "; DstInt.print(DOUT, tri_);
DOUT << ": ";
// Save a copy of the virtual register live interval. We'll manually
// merge this into the "real" physical register live interval this is
// coalesced with.
LiveInterval *SavedLI = 0;
if (RealDstReg)
SavedLI = li_->dupInterval(&SrcInt);
else if (RealSrcReg)
SavedLI = li_->dupInterval(&DstInt);
// Check if it is necessary to propagate "isDead" property.
if (!isExtSubReg && !isInsSubReg) {
MachineOperand *mopd = CopyMI->findRegisterDefOperand(DstReg, false);
@ -1445,21 +1454,17 @@ bool SimpleRegisterCoalescing::JoinCopy(CopyRec &TheCopy, bool &Again) {
if (RealDstReg || RealSrcReg) {
LiveInterval &RealInt =
li_->getOrCreateInterval(RealDstReg ? RealDstReg : RealSrcReg);
SmallSet<const VNInfo*, 4> CopiedValNos;
for (LiveInterval::Ranges::const_iterator I = ResSrcInt->ranges.begin(),
E = ResSrcInt->ranges.end(); I != E; ++I) {
const LiveRange *DstLR = ResDstInt->getLiveRangeContaining(I->start);
assert(DstLR && "Invalid joined interval!");
const VNInfo *DstValNo = DstLR->valno;
if (CopiedValNos.insert(DstValNo)) {
VNInfo *ValNo = RealInt.getNextValue(DstValNo->def, DstValNo->copy,
li_->getVNInfoAllocator());
ValNo->hasPHIKill = DstValNo->hasPHIKill;
RealInt.addKills(ValNo, DstValNo->kills);
RealInt.MergeValueInAsValue(*ResDstInt, DstValNo, ValNo);
}
for (LiveInterval::const_vni_iterator I = SavedLI->vni_begin(),
E = SavedLI->vni_end(); I != E; ++I) {
const VNInfo *ValNo = *I;
VNInfo *NewValNo = RealInt.getNextValue(ValNo->def, ValNo->copy,
li_->getVNInfoAllocator());
NewValNo->hasPHIKill = ValNo->hasPHIKill;
NewValNo->redefByEC = ValNo->redefByEC;
RealInt.addKills(NewValNo, ValNo->kills);
RealInt.MergeValueInAsValue(*SavedLI, ValNo, NewValNo);
}
RealInt.weight += SavedLI->weight;
DstReg = RealDstReg ? RealDstReg : RealSrcReg;
}
@ -1529,6 +1534,12 @@ bool SimpleRegisterCoalescing::JoinCopy(CopyRec &TheCopy, bool &Again) {
// being merged.
li_->removeInterval(SrcReg);
// Manually deleted the live interval copy.
if (SavedLI) {
SavedLI->clear();
delete SavedLI;
}
if (isEmpty) {
// Now the copy is being coalesced away, the val# previously defined
// by the copy is being defined by an IMPLICIT_DEF which defines a zero

22
test/CodeGen/X86/2009-02-08-CoalescerBug.ll Normal file
View File

@ -0,0 +1,22 @@
; RUN: llvm-as < %s | llc -march=x86
; PR3486
define i32 @foo(i8 signext %p_26) nounwind {
entry:
%0 = icmp eq i8 %p_26, 0 ; <i1> [#uses=2]
%or.cond = or i1 false, %0 ; <i1> [#uses=2]
%iftmp.1.0 = zext i1 %or.cond to i16 ; <i16> [#uses=1]
br i1 %0, label %bb.i, label %bar.exit
bb.i: ; preds = %entry
%1 = zext i1 %or.cond to i32 ; <i32> [#uses=1]
%2 = sdiv i32 %1, 0 ; <i32> [#uses=1]
%3 = trunc i32 %2 to i16 ; <i16> [#uses=1]
br label %bar.exit
bar.exit: ; preds = %bb.i, %entry
%4 = phi i16 [ %3, %bb.i ], [ %iftmp.1.0, %entry ] ; <i16> [#uses=1]
%5 = trunc i16 %4 to i8 ; <i8> [#uses=1]
%6 = sext i8 %5 to i32 ; <i32> [#uses=1]
ret i32 %6
}