maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Modified VNInfo. The "copy" member is now a union which holds the copy for a register interval, or the defining register for a stack interval. Access is via getCopy/setCopy and getReg/setReg. 

llvm-svn: 78620
This commit is contained in:
Lang Hames 2009-08-10 23:43:28 +00:00
parent 9d26c85bdc
commit 3b90d973b0
7 changed files with 67 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -61,6 +61,10 @@ namespace llvm {
}; };
unsigned char flags; unsigned char flags;
union {
MachineInstr *copy;
unsigned reg;
} cr;
public: public:
/// Holds information about individual kills. /// Holds information about individual kills.
@ -83,27 +87,53 @@ namespace llvm {
/// The index of the defining instruction (if isDefAccurate() returns true). /// The index of the defining instruction (if isDefAccurate() returns true).
unsigned def; unsigned def;
MachineInstr *copy;
KillSet kills; KillSet kills;
VNInfo() VNInfo()
: flags(IS_UNUSED), id(~1U), def(0), copy(0) {} : flags(IS_UNUSED), id(~1U), def(0) { cr.copy = 0; }
/// VNInfo constructor. /// VNInfo constructor.
/// d is presumed to point to the actual defining instr. If it doesn't /// d is presumed to point to the actual defining instr. If it doesn't
/// setIsDefAccurate(false) should be called after construction. /// setIsDefAccurate(false) should be called after construction.
VNInfo(unsigned i, unsigned d, MachineInstr *c) VNInfo(unsigned i, unsigned d, MachineInstr *c)
: flags(IS_DEF_ACCURATE), id(i), def(d), copy(c) {} : flags(IS_DEF_ACCURATE), id(i), def(d) { cr.copy = c; }
/// VNInfo construtor, copies values from orig, except for the value number. /// VNInfo construtor, copies values from orig, except for the value number.
VNInfo(unsigned i, const VNInfo &orig) VNInfo(unsigned i, const VNInfo &orig)
: flags(orig.flags), id(i), def(orig.def), copy(orig.copy), : flags(orig.flags), cr(orig.cr), id(i), def(orig.def), kills(orig.kills)
kills(orig.kills) {} { }
/// Copy from the parameter into this VNInfo.
void copyFrom(VNInfo &src) {
flags = src.flags;
cr = src.cr;
def = src.def;
kills = src.kills;
}
/// Used for copying value number info. /// Used for copying value number info.
unsigned getFlags() const { return flags; } unsigned getFlags() const { return flags; }
void setFlags(unsigned flags) { this->flags = flags; } void setFlags(unsigned flags) { this->flags = flags; }
/// For a register interval, if this VN was definied by a copy instr
/// getCopy() returns a pointer to it, otherwise returns 0.
/// For a stack interval the behaviour of this method is undefined.
MachineInstr* getCopy() const { return cr.copy; }
/// For a register interval, set the copy member.
/// This method should not be called on stack intervals as it may lead to
/// undefined behavior.
void setCopy(MachineInstr *c) { cr.copy = c; }
/// For a stack interval, returns the reg which this stack interval was
/// defined from.
/// For a register interval the behaviour of this method is undefined.
unsigned getReg() const { return cr.reg; }
/// For a stack interval, set the defining register.
/// This method should not be called on register intervals as it may lead
/// to undefined behaviour.
void setReg(unsigned reg) { cr.reg = reg; }
/// Returns true if one or more kills are PHI nodes. /// Returns true if one or more kills are PHI nodes.
bool hasPHIKill() const { return flags & HAS_PHI_KILL; } bool hasPHIKill() const { return flags & HAS_PHI_KILL; }
void setHasPHIKill(bool hasKill) { void setHasPHIKill(bool hasKill) {
@ -318,15 +348,6 @@ namespace llvm {
return valnos[ValNo]; return valnos[ValNo];
} }
/// copyValNumInfo - Copy the value number info for one value number to
/// another.
void copyValNumInfo(VNInfo *DstValNo, const VNInfo *SrcValNo) {
DstValNo->def = SrcValNo->def;
DstValNo->copy = SrcValNo->copy;
DstValNo->setFlags(SrcValNo->getFlags());
DstValNo->kills = SrcValNo->kills;
}
/// getNextValue - Create a new value number and return it. MIIdx specifies /// getNextValue - Create a new value number and return it. MIIdx specifies
/// the instruction that defines the value number. /// the instruction that defines the value number.
VNInfo *getNextValue(unsigned MIIdx, MachineInstr *CopyMI, VNInfo *getNextValue(unsigned MIIdx, MachineInstr *CopyMI,

2
llvm/lib/CodeGen/LiveInterval.cpp
View File

@ -712,7 +712,7 @@ VNInfo* LiveInterval::MergeValueNumberInto(VNInfo *V1, VNInfo *V2) {
// Make sure V2 is smaller than V1. // Make sure V2 is smaller than V1.
if (V1->id < V2->id) { if (V1->id < V2->id) {
copyValNumInfo(V1, V2); V1->copyFrom(*V2);
std::swap(V1, V2); std::swap(V1, V2);
} }

20
llvm/lib/CodeGen/LiveIntervalAnalysis.cpp
View File

@ -740,14 +740,14 @@ void LiveIntervals::handleVirtualRegisterDef(MachineBasicBlock *mbb,
// The new value number (#1) is defined by the instruction we claimed // The new value number (#1) is defined by the instruction we claimed
// defined value #0. // defined value #0.
VNInfo *ValNo = interval.getNextValue(OldValNo->def, OldValNo->copy, VNInfo *ValNo = interval.getNextValue(OldValNo->def, OldValNo->getCopy(),
false, // update at * false, // update at *
VNInfoAllocator); VNInfoAllocator);
ValNo->setFlags(OldValNo->getFlags()); // * <- updating here ValNo->setFlags(OldValNo->getFlags()); // * <- updating here
// Value#0 is now defined by the 2-addr instruction. // Value#0 is now defined by the 2-addr instruction.
OldValNo->def = RedefIndex; OldValNo->def = RedefIndex;
OldValNo->copy = 0; OldValNo->setCopy(0);
if (MO.isEarlyClobber()) if (MO.isEarlyClobber())
OldValNo->setHasRedefByEC(true); OldValNo->setHasRedefByEC(true);
@ -1129,21 +1129,21 @@ LiveInterval* LiveIntervals::dupInterval(LiveInterval *li) {
/// getVNInfoSourceReg - Helper function that parses the specified VNInfo /// getVNInfoSourceReg - Helper function that parses the specified VNInfo
/// copy field and returns the source register that defines it. /// copy field and returns the source register that defines it.
unsigned LiveIntervals::getVNInfoSourceReg(const VNInfo *VNI) const { unsigned LiveIntervals::getVNInfoSourceReg(const VNInfo *VNI) const {
if (!VNI->copy) if (!VNI->getCopy())
return 0; return 0;
if (VNI->copy->getOpcode() == TargetInstrInfo::EXTRACT_SUBREG) { if (VNI->getCopy()->getOpcode() == TargetInstrInfo::EXTRACT_SUBREG) {
// If it's extracting out of a physical register, return the sub-register. // If it's extracting out of a physical register, return the sub-register.
unsigned Reg = VNI->copy->getOperand(1).getReg(); unsigned Reg = VNI->getCopy()->getOperand(1).getReg();
if (TargetRegisterInfo::isPhysicalRegister(Reg)) if (TargetRegisterInfo::isPhysicalRegister(Reg))
Reg = tri_->getSubReg(Reg, VNI->copy->getOperand(2).getImm()); Reg = tri_->getSubReg(Reg, VNI->getCopy()->getOperand(2).getImm());
return Reg; return Reg;
} else if (VNI->copy->getOpcode() == TargetInstrInfo::INSERT_SUBREG || } else if (VNI->getCopy()->getOpcode() == TargetInstrInfo::INSERT_SUBREG ||
VNI->copy->getOpcode() == TargetInstrInfo::SUBREG_TO_REG) VNI->getCopy()->getOpcode() == TargetInstrInfo::SUBREG_TO_REG)
return VNI->copy->getOperand(2).getReg(); return VNI->getCopy()->getOperand(2).getReg();
unsigned SrcReg, DstReg, SrcSubReg, DstSubReg; unsigned SrcReg, DstReg, SrcSubReg, DstSubReg;
if (tii_->isMoveInstr(*VNI->copy, SrcReg, DstReg, SrcSubReg, DstSubReg)) if (tii_->isMoveInstr(*VNI->getCopy(), SrcReg, DstReg, SrcSubReg, DstSubReg))
return SrcReg; return SrcReg;
llvm_unreachable("Unrecognized copy instruction!"); llvm_unreachable("Unrecognized copy instruction!");
return 0; return 0;

2
llvm/lib/CodeGen/PreAllocSplitting.cpp
View File

@ -741,7 +741,7 @@ void PreAllocSplitting::ReconstructLiveInterval(LiveInterval* LI) {
unsigned SrcReg, DstReg, SrcSubIdx, DstSubIdx; unsigned SrcReg, DstReg, SrcSubIdx, DstSubIdx;
if (TII->isMoveInstr(*DI, SrcReg, DstReg, SrcSubIdx, DstSubIdx)) if (TII->isMoveInstr(*DI, SrcReg, DstReg, SrcSubIdx, DstSubIdx))
if (DstReg == LI->reg) if (DstReg == LI->reg)
NewVN->copy = &*DI; NewVN->setCopy(&*DI);
NewVNs[&*DI] = NewVN; NewVNs[&*DI] = NewVN;
} }

2
llvm/lib/CodeGen/RegAllocPBQP.cpp
View File

@ -447,7 +447,7 @@ PBQPRegAlloc::CoalesceMap PBQPRegAlloc::findCoalesces() {
vniItr != vniEnd; ++vniItr) { vniItr != vniEnd; ++vniItr) {
// We want to make sure we skip the copy instruction itself. // We want to make sure we skip the copy instruction itself.
if ((*vniItr)->copy == instr) if ((*vniItr)->getCopy() == instr)
continue; continue;
if (srcLI->liveAt((*vniItr)->def)) { if (srcLI->liveAt((*vniItr)->def)) {

30
llvm/lib/CodeGen/SimpleRegisterCoalescing.cpp
View File

@ -119,7 +119,7 @@ bool SimpleRegisterCoalescing::AdjustCopiesBackFrom(LiveInterval &IntA,
// Get the location that B is defined at. Two options: either this value has // Get the location that B is defined at. Two options: either this value has
// an unknown definition point or it is defined at CopyIdx. If unknown, we // an unknown definition point or it is defined at CopyIdx. If unknown, we
// can't process it. // can't process it.
if (!BValNo->copy) return false; if (!BValNo->getCopy()) return false;
assert(BValNo->def == CopyIdx && "Copy doesn't define the value?"); assert(BValNo->def == CopyIdx && "Copy doesn't define the value?");
// AValNo is the value number in A that defines the copy, A3 in the example. // AValNo is the value number in A that defines the copy, A3 in the example.
@ -194,7 +194,7 @@ bool SimpleRegisterCoalescing::AdjustCopiesBackFrom(LiveInterval &IntA,
// that defines this value #'. Update the the valnum with the new defining // that defines this value #'. Update the the valnum with the new defining
// instruction #. // instruction #.
BValNo->def = FillerStart; BValNo->def = FillerStart;
BValNo->copy = NULL; BValNo->setCopy(0);
// Okay, we can merge them. We need to insert a new liverange: // Okay, we can merge them. We need to insert a new liverange:
// [ValLR.end, BLR.begin) of either value number, then we merge the // [ValLR.end, BLR.begin) of either value number, then we merge the
@ -307,7 +307,7 @@ bool SimpleRegisterCoalescing::RemoveCopyByCommutingDef(LiveInterval &IntA,
// Get the location that B is defined at. Two options: either this value has // Get the location that B is defined at. Two options: either this value has
// an unknown definition point or it is defined at CopyIdx. If unknown, we // an unknown definition point or it is defined at CopyIdx. If unknown, we
// can't process it. // can't process it.
if (!BValNo->copy) return false; if (!BValNo->getCopy()) return false;
assert(BValNo->def == CopyIdx && "Copy doesn't define the value?"); assert(BValNo->def == CopyIdx && "Copy doesn't define the value?");
// AValNo is the value number in A that defines the copy, A3 in the example. // AValNo is the value number in A that defines the copy, A3 in the example.
@ -463,7 +463,7 @@ bool SimpleRegisterCoalescing::RemoveCopyByCommutingDef(LiveInterval &IntA,
// is updated. Kills are also updated. // is updated. Kills are also updated.
VNInfo *ValNo = BValNo; VNInfo *ValNo = BValNo;
ValNo->def = AValNo->def; ValNo->def = AValNo->def;
ValNo->copy = NULL; ValNo->setCopy(0);
for (unsigned j = 0, ee = ValNo->kills.size(); j != ee; ++j) { for (unsigned j = 0, ee = ValNo->kills.size(); j != ee; ++j) {
unsigned Kill = ValNo->kills[j].killIdx; unsigned Kill = ValNo->kills[j].killIdx;
if (Kill != BLR->end) if (Kill != BLR->end)
@ -637,15 +637,15 @@ bool SimpleRegisterCoalescing::ReMaterializeTrivialDef(LiveInterval &SrcInt,
unsigned DefIdx = li_->getDefIndex(CopyIdx); unsigned DefIdx = li_->getDefIndex(CopyIdx);
const LiveRange *DLR= li_->getInterval(DstReg).getLiveRangeContaining(DefIdx); const LiveRange *DLR= li_->getInterval(DstReg).getLiveRangeContaining(DefIdx);
DLR->valno->copy = NULL; DLR->valno->setCopy(0);
// Don't forget to update sub-register intervals. // Don't forget to update sub-register intervals.
if (TargetRegisterInfo::isPhysicalRegister(DstReg)) { if (TargetRegisterInfo::isPhysicalRegister(DstReg)) {
for (const unsigned* SR = tri_->getSubRegisters(DstReg); *SR; ++SR) { for (const unsigned* SR = tri_->getSubRegisters(DstReg); *SR; ++SR) {
if (!li_->hasInterval(*SR)) if (!li_->hasInterval(*SR))
continue; continue;
DLR = li_->getInterval(*SR).getLiveRangeContaining(DefIdx); DLR = li_->getInterval(*SR).getLiveRangeContaining(DefIdx);
if (DLR && DLR->valno->copy == CopyMI) if (DLR && DLR->valno->getCopy() == CopyMI)
DLR->valno->copy = NULL; DLR->valno->setCopy(0);
} }
} }
@ -682,8 +682,8 @@ bool SimpleRegisterCoalescing::ReMaterializeTrivialDef(LiveInterval &SrcInt,
if (MO.isDef() && li_->hasInterval(MO.getReg())) { if (MO.isDef() && li_->hasInterval(MO.getReg())) {
unsigned Reg = MO.getReg(); unsigned Reg = MO.getReg();
DLR = li_->getInterval(Reg).getLiveRangeContaining(DefIdx); DLR = li_->getInterval(Reg).getLiveRangeContaining(DefIdx);
if (DLR && DLR->valno->copy == CopyMI) if (DLR && DLR->valno->getCopy() == CopyMI)
DLR->valno->copy = NULL; DLR->valno->setCopy(0);
} }
} }
@ -791,7 +791,7 @@ SimpleRegisterCoalescing::UpdateRegDefsUses(unsigned SrcReg, unsigned DstReg,
unsigned DefIdx = li_->getDefIndex(li_->getInstructionIndex(UseMI)); unsigned DefIdx = li_->getDefIndex(li_->getInstructionIndex(UseMI));
if (const LiveRange *DLR = LI.getLiveRangeContaining(DefIdx)) { if (const LiveRange *DLR = LI.getLiveRangeContaining(DefIdx)) {
if (DLR->valno->def == DefIdx) if (DLR->valno->def == DefIdx)
DLR->valno->copy = UseMI; DLR->valno->setCopy(UseMI);
} }
} }
} }
@ -1653,7 +1653,7 @@ bool SimpleRegisterCoalescing::JoinCopy(CopyRec &TheCopy, bool &Again) {
for (LiveInterval::const_vni_iterator I = SavedLI->vni_begin(), for (LiveInterval::const_vni_iterator I = SavedLI->vni_begin(),
E = SavedLI->vni_end(); I != E; ++I) { E = SavedLI->vni_end(); I != E; ++I) {
const VNInfo *ValNo = *I; const VNInfo *ValNo = *I;
VNInfo *NewValNo = RealInt.getNextValue(ValNo->def, ValNo->copy, VNInfo *NewValNo = RealInt.getNextValue(ValNo->def, ValNo->getCopy(),
false, // updated at * false, // updated at *
li_->getVNInfoAllocator()); li_->getVNInfoAllocator());
NewValNo->setFlags(ValNo->getFlags()); // * updated here. NewValNo->setFlags(ValNo->getFlags()); // * updated here.
@ -1833,7 +1833,7 @@ bool SimpleRegisterCoalescing::RangeIsDefinedByCopyFromReg(LiveInterval &li,
DstReg == li.reg && SrcReg == Reg) { DstReg == li.reg && SrcReg == Reg) {
// Cache computed info. // Cache computed info.
LR->valno->def = LR->start; LR->valno->def = LR->start;
LR->valno->copy = DefMI; LR->valno->setCopy(DefMI);
return true; return true;
} }
} }
@ -1986,7 +1986,7 @@ bool SimpleRegisterCoalescing::SimpleJoin(LiveInterval &LHS, LiveInterval &RHS){
// value number is defined where the RHS value number was. // value number is defined where the RHS value number was.
const VNInfo *VNI = RHS.getValNumInfo(0); const VNInfo *VNI = RHS.getValNumInfo(0);
LHSValNo->def = VNI->def; LHSValNo->def = VNI->def;
LHSValNo->copy = VNI->copy; LHSValNo->setCopy(VNI->getCopy());
// Okay, the final step is to loop over the RHS live intervals, adding them to // Okay, the final step is to loop over the RHS live intervals, adding them to
// the LHS. // the LHS.
@ -2159,7 +2159,7 @@ SimpleRegisterCoalescing::JoinIntervals(LiveInterval &LHS, LiveInterval &RHS,
for (LiveInterval::vni_iterator i = LHS.vni_begin(), e = LHS.vni_end(); for (LiveInterval::vni_iterator i = LHS.vni_begin(), e = LHS.vni_end();
i != e; ++i) { i != e; ++i) {
VNInfo *VNI = *i; VNInfo *VNI = *i;
if (VNI->isUnused() || VNI->copy == 0) // Src not defined by a copy? if (VNI->isUnused() || VNI->getCopy() == 0) // Src not defined by a copy?
continue; continue;
// DstReg is known to be a register in the LHS interval. If the src is // DstReg is known to be a register in the LHS interval. If the src is
@ -2176,7 +2176,7 @@ SimpleRegisterCoalescing::JoinIntervals(LiveInterval &LHS, LiveInterval &RHS,
for (LiveInterval::vni_iterator i = RHS.vni_begin(), e = RHS.vni_end(); for (LiveInterval::vni_iterator i = RHS.vni_begin(), e = RHS.vni_end();
i != e; ++i) { i != e; ++i) {
VNInfo *VNI = *i; VNInfo *VNI = *i;
if (VNI->isUnused() || VNI->copy == 0) // Src not defined by a copy? if (VNI->isUnused() || VNI->getCopy() == 0) // Src not defined by a copy?
continue; continue;
// DstReg is known to be a register in the RHS interval. If the src is // DstReg is known to be a register in the RHS interval. If the src is

4
llvm/lib/CodeGen/StrongPHIElimination.cpp
View File

@ -790,7 +790,7 @@ void StrongPHIElimination::ScheduleCopies(MachineBasicBlock* MBB,
true); true);
LiveRange R = LI.addLiveRangeToEndOfBlock(I->first, I->second); LiveRange R = LI.addLiveRangeToEndOfBlock(I->first, I->second);
R.valno->copy = I->second; R.valno->setCopy(I->second);
R.valno->def = R.valno->def =
LiveIntervals::getDefIndex(LI.getInstructionIndex(I->second)); LiveIntervals::getDefIndex(LI.getInstructionIndex(I->second));
} }
@ -974,7 +974,7 @@ bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) {
LiveRange R = LI.addLiveRangeToEndOfBlock(I->first, LiveRange R = LI.addLiveRangeToEndOfBlock(I->first,
--SI->second->getFirstTerminator()); --SI->second->getFirstTerminator());
R.valno->copy = --SI->second->getFirstTerminator(); R.valno->setCopy(--SI->second->getFirstTerminator());
R.valno->def = LiveIntervals::getDefIndex(instrIdx); R.valno->def = LiveIntervals::getDefIndex(instrIdx);
DOUT << "Renaming failed: " << SI->first << " -> " DOUT << "Renaming failed: " << SI->first << " -> "