2010-01-07 00:48:02 +08:00
|
|
|
//===----- AggressiveAntiDepBreaker.cpp - Anti-dep breaker ----------------===//
|
2009-10-27 03:32:42 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the AggressiveAntiDepBreaker class, which
|
|
|
|
// implements register anti-dependence breaking during post-RA
|
|
|
|
// scheduling. It attempts to break all anti-dependencies within a
|
|
|
|
// block.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "AggressiveAntiDepBreaker.h"
|
|
|
|
#include "llvm/CodeGen/MachineBasicBlock.h"
|
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstr.h"
|
2012-06-07 04:29:31 +08:00
|
|
|
#include "llvm/CodeGen/RegisterClassInfo.h"
|
2009-10-27 06:31:16 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2009-10-27 03:32:42 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
2009-10-27 03:32:42 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:02:50 +08:00
|
|
|
#define DEBUG_TYPE "post-RA-sched"
|
|
|
|
|
2009-11-20 07:12:37 +08:00
|
|
|
// If DebugDiv > 0 then only break antidep with (ID % DebugDiv) == DebugMod
|
|
|
|
static cl::opt<int>
|
|
|
|
DebugDiv("agg-antidep-debugdiv",
|
2010-04-10 05:38:26 +08:00
|
|
|
cl::desc("Debug control for aggressive anti-dep breaker"),
|
|
|
|
cl::init(0), cl::Hidden);
|
2009-11-20 07:12:37 +08:00
|
|
|
static cl::opt<int>
|
|
|
|
DebugMod("agg-antidep-debugmod",
|
2010-04-10 05:38:26 +08:00
|
|
|
cl::desc("Debug control for aggressive anti-dep breaker"),
|
|
|
|
cl::init(0), cl::Hidden);
|
2009-11-20 07:12:37 +08:00
|
|
|
|
2009-12-10 01:18:22 +08:00
|
|
|
AggressiveAntiDepState::AggressiveAntiDepState(const unsigned TargetRegs,
|
|
|
|
MachineBasicBlock *BB) :
|
2010-07-16 03:58:14 +08:00
|
|
|
NumTargetRegs(TargetRegs), GroupNodes(TargetRegs, 0),
|
|
|
|
GroupNodeIndices(TargetRegs, 0),
|
|
|
|
KillIndices(TargetRegs, 0),
|
|
|
|
DefIndices(TargetRegs, 0)
|
|
|
|
{
|
2009-12-10 01:18:22 +08:00
|
|
|
const unsigned BBSize = BB->size();
|
|
|
|
for (unsigned i = 0; i < NumTargetRegs; ++i) {
|
|
|
|
// Initialize all registers to be in their own group. Initially we
|
|
|
|
// assign the register to the same-indexed GroupNode.
|
2009-10-27 06:31:16 +08:00
|
|
|
GroupNodeIndices[i] = i;
|
2009-12-10 01:18:22 +08:00
|
|
|
// Initialize the indices to indicate that no registers are live.
|
|
|
|
KillIndices[i] = ~0u;
|
|
|
|
DefIndices[i] = BBSize;
|
|
|
|
}
|
2009-10-27 06:31:16 +08:00
|
|
|
}
|
|
|
|
|
2010-07-16 03:41:20 +08:00
|
|
|
unsigned AggressiveAntiDepState::GetGroup(unsigned Reg) {
|
2009-10-27 06:31:16 +08:00
|
|
|
unsigned Node = GroupNodeIndices[Reg];
|
|
|
|
while (GroupNodes[Node] != Node)
|
|
|
|
Node = GroupNodes[Node];
|
|
|
|
|
|
|
|
return Node;
|
|
|
|
}
|
|
|
|
|
2009-11-14 03:52:48 +08:00
|
|
|
void AggressiveAntiDepState::GetGroupRegs(
|
|
|
|
unsigned Group,
|
|
|
|
std::vector<unsigned> &Regs,
|
|
|
|
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference> *RegRefs)
|
2009-10-27 06:31:16 +08:00
|
|
|
{
|
2009-12-10 01:18:22 +08:00
|
|
|
for (unsigned Reg = 0; Reg != NumTargetRegs; ++Reg) {
|
2009-11-14 03:52:48 +08:00
|
|
|
if ((GetGroup(Reg) == Group) && (RegRefs->count(Reg) > 0))
|
2009-10-27 06:31:16 +08:00
|
|
|
Regs.push_back(Reg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned AggressiveAntiDepState::UnionGroups(unsigned Reg1, unsigned Reg2)
|
|
|
|
{
|
|
|
|
assert(GroupNodes[0] == 0 && "GroupNode 0 not parent!");
|
|
|
|
assert(GroupNodeIndices[0] == 0 && "Reg 0 not in Group 0!");
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 06:31:16 +08:00
|
|
|
// find group for each register
|
|
|
|
unsigned Group1 = GetGroup(Reg1);
|
|
|
|
unsigned Group2 = GetGroup(Reg2);
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 06:31:16 +08:00
|
|
|
// if either group is 0, then that must become the parent
|
|
|
|
unsigned Parent = (Group1 == 0) ? Group1 : Group2;
|
|
|
|
unsigned Other = (Parent == Group1) ? Group2 : Group1;
|
|
|
|
GroupNodes.at(Other) = Parent;
|
|
|
|
return Parent;
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 06:31:16 +08:00
|
|
|
unsigned AggressiveAntiDepState::LeaveGroup(unsigned Reg)
|
|
|
|
{
|
|
|
|
// Create a new GroupNode for Reg. Reg's existing GroupNode must
|
|
|
|
// stay as is because there could be other GroupNodes referring to
|
|
|
|
// it.
|
|
|
|
unsigned idx = GroupNodes.size();
|
|
|
|
GroupNodes.push_back(idx);
|
|
|
|
GroupNodeIndices[Reg] = idx;
|
|
|
|
return idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AggressiveAntiDepState::IsLive(unsigned Reg)
|
|
|
|
{
|
|
|
|
// KillIndex must be defined and DefIndex not defined for a register
|
|
|
|
// to be live.
|
|
|
|
return((KillIndices[Reg] != ~0u) && (DefIndices[Reg] == ~0u));
|
|
|
|
}
|
|
|
|
|
2014-08-05 05:25:23 +08:00
|
|
|
AggressiveAntiDepBreaker::AggressiveAntiDepBreaker(
|
|
|
|
MachineFunction &MFi, const RegisterClassInfo &RCI,
|
|
|
|
TargetSubtargetInfo::RegClassVector &CriticalPathRCs)
|
|
|
|
: AntiDepBreaker(), MF(MFi), MRI(MF.getRegInfo()),
|
2014-08-05 10:39:49 +08:00
|
|
|
TII(MF.getSubtarget().getInstrInfo()),
|
|
|
|
TRI(MF.getSubtarget().getRegisterInfo()), RegClassInfo(RCI),
|
|
|
|
State(nullptr) {
|
2009-11-14 03:52:48 +08:00
|
|
|
/* Collect a bitset of all registers that are only broken if they
|
|
|
|
are on the critical path. */
|
|
|
|
for (unsigned i = 0, e = CriticalPathRCs.size(); i < e; ++i) {
|
|
|
|
BitVector CPSet = TRI->getAllocatableSet(MF, CriticalPathRCs[i]);
|
|
|
|
if (CriticalPathSet.none())
|
|
|
|
CriticalPathSet = CPSet;
|
|
|
|
else
|
|
|
|
CriticalPathSet |= CPSet;
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "AntiDep Critical-Path Registers:");
|
2010-01-07 00:48:02 +08:00
|
|
|
DEBUG(for (int r = CriticalPathSet.find_first(); r != -1;
|
2009-11-14 03:52:48 +08:00
|
|
|
r = CriticalPathSet.find_next(r))
|
2009-12-24 08:14:25 +08:00
|
|
|
dbgs() << " " << TRI->getName(r));
|
|
|
|
DEBUG(dbgs() << '\n');
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
AggressiveAntiDepBreaker::~AggressiveAntiDepBreaker() {
|
2009-10-27 06:31:16 +08:00
|
|
|
delete State;
|
|
|
|
}
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2009-10-27 06:31:16 +08:00
|
|
|
void AggressiveAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
|
2014-04-14 08:51:57 +08:00
|
|
|
assert(!State);
|
2009-12-10 01:18:22 +08:00
|
|
|
State = new AggressiveAntiDepState(TRI->getNumRegs(), BB);
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2015-09-26 05:25:19 +08:00
|
|
|
bool IsReturnBlock = BB->isReturnBlock();
|
2010-07-16 02:43:09 +08:00
|
|
|
std::vector<unsigned> &KillIndices = State->GetKillIndices();
|
|
|
|
std::vector<unsigned> &DefIndices = State->GetDefIndices();
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2013-02-06 02:21:52 +08:00
|
|
|
// Examine the live-in regs of all successors.
|
2010-06-16 15:35:02 +08:00
|
|
|
for (MachineBasicBlock::succ_iterator SI = BB->succ_begin(),
|
2009-10-27 03:32:42 +08:00
|
|
|
SE = BB->succ_end(); SI != SE; ++SI)
|
2015-09-10 02:08:03 +08:00
|
|
|
for (const auto &LI : (*SI)->liveins()) {
|
|
|
|
for (MCRegAliasIterator AI(LI.PhysReg, TRI, true); AI.isValid(); ++AI) {
|
2012-06-02 07:28:30 +08:00
|
|
|
unsigned Reg = *AI;
|
2010-12-15 07:23:15 +08:00
|
|
|
State->UnionGroups(Reg, 0);
|
|
|
|
KillIndices[Reg] = BB->size();
|
|
|
|
DefIndices[Reg] = ~0u;
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
2010-06-16 15:35:02 +08:00
|
|
|
}
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
// Mark live-out callee-saved registers. In a return block this is
|
|
|
|
// all callee-saved registers. In non-return this is any
|
|
|
|
// callee-saved register that is not saved in the prolog.
|
2016-07-29 02:40:00 +08:00
|
|
|
const MachineFrameInfo &MFI = MF.getFrameInfo();
|
|
|
|
BitVector Pristine = MFI.getPristineRegs(MF);
|
2014-04-04 13:16:06 +08:00
|
|
|
for (const MCPhysReg *I = TRI->getCalleeSavedRegs(&MF); *I; ++I) {
|
2009-10-27 03:32:42 +08:00
|
|
|
unsigned Reg = *I;
|
|
|
|
if (!IsReturnBlock && !Pristine.test(Reg)) continue;
|
2012-06-02 07:28:30 +08:00
|
|
|
for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI) {
|
|
|
|
unsigned AliasReg = *AI;
|
2009-10-27 06:31:16 +08:00
|
|
|
State->UnionGroups(AliasReg, 0);
|
2009-10-27 03:32:42 +08:00
|
|
|
KillIndices[AliasReg] = BB->size();
|
|
|
|
DefIndices[AliasReg] = ~0u;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void AggressiveAntiDepBreaker::FinishBlock() {
|
2009-10-27 06:31:16 +08:00
|
|
|
delete State;
|
2014-04-14 08:51:57 +08:00
|
|
|
State = nullptr;
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
2016-02-28 03:33:37 +08:00
|
|
|
void AggressiveAntiDepBreaker::Observe(MachineInstr &MI, unsigned Count,
|
2010-04-10 05:38:26 +08:00
|
|
|
unsigned InsertPosIndex) {
|
2009-10-27 03:32:42 +08:00
|
|
|
assert(Count < InsertPosIndex && "Instruction index out of expected range!");
|
|
|
|
|
2009-10-30 07:30:59 +08:00
|
|
|
std::set<unsigned> PassthruRegs;
|
|
|
|
GetPassthruRegs(MI, PassthruRegs);
|
|
|
|
PrescanInstruction(MI, Count, PassthruRegs);
|
|
|
|
ScanInstruction(MI, Count);
|
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "Observe: ");
|
2016-02-28 03:33:37 +08:00
|
|
|
DEBUG(MI.dump());
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\tRegs:");
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2010-07-16 02:43:09 +08:00
|
|
|
std::vector<unsigned> &DefIndices = State->GetDefIndices();
|
2009-12-10 01:18:22 +08:00
|
|
|
for (unsigned Reg = 0; Reg != TRI->getNumRegs(); ++Reg) {
|
2009-10-27 03:32:42 +08:00
|
|
|
// If Reg is current live, then mark that it can't be renamed as
|
|
|
|
// we don't know the extent of its live-range anymore (now that it
|
|
|
|
// has been scheduled). If it is not live but was defined in the
|
|
|
|
// previous schedule region, then set its def index to the most
|
|
|
|
// conservative location (i.e. the beginning of the previous
|
|
|
|
// schedule region).
|
2009-10-27 06:31:16 +08:00
|
|
|
if (State->IsLive(Reg)) {
|
|
|
|
DEBUG(if (State->GetGroup(Reg) != 0)
|
2010-01-07 00:48:02 +08:00
|
|
|
dbgs() << " " << TRI->getName(Reg) << "=g" <<
|
2009-10-27 06:31:16 +08:00
|
|
|
State->GetGroup(Reg) << "->g0(region live-out)");
|
|
|
|
State->UnionGroups(Reg, 0);
|
2010-01-07 00:48:02 +08:00
|
|
|
} else if ((DefIndices[Reg] < InsertPosIndex)
|
|
|
|
&& (DefIndices[Reg] >= Count)) {
|
2009-10-27 03:32:42 +08:00
|
|
|
DefIndices[Reg] = Count;
|
|
|
|
}
|
|
|
|
}
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << '\n');
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
2016-02-28 03:33:37 +08:00
|
|
|
bool AggressiveAntiDepBreaker::IsImplicitDefUse(MachineInstr &MI,
|
|
|
|
MachineOperand &MO) {
|
2009-10-27 03:32:42 +08:00
|
|
|
if (!MO.isReg() || !MO.isImplicit())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned Reg = MO.getReg();
|
|
|
|
if (Reg == 0)
|
|
|
|
return false;
|
|
|
|
|
2015-10-10 03:48:48 +08:00
|
|
|
MachineOperand *Op = nullptr;
|
|
|
|
if (MO.isDef())
|
2016-02-28 03:33:37 +08:00
|
|
|
Op = MI.findRegisterUseOperand(Reg, true);
|
2015-10-10 03:48:48 +08:00
|
|
|
else
|
2016-02-28 03:33:37 +08:00
|
|
|
Op = MI.findRegisterDefOperand(Reg);
|
2015-10-10 03:48:48 +08:00
|
|
|
|
2014-04-14 08:51:57 +08:00
|
|
|
return(Op && Op->isImplicit());
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
2016-02-28 03:33:37 +08:00
|
|
|
void AggressiveAntiDepBreaker::GetPassthruRegs(
|
|
|
|
MachineInstr &MI, std::set<unsigned> &PassthruRegs) {
|
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2009-10-27 03:32:42 +08:00
|
|
|
if (!MO.isReg()) continue;
|
2016-02-28 03:33:37 +08:00
|
|
|
if ((MO.isDef() && MI.isRegTiedToUseOperand(i)) ||
|
2009-10-27 03:32:42 +08:00
|
|
|
IsImplicitDefUse(MI, MO)) {
|
|
|
|
const unsigned Reg = MO.getReg();
|
2013-05-23 07:17:36 +08:00
|
|
|
for (MCSubRegIterator SubRegs(Reg, TRI, /*IncludeSelf=*/true);
|
|
|
|
SubRegs.isValid(); ++SubRegs)
|
2012-06-02 07:28:30 +08:00
|
|
|
PassthruRegs.insert(*SubRegs);
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-21 03:32:48 +08:00
|
|
|
/// AntiDepEdges - Return in Edges the anti- and output- dependencies
|
|
|
|
/// in SU that we want to consider for breaking.
|
2010-04-20 07:11:58 +08:00
|
|
|
static void AntiDepEdges(const SUnit *SU, std::vector<const SDep*>& Edges) {
|
2009-11-21 03:32:48 +08:00
|
|
|
SmallSet<unsigned, 4> RegSet;
|
2010-04-20 07:11:58 +08:00
|
|
|
for (SUnit::const_pred_iterator P = SU->Preds.begin(), PE = SU->Preds.end();
|
2009-10-27 03:32:42 +08:00
|
|
|
P != PE; ++P) {
|
2009-11-13 03:08:21 +08:00
|
|
|
if ((P->getKind() == SDep::Anti) || (P->getKind() == SDep::Output)) {
|
2014-11-19 15:49:26 +08:00
|
|
|
if (RegSet.insert(P->getReg()).second)
|
2009-10-27 03:32:42 +08:00
|
|
|
Edges.push_back(&*P);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-14 03:52:48 +08:00
|
|
|
/// CriticalPathStep - Return the next SUnit after SU on the bottom-up
|
|
|
|
/// critical path.
|
2010-04-20 07:11:58 +08:00
|
|
|
static const SUnit *CriticalPathStep(const SUnit *SU) {
|
2014-04-14 08:51:57 +08:00
|
|
|
const SDep *Next = nullptr;
|
2009-11-14 03:52:48 +08:00
|
|
|
unsigned NextDepth = 0;
|
|
|
|
// Find the predecessor edge with the greatest depth.
|
2014-04-14 08:51:57 +08:00
|
|
|
if (SU) {
|
2010-04-20 07:11:58 +08:00
|
|
|
for (SUnit::const_pred_iterator P = SU->Preds.begin(), PE = SU->Preds.end();
|
2009-11-14 03:52:48 +08:00
|
|
|
P != PE; ++P) {
|
2010-04-20 07:11:58 +08:00
|
|
|
const SUnit *PredSU = P->getSUnit();
|
2009-11-14 03:52:48 +08:00
|
|
|
unsigned PredLatency = P->getLatency();
|
|
|
|
unsigned PredTotalLatency = PredSU->getDepth() + PredLatency;
|
|
|
|
// In the case of a latency tie, prefer an anti-dependency edge over
|
|
|
|
// other types of edges.
|
|
|
|
if (NextDepth < PredTotalLatency ||
|
|
|
|
(NextDepth == PredTotalLatency && P->getKind() == SDep::Anti)) {
|
|
|
|
NextDepth = PredTotalLatency;
|
|
|
|
Next = &*P;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-14 08:51:57 +08:00
|
|
|
return (Next) ? Next->getSUnit() : nullptr;
|
2009-11-14 03:52:48 +08:00
|
|
|
}
|
|
|
|
|
2009-10-30 03:17:04 +08:00
|
|
|
void AggressiveAntiDepBreaker::HandleLastUse(unsigned Reg, unsigned KillIdx,
|
2010-01-07 00:48:02 +08:00
|
|
|
const char *tag,
|
|
|
|
const char *header,
|
2009-11-20 07:12:37 +08:00
|
|
|
const char *footer) {
|
2010-07-16 02:43:09 +08:00
|
|
|
std::vector<unsigned> &KillIndices = State->GetKillIndices();
|
|
|
|
std::vector<unsigned> &DefIndices = State->GetDefIndices();
|
2010-01-07 00:48:02 +08:00
|
|
|
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
|
2009-10-30 03:17:04 +08:00
|
|
|
RegRefs = State->GetRegRefs();
|
|
|
|
|
Correct the AggressiveAntiDepBreaker's handling of subregisters defining super registers
As the AggressiveAntiDepBreaker iterated backward through a scheduling region,
we must leave super registers live through subregister definitions so that all
relevant subregister definitions are renamed together. The problem was that we
were also discarding sub-register use locations as the sub-registers are
redefined. The result is that we'd rename the super register along with some,
but not all, subregister definitions.
R0_D = {R0_L, R1_L}
R0_L = {R0_S, R1_S}
%R0_L<def> = TRLi9 16, pred:8, pred:%noreg
%R1_L<def> = LSRLrr %R1_L<kill>, %R0_S, pred:8, pred:%noreg
%R0_L<def> = LSRLrr %R2_L, %R0_S, pred:8, pred:%noreg, %R0_L<imp-use,kill>
%R1_L<def> = ANDLri %R1_L<kill>, 2047, pred:8, pred:%noreg
%R0_L<def> = ANDLri %R0_L<kill>, 2047, pred:8, pred:%noreg
%R4_D<def> = ASRDrr %R0_D<kill>, %R6_S
Anti: %R4_D<def> = ASRDrr %R0_D<kill>, %R6_S
Def Groups: R4_D=g213->g215(via R4_S)->g214(via R4_L)->g216(via R5_S)->g216(via R4_L)->g217(via R5_L)
Use Groups: R0_D=g0->g218(last-use) R1_L->g219(last-use) R6_S=g204->g220(last-use)
Anti: %R0_L<def> = ANDLri %R0_L<kill>, 2047, pred:8, pred:%noreg
Def Groups: R0_L=g208->g209(via R0_S)->g218(via R0_D)->g210(via R1_S)->g210(via R0_D)
Antidep reg: R0_L (real dependency)
Use Groups: R0_L=g210->g224(last-use) R0_S->g225(last-use) R1_S->g226(last-use)
Anti: %R1_L<def> = ANDLri %R1_L<kill>, 2047, pred:8, pred:%noreg
Def Groups: R1_L=g219->g210(via R0_D)
Antidep reg: R1_L (real dependency)
Use Groups: R1_L=g210->g229(last-use)
Anti: %R0_L<def> = LSRLrr %R2_L, %R0_S, pred:8, pred:%noreg, %R0_L<imp-use,kill>
Def Groups: R0_L=g224->g225(via R0_S)->g210(via R0_D)->g226(via R1_S)->g226(via R0_D)
Antidep reg: R0_L Use Groups: R2_L=g192 R0_S=g226->g230(last-use) R0_L=g226->g231(last-use) R1_S->g232(last-use)
Anti: %R1_L<def> = LSRLrr %R1_L<kill>, %R0_S, pred:8, pred:%noreg
Def Groups: R1_L=g229->g226(via R0_D)
Antidep reg: R1_L Use Groups: R1_L=g226->g233(last-use) R0_S=g230
Anti: %R0_L<def> = TRLi9 16, pred:8, pred:%noreg
Def Groups: R0_L=g231->g230(via R0_S)->g226(via R0_D)->g232(via R1_S)->g232(via R0_D)
Antidep reg: R0_L
Rename Candidates for Group g232:
R0_D: elcInt64Regs :: R0_D R1_D R2_D R3_D R4_D R5_D R8_D R9_D R10_D R11_D R12_D R13_D R14_D R15_D R16_D R17_D R18_D R19_D R20_D R21_D R22_D R23_D R24_D R25_D
R0_L: elcIntRegs :: R0_L R1_L R2_L R3_L R4_L R5_L R8_L R9_L R10_L R11_L R12_L R13_L R14_L R15_L R16_L R17_L R18_L R19_L R20_L R21_L R22_L R23_L R24_L R25_L
R0_S: elcShrtRegs elcShrtRegs :: R0_S R1_S R2_S R3_S R4_S R5_S R8_S R9_S R10_S R11_S R12_S R13_S R14_S R15_S R16_S R17_S R18_S R19_S R20_S R21_S R22_S R23_S R24_S R25_S
Find Registers: [R12_D: R12_D R12_L R12_S]
Breaking anti-dependence edge on R0_L: R0_D->R12_D(1 refs) R0_L->R12_L(2 refs) R0_S->R12_S(2 refs)
Use Groups:
...
%R12_L<def> = TRLi9 16, pred:8, pred:%noreg
%R1_L<def> = LSRLrr %R1_L<kill>, %R12_S, pred:8, pred:%noreg
%R0_L<def> = LSRLrr %R2_L<kill>, %R12_S, pred:8, pred:%noreg, %R12_L<imp-use>
%R1_L<def> = ANDLri %R1_L<kill>, 2047, pred:8, pred:%noreg
%R0_L<def> = ANDLri %R0_L<kill>, 2047, pred:8, pred:%noreg
%R4_D<def> = ASRDrr %R12_D<kill>, %R6_S
With this change, we now produce:
Anti: %R4_D<def> = ASRDrr %R0_D<kill>, %R6_S
Def Groups: R4_D=g213->g215(via R4_S)->g214(via R4_L)->g216(via R5_S)->g216(via R4_L)->g217(via R5_L)
Use Groups: R0_D=g0->g218(last-use) R1_L->g219(last-use) R6_S=g204->g220(last-use)
Anti: %R0_L<def> = ANDLri %R0_L<kill>, 2047, pred:8, pred:%noreg
Def Groups: R0_L=g208->g209(via R0_S)->g218(via R0_D)->g210(via R1_S)->g210(via R0_D)
Antidep reg: R0_L (real dependency)
Use Groups: R0_L=g210
Anti: %R1_L<def> = ANDLri %R1_L<kill>, 2047, pred:8, pred:%noreg
Def Groups: R1_L=g219->g210(via R0_D)
Antidep reg: R1_L (real dependency)
Use Groups: R1_L=g210
Anti: %R0_L<def> = LSRLrr %R2_L, %R0_S, pred:8, pred:%noreg, %R0_L<imp-use,kill>
Def Groups: R0_L=g210->g210(via R0_D)->g210(via R0_D)
Antidep reg: R0_L Use Groups: R2_L=g192 R0_S=g210 R0_L=g210
Anti: %R1_L<def> = LSRLrr %R1_L<kill>, %R0_S, pred:8, pred:%noreg
Def Groups: R1_L=g210->g210(via R0_D)
Antidep reg: R1_L Use Groups: R1_L=g210 R0_S=g210
Anti: %R0_L<def> = TRLi9 16, pred:8, pred:%noreg
Def Groups: R0_L=g210->g210(via R0_D)->g210(via R0_D)
Antidep reg: R0_L
Rename Candidates for Group g210:
R0_D: elcInt64Regs :: R0_D R1_D R2_D R3_D R4_D R5_D R8_D R9_D R10_D R11_D R12_D R13_D R14_D R15_D R16_D R17_D R18_D R19_D R20_D R21_D R22_D R23_D R24_D R25_D
R0_L: elcIntRegs elcIntAIRegs elcIntRegs elcIntRegs elcIntRegs elcIntRegs :: R0_L R1_L R2_L R3_L R4_L R5_L R8_L R9_L R10_L R11_L R12_L R13_L R14_L R15_L R16_L R17_L R18_L R19_L R20_L R21_L R22_L R23_L R24_L R25_L
R1_L: elcIntRegs elcIntRegs elcIntRegs elcIntRegs elcIntRegs :: R0_L R1_L R2_L R3_L R4_L R5_L R8_L R9_L R10_L R11_L R12_L R13_L R14_L R15_L R16_L R17_L R18_L R19_L R20_L R21_L R22_L R23_L R24_L R25_L
R0_S: elcShrtRegs elcShrtRegs :: R0_S R1_S R2_S R3_S R4_S R5_S R8_S R9_S R10_S R11_S R12_S R13_S R14_S R15_S R16_S R17_S R18_S R19_S R20_S R21_S R22_S R23_S R24_S R25_S
Find Registers: [R12_D: R12_D R12_L R13_L R12_S]
Breaking anti-dependence edge on R0_L: R0_D->R12_D(1 refs) R0_L->R12_L(7 refs) R1_L->R13_L(5 refs) R0_S->R12_S(2 refs)
Use Groups:
...
%R12_L<def> = TRLi9 16, pred:8, pred:%noreg
%R13_L<def> = LSRLrr %R13_L<kill>, %R12_S, pred:8, pred:%noreg
%R12_L<def> = LSRLrr %R2_L<kill>, %R12_S<kill>, pred:8, pred:%noreg, %R12_L<imp-use,kill>
%R13_L<def> = ANDLri %R13_L<kill>, 2047, pred:8, pred:%noreg
%R12_L<def> = ANDLri %R12_L<kill>, 2047, pred:8, pred:%noreg
%R4_D<def> = ASRDrr %R12_D, %R6_S, %R12_L<imp-def>, %R12_S<imp-def>, %R13_S<imp-def>
As demonstrated by this example, this is also somewhat unfortunate, because
there is actually no need to rename the super register in this case (it is
fully covered by later subregister definitions), but we don't seem to track
enough information here to exploit that either.
Thanks to Daniil Troshkov for reporting the issue. The debug outputs in this
commit message are from Daniil.
llvm-svn: 227311
2015-01-28 22:44:14 +08:00
|
|
|
// FIXME: We must leave subregisters of live super registers as live, so that
|
|
|
|
// we don't clear out the register tracking information for subregisters of
|
|
|
|
// super registers we're still tracking (and with which we're unioning
|
|
|
|
// subregister definitions).
|
|
|
|
for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI)
|
|
|
|
if (TRI->isSuperRegister(Reg, *AI) && State->IsLive(*AI)) {
|
|
|
|
DEBUG(if (!header && footer) dbgs() << footer);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-10-30 03:17:04 +08:00
|
|
|
if (!State->IsLive(Reg)) {
|
|
|
|
KillIndices[Reg] = KillIdx;
|
|
|
|
DefIndices[Reg] = ~0u;
|
|
|
|
RegRefs.erase(Reg);
|
|
|
|
State->LeaveGroup(Reg);
|
2014-04-14 08:51:57 +08:00
|
|
|
DEBUG(if (header) {
|
|
|
|
dbgs() << header << TRI->getName(Reg); header = nullptr; });
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "->g" << State->GetGroup(Reg) << tag);
|
2016-04-01 10:05:29 +08:00
|
|
|
// Repeat for subregisters. Note that we only do this if the superregister
|
|
|
|
// was not live because otherwise, regardless whether we have an explicit
|
|
|
|
// use of the subregister, the subregister's contents are needed for the
|
|
|
|
// uses of the superregister.
|
|
|
|
for (MCSubRegIterator SubRegs(Reg, TRI); SubRegs.isValid(); ++SubRegs) {
|
|
|
|
unsigned SubregReg = *SubRegs;
|
|
|
|
if (!State->IsLive(SubregReg)) {
|
|
|
|
KillIndices[SubregReg] = KillIdx;
|
|
|
|
DefIndices[SubregReg] = ~0u;
|
|
|
|
RegRefs.erase(SubregReg);
|
|
|
|
State->LeaveGroup(SubregReg);
|
|
|
|
DEBUG(if (header) {
|
|
|
|
dbgs() << header << TRI->getName(Reg); header = nullptr; });
|
|
|
|
DEBUG(dbgs() << " " << TRI->getName(SubregReg) << "->g" <<
|
|
|
|
State->GetGroup(SubregReg) << tag);
|
|
|
|
}
|
2009-10-30 03:17:04 +08:00
|
|
|
}
|
|
|
|
}
|
2009-11-20 07:12:37 +08:00
|
|
|
|
2014-04-14 08:51:57 +08:00
|
|
|
DEBUG(if (!header && footer) dbgs() << footer);
|
2009-10-30 03:17:04 +08:00
|
|
|
}
|
|
|
|
|
2016-02-28 03:33:37 +08:00
|
|
|
void AggressiveAntiDepBreaker::PrescanInstruction(
|
|
|
|
MachineInstr &MI, unsigned Count, std::set<unsigned> &PassthruRegs) {
|
2010-07-16 02:43:09 +08:00
|
|
|
std::vector<unsigned> &DefIndices = State->GetDefIndices();
|
2010-01-07 00:48:02 +08:00
|
|
|
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
|
2009-10-27 06:31:16 +08:00
|
|
|
RegRefs = State->GetRegRefs();
|
|
|
|
|
2009-10-30 03:17:04 +08:00
|
|
|
// Handle dead defs by simulating a last-use of the register just
|
2011-04-15 13:18:47 +08:00
|
|
|
// after the def. A dead def can occur because the def is truly
|
2009-10-30 03:17:04 +08:00
|
|
|
// dead, or because only a subregister is live at the def. If we
|
|
|
|
// don't do this the dead def will be incorrectly merged into the
|
|
|
|
// previous def.
|
2016-02-28 03:33:37 +08:00
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2009-10-27 03:32:42 +08:00
|
|
|
if (!MO.isReg() || !MO.isDef()) continue;
|
|
|
|
unsigned Reg = MO.getReg();
|
|
|
|
if (Reg == 0) continue;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-11-20 07:12:37 +08:00
|
|
|
HandleLastUse(Reg, Count + 1, "", "\tDead Def: ", "\n");
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\tDef Groups:");
|
2016-02-28 03:33:37 +08:00
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2009-10-27 03:32:42 +08:00
|
|
|
if (!MO.isReg() || !MO.isDef()) continue;
|
|
|
|
unsigned Reg = MO.getReg();
|
|
|
|
if (Reg == 0) continue;
|
|
|
|
|
2010-01-07 00:48:02 +08:00
|
|
|
DEBUG(dbgs() << " " << TRI->getName(Reg) << "=g" << State->GetGroup(Reg));
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2009-10-30 03:17:04 +08:00
|
|
|
// If MI's defs have a special allocation requirement, don't allow
|
2009-10-27 03:32:42 +08:00
|
|
|
// any def registers to be changed. Also assume all registers
|
2015-12-03 02:58:51 +08:00
|
|
|
// defined in a call must not be changed (ABI). Inline assembly may
|
|
|
|
// reference either system calls or the register directly. Skip it until we
|
|
|
|
// can tell user specified registers from compiler-specified.
|
2016-02-28 03:33:37 +08:00
|
|
|
if (MI.isCall() || MI.hasExtraDefRegAllocReq() || TII->isPredicated(MI) ||
|
|
|
|
MI.isInlineAsm()) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(if (State->GetGroup(Reg) != 0) dbgs() << "->g0(alloc-req)");
|
2009-10-27 06:31:16 +08:00
|
|
|
State->UnionGroups(Reg, 0);
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Any aliased that are live at this point are completely or
|
2009-10-30 03:17:04 +08:00
|
|
|
// partially defined here, so group those aliases with Reg.
|
2012-06-02 07:28:30 +08:00
|
|
|
for (MCRegAliasIterator AI(Reg, TRI, false); AI.isValid(); ++AI) {
|
|
|
|
unsigned AliasReg = *AI;
|
2009-10-27 06:31:16 +08:00
|
|
|
if (State->IsLive(AliasReg)) {
|
|
|
|
State->UnionGroups(Reg, AliasReg);
|
2010-01-07 00:48:02 +08:00
|
|
|
DEBUG(dbgs() << "->g" << State->GetGroup(Reg) << "(via " <<
|
2009-10-27 03:32:42 +08:00
|
|
|
TRI->getName(AliasReg) << ")");
|
|
|
|
}
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// Note register reference...
|
2014-04-14 08:51:57 +08:00
|
|
|
const TargetRegisterClass *RC = nullptr;
|
2016-02-28 03:33:37 +08:00
|
|
|
if (i < MI.getDesc().getNumOperands())
|
|
|
|
RC = TII->getRegClass(MI.getDesc(), i, TRI, MF);
|
2009-10-27 06:31:16 +08:00
|
|
|
AggressiveAntiDepState::RegisterReference RR = { &MO, RC };
|
2009-10-27 03:32:42 +08:00
|
|
|
RegRefs.insert(std::make_pair(Reg, RR));
|
|
|
|
}
|
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << '\n');
|
2009-10-30 03:17:04 +08:00
|
|
|
|
|
|
|
// Scan the register defs for this instruction and update
|
|
|
|
// live-ranges.
|
2016-02-28 03:33:37 +08:00
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2009-10-30 03:17:04 +08:00
|
|
|
if (!MO.isReg() || !MO.isDef()) continue;
|
|
|
|
unsigned Reg = MO.getReg();
|
|
|
|
if (Reg == 0) continue;
|
2009-11-20 07:12:37 +08:00
|
|
|
// Ignore KILLs and passthru registers for liveness...
|
2016-02-28 03:33:37 +08:00
|
|
|
if (MI.isKill() || (PassthruRegs.count(Reg) != 0))
|
2009-11-20 07:12:37 +08:00
|
|
|
continue;
|
2009-10-30 03:17:04 +08:00
|
|
|
|
2009-11-20 07:12:37 +08:00
|
|
|
// Update def for Reg and aliases.
|
Fix the aggressive anti-dep breaker's subregister definition handling
The aggressive anti-dependency breaker scans instructions, bottom-up, within the
scheduling region in order to find opportunities where register renaming can
be used to break anti-dependencies.
Unfortunately, the aggressive anti-dep breaker was treating a register definition
as defining all of that register's aliases (including super registers). This behavior
is incorrect when the super register is live and there are other definitions of
subregisters of the super register.
For example, given the following sequence:
%CR2EQ<def> = CROR %CR3UN, %CR3UN<kill>
%CR2GT<def> = IMPLICIT_DEF
%X4<def> = MFOCRF8 %CR2
the analysis of the first subregister definition would work as expected:
Anti: %CR2GT<def> = IMPLICIT_DEF
Def Groups: CR2GT=g194->g0(via CR2)
Antidep reg: CR2GT (zero group)
Use Groups:
but the analysis of the second one would not:
Anti: %CR2EQ<def> = CROR %CR3UN, %CR3UN<kill>
Def Groups: CR2EQ=g195
Antidep reg: CR2EQ
Rename Candidates for Group g195: ...
because, when processing the %CR2GT<def>, we'd mark all super registers of
%CR2GT (%CR2 in this case) as defined. As a result, when processing
%CR2EQ<def>, %CR2 no longer appears to be live, and %CR2EQ<def>'s group is not
%unioned with the %CR2 group.
I don't have an in-tree test case for this yet (and even if I did, I don't have
a small one).
llvm-svn: 202294
2014-02-27 04:20:30 +08:00
|
|
|
for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI) {
|
|
|
|
// We need to be careful here not to define already-live super registers.
|
|
|
|
// If the super register is already live, then this definition is not
|
|
|
|
// a definition of the whole super register (just a partial insertion
|
|
|
|
// into it). Earlier subregister definitions (which we've not yet visited
|
|
|
|
// because we're iterating bottom-up) need to be linked to the same group
|
|
|
|
// as this definition.
|
|
|
|
if (TRI->isSuperRegister(Reg, *AI) && State->IsLive(*AI))
|
|
|
|
continue;
|
|
|
|
|
2012-06-02 07:28:30 +08:00
|
|
|
DefIndices[*AI] = Count;
|
Fix the aggressive anti-dep breaker's subregister definition handling
The aggressive anti-dependency breaker scans instructions, bottom-up, within the
scheduling region in order to find opportunities where register renaming can
be used to break anti-dependencies.
Unfortunately, the aggressive anti-dep breaker was treating a register definition
as defining all of that register's aliases (including super registers). This behavior
is incorrect when the super register is live and there are other definitions of
subregisters of the super register.
For example, given the following sequence:
%CR2EQ<def> = CROR %CR3UN, %CR3UN<kill>
%CR2GT<def> = IMPLICIT_DEF
%X4<def> = MFOCRF8 %CR2
the analysis of the first subregister definition would work as expected:
Anti: %CR2GT<def> = IMPLICIT_DEF
Def Groups: CR2GT=g194->g0(via CR2)
Antidep reg: CR2GT (zero group)
Use Groups:
but the analysis of the second one would not:
Anti: %CR2EQ<def> = CROR %CR3UN, %CR3UN<kill>
Def Groups: CR2EQ=g195
Antidep reg: CR2EQ
Rename Candidates for Group g195: ...
because, when processing the %CR2GT<def>, we'd mark all super registers of
%CR2GT (%CR2 in this case) as defined. As a result, when processing
%CR2EQ<def>, %CR2 no longer appears to be live, and %CR2EQ<def>'s group is not
%unioned with the %CR2 group.
I don't have an in-tree test case for this yet (and even if I did, I don't have
a small one).
llvm-svn: 202294
2014-02-27 04:20:30 +08:00
|
|
|
}
|
2009-10-30 03:17:04 +08:00
|
|
|
}
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
2016-02-28 03:33:37 +08:00
|
|
|
void AggressiveAntiDepBreaker::ScanInstruction(MachineInstr &MI,
|
2010-04-10 05:38:26 +08:00
|
|
|
unsigned Count) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\tUse Groups:");
|
2010-01-07 00:48:02 +08:00
|
|
|
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
|
2009-10-27 06:31:16 +08:00
|
|
|
RegRefs = State->GetRegRefs();
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2010-06-16 15:35:02 +08:00
|
|
|
// If MI's uses have special allocation requirement, don't allow
|
|
|
|
// any use registers to be changed. Also assume all registers
|
|
|
|
// used in a call must not be changed (ABI).
|
2015-12-03 02:58:51 +08:00
|
|
|
// Inline Assembly register uses also cannot be safely changed.
|
2010-06-16 15:35:02 +08:00
|
|
|
// FIXME: The issue with predicated instruction is more complex. We are being
|
|
|
|
// conservatively here because the kill markers cannot be trusted after
|
|
|
|
// if-conversion:
|
|
|
|
// %R6<def> = LDR %SP, %reg0, 92, pred:14, pred:%reg0; mem:LD4[FixedStack14]
|
|
|
|
// ...
|
|
|
|
// STR %R0, %R6<kill>, %reg0, 0, pred:0, pred:%CPSR; mem:ST4[%395]
|
|
|
|
// %R6<def> = LDR %SP, %reg0, 100, pred:0, pred:%CPSR; mem:LD4[FixedStack12]
|
|
|
|
// STR %R0, %R6<kill>, %reg0, 0, pred:14, pred:%reg0; mem:ST4[%396](align=8)
|
|
|
|
//
|
|
|
|
// The first R6 kill is not really a kill since it's killed by a predicated
|
|
|
|
// instruction which may not be executed. The second R6 def may or may not
|
|
|
|
// re-define R6 so it's not safe to change it since the last R6 use cannot be
|
|
|
|
// changed.
|
2016-02-28 03:33:37 +08:00
|
|
|
bool Special = MI.isCall() || MI.hasExtraSrcRegAllocReq() ||
|
|
|
|
TII->isPredicated(MI) || MI.isInlineAsm();
|
2010-06-16 15:35:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// Scan the register uses for this instruction and update
|
|
|
|
// live-ranges, groups and RegRefs.
|
2016-02-28 03:33:37 +08:00
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2009-10-27 03:32:42 +08:00
|
|
|
if (!MO.isReg() || !MO.isUse()) continue;
|
|
|
|
unsigned Reg = MO.getReg();
|
|
|
|
if (Reg == 0) continue;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
|
|
|
DEBUG(dbgs() << " " << TRI->getName(Reg) << "=g" <<
|
|
|
|
State->GetGroup(Reg));
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
// It wasn't previously live but now it is, this is a kill. Forget
|
|
|
|
// the previous live-range information and start a new live-range
|
|
|
|
// for the register.
|
2009-10-30 03:17:04 +08:00
|
|
|
HandleLastUse(Reg, Count, "(last-use)");
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2010-06-16 15:35:02 +08:00
|
|
|
if (Special) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(if (State->GetGroup(Reg) != 0) dbgs() << "->g0(alloc-req)");
|
2009-10-27 06:31:16 +08:00
|
|
|
State->UnionGroups(Reg, 0);
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Note register reference...
|
2014-04-14 08:51:57 +08:00
|
|
|
const TargetRegisterClass *RC = nullptr;
|
2016-02-28 03:33:37 +08:00
|
|
|
if (i < MI.getDesc().getNumOperands())
|
|
|
|
RC = TII->getRegClass(MI.getDesc(), i, TRI, MF);
|
2009-10-27 06:31:16 +08:00
|
|
|
AggressiveAntiDepState::RegisterReference RR = { &MO, RC };
|
2009-10-27 03:32:42 +08:00
|
|
|
RegRefs.insert(std::make_pair(Reg, RR));
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << '\n');
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
// Form a group of all defs and uses of a KILL instruction to ensure
|
|
|
|
// that all registers are renamed as a group.
|
2016-02-28 03:33:37 +08:00
|
|
|
if (MI.isKill()) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\tKill Group:");
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
unsigned FirstReg = 0;
|
2016-02-28 03:33:37 +08:00
|
|
|
for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI.getOperand(i);
|
2009-10-27 03:32:42 +08:00
|
|
|
if (!MO.isReg()) continue;
|
|
|
|
unsigned Reg = MO.getReg();
|
|
|
|
if (Reg == 0) continue;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
if (FirstReg != 0) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "=" << TRI->getName(Reg));
|
2009-10-27 06:31:16 +08:00
|
|
|
State->UnionGroups(FirstReg, Reg);
|
2009-10-27 03:32:42 +08:00
|
|
|
} else {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " " << TRI->getName(Reg));
|
2009-10-27 03:32:42 +08:00
|
|
|
FirstReg = Reg;
|
|
|
|
}
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "->g" << State->GetGroup(FirstReg) << '\n');
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BitVector AggressiveAntiDepBreaker::GetRenameRegisters(unsigned Reg) {
|
|
|
|
BitVector BV(TRI->getNumRegs(), false);
|
|
|
|
bool first = true;
|
|
|
|
|
|
|
|
// Check all references that need rewriting for Reg. For each, use
|
|
|
|
// the corresponding register class to narrow the set of registers
|
|
|
|
// that are appropriate for renaming.
|
2015-07-19 04:05:10 +08:00
|
|
|
for (const auto &Q : make_range(State->GetRegRefs().equal_range(Reg))) {
|
|
|
|
const TargetRegisterClass *RC = Q.second.RC;
|
2014-04-14 08:51:57 +08:00
|
|
|
if (!RC) continue;
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
BitVector RCBV = TRI->getAllocatableSet(MF, RC);
|
|
|
|
if (first) {
|
|
|
|
BV |= RCBV;
|
|
|
|
first = false;
|
|
|
|
} else {
|
|
|
|
BV &= RCBV;
|
|
|
|
}
|
|
|
|
|
2014-11-17 13:50:14 +08:00
|
|
|
DEBUG(dbgs() << " " << TRI->getRegClassName(RC));
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
return BV;
|
2010-01-07 00:48:02 +08:00
|
|
|
}
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
bool AggressiveAntiDepBreaker::FindSuitableFreeRegisters(
|
2009-11-05 09:19:35 +08:00
|
|
|
unsigned AntiDepGroupIndex,
|
|
|
|
RenameOrderType& RenameOrder,
|
|
|
|
std::map<unsigned, unsigned> &RenameMap) {
|
2010-07-16 02:43:09 +08:00
|
|
|
std::vector<unsigned> &KillIndices = State->GetKillIndices();
|
|
|
|
std::vector<unsigned> &DefIndices = State->GetDefIndices();
|
2010-01-07 00:48:02 +08:00
|
|
|
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
|
2009-10-27 06:31:16 +08:00
|
|
|
RegRefs = State->GetRegRefs();
|
|
|
|
|
2009-11-14 03:52:48 +08:00
|
|
|
// Collect all referenced registers in the same group as
|
|
|
|
// AntiDepReg. These all need to be renamed together if we are to
|
|
|
|
// break the anti-dependence.
|
2009-10-27 03:32:42 +08:00
|
|
|
std::vector<unsigned> Regs;
|
2009-11-14 03:52:48 +08:00
|
|
|
State->GetGroupRegs(AntiDepGroupIndex, Regs, &RegRefs);
|
2009-10-27 03:32:42 +08:00
|
|
|
assert(Regs.size() > 0 && "Empty register group!");
|
|
|
|
if (Regs.size() == 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Find the "superest" register in the group. At the same time,
|
|
|
|
// collect the BitVector of registers that can be used to rename
|
|
|
|
// each register.
|
2010-01-07 00:48:02 +08:00
|
|
|
DEBUG(dbgs() << "\tRename Candidates for Group g" << AntiDepGroupIndex
|
|
|
|
<< ":\n");
|
2009-10-27 03:32:42 +08:00
|
|
|
std::map<unsigned, BitVector> RenameRegisterMap;
|
|
|
|
unsigned SuperReg = 0;
|
|
|
|
for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
|
|
|
|
unsigned Reg = Regs[i];
|
|
|
|
if ((SuperReg == 0) || TRI->isSuperRegister(SuperReg, Reg))
|
|
|
|
SuperReg = Reg;
|
|
|
|
|
|
|
|
// If Reg has any references, then collect possible rename regs
|
|
|
|
if (RegRefs.count(Reg) > 0) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\t\t" << TRI->getName(Reg) << ":");
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2016-02-14 00:39:39 +08:00
|
|
|
BitVector &BV = RenameRegisterMap[Reg];
|
|
|
|
assert(BV.empty());
|
|
|
|
BV = GetRenameRegisters(Reg);
|
|
|
|
|
|
|
|
DEBUG({
|
|
|
|
dbgs() << " ::";
|
|
|
|
for (int r = BV.find_first(); r != -1; r = BV.find_next(r))
|
|
|
|
dbgs() << " " << TRI->getName(r);
|
|
|
|
dbgs() << "\n";
|
|
|
|
});
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// All group registers should be a subreg of SuperReg.
|
|
|
|
for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
|
|
|
|
unsigned Reg = Regs[i];
|
|
|
|
if (Reg == SuperReg) continue;
|
|
|
|
bool IsSub = TRI->isSubRegister(SuperReg, Reg);
|
Disable IsSub subregister assert. pr18663.
This is a follow-up to the activity in the bug at
http://llvm.org/bugs/show_bug.cgi?id=18663 . The underlying issue has
to do with how the KILL pseudo-instruction is handled. I defer to
Hal/Jakob/Uli for additional details and background.
This will disable the (bad?) assert, add an associated fixme comment,
and add a pair of tests.
The code change and the pr18663-2.ll test are copied from the referenced
bug. That test does not immediately fail in my environment, but I have
added the pr18663.ll test which does.
(Comment from Hal)
to provide everyone else with some context, this assert was not bad when
it was written. At that time, we only generated KILL pseudo instructions
around subregister copies. This logic, unfortunately, had its own problems.
In r199797, the relevant logic in MachineCopyPropagation was replaced to
generate KILLs for other kinds of copies too. This change in semantics broke
this now-problematic assumption in AggressiveAntiDepBreaker. The
AggressiveAntiDepBreaker really needs a proper cleanup to deal with the
change, but removing the assert (which just allows the function to return
false) is a safe conservative behavior, and should do for the time being.
llvm-svn: 214429
2014-08-01 03:50:53 +08:00
|
|
|
// FIXME: remove this once PR18663 has been properly fixed. For now,
|
|
|
|
// return a conservative answer:
|
|
|
|
// assert(IsSub && "Expecting group subregister");
|
2009-10-27 03:32:42 +08:00
|
|
|
if (!IsSub)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-11-21 07:33:54 +08:00
|
|
|
#ifndef NDEBUG
|
|
|
|
// If DebugDiv > 0 then only rename (renamecnt % DebugDiv) == DebugMod
|
|
|
|
if (DebugDiv > 0) {
|
|
|
|
static int renamecnt = 0;
|
|
|
|
if (renamecnt++ % DebugDiv != DebugMod)
|
|
|
|
return false;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
dbgs() << "*** Performing rename " << TRI->getName(SuperReg) <<
|
2009-11-21 07:33:54 +08:00
|
|
|
" for debug ***\n";
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-11-05 09:19:35 +08:00
|
|
|
// Check each possible rename register for SuperReg in round-robin
|
|
|
|
// order. If that register is available, and the corresponding
|
|
|
|
// registers are available for the other group subregisters, then we
|
|
|
|
// can use those registers to rename.
|
2010-07-12 10:55:34 +08:00
|
|
|
|
|
|
|
// FIXME: Using getMinimalPhysRegClass is very conservative. We should
|
|
|
|
// check every use of the register and find the largest register class
|
|
|
|
// that can be used in all of them.
|
2010-01-07 00:48:02 +08:00
|
|
|
const TargetRegisterClass *SuperRC =
|
2010-07-12 10:55:34 +08:00
|
|
|
TRI->getMinimalPhysRegClass(SuperReg, MVT::Other);
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2012-11-29 11:34:17 +08:00
|
|
|
ArrayRef<MCPhysReg> Order = RegClassInfo.getOrder(SuperRC);
|
2011-06-17 05:56:21 +08:00
|
|
|
if (Order.empty()) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\tEmpty Super Regclass!!\n");
|
2009-11-05 09:19:35 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\tFind Registers:");
|
2009-11-20 07:12:37 +08:00
|
|
|
|
2014-10-10 23:32:50 +08:00
|
|
|
RenameOrder.insert(RenameOrderType::value_type(SuperRC, Order.size()));
|
2009-11-05 09:19:35 +08:00
|
|
|
|
2011-06-17 05:56:21 +08:00
|
|
|
unsigned OrigR = RenameOrder[SuperRC];
|
|
|
|
unsigned EndR = ((OrigR == Order.size()) ? 0 : OrigR);
|
|
|
|
unsigned R = OrigR;
|
2009-11-05 09:19:35 +08:00
|
|
|
do {
|
2011-06-17 05:56:21 +08:00
|
|
|
if (R == 0) R = Order.size();
|
2009-11-05 09:19:35 +08:00
|
|
|
--R;
|
2011-06-17 05:56:21 +08:00
|
|
|
const unsigned NewSuperReg = Order[R];
|
2010-09-03 01:12:55 +08:00
|
|
|
// Don't consider non-allocatable registers
|
2012-10-16 06:41:03 +08:00
|
|
|
if (!MRI.isAllocatable(NewSuperReg)) continue;
|
2009-10-27 03:32:42 +08:00
|
|
|
// Don't replace a register with itself.
|
2009-11-21 07:33:54 +08:00
|
|
|
if (NewSuperReg == SuperReg) continue;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " [" << TRI->getName(NewSuperReg) << ':');
|
2009-11-21 07:33:54 +08:00
|
|
|
RenameMap.clear();
|
|
|
|
|
|
|
|
// For each referenced group register (which must be a SuperReg or
|
|
|
|
// a subregister of SuperReg), find the corresponding subregister
|
|
|
|
// of NewSuperReg and make sure it is free to be renamed.
|
|
|
|
for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
|
|
|
|
unsigned Reg = Regs[i];
|
|
|
|
unsigned NewReg = 0;
|
|
|
|
if (Reg == SuperReg) {
|
|
|
|
NewReg = NewSuperReg;
|
|
|
|
} else {
|
|
|
|
unsigned NewSubRegIdx = TRI->getSubRegIndex(SuperReg, Reg);
|
|
|
|
if (NewSubRegIdx != 0)
|
|
|
|
NewReg = TRI->getSubReg(NewSuperReg, NewSubRegIdx);
|
|
|
|
}
|
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " " << TRI->getName(NewReg));
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-11-21 07:33:54 +08:00
|
|
|
// Check if Reg can be renamed to NewReg.
|
2016-02-14 00:39:39 +08:00
|
|
|
if (!RenameRegisterMap[Reg].test(NewReg)) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "(no rename)");
|
2009-11-21 07:33:54 +08:00
|
|
|
goto next_super_reg;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If NewReg is dead and NewReg's most recent def is not before
|
|
|
|
// Regs's kill, it's safe to replace Reg with NewReg. We
|
|
|
|
// must also check all aliases of NewReg, because we can't define a
|
|
|
|
// register when any sub or super is already live.
|
|
|
|
if (State->IsLive(NewReg) || (KillIndices[Reg] > DefIndices[NewReg])) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "(live)");
|
2009-11-21 07:33:54 +08:00
|
|
|
goto next_super_reg;
|
|
|
|
} else {
|
|
|
|
bool found = false;
|
2012-06-02 07:28:30 +08:00
|
|
|
for (MCRegAliasIterator AI(NewReg, TRI, false); AI.isValid(); ++AI) {
|
|
|
|
unsigned AliasReg = *AI;
|
2010-01-07 00:48:02 +08:00
|
|
|
if (State->IsLive(AliasReg) ||
|
|
|
|
(KillIndices[Reg] > DefIndices[AliasReg])) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "(alias " << TRI->getName(AliasReg) << " live)");
|
2009-11-21 07:33:54 +08:00
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
2009-11-21 07:33:54 +08:00
|
|
|
if (found)
|
|
|
|
goto next_super_reg;
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2014-12-09 09:00:59 +08:00
|
|
|
// We cannot rename 'Reg' to 'NewReg' if one of the uses of 'Reg' also
|
|
|
|
// defines 'NewReg' via an early-clobber operand.
|
2015-07-19 04:05:10 +08:00
|
|
|
for (const auto &Q : make_range(RegRefs.equal_range(Reg))) {
|
|
|
|
MachineInstr *UseMI = Q.second.Operand->getParent();
|
2014-12-09 09:00:59 +08:00
|
|
|
int Idx = UseMI->findRegisterDefOperandIdx(NewReg, false, true, TRI);
|
|
|
|
if (Idx == -1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (UseMI->getOperand(Idx).isEarlyClobber()) {
|
|
|
|
DEBUG(dbgs() << "(ec)");
|
|
|
|
goto next_super_reg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-31 15:51:36 +08:00
|
|
|
// Also, we cannot rename 'Reg' to 'NewReg' if the instruction defining
|
|
|
|
// 'Reg' is an early-clobber define and that instruction also uses
|
|
|
|
// 'NewReg'.
|
|
|
|
for (const auto &Q : make_range(RegRefs.equal_range(Reg))) {
|
|
|
|
if (!Q.second.Operand->isDef() || !Q.second.Operand->isEarlyClobber())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
MachineInstr *DefMI = Q.second.Operand->getParent();
|
|
|
|
if (DefMI->readsRegister(NewReg, TRI)) {
|
|
|
|
DEBUG(dbgs() << "(ec)");
|
|
|
|
goto next_super_reg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-21 07:33:54 +08:00
|
|
|
// Record that 'Reg' can be renamed to 'NewReg'.
|
|
|
|
RenameMap.insert(std::pair<unsigned, unsigned>(Reg, NewReg));
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-11-21 07:33:54 +08:00
|
|
|
// If we fall-out here, then every register in the group can be
|
|
|
|
// renamed, as recorded in RenameMap.
|
|
|
|
RenameOrder.erase(SuperRC);
|
|
|
|
RenameOrder.insert(RenameOrderType::value_type(SuperRC, R));
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "]\n");
|
2009-11-21 07:33:54 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
next_super_reg:
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << ']');
|
2009-11-05 09:19:35 +08:00
|
|
|
} while (R != EndR);
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << '\n');
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
// No registers are free and available!
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// BreakAntiDependencies - Identifiy anti-dependencies within the
|
|
|
|
/// ScheduleDAG and break them by renaming registers.
|
|
|
|
///
|
2009-10-27 06:31:16 +08:00
|
|
|
unsigned AggressiveAntiDepBreaker::BreakAntiDependencies(
|
2010-04-20 07:11:58 +08:00
|
|
|
const std::vector<SUnit>& SUnits,
|
|
|
|
MachineBasicBlock::iterator Begin,
|
|
|
|
MachineBasicBlock::iterator End,
|
2011-06-03 05:26:52 +08:00
|
|
|
unsigned InsertPosIndex,
|
|
|
|
DbgValueVector &DbgValues) {
|
|
|
|
|
2010-07-16 02:43:09 +08:00
|
|
|
std::vector<unsigned> &KillIndices = State->GetKillIndices();
|
|
|
|
std::vector<unsigned> &DefIndices = State->GetDefIndices();
|
2010-01-07 00:48:02 +08:00
|
|
|
std::multimap<unsigned, AggressiveAntiDepState::RegisterReference>&
|
2009-10-27 06:31:16 +08:00
|
|
|
RegRefs = State->GetRegRefs();
|
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// The code below assumes that there is at least one instruction,
|
|
|
|
// so just duck out immediately if the block is empty.
|
2009-11-04 04:57:50 +08:00
|
|
|
if (SUnits.empty()) return 0;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-11-05 09:19:35 +08:00
|
|
|
// For each regclass the next register to use for renaming.
|
|
|
|
RenameOrderType RenameOrder;
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
// ...need a map from MI to SUnit.
|
2010-04-20 07:11:58 +08:00
|
|
|
std::map<MachineInstr *, const SUnit *> MISUnitMap;
|
2009-10-27 03:32:42 +08:00
|
|
|
for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
|
2010-04-20 07:11:58 +08:00
|
|
|
const SUnit *SU = &SUnits[i];
|
|
|
|
MISUnitMap.insert(std::pair<MachineInstr *, const SUnit *>(SU->getInstr(),
|
|
|
|
SU));
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
|
2009-11-14 03:52:48 +08:00
|
|
|
// Track progress along the critical path through the SUnit graph as
|
|
|
|
// we walk the instructions. This is needed for regclasses that only
|
|
|
|
// break critical-path anti-dependencies.
|
2014-04-14 08:51:57 +08:00
|
|
|
const SUnit *CriticalPathSU = nullptr;
|
|
|
|
MachineInstr *CriticalPathMI = nullptr;
|
2009-11-14 03:52:48 +08:00
|
|
|
if (CriticalPathSet.any()) {
|
|
|
|
for (unsigned i = 0, e = SUnits.size(); i != e; ++i) {
|
2010-04-20 07:11:58 +08:00
|
|
|
const SUnit *SU = &SUnits[i];
|
2010-01-07 00:48:02 +08:00
|
|
|
if (!CriticalPathSU ||
|
|
|
|
((SU->getDepth() + SU->Latency) >
|
2009-11-14 03:52:48 +08:00
|
|
|
(CriticalPathSU->getDepth() + CriticalPathSU->Latency))) {
|
|
|
|
CriticalPathSU = SU;
|
|
|
|
}
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-11-14 03:52:48 +08:00
|
|
|
CriticalPathMI = CriticalPathSU->getInstr();
|
|
|
|
}
|
|
|
|
|
2010-01-07 00:48:02 +08:00
|
|
|
#ifndef NDEBUG
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\n===== Aggressive anti-dependency breaking\n");
|
|
|
|
DEBUG(dbgs() << "Available regs:");
|
2009-11-21 03:32:48 +08:00
|
|
|
for (unsigned Reg = 0; Reg < TRI->getNumRegs(); ++Reg) {
|
|
|
|
if (!State->IsLive(Reg))
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " " << TRI->getName(Reg));
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << '\n');
|
2009-10-27 03:32:42 +08:00
|
|
|
#endif
|
|
|
|
|
2016-05-27 02:22:53 +08:00
|
|
|
BitVector RegAliases(TRI->getNumRegs());
|
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// Attempt to break anti-dependence edges. Walk the instructions
|
|
|
|
// from the bottom up, tracking information about liveness as we go
|
|
|
|
// to help determine which registers are available.
|
|
|
|
unsigned Broken = 0;
|
|
|
|
unsigned Count = InsertPosIndex - 1;
|
|
|
|
for (MachineBasicBlock::iterator I = End, E = Begin;
|
|
|
|
I != E; --Count) {
|
2016-02-28 03:33:37 +08:00
|
|
|
MachineInstr &MI = *--I;
|
2009-10-27 03:32:42 +08:00
|
|
|
|
2016-02-28 03:33:37 +08:00
|
|
|
if (MI.isDebugValue())
|
2012-01-17 06:53:41 +08:00
|
|
|
continue;
|
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "Anti: ");
|
2016-02-28 03:33:37 +08:00
|
|
|
DEBUG(MI.dump());
|
2009-10-27 03:32:42 +08:00
|
|
|
|
|
|
|
std::set<unsigned> PassthruRegs;
|
|
|
|
GetPassthruRegs(MI, PassthruRegs);
|
|
|
|
|
|
|
|
// Process the defs in MI...
|
|
|
|
PrescanInstruction(MI, Count, PassthruRegs);
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-11-21 03:32:48 +08:00
|
|
|
// The dependence edges that represent anti- and output-
|
2009-11-14 03:52:48 +08:00
|
|
|
// dependencies that are candidates for breaking.
|
2010-04-20 07:11:58 +08:00
|
|
|
std::vector<const SDep *> Edges;
|
2016-02-28 03:33:37 +08:00
|
|
|
const SUnit *PathSU = MISUnitMap[&MI];
|
2009-11-21 03:32:48 +08:00
|
|
|
AntiDepEdges(PathSU, Edges);
|
2009-11-14 03:52:48 +08:00
|
|
|
|
|
|
|
// If MI is not on the critical path, then we don't rename
|
|
|
|
// registers in the CriticalPathSet.
|
2014-04-14 08:51:57 +08:00
|
|
|
BitVector *ExcludeRegs = nullptr;
|
2016-02-28 03:33:37 +08:00
|
|
|
if (&MI == CriticalPathMI) {
|
2009-11-14 03:52:48 +08:00
|
|
|
CriticalPathSU = CriticalPathStep(CriticalPathSU);
|
2014-04-14 08:51:57 +08:00
|
|
|
CriticalPathMI = (CriticalPathSU) ? CriticalPathSU->getInstr() : nullptr;
|
2013-09-12 12:22:31 +08:00
|
|
|
} else if (CriticalPathSet.any()) {
|
2009-11-14 03:52:48 +08:00
|
|
|
ExcludeRegs = &CriticalPathSet;
|
|
|
|
}
|
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// Ignore KILL instructions (they form a group in ScanInstruction
|
|
|
|
// but don't cause any anti-dependence breaking themselves)
|
2016-02-28 03:33:37 +08:00
|
|
|
if (!MI.isKill()) {
|
2009-10-27 03:32:42 +08:00
|
|
|
// Attempt to break each anti-dependency...
|
|
|
|
for (unsigned i = 0, e = Edges.size(); i != e; ++i) {
|
2010-04-20 07:11:58 +08:00
|
|
|
const SDep *Edge = Edges[i];
|
2009-10-27 03:32:42 +08:00
|
|
|
SUnit *NextSU = Edge->getSUnit();
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-11-13 03:08:21 +08:00
|
|
|
if ((Edge->getKind() != SDep::Anti) &&
|
|
|
|
(Edge->getKind() != SDep::Output)) continue;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
unsigned AntiDepReg = Edge->getReg();
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\tAntidep reg: " << TRI->getName(AntiDepReg));
|
2009-10-27 03:32:42 +08:00
|
|
|
assert(AntiDepReg != 0 && "Anti-dependence on reg0?");
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2012-10-16 06:41:03 +08:00
|
|
|
if (!MRI.isAllocatable(AntiDepReg)) {
|
2009-10-27 03:32:42 +08:00
|
|
|
// Don't break anti-dependencies on non-allocatable registers.
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " (non-allocatable)\n");
|
2009-10-27 03:32:42 +08:00
|
|
|
continue;
|
2014-04-14 08:51:57 +08:00
|
|
|
} else if (ExcludeRegs && ExcludeRegs->test(AntiDepReg)) {
|
2009-11-14 03:52:48 +08:00
|
|
|
// Don't break anti-dependencies for critical path registers
|
|
|
|
// if not on the critical path
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " (not critical-path)\n");
|
2009-11-14 03:52:48 +08:00
|
|
|
continue;
|
2009-10-27 03:32:42 +08:00
|
|
|
} else if (PassthruRegs.count(AntiDepReg) != 0) {
|
|
|
|
// If the anti-dep register liveness "passes-thru", then
|
|
|
|
// don't try to change it. It will be changed along with
|
|
|
|
// the use if required to break an earlier antidep.
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " (passthru)\n");
|
2009-10-27 03:32:42 +08:00
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
// No anti-dep breaking for implicit deps
|
2016-02-28 03:33:37 +08:00
|
|
|
MachineOperand *AntiDepOp = MI.findRegisterDefOperand(AntiDepReg);
|
2014-04-14 08:51:57 +08:00
|
|
|
assert(AntiDepOp && "Can't find index for defined register operand");
|
|
|
|
if (!AntiDepOp || AntiDepOp->isImplicit()) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " (implicit)\n");
|
2009-10-27 03:32:42 +08:00
|
|
|
continue;
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// If the SUnit has other dependencies on the SUnit that
|
|
|
|
// it anti-depends on, don't bother breaking the
|
|
|
|
// anti-dependency since those edges would prevent such
|
|
|
|
// units from being scheduled past each other
|
|
|
|
// regardless.
|
2009-11-21 03:32:48 +08:00
|
|
|
//
|
|
|
|
// Also, if there are dependencies on other SUnits with the
|
|
|
|
// same register as the anti-dependency, don't attempt to
|
|
|
|
// break it.
|
2010-04-20 07:11:58 +08:00
|
|
|
for (SUnit::const_pred_iterator P = PathSU->Preds.begin(),
|
2009-10-27 03:32:42 +08:00
|
|
|
PE = PathSU->Preds.end(); P != PE; ++P) {
|
2009-11-21 03:32:48 +08:00
|
|
|
if (P->getSUnit() == NextSU ?
|
|
|
|
(P->getKind() != SDep::Anti || P->getReg() != AntiDepReg) :
|
|
|
|
(P->getKind() == SDep::Data && P->getReg() == AntiDepReg)) {
|
|
|
|
AntiDepReg = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-04-20 07:11:58 +08:00
|
|
|
for (SUnit::const_pred_iterator P = PathSU->Preds.begin(),
|
2009-11-21 03:32:48 +08:00
|
|
|
PE = PathSU->Preds.end(); P != PE; ++P) {
|
|
|
|
if ((P->getSUnit() == NextSU) && (P->getKind() != SDep::Anti) &&
|
|
|
|
(P->getKind() != SDep::Output)) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " (real dependency)\n");
|
2009-10-27 03:32:42 +08:00
|
|
|
AntiDepReg = 0;
|
|
|
|
break;
|
2010-01-07 00:48:02 +08:00
|
|
|
} else if ((P->getSUnit() != NextSU) &&
|
|
|
|
(P->getKind() == SDep::Data) &&
|
2009-11-21 03:32:48 +08:00
|
|
|
(P->getReg() == AntiDepReg)) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " (other dependency)\n");
|
2009-11-21 03:32:48 +08:00
|
|
|
AntiDepReg = 0;
|
|
|
|
break;
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
if (AntiDepReg == 0) continue;
|
2016-05-27 02:22:53 +08:00
|
|
|
|
|
|
|
// If the definition of the anti-dependency register does not start
|
|
|
|
// a new live range, bail out. This can happen if the anti-dep
|
|
|
|
// register is a sub-register of another register whose live range
|
|
|
|
// spans over PathSU. In such case, PathSU defines only a part of
|
|
|
|
// the larger register.
|
|
|
|
RegAliases.reset();
|
|
|
|
for (MCRegAliasIterator AI(AntiDepReg, TRI, true); AI.isValid(); ++AI)
|
|
|
|
RegAliases.set(*AI);
|
|
|
|
for (SDep S : PathSU->Succs) {
|
|
|
|
SDep::Kind K = S.getKind();
|
|
|
|
if (K != SDep::Data && K != SDep::Output && K != SDep::Anti)
|
|
|
|
continue;
|
|
|
|
unsigned R = S.getReg();
|
|
|
|
if (!RegAliases[R])
|
|
|
|
continue;
|
|
|
|
if (R == AntiDepReg || TRI->isSubRegister(AntiDepReg, R))
|
|
|
|
continue;
|
|
|
|
AntiDepReg = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (AntiDepReg == 0) continue;
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
assert(AntiDepReg != 0);
|
|
|
|
if (AntiDepReg == 0) continue;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// Determine AntiDepReg's register group.
|
2009-10-27 06:31:16 +08:00
|
|
|
const unsigned GroupIndex = State->GetGroup(AntiDepReg);
|
2009-10-27 03:32:42 +08:00
|
|
|
if (GroupIndex == 0) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << " (zero group)\n");
|
2009-10-27 03:32:42 +08:00
|
|
|
continue;
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << '\n');
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// Look for a suitable register to use to break the anti-dependence.
|
|
|
|
std::map<unsigned, unsigned> RenameMap;
|
2009-11-05 09:19:35 +08:00
|
|
|
if (FindSuitableFreeRegisters(GroupIndex, RenameOrder, RenameMap)) {
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << "\tBreaking anti-dependence edge on "
|
2009-10-27 03:32:42 +08:00
|
|
|
<< TRI->getName(AntiDepReg) << ":");
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// Handle each group register...
|
|
|
|
for (std::map<unsigned, unsigned>::iterator
|
|
|
|
S = RenameMap.begin(), E = RenameMap.end(); S != E; ++S) {
|
|
|
|
unsigned CurrReg = S->first;
|
|
|
|
unsigned NewReg = S->second;
|
2010-01-07 00:48:02 +08:00
|
|
|
|
|
|
|
DEBUG(dbgs() << " " << TRI->getName(CurrReg) << "->" <<
|
|
|
|
TRI->getName(NewReg) << "(" <<
|
2009-10-27 03:32:42 +08:00
|
|
|
RegRefs.count(CurrReg) << " refs)");
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// Update the references to the old register CurrReg to
|
|
|
|
// refer to the new register NewReg.
|
2015-07-19 04:05:10 +08:00
|
|
|
for (const auto &Q : make_range(RegRefs.equal_range(CurrReg))) {
|
|
|
|
Q.second.Operand->setReg(NewReg);
|
2010-06-02 07:48:44 +08:00
|
|
|
// If the SU for the instruction being updated has debug
|
|
|
|
// information related to the anti-dependency register, make
|
|
|
|
// sure to update that as well.
|
2015-07-19 04:05:10 +08:00
|
|
|
const SUnit *SU = MISUnitMap[Q.second.Operand->getParent()];
|
2010-06-02 23:29:36 +08:00
|
|
|
if (!SU) continue;
|
2011-06-03 05:26:52 +08:00
|
|
|
for (DbgValueVector::iterator DVI = DbgValues.begin(),
|
|
|
|
DVE = DbgValues.end(); DVI != DVE; ++DVI)
|
2015-07-19 04:05:10 +08:00
|
|
|
if (DVI->second == Q.second.Operand->getParent())
|
2016-02-28 03:33:37 +08:00
|
|
|
UpdateDbgValue(*DVI->first, AntiDepReg, NewReg);
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
// We just went back in time and modified history; the
|
|
|
|
// liveness information for CurrReg is now inconsistent. Set
|
|
|
|
// the state as if it were dead.
|
2009-10-27 06:31:16 +08:00
|
|
|
State->UnionGroups(NewReg, 0);
|
2009-10-27 03:32:42 +08:00
|
|
|
RegRefs.erase(NewReg);
|
|
|
|
DefIndices[NewReg] = DefIndices[CurrReg];
|
|
|
|
KillIndices[NewReg] = KillIndices[CurrReg];
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 06:31:16 +08:00
|
|
|
State->UnionGroups(CurrReg, 0);
|
2009-10-27 03:32:42 +08:00
|
|
|
RegRefs.erase(CurrReg);
|
|
|
|
DefIndices[CurrReg] = KillIndices[CurrReg];
|
|
|
|
KillIndices[CurrReg] = ~0u;
|
|
|
|
assert(((KillIndices[CurrReg] == ~0u) !=
|
|
|
|
(DefIndices[CurrReg] == ~0u)) &&
|
|
|
|
"Kill and Def maps aren't consistent for AntiDepReg!");
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
++Broken;
|
2009-12-24 08:14:25 +08:00
|
|
|
DEBUG(dbgs() << '\n');
|
2009-10-27 03:32:42 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ScanInstruction(MI, Count);
|
|
|
|
}
|
2010-01-07 00:48:02 +08:00
|
|
|
|
2009-10-27 03:32:42 +08:00
|
|
|
return Broken;
|
|
|
|
}
|