2010-07-20 23:41:07 +08:00
|
|
|
//===---------- SplitKit.cpp - Toolkit for splitting live ranges ----------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file contains the SplitAnalysis class as well as mutator functions for
|
|
|
|
// live range splitting.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "SplitKit.h"
|
2011-03-03 07:05:19 +08:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
2010-07-20 23:41:07 +08:00
|
|
|
#include "llvm/CodeGen/LiveIntervalAnalysis.h"
|
2012-04-03 06:44:18 +08:00
|
|
|
#include "llvm/CodeGen/LiveRangeEdit.h"
|
2016-04-13 11:08:27 +08:00
|
|
|
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
|
2010-10-29 04:34:50 +08:00
|
|
|
#include "llvm/CodeGen/MachineDominators.h"
|
2010-07-27 07:44:11 +08:00
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
2011-09-15 00:45:39 +08:00
|
|
|
#include "llvm/CodeGen/MachineLoopInfo.h"
|
2010-07-20 23:41:07 +08:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
2012-11-29 03:13:06 +08:00
|
|
|
#include "llvm/CodeGen/VirtRegMap.h"
|
2010-07-20 23:41:07 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-07-21 05:46:58 +08:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2010-07-20 23:41:07 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:02:50 +08:00
|
|
|
#define DEBUG_TYPE "regalloc"
|
|
|
|
|
2011-03-03 07:05:19 +08:00
|
|
|
STATISTIC(NumFinished, "Number of splits finished");
|
|
|
|
STATISTIC(NumSimple, "Number of splits that were simple");
|
2011-05-06 01:22:53 +08:00
|
|
|
STATISTIC(NumCopies, "Number of copies inserted for splitting");
|
|
|
|
STATISTIC(NumRemats, "Number of rematerialized defs for splitting");
|
2011-05-11 01:37:41 +08:00
|
|
|
STATISTIC(NumRepairs, "Number of invalid live ranges repaired");
|
2011-03-03 07:05:19 +08:00
|
|
|
|
2010-07-20 23:41:07 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2016-05-12 06:28:29 +08:00
|
|
|
// Last Insert Point Analysis
|
2010-07-20 23:41:07 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2016-05-12 06:28:29 +08:00
|
|
|
InsertPointAnalysis::InsertPointAnalysis(const LiveIntervals &lis,
|
|
|
|
unsigned BBNum)
|
2016-05-24 03:39:19 +08:00
|
|
|
: LIS(lis), LastInsertPoint(BBNum) {}
|
2010-07-20 23:41:07 +08:00
|
|
|
|
2016-05-12 06:28:29 +08:00
|
|
|
SlotIndex
|
2016-05-24 03:39:19 +08:00
|
|
|
InsertPointAnalysis::computeLastInsertPoint(const LiveInterval &CurLI,
|
|
|
|
const MachineBasicBlock &MBB) {
|
2016-05-12 06:28:29 +08:00
|
|
|
unsigned Num = MBB.getNumber();
|
|
|
|
std::pair<SlotIndex, SlotIndex> &LIP = LastInsertPoint[Num];
|
|
|
|
SlotIndex MBBEnd = LIS.getMBBEndIdx(&MBB);
|
2011-04-05 12:20:27 +08:00
|
|
|
|
2016-04-25 22:31:32 +08:00
|
|
|
SmallVector<const MachineBasicBlock *, 1> EHPadSucessors;
|
2016-05-12 06:28:29 +08:00
|
|
|
for (const MachineBasicBlock *SMBB : MBB.successors())
|
2016-04-25 22:31:32 +08:00
|
|
|
if (SMBB->isEHPad())
|
|
|
|
EHPadSucessors.push_back(SMBB);
|
|
|
|
|
2016-05-12 06:28:29 +08:00
|
|
|
// Compute insert points on the first call. The pair is independent of the
|
2011-04-05 12:20:27 +08:00
|
|
|
// current live interval.
|
2016-05-12 06:28:29 +08:00
|
|
|
if (!LIP.first.isValid()) {
|
|
|
|
MachineBasicBlock::const_iterator FirstTerm = MBB.getFirstTerminator();
|
|
|
|
if (FirstTerm == MBB.end())
|
|
|
|
LIP.first = MBBEnd;
|
2011-04-05 12:20:27 +08:00
|
|
|
else
|
2016-05-12 06:28:29 +08:00
|
|
|
LIP.first = LIS.getInstructionIndex(*FirstTerm);
|
2011-04-05 12:20:27 +08:00
|
|
|
|
|
|
|
// If there is a landing pad successor, also find the call instruction.
|
2016-04-25 22:31:32 +08:00
|
|
|
if (EHPadSucessors.empty())
|
2016-05-12 06:28:29 +08:00
|
|
|
return LIP.first;
|
2011-04-05 12:20:27 +08:00
|
|
|
// There may not be a call instruction (?) in which case we ignore LPad.
|
2016-05-12 06:28:29 +08:00
|
|
|
LIP.second = LIP.first;
|
|
|
|
for (MachineBasicBlock::const_iterator I = MBB.end(), E = MBB.begin();
|
2011-06-28 09:18:58 +08:00
|
|
|
I != E;) {
|
|
|
|
--I;
|
2011-12-07 15:15:52 +08:00
|
|
|
if (I->isCall()) {
|
2016-05-12 06:28:29 +08:00
|
|
|
LIP.second = LIS.getInstructionIndex(*I);
|
2011-04-05 12:20:27 +08:00
|
|
|
break;
|
|
|
|
}
|
2011-06-28 09:18:58 +08:00
|
|
|
}
|
2011-04-05 12:20:27 +08:00
|
|
|
}
|
|
|
|
|
2016-05-12 06:28:29 +08:00
|
|
|
// If CurLI is live into a landing pad successor, move the last insert point
|
2011-04-05 12:20:27 +08:00
|
|
|
// back to the call that may throw.
|
2016-05-12 06:28:29 +08:00
|
|
|
if (!LIP.second)
|
|
|
|
return LIP.first;
|
2016-04-25 22:31:32 +08:00
|
|
|
|
|
|
|
if (none_of(EHPadSucessors, [&](const MachineBasicBlock *EHPad) {
|
2016-05-24 03:39:19 +08:00
|
|
|
return LIS.isLiveInToMBB(CurLI, EHPad);
|
2016-04-25 22:31:32 +08:00
|
|
|
}))
|
2016-05-12 06:28:29 +08:00
|
|
|
return LIP.first;
|
2012-01-11 10:07:05 +08:00
|
|
|
|
|
|
|
// Find the value leaving MBB.
|
2016-05-24 03:39:19 +08:00
|
|
|
const VNInfo *VNI = CurLI.getVNInfoBefore(MBBEnd);
|
2012-01-11 10:07:05 +08:00
|
|
|
if (!VNI)
|
2016-05-12 06:28:29 +08:00
|
|
|
return LIP.first;
|
2012-01-11 10:07:05 +08:00
|
|
|
|
|
|
|
// If the value leaving MBB was defined after the call in MBB, it can't
|
|
|
|
// really be live-in to the landing pad. This can happen if the landing pad
|
|
|
|
// has a PHI, and this register is undef on the exceptional edge.
|
|
|
|
// <rdar://problem/10664933>
|
2016-05-12 06:28:29 +08:00
|
|
|
if (!SlotIndex::isEarlierInstr(VNI->def, LIP.second) && VNI->def < MBBEnd)
|
|
|
|
return LIP.first;
|
2012-01-11 10:07:05 +08:00
|
|
|
|
|
|
|
// Value is properly live-in to the landing pad.
|
2016-05-12 06:28:29 +08:00
|
|
|
// Only allow inserts before the call.
|
|
|
|
return LIP.second;
|
2010-07-21 05:46:58 +08:00
|
|
|
}
|
|
|
|
|
2012-01-11 10:07:00 +08:00
|
|
|
MachineBasicBlock::iterator
|
2016-05-24 03:39:19 +08:00
|
|
|
InsertPointAnalysis::getLastInsertPointIter(const LiveInterval &CurLI,
|
|
|
|
MachineBasicBlock &MBB) {
|
|
|
|
SlotIndex LIP = getLastInsertPoint(CurLI, MBB);
|
2016-05-12 06:28:29 +08:00
|
|
|
if (LIP == LIS.getMBBEndIdx(&MBB))
|
|
|
|
return MBB.end();
|
|
|
|
return LIS.getInstructionFromIndex(LIP);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Split Analysis
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
SplitAnalysis::SplitAnalysis(const VirtRegMap &vrm, const LiveIntervals &lis,
|
|
|
|
const MachineLoopInfo &mli)
|
|
|
|
: MF(vrm.getMachineFunction()), VRM(vrm), LIS(lis), Loops(mli),
|
|
|
|
TII(*MF.getSubtarget().getInstrInfo()), CurLI(nullptr),
|
|
|
|
IPA(lis, MF.getNumBlockIDs()) {}
|
|
|
|
|
|
|
|
void SplitAnalysis::clear() {
|
|
|
|
UseSlots.clear();
|
|
|
|
UseBlocks.clear();
|
|
|
|
ThroughBlocks.clear();
|
|
|
|
CurLI = nullptr;
|
|
|
|
DidRepairRange = false;
|
2012-01-11 10:07:00 +08:00
|
|
|
}
|
|
|
|
|
2011-01-26 08:50:53 +08:00
|
|
|
/// analyzeUses - Count instructions, basic blocks, and loops using CurLI.
|
2010-07-21 00:12:37 +08:00
|
|
|
void SplitAnalysis::analyzeUses() {
|
2011-04-05 23:18:18 +08:00
|
|
|
assert(UseSlots.empty() && "Call clear first");
|
|
|
|
|
|
|
|
// First get all the defs from the interval values. This provides the correct
|
|
|
|
// slots for early clobbers.
|
2014-12-11 07:07:54 +08:00
|
|
|
for (const VNInfo *VNI : CurLI->valnos)
|
|
|
|
if (!VNI->isPHIDef() && !VNI->isUnused())
|
|
|
|
UseSlots.push_back(VNI->def);
|
2011-04-05 23:18:18 +08:00
|
|
|
|
|
|
|
// Get use slots form the use-def chain.
|
2011-01-26 08:50:53 +08:00
|
|
|
const MachineRegisterInfo &MRI = MF.getRegInfo();
|
2014-03-18 03:36:09 +08:00
|
|
|
for (MachineOperand &MO : MRI.use_nodbg_operands(CurLI->reg))
|
|
|
|
if (!MO.isUndef())
|
2016-02-27 14:40:41 +08:00
|
|
|
UseSlots.push_back(LIS.getInstructionIndex(*MO.getParent()).getRegSlot());
|
2011-04-05 23:18:18 +08:00
|
|
|
|
2011-01-19 05:13:27 +08:00
|
|
|
array_pod_sort(UseSlots.begin(), UseSlots.end());
|
2011-03-06 02:33:49 +08:00
|
|
|
|
2011-04-05 23:18:18 +08:00
|
|
|
// Remove duplicates, keeping the smaller slot for each instruction.
|
|
|
|
// That is what we want for early clobbers.
|
|
|
|
UseSlots.erase(std::unique(UseSlots.begin(), UseSlots.end(),
|
|
|
|
SlotIndex::isSameInstr),
|
|
|
|
UseSlots.end());
|
|
|
|
|
2011-03-06 02:33:49 +08:00
|
|
|
// Compute per-live block info.
|
|
|
|
if (!calcLiveBlockInfo()) {
|
|
|
|
// FIXME: calcLiveBlockInfo found inconsistencies in the live range.
|
2011-06-27 06:34:10 +08:00
|
|
|
// I am looking at you, RegisterCoalescer!
|
2011-05-04 04:42:13 +08:00
|
|
|
DidRepairRange = true;
|
2011-05-11 01:37:41 +08:00
|
|
|
++NumRepairs;
|
2011-03-06 02:33:49 +08:00
|
|
|
DEBUG(dbgs() << "*** Fixing inconsistent live interval! ***\n");
|
|
|
|
const_cast<LiveIntervals&>(LIS)
|
|
|
|
.shrinkToUses(const_cast<LiveInterval*>(CurLI));
|
2011-04-06 11:57:00 +08:00
|
|
|
UseBlocks.clear();
|
|
|
|
ThroughBlocks.clear();
|
2011-03-06 02:33:49 +08:00
|
|
|
bool fixed = calcLiveBlockInfo();
|
|
|
|
(void)fixed;
|
|
|
|
assert(fixed && "Couldn't fix broken live interval");
|
|
|
|
}
|
|
|
|
|
2011-03-28 06:49:23 +08:00
|
|
|
DEBUG(dbgs() << "Analyze counted "
|
2011-04-06 11:57:00 +08:00
|
|
|
<< UseSlots.size() << " instrs in "
|
|
|
|
<< UseBlocks.size() << " blocks, through "
|
2011-04-09 10:59:09 +08:00
|
|
|
<< NumThroughBlocks << " blocks.\n");
|
2010-07-20 23:41:07 +08:00
|
|
|
}
|
|
|
|
|
2011-02-10 06:50:26 +08:00
|
|
|
/// calcLiveBlockInfo - Fill the LiveBlocks array with information about blocks
|
|
|
|
/// where CurLI is live.
|
2011-03-06 02:33:49 +08:00
|
|
|
bool SplitAnalysis::calcLiveBlockInfo() {
|
2011-04-09 10:59:09 +08:00
|
|
|
ThroughBlocks.resize(MF.getNumBlockIDs());
|
2011-05-30 09:33:26 +08:00
|
|
|
NumThroughBlocks = NumGapBlocks = 0;
|
2011-02-10 06:50:26 +08:00
|
|
|
if (CurLI->empty())
|
2011-03-06 02:33:49 +08:00
|
|
|
return true;
|
2011-02-10 06:50:26 +08:00
|
|
|
|
|
|
|
LiveInterval::const_iterator LVI = CurLI->begin();
|
|
|
|
LiveInterval::const_iterator LVE = CurLI->end();
|
|
|
|
|
|
|
|
SmallVectorImpl<SlotIndex>::const_iterator UseI, UseE;
|
|
|
|
UseI = UseSlots.begin();
|
|
|
|
UseE = UseSlots.end();
|
|
|
|
|
|
|
|
// Loop over basic blocks where CurLI is live.
|
2015-10-10 06:56:24 +08:00
|
|
|
MachineFunction::iterator MFI =
|
|
|
|
LIS.getMBBFromIndex(LVI->start)->getIterator();
|
2011-02-10 06:50:26 +08:00
|
|
|
for (;;) {
|
|
|
|
BlockInfo BI;
|
2015-10-10 06:56:24 +08:00
|
|
|
BI.MBB = &*MFI;
|
2011-04-04 23:32:15 +08:00
|
|
|
SlotIndex Start, Stop;
|
2014-03-02 21:30:33 +08:00
|
|
|
std::tie(Start, Stop) = LIS.getSlotIndexes()->getMBBRange(BI.MBB);
|
2011-02-10 06:50:26 +08:00
|
|
|
|
2011-05-30 09:33:26 +08:00
|
|
|
// If the block contains no uses, the range must be live through. At one
|
2011-06-27 06:34:10 +08:00
|
|
|
// point, RegisterCoalescer could create dangling ranges that ended
|
2011-05-30 09:33:26 +08:00
|
|
|
// mid-block.
|
|
|
|
if (UseI == UseE || *UseI >= Stop) {
|
|
|
|
++NumThroughBlocks;
|
|
|
|
ThroughBlocks.set(BI.MBB->getNumber());
|
|
|
|
// The range shouldn't end mid-block if there are no uses. This shouldn't
|
|
|
|
// happen.
|
|
|
|
if (LVI->end < Stop)
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
// This block has uses. Find the first and last uses in the block.
|
2011-08-03 06:54:14 +08:00
|
|
|
BI.FirstInstr = *UseI;
|
|
|
|
assert(BI.FirstInstr >= Start);
|
2011-02-10 06:50:26 +08:00
|
|
|
do ++UseI;
|
2011-04-04 23:32:15 +08:00
|
|
|
while (UseI != UseE && *UseI < Stop);
|
2011-08-03 06:54:14 +08:00
|
|
|
BI.LastInstr = UseI[-1];
|
|
|
|
assert(BI.LastInstr < Stop);
|
2011-02-10 06:50:26 +08:00
|
|
|
|
2011-05-30 09:33:26 +08:00
|
|
|
// LVI is the first live segment overlapping MBB.
|
|
|
|
BI.LiveIn = LVI->start <= Start;
|
|
|
|
|
2011-08-03 06:37:22 +08:00
|
|
|
// When not live in, the first use should be a def.
|
|
|
|
if (!BI.LiveIn) {
|
2013-10-11 05:28:43 +08:00
|
|
|
assert(LVI->start == LVI->valno->def && "Dangling Segment start");
|
2011-08-03 06:54:14 +08:00
|
|
|
assert(LVI->start == BI.FirstInstr && "First instr should be a def");
|
|
|
|
BI.FirstDef = BI.FirstInstr;
|
2011-08-03 06:37:22 +08:00
|
|
|
}
|
|
|
|
|
2011-05-30 09:33:26 +08:00
|
|
|
// Look for gaps in the live range.
|
|
|
|
BI.LiveOut = true;
|
|
|
|
while (LVI->end < Stop) {
|
|
|
|
SlotIndex LastStop = LVI->end;
|
|
|
|
if (++LVI == LVE || LVI->start >= Stop) {
|
|
|
|
BI.LiveOut = false;
|
2011-08-03 06:54:14 +08:00
|
|
|
BI.LastInstr = LastStop;
|
2011-05-30 09:33:26 +08:00
|
|
|
break;
|
|
|
|
}
|
2011-08-03 06:37:22 +08:00
|
|
|
|
2011-05-30 09:33:26 +08:00
|
|
|
if (LastStop < LVI->start) {
|
|
|
|
// There is a gap in the live range. Create duplicate entries for the
|
|
|
|
// live-in snippet and the live-out snippet.
|
|
|
|
++NumGapBlocks;
|
|
|
|
|
|
|
|
// Push the Live-in part.
|
|
|
|
BI.LiveOut = false;
|
|
|
|
UseBlocks.push_back(BI);
|
2011-08-03 06:54:14 +08:00
|
|
|
UseBlocks.back().LastInstr = LastStop;
|
2011-05-30 09:33:26 +08:00
|
|
|
|
|
|
|
// Set up BI for the live-out part.
|
|
|
|
BI.LiveIn = false;
|
|
|
|
BI.LiveOut = true;
|
2011-08-03 06:54:14 +08:00
|
|
|
BI.FirstInstr = BI.FirstDef = LVI->start;
|
2011-05-30 09:33:26 +08:00
|
|
|
}
|
2011-08-03 06:37:22 +08:00
|
|
|
|
2013-10-11 05:28:43 +08:00
|
|
|
// A Segment that starts in the middle of the block must be a def.
|
|
|
|
assert(LVI->start == LVI->valno->def && "Dangling Segment start");
|
2011-08-03 06:37:22 +08:00
|
|
|
if (!BI.FirstDef)
|
|
|
|
BI.FirstDef = LVI->start;
|
2011-02-10 06:50:26 +08:00
|
|
|
}
|
|
|
|
|
2011-04-06 11:57:00 +08:00
|
|
|
UseBlocks.push_back(BI);
|
2011-05-30 05:24:39 +08:00
|
|
|
|
2011-05-30 09:33:26 +08:00
|
|
|
// LVI is now at LVE or LVI->end >= Stop.
|
|
|
|
if (LVI == LVE)
|
|
|
|
break;
|
|
|
|
}
|
2011-02-10 06:50:26 +08:00
|
|
|
|
|
|
|
// Live segment ends exactly at Stop. Move to the next segment.
|
2011-04-04 23:32:15 +08:00
|
|
|
if (LVI->end == Stop && ++LVI == LVE)
|
2011-02-10 06:50:26 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
// Pick the next basic block.
|
2011-04-04 23:32:15 +08:00
|
|
|
if (LVI->start < Stop)
|
2011-02-10 06:50:26 +08:00
|
|
|
++MFI;
|
|
|
|
else
|
2015-10-10 06:56:24 +08:00
|
|
|
MFI = LIS.getMBBFromIndex(LVI->start)->getIterator();
|
2011-02-10 06:50:26 +08:00
|
|
|
}
|
2011-05-28 10:32:57 +08:00
|
|
|
|
|
|
|
assert(getNumLiveBlocks() == countLiveBlocks(CurLI) && "Bad block count");
|
2011-03-06 02:33:49 +08:00
|
|
|
return true;
|
2011-02-10 06:50:26 +08:00
|
|
|
}
|
|
|
|
|
2011-04-27 06:33:12 +08:00
|
|
|
unsigned SplitAnalysis::countLiveBlocks(const LiveInterval *cli) const {
|
|
|
|
if (cli->empty())
|
|
|
|
return 0;
|
|
|
|
LiveInterval *li = const_cast<LiveInterval*>(cli);
|
|
|
|
LiveInterval::iterator LVI = li->begin();
|
|
|
|
LiveInterval::iterator LVE = li->end();
|
|
|
|
unsigned Count = 0;
|
|
|
|
|
|
|
|
// Loop over basic blocks where li is live.
|
2015-10-10 06:56:24 +08:00
|
|
|
MachineFunction::const_iterator MFI =
|
|
|
|
LIS.getMBBFromIndex(LVI->start)->getIterator();
|
|
|
|
SlotIndex Stop = LIS.getMBBEndIdx(&*MFI);
|
2011-04-27 06:33:12 +08:00
|
|
|
for (;;) {
|
|
|
|
++Count;
|
|
|
|
LVI = li->advanceTo(LVI, Stop);
|
|
|
|
if (LVI == LVE)
|
|
|
|
return Count;
|
|
|
|
do {
|
|
|
|
++MFI;
|
2015-10-10 06:56:24 +08:00
|
|
|
Stop = LIS.getMBBEndIdx(&*MFI);
|
2011-04-27 06:33:12 +08:00
|
|
|
} while (Stop <= LVI->start);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-22 07:09:46 +08:00
|
|
|
bool SplitAnalysis::isOriginalEndpoint(SlotIndex Idx) const {
|
|
|
|
unsigned OrigReg = VRM.getOriginal(CurLI->reg);
|
|
|
|
const LiveInterval &Orig = LIS.getInterval(OrigReg);
|
|
|
|
assert(!Orig.empty() && "Splitting empty interval?");
|
|
|
|
LiveInterval::const_iterator I = Orig.find(Idx);
|
|
|
|
|
|
|
|
// Range containing Idx should begin at Idx.
|
|
|
|
if (I != Orig.end() && I->start <= Idx)
|
|
|
|
return I->start == Idx;
|
|
|
|
|
|
|
|
// Range does not contain Idx, previous must end at Idx.
|
|
|
|
return I != Orig.begin() && (--I)->end == Idx;
|
|
|
|
}
|
|
|
|
|
2010-07-20 23:41:07 +08:00
|
|
|
void SplitAnalysis::analyze(const LiveInterval *li) {
|
|
|
|
clear();
|
2011-01-26 08:50:53 +08:00
|
|
|
CurLI = li;
|
2010-07-21 00:12:37 +08:00
|
|
|
analyzeUses();
|
2010-07-20 23:41:07 +08:00
|
|
|
}
|
|
|
|
|
2010-12-16 01:49:52 +08:00
|
|
|
|
2010-08-19 03:00:08 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2011-03-02 09:59:34 +08:00
|
|
|
// Split Editor
|
2010-08-19 03:00:08 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-03-02 09:59:34 +08:00
|
|
|
/// Create a new SplitEditor for editing the LiveInterval analyzed by SA.
|
2014-08-05 05:25:23 +08:00
|
|
|
SplitEditor::SplitEditor(SplitAnalysis &sa, LiveIntervals &lis, VirtRegMap &vrm,
|
2013-06-18 03:00:36 +08:00
|
|
|
MachineDominatorTree &mdt,
|
|
|
|
MachineBlockFrequencyInfo &mbfi)
|
2014-08-05 05:25:23 +08:00
|
|
|
: SA(sa), LIS(lis), VRM(vrm), MRI(vrm.getMachineFunction().getRegInfo()),
|
2014-10-14 15:22:00 +08:00
|
|
|
MDT(mdt), TII(*vrm.getMachineFunction().getSubtarget().getInstrInfo()),
|
|
|
|
TRI(*vrm.getMachineFunction().getSubtarget().getRegisterInfo()),
|
2014-08-05 05:25:23 +08:00
|
|
|
MBFI(mbfi), Edit(nullptr), OpenIdx(0), SpillMode(SM_Partition),
|
|
|
|
RegAssign(Allocator) {}
|
2011-03-03 09:29:13 +08:00
|
|
|
|
Add an interface for SplitKit complement spill modes.
SplitKit always computes a complement live range to cover the places
where the original live range was live, but no explicit region has been
allocated.
Currently, the complement live range is created to be as small as
possible - it never overlaps any of the regions. This minimizes
register pressure, but if the complement is going to be spilled anyway,
that is not very important. The spiller will eliminate redundant
spills, and hoist others by making the spill slot live range overlap
some of the regions created by splitting. Stack slots are cheap.
This patch adds the interface to enable spill modes in SplitKit. In
spill mode, SplitKit will assume that the complement is going to spill,
so it will allow it to overlap regions in order to avoid back-copies.
By doing some of the spiller's work early, the complement live range
becomes simpler. In some cases, it can become much simpler because no
extra PHI-defs are required. This will speed up both splitting and
spilling.
This is only the interface to enable spill modes, no implementation yet.
llvm-svn: 139500
2011-09-13 00:49:21 +08:00
|
|
|
void SplitEditor::reset(LiveRangeEdit &LRE, ComplementSpillMode SM) {
|
|
|
|
Edit = &LRE;
|
|
|
|
SpillMode = SM;
|
2011-03-03 09:29:13 +08:00
|
|
|
OpenIdx = 0;
|
|
|
|
RegAssign.clear();
|
|
|
|
Values.clear();
|
2011-09-14 00:47:53 +08:00
|
|
|
|
|
|
|
// Reset the LiveRangeCalc instances needed for this spill mode.
|
2012-06-05 02:21:16 +08:00
|
|
|
LRCalc[0].reset(&VRM.getMachineFunction(), LIS.getSlotIndexes(), &MDT,
|
|
|
|
&LIS.getVNInfoAllocator());
|
2011-09-14 00:47:53 +08:00
|
|
|
if (SpillMode)
|
2012-06-05 02:21:16 +08:00
|
|
|
LRCalc[1].reset(&VRM.getMachineFunction(), LIS.getSlotIndexes(), &MDT,
|
|
|
|
&LIS.getVNInfoAllocator());
|
2011-03-03 09:29:13 +08:00
|
|
|
|
2011-03-02 09:59:34 +08:00
|
|
|
// We don't need an AliasAnalysis since we will only be performing
|
|
|
|
// cheap-as-a-copy remats anyway.
|
2014-04-14 08:51:57 +08:00
|
|
|
Edit->anyRematerializable(nullptr);
|
2011-03-02 09:59:34 +08:00
|
|
|
}
|
|
|
|
|
2012-09-12 06:23:19 +08:00
|
|
|
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
2016-01-30 04:50:44 +08:00
|
|
|
LLVM_DUMP_METHOD void SplitEditor::dump() const {
|
2011-03-02 09:59:34 +08:00
|
|
|
if (RegAssign.empty()) {
|
|
|
|
dbgs() << " empty\n";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (RegAssignMap::const_iterator I = RegAssign.begin(); I.valid(); ++I)
|
|
|
|
dbgs() << " [" << I.start() << ';' << I.stop() << "):" << I.value();
|
|
|
|
dbgs() << '\n';
|
2010-09-14 05:29:45 +08:00
|
|
|
}
|
2012-09-07 03:06:06 +08:00
|
|
|
#endif
|
2010-09-14 05:29:45 +08:00
|
|
|
|
2011-03-02 09:59:34 +08:00
|
|
|
VNInfo *SplitEditor::defValue(unsigned RegIdx,
|
|
|
|
const VNInfo *ParentVNI,
|
|
|
|
SlotIndex Idx) {
|
|
|
|
assert(ParentVNI && "Mapping NULL value");
|
|
|
|
assert(Idx.isValid() && "Invalid SlotIndex");
|
2011-03-03 07:31:50 +08:00
|
|
|
assert(Edit->getParent().getVNInfoAt(Idx) == ParentVNI && "Bad Parent VNI");
|
2013-08-15 07:50:04 +08:00
|
|
|
LiveInterval *LI = &LIS.getInterval(Edit->get(RegIdx));
|
2011-03-02 09:59:34 +08:00
|
|
|
|
|
|
|
// Create a new value.
|
2012-02-04 13:20:49 +08:00
|
|
|
VNInfo *VNI = LI->getNextValue(Idx, LIS.getVNInfoAllocator());
|
2011-03-02 09:59:34 +08:00
|
|
|
|
|
|
|
// Use insert for lookup, so we can add missing values with a second lookup.
|
|
|
|
std::pair<ValueMap::iterator, bool> InsP =
|
2011-09-14 07:09:04 +08:00
|
|
|
Values.insert(std::make_pair(std::make_pair(RegIdx, ParentVNI->id),
|
|
|
|
ValueForcePair(VNI, false)));
|
2011-03-02 09:59:34 +08:00
|
|
|
|
|
|
|
// This was the first time (RegIdx, ParentVNI) was mapped.
|
|
|
|
// Keep it as a simple def without any liveness.
|
|
|
|
if (InsP.second)
|
|
|
|
return VNI;
|
|
|
|
|
|
|
|
// If the previous value was a simple mapping, add liveness for it now.
|
2011-09-14 07:09:04 +08:00
|
|
|
if (VNInfo *OldVNI = InsP.first->second.getPointer()) {
|
2011-03-02 09:59:34 +08:00
|
|
|
SlotIndex Def = OldVNI->def;
|
2013-10-11 05:28:43 +08:00
|
|
|
LI->addSegment(LiveInterval::Segment(Def, Def.getDeadSlot(), OldVNI));
|
2011-09-14 07:09:04 +08:00
|
|
|
// No longer a simple mapping. Switch to a complex, non-forced mapping.
|
|
|
|
InsP.first->second = ValueForcePair();
|
2011-03-02 09:59:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// This is a complex mapping, add liveness for VNI
|
|
|
|
SlotIndex Def = VNI->def;
|
2013-10-11 05:28:43 +08:00
|
|
|
LI->addSegment(LiveInterval::Segment(Def, Def.getDeadSlot(), VNI));
|
2011-03-02 09:59:34 +08:00
|
|
|
|
|
|
|
return VNI;
|
2010-09-14 07:29:09 +08:00
|
|
|
}
|
|
|
|
|
2011-09-14 07:09:04 +08:00
|
|
|
void SplitEditor::forceRecompute(unsigned RegIdx, const VNInfo *ParentVNI) {
|
2011-03-02 09:59:34 +08:00
|
|
|
assert(ParentVNI && "Mapping NULL value");
|
2011-09-14 07:09:04 +08:00
|
|
|
ValueForcePair &VFP = Values[std::make_pair(RegIdx, ParentVNI->id)];
|
|
|
|
VNInfo *VNI = VFP.getPointer();
|
2011-03-02 09:59:34 +08:00
|
|
|
|
2011-09-14 07:09:04 +08:00
|
|
|
// ParentVNI was either unmapped or already complex mapped. Either way, just
|
|
|
|
// set the force bit.
|
|
|
|
if (!VNI) {
|
|
|
|
VFP.setInt(true);
|
2011-03-02 09:59:34 +08:00
|
|
|
return;
|
2011-09-14 07:09:04 +08:00
|
|
|
}
|
2011-03-02 09:59:34 +08:00
|
|
|
|
|
|
|
// This was previously a single mapping. Make sure the old def is represented
|
|
|
|
// by a trivial live range.
|
|
|
|
SlotIndex Def = VNI->def;
|
2013-08-15 07:50:04 +08:00
|
|
|
LiveInterval *LI = &LIS.getInterval(Edit->get(RegIdx));
|
2013-10-11 05:28:43 +08:00
|
|
|
LI->addSegment(LiveInterval::Segment(Def, Def.getDeadSlot(), VNI));
|
2011-09-14 07:09:04 +08:00
|
|
|
// Mark as complex mapped, forced.
|
2014-04-14 08:51:57 +08:00
|
|
|
VFP = ValueForcePair(nullptr, true);
|
2011-09-14 02:05:29 +08:00
|
|
|
}
|
|
|
|
|
2011-02-03 14:18:29 +08:00
|
|
|
VNInfo *SplitEditor::defFromParent(unsigned RegIdx,
|
2010-11-11 03:31:50 +08:00
|
|
|
VNInfo *ParentVNI,
|
|
|
|
SlotIndex UseIdx,
|
|
|
|
MachineBasicBlock &MBB,
|
|
|
|
MachineBasicBlock::iterator I) {
|
2014-04-14 08:51:57 +08:00
|
|
|
MachineInstr *CopyMI = nullptr;
|
2010-11-11 03:31:50 +08:00
|
|
|
SlotIndex Def;
|
2013-08-15 07:50:04 +08:00
|
|
|
LiveInterval *LI = &LIS.getInterval(Edit->get(RegIdx));
|
2010-11-11 03:31:50 +08:00
|
|
|
|
2011-05-02 13:29:58 +08:00
|
|
|
// We may be trying to avoid interference that ends at a deleted instruction,
|
|
|
|
// so always begin RegIdx 0 early and all others late.
|
|
|
|
bool Late = RegIdx != 0;
|
|
|
|
|
2010-11-11 03:31:50 +08:00
|
|
|
// Attempt cheap-as-a-copy rematerialization.
|
2016-04-13 11:08:27 +08:00
|
|
|
unsigned Original = VRM.getOriginal(Edit->get(RegIdx));
|
|
|
|
LiveInterval &OrigLI = LIS.getInterval(Original);
|
|
|
|
VNInfo *OrigVNI = OrigLI.getVNInfoAt(UseIdx);
|
2010-11-11 03:31:50 +08:00
|
|
|
LiveRangeEdit::Remat RM(ParentVNI);
|
2016-04-13 11:08:27 +08:00
|
|
|
RM.OrigMI = LIS.getInstructionFromIndex(OrigVNI->def);
|
|
|
|
|
|
|
|
if (Edit->canRematerializeAt(RM, OrigVNI, UseIdx, true)) {
|
2012-04-03 06:22:53 +08:00
|
|
|
Def = Edit->rematerializeAt(MBB, I, LI->reg, RM, TRI, Late);
|
2011-05-06 01:22:53 +08:00
|
|
|
++NumRemats;
|
2010-11-11 03:31:50 +08:00
|
|
|
} else {
|
|
|
|
// Can't remat, just insert a copy from parent.
|
2011-02-03 14:18:29 +08:00
|
|
|
CopyMI = BuildMI(MBB, I, DebugLoc(), TII.get(TargetOpcode::COPY), LI->reg)
|
2011-03-03 07:31:50 +08:00
|
|
|
.addReg(Edit->getReg());
|
2016-02-27 14:40:41 +08:00
|
|
|
Def = LIS.getSlotIndexes()
|
|
|
|
->insertMachineInstrInMaps(*CopyMI, Late)
|
|
|
|
.getRegSlot();
|
2011-05-06 01:22:53 +08:00
|
|
|
++NumCopies;
|
2010-11-11 03:31:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Define the value in Reg.
|
2012-02-04 13:20:49 +08:00
|
|
|
return defValue(RegIdx, ParentVNI, Def);
|
2010-11-11 03:31:50 +08:00
|
|
|
}
|
|
|
|
|
2010-09-16 08:01:36 +08:00
|
|
|
/// Create a new virtual register and live interval.
|
2011-04-13 02:11:31 +08:00
|
|
|
unsigned SplitEditor::openIntv() {
|
2011-02-03 14:18:29 +08:00
|
|
|
// Create the complement as index 0.
|
2011-03-03 07:31:50 +08:00
|
|
|
if (Edit->empty())
|
2013-08-15 07:50:16 +08:00
|
|
|
Edit->createEmptyInterval();
|
2011-02-03 14:18:29 +08:00
|
|
|
|
|
|
|
// Create the open interval.
|
2011-03-03 07:31:50 +08:00
|
|
|
OpenIdx = Edit->size();
|
2013-08-15 07:50:16 +08:00
|
|
|
Edit->createEmptyInterval();
|
2011-04-13 02:11:31 +08:00
|
|
|
return OpenIdx;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SplitEditor::selectIntv(unsigned Idx) {
|
|
|
|
assert(Idx != 0 && "Cannot select the complement interval");
|
|
|
|
assert(Idx < Edit->size() && "Can only select previously opened interval");
|
Reapply r134047 now that the world is ready for it.
This patch will sometimes choose live range split points next to
interference instead of always splitting next to a register point. That
means spill code can now appear almost anywhere, and it was necessary
to fix code that didn't expect that.
The difficult places were:
- Between a CALL returning a value on the x87 stack and the
corresponding FpPOP_RETVAL (was FpGET_ST0). Probably also near x87
inline assembly, but that didn't actually show up in testing.
- Between a CALL popping arguments off the stack and the corresponding
ADJCALLSTACKUP.
Both are fixed now. The only place spill code can't appear is after
terminators, see SplitAnalysis::getLastSplitPoint.
Original commit message:
Rewrite RAGreedy::splitAroundRegion, now with cool ASCII art.
This function has to deal with a lot of special cases, and the old
version got it wrong sometimes. In particular, it would sometimes leave
multiple uses in the stack interval in a single block. That causes bad
code with multiple reloads in the same basic block.
The new version handles block entry and exit in a single pass. It first
eliminates all the easy cases, and then goes on to create a local
interval for the blocks with difficult interference. Previously, we
would only create the local interval for completely isolated blocks.
It can happen that the stack interval becomes completely empty because
we could allocate a register in all edge bundles, and the new local
intervals deal with the interference. The empty stack interval is
harmless, but we need to remove a SplitKit assertion that checks for
empty intervals.
llvm-svn: 134125
2011-06-30 09:30:39 +08:00
|
|
|
DEBUG(dbgs() << " selectIntv " << OpenIdx << " -> " << Idx << '\n');
|
2011-04-13 02:11:31 +08:00
|
|
|
OpenIdx = Idx;
|
2010-07-27 07:44:11 +08:00
|
|
|
}
|
|
|
|
|
2011-02-04 01:04:16 +08:00
|
|
|
SlotIndex SplitEditor::enterIntvBefore(SlotIndex Idx) {
|
2011-02-03 14:18:29 +08:00
|
|
|
assert(OpenIdx && "openIntv not called before enterIntvBefore");
|
2010-10-08 01:56:35 +08:00
|
|
|
DEBUG(dbgs() << " enterIntvBefore " << Idx);
|
2011-02-04 01:04:16 +08:00
|
|
|
Idx = Idx.getBaseIndex();
|
2011-03-03 07:31:50 +08:00
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(Idx);
|
2010-09-16 08:01:36 +08:00
|
|
|
if (!ParentVNI) {
|
2010-10-08 01:56:35 +08:00
|
|
|
DEBUG(dbgs() << ": not live\n");
|
2011-02-04 01:04:16 +08:00
|
|
|
return Idx;
|
2010-08-13 01:07:14 +08:00
|
|
|
}
|
2011-02-04 01:04:16 +08:00
|
|
|
DEBUG(dbgs() << ": valno " << ParentVNI->id << '\n');
|
2011-01-26 08:50:53 +08:00
|
|
|
MachineInstr *MI = LIS.getInstructionFromIndex(Idx);
|
2010-09-16 08:01:36 +08:00
|
|
|
assert(MI && "enterIntvBefore called with invalid index");
|
2010-11-11 03:31:50 +08:00
|
|
|
|
2011-02-04 01:04:16 +08:00
|
|
|
VNInfo *VNI = defFromParent(OpenIdx, ParentVNI, Idx, *MI->getParent(), MI);
|
|
|
|
return VNI->def;
|
2010-08-13 01:07:14 +08:00
|
|
|
}
|
|
|
|
|
Reapply r134047 now that the world is ready for it.
This patch will sometimes choose live range split points next to
interference instead of always splitting next to a register point. That
means spill code can now appear almost anywhere, and it was necessary
to fix code that didn't expect that.
The difficult places were:
- Between a CALL returning a value on the x87 stack and the
corresponding FpPOP_RETVAL (was FpGET_ST0). Probably also near x87
inline assembly, but that didn't actually show up in testing.
- Between a CALL popping arguments off the stack and the corresponding
ADJCALLSTACKUP.
Both are fixed now. The only place spill code can't appear is after
terminators, see SplitAnalysis::getLastSplitPoint.
Original commit message:
Rewrite RAGreedy::splitAroundRegion, now with cool ASCII art.
This function has to deal with a lot of special cases, and the old
version got it wrong sometimes. In particular, it would sometimes leave
multiple uses in the stack interval in a single block. That causes bad
code with multiple reloads in the same basic block.
The new version handles block entry and exit in a single pass. It first
eliminates all the easy cases, and then goes on to create a local
interval for the blocks with difficult interference. Previously, we
would only create the local interval for completely isolated blocks.
It can happen that the stack interval becomes completely empty because
we could allocate a register in all edge bundles, and the new local
intervals deal with the interference. The empty stack interval is
harmless, but we need to remove a SplitKit assertion that checks for
empty intervals.
llvm-svn: 134125
2011-06-30 09:30:39 +08:00
|
|
|
SlotIndex SplitEditor::enterIntvAfter(SlotIndex Idx) {
|
|
|
|
assert(OpenIdx && "openIntv not called before enterIntvAfter");
|
|
|
|
DEBUG(dbgs() << " enterIntvAfter " << Idx);
|
|
|
|
Idx = Idx.getBoundaryIndex();
|
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(Idx);
|
|
|
|
if (!ParentVNI) {
|
|
|
|
DEBUG(dbgs() << ": not live\n");
|
|
|
|
return Idx;
|
|
|
|
}
|
|
|
|
DEBUG(dbgs() << ": valno " << ParentVNI->id << '\n');
|
|
|
|
MachineInstr *MI = LIS.getInstructionFromIndex(Idx);
|
|
|
|
assert(MI && "enterIntvAfter called with invalid index");
|
|
|
|
|
|
|
|
VNInfo *VNI = defFromParent(OpenIdx, ParentVNI, Idx, *MI->getParent(),
|
2014-03-02 20:27:27 +08:00
|
|
|
std::next(MachineBasicBlock::iterator(MI)));
|
Reapply r134047 now that the world is ready for it.
This patch will sometimes choose live range split points next to
interference instead of always splitting next to a register point. That
means spill code can now appear almost anywhere, and it was necessary
to fix code that didn't expect that.
The difficult places were:
- Between a CALL returning a value on the x87 stack and the
corresponding FpPOP_RETVAL (was FpGET_ST0). Probably also near x87
inline assembly, but that didn't actually show up in testing.
- Between a CALL popping arguments off the stack and the corresponding
ADJCALLSTACKUP.
Both are fixed now. The only place spill code can't appear is after
terminators, see SplitAnalysis::getLastSplitPoint.
Original commit message:
Rewrite RAGreedy::splitAroundRegion, now with cool ASCII art.
This function has to deal with a lot of special cases, and the old
version got it wrong sometimes. In particular, it would sometimes leave
multiple uses in the stack interval in a single block. That causes bad
code with multiple reloads in the same basic block.
The new version handles block entry and exit in a single pass. It first
eliminates all the easy cases, and then goes on to create a local
interval for the blocks with difficult interference. Previously, we
would only create the local interval for completely isolated blocks.
It can happen that the stack interval becomes completely empty because
we could allocate a register in all edge bundles, and the new local
intervals deal with the interference. The empty stack interval is
harmless, but we need to remove a SplitKit assertion that checks for
empty intervals.
llvm-svn: 134125
2011-06-30 09:30:39 +08:00
|
|
|
return VNI->def;
|
|
|
|
}
|
|
|
|
|
2011-02-04 01:04:16 +08:00
|
|
|
SlotIndex SplitEditor::enterIntvAtEnd(MachineBasicBlock &MBB) {
|
2011-02-03 14:18:29 +08:00
|
|
|
assert(OpenIdx && "openIntv not called before enterIntvAtEnd");
|
2011-02-04 01:04:16 +08:00
|
|
|
SlotIndex End = LIS.getMBBEndIdx(&MBB);
|
|
|
|
SlotIndex Last = End.getPrevSlot();
|
|
|
|
DEBUG(dbgs() << " enterIntvAtEnd BB#" << MBB.getNumber() << ", " << Last);
|
2011-03-03 07:31:50 +08:00
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(Last);
|
2010-09-16 08:01:36 +08:00
|
|
|
if (!ParentVNI) {
|
2010-10-08 01:56:35 +08:00
|
|
|
DEBUG(dbgs() << ": not live\n");
|
2011-02-04 01:04:16 +08:00
|
|
|
return End;
|
2010-07-27 07:44:11 +08:00
|
|
|
}
|
2010-10-08 01:56:35 +08:00
|
|
|
DEBUG(dbgs() << ": valno " << ParentVNI->id);
|
2011-02-04 01:04:16 +08:00
|
|
|
VNInfo *VNI = defFromParent(OpenIdx, ParentVNI, Last, MBB,
|
2012-01-11 10:07:00 +08:00
|
|
|
SA.getLastSplitPointIter(&MBB));
|
2011-02-04 01:04:16 +08:00
|
|
|
RegAssign.insert(VNI->def, End, OpenIdx);
|
2011-02-03 14:18:29 +08:00
|
|
|
DEBUG(dump());
|
2011-02-04 01:04:16 +08:00
|
|
|
return VNI->def;
|
2010-07-27 07:44:11 +08:00
|
|
|
}
|
|
|
|
|
2011-01-26 08:50:53 +08:00
|
|
|
/// useIntv - indicate that all instructions in MBB should use OpenLI.
|
2010-08-05 06:08:39 +08:00
|
|
|
void SplitEditor::useIntv(const MachineBasicBlock &MBB) {
|
2011-01-26 08:50:53 +08:00
|
|
|
useIntv(LIS.getMBBStartIdx(&MBB), LIS.getMBBEndIdx(&MBB));
|
2010-07-27 07:44:11 +08:00
|
|
|
}
|
|
|
|
|
2010-08-05 06:08:39 +08:00
|
|
|
void SplitEditor::useIntv(SlotIndex Start, SlotIndex End) {
|
2011-02-03 14:18:29 +08:00
|
|
|
assert(OpenIdx && "openIntv not called before useIntv");
|
|
|
|
DEBUG(dbgs() << " useIntv [" << Start << ';' << End << "):");
|
|
|
|
RegAssign.insert(Start, End, OpenIdx);
|
|
|
|
DEBUG(dump());
|
2010-07-27 07:44:11 +08:00
|
|
|
}
|
|
|
|
|
2011-02-04 01:04:16 +08:00
|
|
|
SlotIndex SplitEditor::leaveIntvAfter(SlotIndex Idx) {
|
2011-02-03 14:18:29 +08:00
|
|
|
assert(OpenIdx && "openIntv not called before leaveIntvAfter");
|
2010-10-08 01:56:35 +08:00
|
|
|
DEBUG(dbgs() << " leaveIntvAfter " << Idx);
|
2010-08-13 01:07:14 +08:00
|
|
|
|
2010-09-16 08:01:36 +08:00
|
|
|
// The interval must be live beyond the instruction at Idx.
|
2011-09-16 08:03:35 +08:00
|
|
|
SlotIndex Boundary = Idx.getBoundaryIndex();
|
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(Boundary);
|
2010-09-16 08:01:36 +08:00
|
|
|
if (!ParentVNI) {
|
2010-10-08 01:56:35 +08:00
|
|
|
DEBUG(dbgs() << ": not live\n");
|
2011-09-16 08:03:35 +08:00
|
|
|
return Boundary.getNextSlot();
|
2010-08-13 01:07:14 +08:00
|
|
|
}
|
2011-02-04 01:04:16 +08:00
|
|
|
DEBUG(dbgs() << ": valno " << ParentVNI->id << '\n');
|
2011-09-16 08:03:35 +08:00
|
|
|
MachineInstr *MI = LIS.getInstructionFromIndex(Boundary);
|
2011-02-09 02:50:18 +08:00
|
|
|
assert(MI && "No instruction at index");
|
2011-09-16 08:03:35 +08:00
|
|
|
|
|
|
|
// In spill mode, make live ranges as short as possible by inserting the copy
|
|
|
|
// before MI. This is only possible if that instruction doesn't redefine the
|
|
|
|
// value. The inserted COPY is not a kill, and we don't need to recompute
|
|
|
|
// the source live range. The spiller also won't try to hoist this copy.
|
|
|
|
if (SpillMode && !SlotIndex::isSameInstr(ParentVNI->def, Idx) &&
|
|
|
|
MI->readsVirtualRegister(Edit->getReg())) {
|
|
|
|
forceRecompute(0, ParentVNI);
|
|
|
|
defFromParent(0, ParentVNI, Idx, *MI->getParent(), MI);
|
|
|
|
return Idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
VNInfo *VNI = defFromParent(0, ParentVNI, Boundary, *MI->getParent(),
|
2014-03-02 20:27:27 +08:00
|
|
|
std::next(MachineBasicBlock::iterator(MI)));
|
2011-02-04 01:04:16 +08:00
|
|
|
return VNI->def;
|
2010-08-13 01:07:14 +08:00
|
|
|
}
|
|
|
|
|
2011-02-10 07:30:25 +08:00
|
|
|
SlotIndex SplitEditor::leaveIntvBefore(SlotIndex Idx) {
|
|
|
|
assert(OpenIdx && "openIntv not called before leaveIntvBefore");
|
|
|
|
DEBUG(dbgs() << " leaveIntvBefore " << Idx);
|
|
|
|
|
|
|
|
// The interval must be live into the instruction at Idx.
|
2011-07-19 02:47:13 +08:00
|
|
|
Idx = Idx.getBaseIndex();
|
2011-03-03 07:31:50 +08:00
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(Idx);
|
2011-02-10 07:30:25 +08:00
|
|
|
if (!ParentVNI) {
|
|
|
|
DEBUG(dbgs() << ": not live\n");
|
|
|
|
return Idx.getNextSlot();
|
|
|
|
}
|
|
|
|
DEBUG(dbgs() << ": valno " << ParentVNI->id << '\n');
|
|
|
|
|
|
|
|
MachineInstr *MI = LIS.getInstructionFromIndex(Idx);
|
|
|
|
assert(MI && "No instruction at index");
|
|
|
|
VNInfo *VNI = defFromParent(0, ParentVNI, Idx, *MI->getParent(), MI);
|
|
|
|
return VNI->def;
|
|
|
|
}
|
|
|
|
|
2011-02-04 01:04:16 +08:00
|
|
|
SlotIndex SplitEditor::leaveIntvAtTop(MachineBasicBlock &MBB) {
|
2011-02-03 14:18:29 +08:00
|
|
|
assert(OpenIdx && "openIntv not called before leaveIntvAtTop");
|
2011-01-26 08:50:53 +08:00
|
|
|
SlotIndex Start = LIS.getMBBStartIdx(&MBB);
|
2010-10-08 01:56:35 +08:00
|
|
|
DEBUG(dbgs() << " leaveIntvAtTop BB#" << MBB.getNumber() << ", " << Start);
|
2010-08-05 06:08:39 +08:00
|
|
|
|
2011-03-03 07:31:50 +08:00
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(Start);
|
2010-09-16 08:01:36 +08:00
|
|
|
if (!ParentVNI) {
|
2010-10-08 01:56:35 +08:00
|
|
|
DEBUG(dbgs() << ": not live\n");
|
2011-02-04 01:04:16 +08:00
|
|
|
return Start;
|
2010-08-05 06:08:39 +08:00
|
|
|
}
|
|
|
|
|
2011-02-03 14:18:29 +08:00
|
|
|
VNInfo *VNI = defFromParent(0, ParentVNI, Start, MBB,
|
2010-11-11 03:31:50 +08:00
|
|
|
MBB.SkipPHIsAndLabels(MBB.begin()));
|
2011-02-03 14:18:29 +08:00
|
|
|
RegAssign.insert(Start, VNI->def, OpenIdx);
|
|
|
|
DEBUG(dump());
|
2011-02-04 01:04:16 +08:00
|
|
|
return VNI->def;
|
2010-07-27 07:44:11 +08:00
|
|
|
}
|
|
|
|
|
2011-02-09 02:50:21 +08:00
|
|
|
void SplitEditor::overlapIntv(SlotIndex Start, SlotIndex End) {
|
|
|
|
assert(OpenIdx && "openIntv not called before overlapIntv");
|
2011-03-03 07:31:50 +08:00
|
|
|
const VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(Start);
|
2011-11-14 09:39:36 +08:00
|
|
|
assert(ParentVNI == Edit->getParent().getVNInfoBefore(End) &&
|
2011-02-09 02:50:21 +08:00
|
|
|
"Parent changes value in extended range");
|
|
|
|
assert(LIS.getMBBFromIndex(Start) == LIS.getMBBFromIndex(End) &&
|
|
|
|
"Range cannot span basic blocks");
|
|
|
|
|
2011-09-14 01:38:57 +08:00
|
|
|
// The complement interval will be extended as needed by LRCalc.extend().
|
2011-04-06 07:43:14 +08:00
|
|
|
if (ParentVNI)
|
2011-09-14 07:09:04 +08:00
|
|
|
forceRecompute(0, ParentVNI);
|
2011-02-09 02:50:21 +08:00
|
|
|
DEBUG(dbgs() << " overlapIntv [" << Start << ';' << End << "):");
|
|
|
|
RegAssign.insert(Start, End, OpenIdx);
|
|
|
|
DEBUG(dump());
|
|
|
|
}
|
|
|
|
|
2011-09-14 06:22:39 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Spill modes
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
void SplitEditor::removeBackCopies(SmallVectorImpl<VNInfo*> &Copies) {
|
2013-08-15 07:50:04 +08:00
|
|
|
LiveInterval *LI = &LIS.getInterval(Edit->get(0));
|
2011-09-14 06:22:39 +08:00
|
|
|
DEBUG(dbgs() << "Removing " << Copies.size() << " back-copies.\n");
|
|
|
|
RegAssignMap::iterator AssignI;
|
|
|
|
AssignI.setMap(RegAssign);
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = Copies.size(); i != e; ++i) {
|
2015-01-22 03:02:30 +08:00
|
|
|
SlotIndex Def = Copies[i]->def;
|
2011-09-14 06:22:39 +08:00
|
|
|
MachineInstr *MI = LIS.getInstructionFromIndex(Def);
|
|
|
|
assert(MI && "No instruction for back-copy");
|
|
|
|
|
|
|
|
MachineBasicBlock *MBB = MI->getParent();
|
|
|
|
MachineBasicBlock::iterator MBBI(MI);
|
|
|
|
bool AtBegin;
|
|
|
|
do AtBegin = MBBI == MBB->begin();
|
|
|
|
while (!AtBegin && (--MBBI)->isDebugValue());
|
|
|
|
|
|
|
|
DEBUG(dbgs() << "Removing " << Def << '\t' << *MI);
|
2015-01-22 03:02:30 +08:00
|
|
|
LIS.removeVRegDefAt(*LI, Def);
|
2016-02-27 14:40:41 +08:00
|
|
|
LIS.RemoveMachineInstrFromMaps(*MI);
|
2011-09-14 06:22:39 +08:00
|
|
|
MI->eraseFromParent();
|
|
|
|
|
2015-01-22 03:02:30 +08:00
|
|
|
// Adjust RegAssign if a register assignment is killed at Def. We want to
|
|
|
|
// avoid calculating the live range of the source register if possible.
|
2012-08-04 04:59:29 +08:00
|
|
|
AssignI.find(Def.getPrevSlot());
|
2011-09-14 06:22:39 +08:00
|
|
|
if (!AssignI.valid() || AssignI.start() >= Def)
|
|
|
|
continue;
|
|
|
|
// If MI doesn't kill the assigned register, just leave it.
|
|
|
|
if (AssignI.stop() != Def)
|
|
|
|
continue;
|
|
|
|
unsigned RegIdx = AssignI.value();
|
|
|
|
if (AtBegin || !MBBI->readsVirtualRegister(Edit->getReg())) {
|
|
|
|
DEBUG(dbgs() << " cannot find simple kill of RegIdx " << RegIdx << '\n');
|
2011-09-14 07:09:04 +08:00
|
|
|
forceRecompute(RegIdx, Edit->getParent().getVNInfoAt(Def));
|
2011-09-14 06:22:39 +08:00
|
|
|
} else {
|
2016-02-27 14:40:41 +08:00
|
|
|
SlotIndex Kill = LIS.getInstructionIndex(*MBBI).getRegSlot();
|
2011-09-14 06:22:39 +08:00
|
|
|
DEBUG(dbgs() << " move kill to " << Kill << '\t' << *MBBI);
|
|
|
|
AssignI.setStop(Kill);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-15 00:45:39 +08:00
|
|
|
MachineBasicBlock*
|
|
|
|
SplitEditor::findShallowDominator(MachineBasicBlock *MBB,
|
|
|
|
MachineBasicBlock *DefMBB) {
|
|
|
|
if (MBB == DefMBB)
|
|
|
|
return MBB;
|
|
|
|
assert(MDT.dominates(DefMBB, MBB) && "MBB must be dominated by the def.");
|
|
|
|
|
|
|
|
const MachineLoopInfo &Loops = SA.Loops;
|
|
|
|
const MachineLoop *DefLoop = Loops.getLoopFor(DefMBB);
|
|
|
|
MachineDomTreeNode *DefDomNode = MDT[DefMBB];
|
|
|
|
|
|
|
|
// Best candidate so far.
|
|
|
|
MachineBasicBlock *BestMBB = MBB;
|
|
|
|
unsigned BestDepth = UINT_MAX;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
const MachineLoop *Loop = Loops.getLoopFor(MBB);
|
|
|
|
|
|
|
|
// MBB isn't in a loop, it doesn't get any better. All dominators have a
|
|
|
|
// higher frequency by definition.
|
|
|
|
if (!Loop) {
|
|
|
|
DEBUG(dbgs() << "Def in BB#" << DefMBB->getNumber() << " dominates BB#"
|
|
|
|
<< MBB->getNumber() << " at depth 0\n");
|
|
|
|
return MBB;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We'll never be able to exit the DefLoop.
|
|
|
|
if (Loop == DefLoop) {
|
|
|
|
DEBUG(dbgs() << "Def in BB#" << DefMBB->getNumber() << " dominates BB#"
|
|
|
|
<< MBB->getNumber() << " in the same loop\n");
|
|
|
|
return MBB;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Least busy dominator seen so far.
|
|
|
|
unsigned Depth = Loop->getLoopDepth();
|
|
|
|
if (Depth < BestDepth) {
|
|
|
|
BestMBB = MBB;
|
|
|
|
BestDepth = Depth;
|
|
|
|
DEBUG(dbgs() << "Def in BB#" << DefMBB->getNumber() << " dominates BB#"
|
|
|
|
<< MBB->getNumber() << " at depth " << Depth << '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
// Leave loop by going to the immediate dominator of the loop header.
|
|
|
|
// This is a bigger stride than simply walking up the dominator tree.
|
|
|
|
MachineDomTreeNode *IDom = MDT[Loop->getHeader()]->getIDom();
|
|
|
|
|
|
|
|
// Too far up the dominator tree?
|
|
|
|
if (!IDom || !MDT.dominates(DefDomNode, IDom))
|
|
|
|
return BestMBB;
|
|
|
|
|
|
|
|
MBB = IDom->getBlock();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-13 11:08:27 +08:00
|
|
|
void SplitEditor::computeRedundantBackCopies(
|
|
|
|
DenseSet<unsigned> &NotToHoistSet, SmallVectorImpl<VNInfo *> &BackCopies) {
|
|
|
|
LiveInterval *LI = &LIS.getInterval(Edit->get(0));
|
|
|
|
LiveInterval *Parent = &Edit->getParent();
|
|
|
|
SmallVector<SmallPtrSet<VNInfo *, 8>, 8> EqualVNs(Parent->getNumValNums());
|
|
|
|
SmallPtrSet<VNInfo *, 8> DominatedVNIs;
|
|
|
|
|
|
|
|
// Aggregate VNIs having the same value as ParentVNI.
|
|
|
|
for (VNInfo *VNI : LI->valnos) {
|
|
|
|
if (VNI->isUnused())
|
|
|
|
continue;
|
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(VNI->def);
|
|
|
|
EqualVNs[ParentVNI->id].insert(VNI);
|
|
|
|
}
|
|
|
|
|
|
|
|
// For VNI aggregation of each ParentVNI, collect dominated, i.e.,
|
|
|
|
// redundant VNIs to BackCopies.
|
|
|
|
for (unsigned i = 0, e = Parent->getNumValNums(); i != e; ++i) {
|
|
|
|
VNInfo *ParentVNI = Parent->getValNumInfo(i);
|
|
|
|
if (!NotToHoistSet.count(ParentVNI->id))
|
|
|
|
continue;
|
|
|
|
SmallPtrSetIterator<VNInfo *> It1 = EqualVNs[ParentVNI->id].begin();
|
|
|
|
SmallPtrSetIterator<VNInfo *> It2 = It1;
|
|
|
|
for (; It1 != EqualVNs[ParentVNI->id].end(); ++It1) {
|
|
|
|
It2 = It1;
|
|
|
|
for (++It2; It2 != EqualVNs[ParentVNI->id].end(); ++It2) {
|
|
|
|
if (DominatedVNIs.count(*It1) || DominatedVNIs.count(*It2))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
MachineBasicBlock *MBB1 = LIS.getMBBFromIndex((*It1)->def);
|
|
|
|
MachineBasicBlock *MBB2 = LIS.getMBBFromIndex((*It2)->def);
|
|
|
|
if (MBB1 == MBB2) {
|
|
|
|
DominatedVNIs.insert((*It1)->def < (*It2)->def ? (*It2) : (*It1));
|
|
|
|
} else if (MDT.dominates(MBB1, MBB2)) {
|
|
|
|
DominatedVNIs.insert(*It2);
|
|
|
|
} else if (MDT.dominates(MBB2, MBB1)) {
|
|
|
|
DominatedVNIs.insert(*It1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!DominatedVNIs.empty()) {
|
|
|
|
forceRecompute(0, ParentVNI);
|
|
|
|
for (auto VNI : DominatedVNIs) {
|
|
|
|
BackCopies.push_back(VNI);
|
|
|
|
}
|
|
|
|
DominatedVNIs.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// For SM_Size mode, find a common dominator for all the back-copies for
|
|
|
|
/// the same ParentVNI and hoist the backcopies to the dominator BB.
|
|
|
|
/// For SM_Speed mode, if the common dominator is hot and it is not beneficial
|
|
|
|
/// to do the hoisting, simply remove the dominated backcopies for the same
|
|
|
|
/// ParentVNI.
|
|
|
|
void SplitEditor::hoistCopies() {
|
2011-09-14 06:22:39 +08:00
|
|
|
// Get the complement interval, always RegIdx 0.
|
2013-08-15 07:50:04 +08:00
|
|
|
LiveInterval *LI = &LIS.getInterval(Edit->get(0));
|
2011-09-14 06:22:39 +08:00
|
|
|
LiveInterval *Parent = &Edit->getParent();
|
|
|
|
|
|
|
|
// Track the nearest common dominator for all back-copies for each ParentVNI,
|
|
|
|
// indexed by ParentVNI->id.
|
|
|
|
typedef std::pair<MachineBasicBlock*, SlotIndex> DomPair;
|
|
|
|
SmallVector<DomPair, 8> NearestDom(Parent->getNumValNums());
|
2016-04-13 11:08:27 +08:00
|
|
|
// The total cost of all the back-copies for each ParentVNI.
|
|
|
|
SmallVector<BlockFrequency, 8> Costs(Parent->getNumValNums());
|
|
|
|
// The ParentVNI->id set for which hoisting back-copies are not beneficial
|
|
|
|
// for Speed.
|
|
|
|
DenseSet<unsigned> NotToHoistSet;
|
2011-09-14 06:22:39 +08:00
|
|
|
|
|
|
|
// Find the nearest common dominator for parent values with multiple
|
|
|
|
// back-copies. If a single back-copy dominates, put it in DomPair.second.
|
2014-12-11 07:07:54 +08:00
|
|
|
for (VNInfo *VNI : LI->valnos) {
|
2012-08-04 04:59:29 +08:00
|
|
|
if (VNI->isUnused())
|
|
|
|
continue;
|
2011-09-14 06:22:39 +08:00
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(VNI->def);
|
|
|
|
assert(ParentVNI && "Parent not live at complement def");
|
|
|
|
|
|
|
|
// Don't hoist remats. The complement is probably going to disappear
|
|
|
|
// completely anyway.
|
|
|
|
if (Edit->didRematerialize(ParentVNI))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
MachineBasicBlock *ValMBB = LIS.getMBBFromIndex(VNI->def);
|
2016-04-13 11:08:27 +08:00
|
|
|
|
2011-09-14 06:22:39 +08:00
|
|
|
DomPair &Dom = NearestDom[ParentVNI->id];
|
|
|
|
|
|
|
|
// Keep directly defined parent values. This is either a PHI or an
|
|
|
|
// instruction in the complement range. All other copies of ParentVNI
|
|
|
|
// should be eliminated.
|
|
|
|
if (VNI->def == ParentVNI->def) {
|
|
|
|
DEBUG(dbgs() << "Direct complement def at " << VNI->def << '\n');
|
|
|
|
Dom = DomPair(ValMBB, VNI->def);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// Skip the singly mapped values. There is nothing to gain from hoisting a
|
|
|
|
// single back-copy.
|
2011-09-14 07:09:04 +08:00
|
|
|
if (Values.lookup(std::make_pair(0, ParentVNI->id)).getPointer()) {
|
2011-09-14 06:22:39 +08:00
|
|
|
DEBUG(dbgs() << "Single complement def at " << VNI->def << '\n');
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Dom.first) {
|
|
|
|
// First time we see ParentVNI. VNI dominates itself.
|
|
|
|
Dom = DomPair(ValMBB, VNI->def);
|
|
|
|
} else if (Dom.first == ValMBB) {
|
|
|
|
// Two defs in the same block. Pick the earlier def.
|
|
|
|
if (!Dom.second.isValid() || VNI->def < Dom.second)
|
|
|
|
Dom.second = VNI->def;
|
|
|
|
} else {
|
|
|
|
// Different basic blocks. Check if one dominates.
|
|
|
|
MachineBasicBlock *Near =
|
|
|
|
MDT.findNearestCommonDominator(Dom.first, ValMBB);
|
|
|
|
if (Near == ValMBB)
|
|
|
|
// Def ValMBB dominates.
|
|
|
|
Dom = DomPair(ValMBB, VNI->def);
|
|
|
|
else if (Near != Dom.first)
|
|
|
|
// None dominate. Hoist to common dominator, need new def.
|
|
|
|
Dom = DomPair(Near, SlotIndex());
|
2016-04-13 11:08:27 +08:00
|
|
|
Costs[ParentVNI->id] += MBFI.getBlockFreq(ValMBB);
|
2011-09-14 06:22:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG(dbgs() << "Multi-mapped complement " << VNI->id << '@' << VNI->def
|
|
|
|
<< " for parent " << ParentVNI->id << '@' << ParentVNI->def
|
|
|
|
<< " hoist to BB#" << Dom.first->getNumber() << ' '
|
|
|
|
<< Dom.second << '\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert the hoisted copies.
|
|
|
|
for (unsigned i = 0, e = Parent->getNumValNums(); i != e; ++i) {
|
|
|
|
DomPair &Dom = NearestDom[i];
|
|
|
|
if (!Dom.first || Dom.second.isValid())
|
|
|
|
continue;
|
2011-09-15 00:45:39 +08:00
|
|
|
// This value needs a hoisted copy inserted at the end of Dom.first.
|
|
|
|
VNInfo *ParentVNI = Parent->getValNumInfo(i);
|
|
|
|
MachineBasicBlock *DefMBB = LIS.getMBBFromIndex(ParentVNI->def);
|
|
|
|
// Get a less loopy dominator than Dom.first.
|
|
|
|
Dom.first = findShallowDominator(Dom.first, DefMBB);
|
2016-04-13 11:08:27 +08:00
|
|
|
if (SpillMode == SM_Speed &&
|
|
|
|
MBFI.getBlockFreq(Dom.first) > Costs[ParentVNI->id]) {
|
|
|
|
NotToHoistSet.insert(ParentVNI->id);
|
|
|
|
continue;
|
|
|
|
}
|
2011-09-14 06:22:39 +08:00
|
|
|
SlotIndex Last = LIS.getMBBEndIdx(Dom.first).getPrevSlot();
|
|
|
|
Dom.second =
|
2011-09-15 00:45:39 +08:00
|
|
|
defFromParent(0, ParentVNI, Last, *Dom.first,
|
2012-01-11 10:07:00 +08:00
|
|
|
SA.getLastSplitPointIter(Dom.first))->def;
|
2011-09-14 06:22:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Remove redundant back-copies that are now known to be dominated by another
|
|
|
|
// def with the same value.
|
|
|
|
SmallVector<VNInfo*, 8> BackCopies;
|
2014-12-11 07:07:54 +08:00
|
|
|
for (VNInfo *VNI : LI->valnos) {
|
2012-08-04 04:59:29 +08:00
|
|
|
if (VNI->isUnused())
|
|
|
|
continue;
|
2011-09-14 06:22:39 +08:00
|
|
|
VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(VNI->def);
|
|
|
|
const DomPair &Dom = NearestDom[ParentVNI->id];
|
2016-04-13 11:08:27 +08:00
|
|
|
if (!Dom.first || Dom.second == VNI->def ||
|
|
|
|
NotToHoistSet.count(ParentVNI->id))
|
2011-09-14 06:22:39 +08:00
|
|
|
continue;
|
|
|
|
BackCopies.push_back(VNI);
|
2011-09-14 07:09:04 +08:00
|
|
|
forceRecompute(0, ParentVNI);
|
2011-09-14 06:22:39 +08:00
|
|
|
}
|
2016-04-13 11:08:27 +08:00
|
|
|
|
|
|
|
// If it is not beneficial to hoist all the BackCopies, simply remove
|
|
|
|
// redundant BackCopies in speed mode.
|
|
|
|
if (SpillMode == SM_Speed && !NotToHoistSet.empty())
|
|
|
|
computeRedundantBackCopies(NotToHoistSet, BackCopies);
|
|
|
|
|
2011-09-14 06:22:39 +08:00
|
|
|
removeBackCopies(BackCopies);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-16 01:24:49 +08:00
|
|
|
/// transferValues - Transfer all possible values to the new live ranges.
|
2011-09-14 01:38:57 +08:00
|
|
|
/// Values that were rematerialized are left alone, they need LRCalc.extend().
|
2011-04-16 01:24:49 +08:00
|
|
|
bool SplitEditor::transferValues() {
|
2011-03-03 07:05:19 +08:00
|
|
|
bool Skipped = false;
|
|
|
|
RegAssignMap::const_iterator AssignI = RegAssign.begin();
|
2014-12-11 07:07:54 +08:00
|
|
|
for (const LiveRange::Segment &S : Edit->getParent()) {
|
|
|
|
DEBUG(dbgs() << " blit " << S << ':');
|
|
|
|
VNInfo *ParentVNI = S.valno;
|
2011-03-03 07:05:19 +08:00
|
|
|
// RegAssign has holes where RegIdx 0 should be used.
|
2014-12-11 07:07:54 +08:00
|
|
|
SlotIndex Start = S.start;
|
2011-03-03 07:05:19 +08:00
|
|
|
AssignI.advanceTo(Start);
|
|
|
|
do {
|
|
|
|
unsigned RegIdx;
|
2014-12-11 07:07:54 +08:00
|
|
|
SlotIndex End = S.end;
|
2011-03-03 07:05:19 +08:00
|
|
|
if (!AssignI.valid()) {
|
|
|
|
RegIdx = 0;
|
|
|
|
} else if (AssignI.start() <= Start) {
|
|
|
|
RegIdx = AssignI.value();
|
|
|
|
if (AssignI.stop() < End) {
|
|
|
|
End = AssignI.stop();
|
|
|
|
++AssignI;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
RegIdx = 0;
|
|
|
|
End = std::min(End, AssignI.start());
|
|
|
|
}
|
2011-04-16 01:24:49 +08:00
|
|
|
|
|
|
|
// The interval [Start;End) is continuously mapped to RegIdx, ParentVNI.
|
2011-03-03 07:05:19 +08:00
|
|
|
DEBUG(dbgs() << " [" << Start << ';' << End << ")=" << RegIdx);
|
2013-10-11 05:28:57 +08:00
|
|
|
LiveRange &LR = LIS.getInterval(Edit->get(RegIdx));
|
2011-04-16 01:24:49 +08:00
|
|
|
|
|
|
|
// Check for a simply defined value that can be blitted directly.
|
2011-09-14 07:09:04 +08:00
|
|
|
ValueForcePair VFP = Values.lookup(std::make_pair(RegIdx, ParentVNI->id));
|
|
|
|
if (VNInfo *VNI = VFP.getPointer()) {
|
2011-03-03 07:05:19 +08:00
|
|
|
DEBUG(dbgs() << ':' << VNI->id);
|
2013-10-11 05:28:57 +08:00
|
|
|
LR.addSegment(LiveInterval::Segment(Start, End, VNI));
|
2011-04-16 01:24:49 +08:00
|
|
|
Start = End;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-09-14 07:09:04 +08:00
|
|
|
// Skip values with forced recomputation.
|
|
|
|
if (VFP.getInt()) {
|
|
|
|
DEBUG(dbgs() << "(recalc)");
|
2011-03-03 07:05:19 +08:00
|
|
|
Skipped = true;
|
2011-04-16 01:24:49 +08:00
|
|
|
Start = End;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-09-14 00:47:53 +08:00
|
|
|
LiveRangeCalc &LRC = getLRCalc(RegIdx);
|
|
|
|
|
2011-04-16 01:24:49 +08:00
|
|
|
// This value has multiple defs in RegIdx, but it wasn't rematerialized,
|
|
|
|
// so the live range is accurate. Add live-in blocks in [Start;End) to the
|
|
|
|
// LiveInBlocks.
|
2015-10-10 06:56:24 +08:00
|
|
|
MachineFunction::iterator MBB = LIS.getMBBFromIndex(Start)->getIterator();
|
2011-04-16 01:24:49 +08:00
|
|
|
SlotIndex BlockStart, BlockEnd;
|
2015-10-10 06:56:24 +08:00
|
|
|
std::tie(BlockStart, BlockEnd) = LIS.getSlotIndexes()->getMBBRange(&*MBB);
|
2011-04-16 01:24:49 +08:00
|
|
|
|
|
|
|
// The first block may be live-in, or it may have its own def.
|
|
|
|
if (Start != BlockStart) {
|
2013-10-11 05:28:57 +08:00
|
|
|
VNInfo *VNI = LR.extendInBlock(BlockStart, std::min(BlockEnd, End));
|
2011-04-16 01:24:49 +08:00
|
|
|
assert(VNI && "Missing def for complex mapped value");
|
|
|
|
DEBUG(dbgs() << ':' << VNI->id << "*BB#" << MBB->getNumber());
|
|
|
|
// MBB has its own def. Is it also live-out?
|
2011-09-13 09:34:21 +08:00
|
|
|
if (BlockEnd <= End)
|
2015-10-10 06:56:24 +08:00
|
|
|
LRC.setLiveOutValue(&*MBB, VNI);
|
2011-09-13 09:34:21 +08:00
|
|
|
|
2011-04-16 01:24:49 +08:00
|
|
|
// Skip to the next block for live-in.
|
|
|
|
++MBB;
|
|
|
|
BlockStart = BlockEnd;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle the live-in blocks covered by [Start;End).
|
|
|
|
assert(Start <= BlockStart && "Expected live-in block");
|
|
|
|
while (BlockStart < End) {
|
|
|
|
DEBUG(dbgs() << ">BB#" << MBB->getNumber());
|
2015-10-10 06:56:24 +08:00
|
|
|
BlockEnd = LIS.getMBBEndIdx(&*MBB);
|
2011-04-16 01:24:49 +08:00
|
|
|
if (BlockStart == ParentVNI->def) {
|
|
|
|
// This block has the def of a parent PHI, so it isn't live-in.
|
|
|
|
assert(ParentVNI->isPHIDef() && "Non-phi defined at block start?");
|
2013-10-11 05:28:57 +08:00
|
|
|
VNInfo *VNI = LR.extendInBlock(BlockStart, std::min(BlockEnd, End));
|
2011-04-16 01:24:49 +08:00
|
|
|
assert(VNI && "Missing def for complex mapped parent PHI");
|
2011-09-13 09:34:21 +08:00
|
|
|
if (End >= BlockEnd)
|
2015-10-10 06:56:24 +08:00
|
|
|
LRC.setLiveOutValue(&*MBB, VNI); // Live-out as well.
|
2011-04-16 01:24:49 +08:00
|
|
|
} else {
|
2011-09-13 09:34:21 +08:00
|
|
|
// This block needs a live-in value. The last block covered may not
|
|
|
|
// be live-out.
|
2011-04-16 01:24:49 +08:00
|
|
|
if (End < BlockEnd)
|
2015-10-10 06:56:24 +08:00
|
|
|
LRC.addLiveInBlock(LR, MDT[&*MBB], End);
|
2011-04-16 01:24:49 +08:00
|
|
|
else {
|
2011-09-13 09:34:21 +08:00
|
|
|
// Live-through, and we don't know the value.
|
2015-10-10 06:56:24 +08:00
|
|
|
LRC.addLiveInBlock(LR, MDT[&*MBB]);
|
|
|
|
LRC.setLiveOutValue(&*MBB, nullptr);
|
2011-04-16 01:24:49 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
BlockStart = BlockEnd;
|
|
|
|
++MBB;
|
|
|
|
}
|
2011-03-03 07:05:19 +08:00
|
|
|
Start = End;
|
2014-12-11 07:07:54 +08:00
|
|
|
} while (Start != S.end);
|
2011-03-03 07:05:19 +08:00
|
|
|
DEBUG(dbgs() << '\n');
|
|
|
|
}
|
2011-04-16 01:24:49 +08:00
|
|
|
|
2012-06-05 02:21:16 +08:00
|
|
|
LRCalc[0].calculateValues();
|
2011-09-14 00:47:53 +08:00
|
|
|
if (SpillMode)
|
2012-06-05 02:21:16 +08:00
|
|
|
LRCalc[1].calculateValues();
|
2011-04-16 01:24:49 +08:00
|
|
|
|
2011-03-03 07:05:19 +08:00
|
|
|
return Skipped;
|
|
|
|
}
|
|
|
|
|
2011-03-03 07:05:16 +08:00
|
|
|
void SplitEditor::extendPHIKillRanges() {
|
2016-04-13 11:08:27 +08:00
|
|
|
// Extend live ranges to be live-out for successor PHI values.
|
2014-12-11 07:07:54 +08:00
|
|
|
for (const VNInfo *PHIVNI : Edit->getParent().valnos) {
|
2011-03-03 07:05:16 +08:00
|
|
|
if (PHIVNI->isUnused() || !PHIVNI->isPHIDef())
|
|
|
|
continue;
|
|
|
|
unsigned RegIdx = RegAssign.lookup(PHIVNI->def);
|
2013-10-11 05:28:57 +08:00
|
|
|
LiveRange &LR = LIS.getInterval(Edit->get(RegIdx));
|
2016-04-13 11:08:27 +08:00
|
|
|
|
|
|
|
// Check whether PHI is dead.
|
|
|
|
const LiveRange::Segment *Segment = LR.getSegmentContaining(PHIVNI->def);
|
|
|
|
assert(Segment != nullptr && "Missing segment for VNI");
|
|
|
|
if (Segment->end == PHIVNI->def.getDeadSlot()) {
|
|
|
|
// This is a dead PHI. Remove it.
|
|
|
|
LR.removeSegment(*Segment, true);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-09-14 01:38:57 +08:00
|
|
|
LiveRangeCalc &LRC = getLRCalc(RegIdx);
|
2011-03-03 07:05:16 +08:00
|
|
|
MachineBasicBlock *MBB = LIS.getMBBFromIndex(PHIVNI->def);
|
|
|
|
for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(),
|
|
|
|
PE = MBB->pred_end(); PI != PE; ++PI) {
|
2011-09-14 01:38:57 +08:00
|
|
|
SlotIndex End = LIS.getMBBEndIdx(*PI);
|
|
|
|
SlotIndex LastUse = End.getPrevSlot();
|
2011-03-03 07:05:16 +08:00
|
|
|
// The predecessor may not have a live-out value. That is OK, like an
|
|
|
|
// undef PHI operand.
|
2011-09-14 01:38:57 +08:00
|
|
|
if (Edit->getParent().liveAt(LastUse)) {
|
|
|
|
assert(RegAssign.lookup(LastUse) == RegIdx &&
|
2011-03-03 07:05:16 +08:00
|
|
|
"Different register assignment in phi predecessor");
|
2013-10-11 05:28:57 +08:00
|
|
|
LRC.extend(LR, End);
|
2011-03-03 07:05:16 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-03 07:31:50 +08:00
|
|
|
/// rewriteAssigned - Rewrite all uses of Edit->getReg().
|
2011-03-03 07:05:19 +08:00
|
|
|
void SplitEditor::rewriteAssigned(bool ExtendRanges) {
|
2011-03-03 07:31:50 +08:00
|
|
|
for (MachineRegisterInfo::reg_iterator RI = MRI.reg_begin(Edit->getReg()),
|
2011-01-26 08:50:53 +08:00
|
|
|
RE = MRI.reg_end(); RI != RE;) {
|
2014-03-14 07:12:04 +08:00
|
|
|
MachineOperand &MO = *RI;
|
2010-10-09 07:42:21 +08:00
|
|
|
MachineInstr *MI = MO.getParent();
|
|
|
|
++RI;
|
2011-02-03 14:18:29 +08:00
|
|
|
// LiveDebugVariables should have handled all DBG_VALUE instructions.
|
2010-10-09 07:42:21 +08:00
|
|
|
if (MI->isDebugValue()) {
|
|
|
|
DEBUG(dbgs() << "Zapping " << *MI);
|
|
|
|
MO.setReg(0);
|
|
|
|
continue;
|
|
|
|
}
|
2011-02-10 05:52:09 +08:00
|
|
|
|
2011-07-25 04:23:50 +08:00
|
|
|
// <undef> operands don't really read the register, so it doesn't matter
|
|
|
|
// which register we choose. When the use operand is tied to a def, we must
|
|
|
|
// use the same register as the def, so just do that always.
|
2016-02-27 14:40:41 +08:00
|
|
|
SlotIndex Idx = LIS.getInstructionIndex(*MI);
|
2011-07-25 04:23:50 +08:00
|
|
|
if (MO.isDef() || MO.isUndef())
|
2011-11-14 04:45:27 +08:00
|
|
|
Idx = Idx.getRegSlot(MO.isEarlyClobber());
|
2011-02-03 14:18:29 +08:00
|
|
|
|
|
|
|
// Rewrite to the mapped register at Idx.
|
|
|
|
unsigned RegIdx = RegAssign.lookup(Idx);
|
2013-08-15 07:50:04 +08:00
|
|
|
LiveInterval *LI = &LIS.getInterval(Edit->get(RegIdx));
|
2011-09-14 01:38:57 +08:00
|
|
|
MO.setReg(LI->reg);
|
2011-02-03 14:18:29 +08:00
|
|
|
DEBUG(dbgs() << " rewr BB#" << MI->getParent()->getNumber() << '\t'
|
|
|
|
<< Idx << ':' << RegIdx << '\t' << *MI);
|
|
|
|
|
2011-03-18 11:06:02 +08:00
|
|
|
// Extend liveness to Idx if the instruction reads reg.
|
2011-07-25 04:33:23 +08:00
|
|
|
if (!ExtendRanges || MO.isUndef())
|
2011-03-18 11:06:02 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// Skip instructions that don't read Reg.
|
|
|
|
if (MO.isDef()) {
|
|
|
|
if (!MO.getSubReg() && !MO.isEarlyClobber())
|
|
|
|
continue;
|
|
|
|
// We may wan't to extend a live range for a partial redef, or for a use
|
|
|
|
// tied to an early clobber.
|
|
|
|
Idx = Idx.getPrevSlot();
|
|
|
|
if (!Edit->getParent().liveAt(Idx))
|
|
|
|
continue;
|
|
|
|
} else
|
2011-11-14 04:45:27 +08:00
|
|
|
Idx = Idx.getRegSlot(true);
|
2011-03-18 11:06:02 +08:00
|
|
|
|
2013-10-11 05:28:57 +08:00
|
|
|
getLRCalc(RegIdx).extend(*LI, Idx.getNextSlot());
|
2010-10-09 07:42:21 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-09 06:46:11 +08:00
|
|
|
void SplitEditor::deleteRematVictims() {
|
|
|
|
SmallVector<MachineInstr*, 8> Dead;
|
2011-03-21 03:46:23 +08:00
|
|
|
for (LiveRangeEdit::iterator I = Edit->begin(), E = Edit->end(); I != E; ++I){
|
2013-08-15 07:50:04 +08:00
|
|
|
LiveInterval *LI = &LIS.getInterval(*I);
|
2014-12-11 07:07:54 +08:00
|
|
|
for (const LiveRange::Segment &S : LI->segments) {
|
2011-11-14 06:42:13 +08:00
|
|
|
// Dead defs end at the dead slot.
|
2014-12-11 07:07:54 +08:00
|
|
|
if (S.end != S.valno->def.getDeadSlot())
|
2011-03-21 03:46:23 +08:00
|
|
|
continue;
|
2016-04-13 11:08:27 +08:00
|
|
|
if (S.valno->isPHIDef())
|
|
|
|
continue;
|
2014-12-11 07:07:54 +08:00
|
|
|
MachineInstr *MI = LIS.getInstructionFromIndex(S.valno->def);
|
2011-03-21 03:46:23 +08:00
|
|
|
assert(MI && "Missing instruction for dead def");
|
|
|
|
MI->addRegisterDead(LI->reg, &TRI);
|
2011-03-09 06:46:11 +08:00
|
|
|
|
2011-03-21 03:46:23 +08:00
|
|
|
if (!MI->allDefsAreDead())
|
|
|
|
continue;
|
2011-03-09 06:46:11 +08:00
|
|
|
|
2011-03-21 03:46:23 +08:00
|
|
|
DEBUG(dbgs() << "All defs dead: " << *MI);
|
|
|
|
Dead.push_back(MI);
|
|
|
|
}
|
2011-03-09 06:46:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Dead.empty())
|
|
|
|
return;
|
|
|
|
|
2012-04-03 06:22:53 +08:00
|
|
|
Edit->eliminateDeadDefs(Dead);
|
2011-03-09 06:46:11 +08:00
|
|
|
}
|
|
|
|
|
2011-04-22 02:38:15 +08:00
|
|
|
void SplitEditor::finish(SmallVectorImpl<unsigned> *LRMap) {
|
2011-03-03 07:05:19 +08:00
|
|
|
++NumFinished;
|
2011-02-03 14:18:29 +08:00
|
|
|
|
|
|
|
// At this point, the live intervals in Edit contain VNInfos corresponding to
|
|
|
|
// the inserted copies.
|
|
|
|
|
|
|
|
// Add the original defs from the parent interval.
|
2014-12-11 07:07:54 +08:00
|
|
|
for (const VNInfo *ParentVNI : Edit->getParent().valnos) {
|
2011-02-04 08:59:23 +08:00
|
|
|
if (ParentVNI->isUnused())
|
|
|
|
continue;
|
2011-03-02 07:14:53 +08:00
|
|
|
unsigned RegIdx = RegAssign.lookup(ParentVNI->def);
|
2012-07-28 05:11:14 +08:00
|
|
|
defValue(RegIdx, ParentVNI, ParentVNI->def);
|
2011-03-16 05:13:22 +08:00
|
|
|
|
2011-09-14 07:09:04 +08:00
|
|
|
// Force rematted values to be recomputed everywhere.
|
2011-03-03 07:05:19 +08:00
|
|
|
// The new live ranges may be truncated.
|
2011-03-03 07:31:50 +08:00
|
|
|
if (Edit->didRematerialize(ParentVNI))
|
|
|
|
for (unsigned i = 0, e = Edit->size(); i != e; ++i)
|
2011-09-14 07:09:04 +08:00
|
|
|
forceRecompute(i, ParentVNI);
|
2010-09-22 06:32:21 +08:00
|
|
|
}
|
2010-10-27 08:39:07 +08:00
|
|
|
|
2011-09-14 06:22:39 +08:00
|
|
|
// Hoist back-copies to the complement interval when in spill mode.
|
|
|
|
switch (SpillMode) {
|
|
|
|
case SM_Partition:
|
|
|
|
// Leave all back-copies as is.
|
|
|
|
break;
|
|
|
|
case SM_Size:
|
|
|
|
case SM_Speed:
|
2016-04-13 11:08:27 +08:00
|
|
|
// hoistCopies will behave differently between size and speed.
|
|
|
|
hoistCopies();
|
2011-09-14 06:22:39 +08:00
|
|
|
}
|
|
|
|
|
2011-04-16 01:24:49 +08:00
|
|
|
// Transfer the simply mapped values, check if any are skipped.
|
|
|
|
bool Skipped = transferValues();
|
2016-04-13 11:08:27 +08:00
|
|
|
|
|
|
|
// Rewrite virtual registers, possibly extending ranges.
|
|
|
|
rewriteAssigned(Skipped);
|
|
|
|
|
2011-04-16 01:24:49 +08:00
|
|
|
if (Skipped)
|
2011-03-03 07:05:19 +08:00
|
|
|
extendPHIKillRanges();
|
|
|
|
else
|
|
|
|
++NumSimple;
|
|
|
|
|
2011-03-09 06:46:11 +08:00
|
|
|
// Delete defs that were rematted everywhere.
|
2011-04-16 01:24:49 +08:00
|
|
|
if (Skipped)
|
2011-03-09 06:46:11 +08:00
|
|
|
deleteRematVictims();
|
2010-09-22 06:32:21 +08:00
|
|
|
|
2010-10-08 07:34:34 +08:00
|
|
|
// Get rid of unused values and set phi-kill flags.
|
2013-08-15 07:50:04 +08:00
|
|
|
for (LiveRangeEdit::iterator I = Edit->begin(), E = Edit->end(); I != E; ++I) {
|
|
|
|
LiveInterval &LI = LIS.getInterval(*I);
|
|
|
|
LI.RenumberValues();
|
|
|
|
}
|
2010-10-08 07:34:34 +08:00
|
|
|
|
2011-04-22 02:38:15 +08:00
|
|
|
// Provide a reverse mapping from original indices to Edit ranges.
|
|
|
|
if (LRMap) {
|
|
|
|
LRMap->clear();
|
|
|
|
for (unsigned i = 0, e = Edit->size(); i != e; ++i)
|
|
|
|
LRMap->push_back(i);
|
|
|
|
}
|
|
|
|
|
2010-10-27 06:36:09 +08:00
|
|
|
// Now check if any registers were separated into multiple components.
|
2011-01-26 08:50:53 +08:00
|
|
|
ConnectedVNInfoEqClasses ConEQ(LIS);
|
2011-03-03 07:31:50 +08:00
|
|
|
for (unsigned i = 0, e = Edit->size(); i != e; ++i) {
|
2010-10-27 06:36:09 +08:00
|
|
|
// Don't use iterators, they are invalidated by create() below.
|
2015-09-22 11:44:41 +08:00
|
|
|
unsigned VReg = Edit->get(i);
|
|
|
|
LiveInterval &LI = LIS.getInterval(VReg);
|
|
|
|
SmallVector<LiveInterval*, 8> SplitLIs;
|
|
|
|
LIS.splitSeparateComponents(LI, SplitLIs);
|
|
|
|
unsigned Original = VRM.getOriginal(VReg);
|
|
|
|
for (LiveInterval *SplitLI : SplitLIs)
|
|
|
|
VRM.setIsSplitFromReg(SplitLI->reg, Original);
|
|
|
|
|
2011-04-22 02:38:15 +08:00
|
|
|
// The new intervals all map back to i.
|
|
|
|
if (LRMap)
|
|
|
|
LRMap->resize(Edit->size(), i);
|
2010-10-27 06:36:09 +08:00
|
|
|
}
|
|
|
|
|
2010-08-11 01:07:22 +08:00
|
|
|
// Calculate spill weight and allocation hints for new intervals.
|
2013-06-18 03:00:36 +08:00
|
|
|
Edit->calculateRegClassAndHint(VRM.getMachineFunction(), SA.Loops, MBFI);
|
2011-04-22 02:38:15 +08:00
|
|
|
|
|
|
|
assert(!LRMap || LRMap->size() == Edit->size());
|
2010-07-27 07:44:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-08-13 01:07:14 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Single Block Splitting
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-08-06 06:20:45 +08:00
|
|
|
bool SplitAnalysis::shouldSplitSingleBlock(const BlockInfo &BI,
|
|
|
|
bool SingleInstrs) const {
|
|
|
|
// Always split for multiple instructions.
|
|
|
|
if (!BI.isOneInstr())
|
|
|
|
return true;
|
|
|
|
// Don't split for single instructions unless explicitly requested.
|
|
|
|
if (!SingleInstrs)
|
|
|
|
return false;
|
|
|
|
// Splitting a live-through range always makes progress.
|
|
|
|
if (BI.LiveIn && BI.LiveOut)
|
|
|
|
return true;
|
|
|
|
// No point in isolating a copy. It has no register class constraints.
|
|
|
|
if (LIS.getInstructionFromIndex(BI.FirstInstr)->isCopyLike())
|
|
|
|
return false;
|
|
|
|
// Finally, don't isolate an end point that was created by earlier splits.
|
|
|
|
return isOriginalEndpoint(BI.FirstInstr);
|
|
|
|
}
|
|
|
|
|
2011-04-13 03:32:53 +08:00
|
|
|
void SplitEditor::splitSingleBlock(const SplitAnalysis::BlockInfo &BI) {
|
|
|
|
openIntv();
|
|
|
|
SlotIndex LastSplitPoint = SA.getLastSplitPoint(BI.MBB->getNumber());
|
2011-08-03 06:54:14 +08:00
|
|
|
SlotIndex SegStart = enterIntvBefore(std::min(BI.FirstInstr,
|
2011-04-13 03:32:53 +08:00
|
|
|
LastSplitPoint));
|
2011-08-03 06:54:14 +08:00
|
|
|
if (!BI.LiveOut || BI.LastInstr < LastSplitPoint) {
|
|
|
|
useIntv(SegStart, leaveIntvAfter(BI.LastInstr));
|
2011-04-13 03:32:53 +08:00
|
|
|
} else {
|
|
|
|
// The last use is after the last valid split point.
|
|
|
|
SlotIndex SegStop = leaveIntvBefore(LastSplitPoint);
|
|
|
|
useIntv(SegStart, SegStop);
|
2011-08-03 06:54:14 +08:00
|
|
|
overlapIntv(SegStop, BI.LastInstr);
|
2011-04-13 03:32:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-16 05:47:57 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Global Live Range Splitting Support
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
// These methods support a method of global live range splitting that uses a
|
|
|
|
// global algorithm to decide intervals for CFG edges. They will insert split
|
|
|
|
// points and color intervals in basic blocks while avoiding interference.
|
|
|
|
//
|
|
|
|
// Note that splitSingleBlock is also useful for blocks where both CFG edges
|
|
|
|
// are on the stack.
|
|
|
|
|
|
|
|
void SplitEditor::splitLiveThroughBlock(unsigned MBBNum,
|
|
|
|
unsigned IntvIn, SlotIndex LeaveBefore,
|
|
|
|
unsigned IntvOut, SlotIndex EnterAfter){
|
|
|
|
SlotIndex Start, Stop;
|
2014-03-02 21:30:33 +08:00
|
|
|
std::tie(Start, Stop) = LIS.getSlotIndexes()->getMBBRange(MBBNum);
|
2011-07-16 05:47:57 +08:00
|
|
|
|
|
|
|
DEBUG(dbgs() << "BB#" << MBBNum << " [" << Start << ';' << Stop
|
|
|
|
<< ") intf " << LeaveBefore << '-' << EnterAfter
|
|
|
|
<< ", live-through " << IntvIn << " -> " << IntvOut);
|
|
|
|
|
|
|
|
assert((IntvIn || IntvOut) && "Use splitSingleBlock for isolated blocks");
|
|
|
|
|
2011-07-23 11:32:26 +08:00
|
|
|
assert((!LeaveBefore || LeaveBefore < Stop) && "Interference after block");
|
|
|
|
assert((!IntvIn || !LeaveBefore || LeaveBefore > Start) && "Impossible intf");
|
|
|
|
assert((!EnterAfter || EnterAfter >= Start) && "Interference before block");
|
|
|
|
|
|
|
|
MachineBasicBlock *MBB = VRM.getMachineFunction().getBlockNumbered(MBBNum);
|
|
|
|
|
2011-07-16 05:47:57 +08:00
|
|
|
if (!IntvOut) {
|
|
|
|
DEBUG(dbgs() << ", spill on entry.\n");
|
|
|
|
//
|
|
|
|
// <<<<<<<<< Possible LeaveBefore interference.
|
|
|
|
// |-----------| Live through.
|
|
|
|
// -____________ Spill on entry.
|
|
|
|
//
|
|
|
|
selectIntv(IntvIn);
|
|
|
|
SlotIndex Idx = leaveIntvAtTop(*MBB);
|
|
|
|
assert((!LeaveBefore || Idx <= LeaveBefore) && "Interference");
|
|
|
|
(void)Idx;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!IntvIn) {
|
|
|
|
DEBUG(dbgs() << ", reload on exit.\n");
|
|
|
|
//
|
|
|
|
// >>>>>>> Possible EnterAfter interference.
|
|
|
|
// |-----------| Live through.
|
|
|
|
// ___________-- Reload on exit.
|
|
|
|
//
|
|
|
|
selectIntv(IntvOut);
|
|
|
|
SlotIndex Idx = enterIntvAtEnd(*MBB);
|
|
|
|
assert((!EnterAfter || Idx >= EnterAfter) && "Interference");
|
|
|
|
(void)Idx;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IntvIn == IntvOut && !LeaveBefore && !EnterAfter) {
|
|
|
|
DEBUG(dbgs() << ", straight through.\n");
|
|
|
|
//
|
|
|
|
// |-----------| Live through.
|
|
|
|
// ------------- Straight through, same intv, no interference.
|
|
|
|
//
|
|
|
|
selectIntv(IntvOut);
|
|
|
|
useIntv(Start, Stop);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We cannot legally insert splits after LSP.
|
|
|
|
SlotIndex LSP = SA.getLastSplitPoint(MBBNum);
|
2011-07-23 11:32:26 +08:00
|
|
|
assert((!IntvOut || !EnterAfter || EnterAfter < LSP) && "Impossible intf");
|
2011-07-16 05:47:57 +08:00
|
|
|
|
|
|
|
if (IntvIn != IntvOut && (!LeaveBefore || !EnterAfter ||
|
|
|
|
LeaveBefore.getBaseIndex() > EnterAfter.getBoundaryIndex())) {
|
|
|
|
DEBUG(dbgs() << ", switch avoiding interference.\n");
|
|
|
|
//
|
|
|
|
// >>>> <<<< Non-overlapping EnterAfter/LeaveBefore interference.
|
|
|
|
// |-----------| Live through.
|
|
|
|
// ------======= Switch intervals between interference.
|
|
|
|
//
|
|
|
|
selectIntv(IntvOut);
|
2011-07-23 11:32:26 +08:00
|
|
|
SlotIndex Idx;
|
|
|
|
if (LeaveBefore && LeaveBefore < LSP) {
|
|
|
|
Idx = enterIntvBefore(LeaveBefore);
|
|
|
|
useIntv(Idx, Stop);
|
|
|
|
} else {
|
|
|
|
Idx = enterIntvAtEnd(*MBB);
|
|
|
|
}
|
2011-07-16 05:47:57 +08:00
|
|
|
selectIntv(IntvIn);
|
|
|
|
useIntv(Start, Idx);
|
|
|
|
assert((!LeaveBefore || Idx <= LeaveBefore) && "Interference");
|
|
|
|
assert((!EnterAfter || Idx >= EnterAfter) && "Interference");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEBUG(dbgs() << ", create local intv for interference.\n");
|
|
|
|
//
|
|
|
|
// >>><><><><<<< Overlapping EnterAfter/LeaveBefore interference.
|
|
|
|
// |-----------| Live through.
|
|
|
|
// ==---------== Switch intervals before/after interference.
|
|
|
|
//
|
|
|
|
assert(LeaveBefore <= EnterAfter && "Missed case");
|
|
|
|
|
|
|
|
selectIntv(IntvOut);
|
|
|
|
SlotIndex Idx = enterIntvAfter(EnterAfter);
|
|
|
|
useIntv(Idx, Stop);
|
|
|
|
assert((!EnterAfter || Idx >= EnterAfter) && "Interference");
|
|
|
|
|
|
|
|
selectIntv(IntvIn);
|
|
|
|
Idx = leaveIntvBefore(LeaveBefore);
|
|
|
|
useIntv(Start, Idx);
|
|
|
|
assert((!LeaveBefore || Idx <= LeaveBefore) && "Interference");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SplitEditor::splitRegInBlock(const SplitAnalysis::BlockInfo &BI,
|
|
|
|
unsigned IntvIn, SlotIndex LeaveBefore) {
|
|
|
|
SlotIndex Start, Stop;
|
2014-03-02 21:30:33 +08:00
|
|
|
std::tie(Start, Stop) = LIS.getSlotIndexes()->getMBBRange(BI.MBB);
|
2011-07-16 05:47:57 +08:00
|
|
|
|
|
|
|
DEBUG(dbgs() << "BB#" << BI.MBB->getNumber() << " [" << Start << ';' << Stop
|
2011-08-03 06:54:14 +08:00
|
|
|
<< "), uses " << BI.FirstInstr << '-' << BI.LastInstr
|
2011-07-16 05:47:57 +08:00
|
|
|
<< ", reg-in " << IntvIn << ", leave before " << LeaveBefore
|
|
|
|
<< (BI.LiveOut ? ", stack-out" : ", killed in block"));
|
|
|
|
|
|
|
|
assert(IntvIn && "Must have register in");
|
|
|
|
assert(BI.LiveIn && "Must be live-in");
|
|
|
|
assert((!LeaveBefore || LeaveBefore > Start) && "Bad interference");
|
|
|
|
|
2011-08-03 06:54:14 +08:00
|
|
|
if (!BI.LiveOut && (!LeaveBefore || LeaveBefore >= BI.LastInstr)) {
|
2011-07-16 05:47:57 +08:00
|
|
|
DEBUG(dbgs() << " before interference.\n");
|
|
|
|
//
|
|
|
|
// <<< Interference after kill.
|
|
|
|
// |---o---x | Killed in block.
|
|
|
|
// ========= Use IntvIn everywhere.
|
|
|
|
//
|
|
|
|
selectIntv(IntvIn);
|
2011-08-03 06:54:14 +08:00
|
|
|
useIntv(Start, BI.LastInstr);
|
2011-07-16 05:47:57 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
SlotIndex LSP = SA.getLastSplitPoint(BI.MBB->getNumber());
|
|
|
|
|
2011-08-03 06:54:14 +08:00
|
|
|
if (!LeaveBefore || LeaveBefore > BI.LastInstr.getBoundaryIndex()) {
|
2011-07-16 05:47:57 +08:00
|
|
|
//
|
|
|
|
// <<< Possible interference after last use.
|
|
|
|
// |---o---o---| Live-out on stack.
|
|
|
|
// =========____ Leave IntvIn after last use.
|
|
|
|
//
|
|
|
|
// < Interference after last use.
|
|
|
|
// |---o---o--o| Live-out on stack, late last use.
|
|
|
|
// ============ Copy to stack after LSP, overlap IntvIn.
|
|
|
|
// \_____ Stack interval is live-out.
|
|
|
|
//
|
2011-08-03 06:54:14 +08:00
|
|
|
if (BI.LastInstr < LSP) {
|
2011-07-16 05:47:57 +08:00
|
|
|
DEBUG(dbgs() << ", spill after last use before interference.\n");
|
|
|
|
selectIntv(IntvIn);
|
2011-08-03 06:54:14 +08:00
|
|
|
SlotIndex Idx = leaveIntvAfter(BI.LastInstr);
|
2011-07-16 05:47:57 +08:00
|
|
|
useIntv(Start, Idx);
|
|
|
|
assert((!LeaveBefore || Idx <= LeaveBefore) && "Interference");
|
|
|
|
} else {
|
|
|
|
DEBUG(dbgs() << ", spill before last split point.\n");
|
|
|
|
selectIntv(IntvIn);
|
2011-07-16 08:13:30 +08:00
|
|
|
SlotIndex Idx = leaveIntvBefore(LSP);
|
2011-08-03 06:54:14 +08:00
|
|
|
overlapIntv(Idx, BI.LastInstr);
|
2011-07-16 05:47:57 +08:00
|
|
|
useIntv(Start, Idx);
|
|
|
|
assert((!LeaveBefore || Idx <= LeaveBefore) && "Interference");
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The interference is overlapping somewhere we wanted to use IntvIn. That
|
|
|
|
// means we need to create a local interval that can be allocated a
|
|
|
|
// different register.
|
|
|
|
unsigned LocalIntv = openIntv();
|
2011-07-16 12:18:47 +08:00
|
|
|
(void)LocalIntv;
|
2011-07-16 05:47:57 +08:00
|
|
|
DEBUG(dbgs() << ", creating local interval " << LocalIntv << ".\n");
|
|
|
|
|
2011-08-03 06:54:14 +08:00
|
|
|
if (!BI.LiveOut || BI.LastInstr < LSP) {
|
2011-07-16 05:47:57 +08:00
|
|
|
//
|
|
|
|
// <<<<<<< Interference overlapping uses.
|
|
|
|
// |---o---o---| Live-out on stack.
|
|
|
|
// =====----____ Leave IntvIn before interference, then spill.
|
|
|
|
//
|
2011-08-03 06:54:14 +08:00
|
|
|
SlotIndex To = leaveIntvAfter(BI.LastInstr);
|
2011-07-16 05:47:57 +08:00
|
|
|
SlotIndex From = enterIntvBefore(LeaveBefore);
|
|
|
|
useIntv(From, To);
|
|
|
|
selectIntv(IntvIn);
|
|
|
|
useIntv(Start, From);
|
|
|
|
assert((!LeaveBefore || From <= LeaveBefore) && "Interference");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// <<<<<<< Interference overlapping uses.
|
|
|
|
// |---o---o--o| Live-out on stack, late last use.
|
|
|
|
// =====------- Copy to stack before LSP, overlap LocalIntv.
|
|
|
|
// \_____ Stack interval is live-out.
|
|
|
|
//
|
|
|
|
SlotIndex To = leaveIntvBefore(LSP);
|
2011-08-03 06:54:14 +08:00
|
|
|
overlapIntv(To, BI.LastInstr);
|
2011-07-16 05:47:57 +08:00
|
|
|
SlotIndex From = enterIntvBefore(std::min(To, LeaveBefore));
|
|
|
|
useIntv(From, To);
|
|
|
|
selectIntv(IntvIn);
|
|
|
|
useIntv(Start, From);
|
|
|
|
assert((!LeaveBefore || From <= LeaveBefore) && "Interference");
|
|
|
|
}
|
|
|
|
|
|
|
|
void SplitEditor::splitRegOutBlock(const SplitAnalysis::BlockInfo &BI,
|
|
|
|
unsigned IntvOut, SlotIndex EnterAfter) {
|
|
|
|
SlotIndex Start, Stop;
|
2014-03-02 21:30:33 +08:00
|
|
|
std::tie(Start, Stop) = LIS.getSlotIndexes()->getMBBRange(BI.MBB);
|
2011-07-16 05:47:57 +08:00
|
|
|
|
|
|
|
DEBUG(dbgs() << "BB#" << BI.MBB->getNumber() << " [" << Start << ';' << Stop
|
2011-08-03 06:54:14 +08:00
|
|
|
<< "), uses " << BI.FirstInstr << '-' << BI.LastInstr
|
2011-07-16 05:47:57 +08:00
|
|
|
<< ", reg-out " << IntvOut << ", enter after " << EnterAfter
|
|
|
|
<< (BI.LiveIn ? ", stack-in" : ", defined in block"));
|
|
|
|
|
|
|
|
SlotIndex LSP = SA.getLastSplitPoint(BI.MBB->getNumber());
|
|
|
|
|
|
|
|
assert(IntvOut && "Must have register out");
|
|
|
|
assert(BI.LiveOut && "Must be live-out");
|
|
|
|
assert((!EnterAfter || EnterAfter < LSP) && "Bad interference");
|
|
|
|
|
2011-08-03 06:54:14 +08:00
|
|
|
if (!BI.LiveIn && (!EnterAfter || EnterAfter <= BI.FirstInstr)) {
|
2011-07-16 05:47:57 +08:00
|
|
|
DEBUG(dbgs() << " after interference.\n");
|
|
|
|
//
|
|
|
|
// >>>> Interference before def.
|
|
|
|
// | o---o---| Defined in block.
|
|
|
|
// ========= Use IntvOut everywhere.
|
|
|
|
//
|
|
|
|
selectIntv(IntvOut);
|
2011-08-03 06:54:14 +08:00
|
|
|
useIntv(BI.FirstInstr, Stop);
|
2011-07-16 05:47:57 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-08-03 06:54:14 +08:00
|
|
|
if (!EnterAfter || EnterAfter < BI.FirstInstr.getBaseIndex()) {
|
2011-07-16 05:47:57 +08:00
|
|
|
DEBUG(dbgs() << ", reload after interference.\n");
|
|
|
|
//
|
|
|
|
// >>>> Interference before def.
|
|
|
|
// |---o---o---| Live-through, stack-in.
|
|
|
|
// ____========= Enter IntvOut before first use.
|
|
|
|
//
|
|
|
|
selectIntv(IntvOut);
|
2011-08-03 06:54:14 +08:00
|
|
|
SlotIndex Idx = enterIntvBefore(std::min(LSP, BI.FirstInstr));
|
2011-07-16 05:47:57 +08:00
|
|
|
useIntv(Idx, Stop);
|
|
|
|
assert((!EnterAfter || Idx >= EnterAfter) && "Interference");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The interference is overlapping somewhere we wanted to use IntvOut. That
|
|
|
|
// means we need to create a local interval that can be allocated a
|
|
|
|
// different register.
|
|
|
|
DEBUG(dbgs() << ", interference overlaps uses.\n");
|
|
|
|
//
|
|
|
|
// >>>>>>> Interference overlapping uses.
|
|
|
|
// |---o---o---| Live-through, stack-in.
|
|
|
|
// ____---====== Create local interval for interference range.
|
|
|
|
//
|
|
|
|
selectIntv(IntvOut);
|
|
|
|
SlotIndex Idx = enterIntvAfter(EnterAfter);
|
|
|
|
useIntv(Idx, Stop);
|
|
|
|
assert((!EnterAfter || Idx >= EnterAfter) && "Interference");
|
|
|
|
|
|
|
|
openIntv();
|
2011-08-03 06:54:14 +08:00
|
|
|
SlotIndex From = enterIntvBefore(std::min(Idx, BI.FirstInstr));
|
2011-07-16 05:47:57 +08:00
|
|
|
useIntv(From, Idx);
|
|
|
|
}
|