mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 02:30:00 +00:00
When registers must be live throughout the scheduling region, increase the limit for the register class. Once we exceed the original limit, they will be spilled, and there's no point further reducing pressure. This isn't a perfect heuristics but avoids a situation where the scheduler could become trapped by trying to achieve the impossible. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@187436 91177308-0d34-0410-b5e6-96231b3b80d8
356 lines
14 KiB
C++
356 lines
14 KiB
C++
//===-- RegisterPressure.h - Dynamic Register Pressure -*- C++ -*-------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the RegisterPressure class which can be used to track
|
|
// MachineInstr level register pressure.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CODEGEN_REGISTERPRESSURE_H
|
|
#define LLVM_CODEGEN_REGISTERPRESSURE_H
|
|
|
|
#include "llvm/ADT/SparseSet.h"
|
|
#include "llvm/CodeGen/SlotIndexes.h"
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
|
|
|
namespace llvm {
|
|
|
|
class LiveIntervals;
|
|
class LiveInterval;
|
|
class RegisterClassInfo;
|
|
class MachineInstr;
|
|
|
|
/// Base class for register pressure results.
|
|
struct RegisterPressure {
|
|
/// Map of max reg pressure indexed by pressure set ID, not class ID.
|
|
std::vector<unsigned> MaxSetPressure;
|
|
|
|
/// List of live in virtual registers or physical register units.
|
|
SmallVector<unsigned,8> LiveInRegs;
|
|
SmallVector<unsigned,8> LiveOutRegs;
|
|
|
|
/// Increase register pressure for each pressure set impacted by this register
|
|
/// class. Normally called by RegPressureTracker, but may be called manually
|
|
/// to account for live through (global liveness).
|
|
///
|
|
/// \param Reg is either a virtual register number or register unit number.
|
|
void increase(unsigned Reg, const TargetRegisterInfo *TRI,
|
|
const MachineRegisterInfo *MRI);
|
|
|
|
/// Decrease register pressure for each pressure set impacted by this register
|
|
/// class. This is only useful to account for spilling or rematerialization.
|
|
///
|
|
/// \param Reg is either a virtual register number or register unit number.
|
|
void decrease(unsigned Reg, const TargetRegisterInfo *TRI,
|
|
const MachineRegisterInfo *MRI);
|
|
|
|
void dump(const TargetRegisterInfo *TRI) const;
|
|
};
|
|
|
|
/// RegisterPressure computed within a region of instructions delimited by
|
|
/// TopIdx and BottomIdx. During pressure computation, the maximum pressure per
|
|
/// register pressure set is increased. Once pressure within a region is fully
|
|
/// computed, the live-in and live-out sets are recorded.
|
|
///
|
|
/// This is preferable to RegionPressure when LiveIntervals are available,
|
|
/// because delimiting regions by SlotIndex is more robust and convenient than
|
|
/// holding block iterators. The block contents can change without invalidating
|
|
/// the pressure result.
|
|
struct IntervalPressure : RegisterPressure {
|
|
/// Record the boundary of the region being tracked.
|
|
SlotIndex TopIdx;
|
|
SlotIndex BottomIdx;
|
|
|
|
void reset();
|
|
|
|
void openTop(SlotIndex NextTop);
|
|
|
|
void openBottom(SlotIndex PrevBottom);
|
|
};
|
|
|
|
/// RegisterPressure computed within a region of instructions delimited by
|
|
/// TopPos and BottomPos. This is a less precise version of IntervalPressure for
|
|
/// use when LiveIntervals are unavailable.
|
|
struct RegionPressure : RegisterPressure {
|
|
/// Record the boundary of the region being tracked.
|
|
MachineBasicBlock::const_iterator TopPos;
|
|
MachineBasicBlock::const_iterator BottomPos;
|
|
|
|
void reset();
|
|
|
|
void openTop(MachineBasicBlock::const_iterator PrevTop);
|
|
|
|
void openBottom(MachineBasicBlock::const_iterator PrevBottom);
|
|
};
|
|
|
|
/// An element of pressure difference that identifies the pressure set and
|
|
/// amount of increase or decrease in units of pressure.
|
|
struct PressureElement {
|
|
unsigned PSetID;
|
|
int UnitIncrease;
|
|
|
|
PressureElement(): PSetID(~0U), UnitIncrease(0) {}
|
|
PressureElement(unsigned id, int inc): PSetID(id), UnitIncrease(inc) {}
|
|
|
|
bool isValid() const { return PSetID != ~0U; }
|
|
|
|
// If signed PSetID is negative, it is invalid; convert it to INT_MAX to give
|
|
// it lowest priority.
|
|
int PSetRank() const { return PSetID & INT_MAX; }
|
|
};
|
|
|
|
/// Store the effects of a change in pressure on things that MI scheduler cares
|
|
/// about.
|
|
///
|
|
/// Excess records the value of the largest difference in register units beyond
|
|
/// the target's pressure limits across the affected pressure sets, where
|
|
/// largest is defined as the absolute value of the difference. Negative
|
|
/// ExcessUnits indicates a reduction in pressure that had already exceeded the
|
|
/// target's limits.
|
|
///
|
|
/// CriticalMax records the largest increase in the tracker's max pressure that
|
|
/// exceeds the critical limit for some pressure set determined by the client.
|
|
///
|
|
/// CurrentMax records the largest increase in the tracker's max pressure that
|
|
/// exceeds the current limit for some pressure set determined by the client.
|
|
struct RegPressureDelta {
|
|
PressureElement Excess;
|
|
PressureElement CriticalMax;
|
|
PressureElement CurrentMax;
|
|
|
|
RegPressureDelta() {}
|
|
};
|
|
|
|
/// \brief A set of live virtual registers and physical register units.
|
|
///
|
|
/// Virtual and physical register numbers require separate sparse sets, but most
|
|
/// of the RegisterPressureTracker handles them uniformly.
|
|
struct LiveRegSet {
|
|
SparseSet<unsigned> PhysRegs;
|
|
SparseSet<unsigned, VirtReg2IndexFunctor> VirtRegs;
|
|
|
|
bool contains(unsigned Reg) {
|
|
if (TargetRegisterInfo::isVirtualRegister(Reg))
|
|
return VirtRegs.count(Reg);
|
|
return PhysRegs.count(Reg);
|
|
}
|
|
|
|
bool insert(unsigned Reg) {
|
|
if (TargetRegisterInfo::isVirtualRegister(Reg))
|
|
return VirtRegs.insert(Reg).second;
|
|
return PhysRegs.insert(Reg).second;
|
|
}
|
|
|
|
bool erase(unsigned Reg) {
|
|
if (TargetRegisterInfo::isVirtualRegister(Reg))
|
|
return VirtRegs.erase(Reg);
|
|
return PhysRegs.erase(Reg);
|
|
}
|
|
};
|
|
|
|
/// Track the current register pressure at some position in the instruction
|
|
/// stream, and remember the high water mark within the region traversed. This
|
|
/// does not automatically consider live-through ranges. The client may
|
|
/// independently adjust for global liveness.
|
|
///
|
|
/// Each RegPressureTracker only works within a MachineBasicBlock. Pressure can
|
|
/// be tracked across a larger region by storing a RegisterPressure result at
|
|
/// each block boundary and explicitly adjusting pressure to account for block
|
|
/// live-in and live-out register sets.
|
|
///
|
|
/// RegPressureTracker holds a reference to a RegisterPressure result that it
|
|
/// computes incrementally. During downward tracking, P.BottomIdx or P.BottomPos
|
|
/// is invalid until it reaches the end of the block or closeRegion() is
|
|
/// explicitly called. Similarly, P.TopIdx is invalid during upward
|
|
/// tracking. Changing direction has the side effect of closing region, and
|
|
/// traversing past TopIdx or BottomIdx reopens it.
|
|
class RegPressureTracker {
|
|
const MachineFunction *MF;
|
|
const TargetRegisterInfo *TRI;
|
|
const RegisterClassInfo *RCI;
|
|
const MachineRegisterInfo *MRI;
|
|
const LiveIntervals *LIS;
|
|
|
|
/// We currently only allow pressure tracking within a block.
|
|
const MachineBasicBlock *MBB;
|
|
|
|
/// Track the max pressure within the region traversed so far.
|
|
RegisterPressure &P;
|
|
|
|
/// Run in two modes dependending on whether constructed with IntervalPressure
|
|
/// or RegisterPressure. If requireIntervals is false, LIS are ignored.
|
|
bool RequireIntervals;
|
|
|
|
/// True if UntiedDefs will be populated.
|
|
bool TrackUntiedDefs;
|
|
|
|
/// Register pressure corresponds to liveness before this instruction
|
|
/// iterator. It may point to the end of the block or a DebugValue rather than
|
|
/// an instruction.
|
|
MachineBasicBlock::const_iterator CurrPos;
|
|
|
|
/// Pressure map indexed by pressure set ID, not class ID.
|
|
std::vector<unsigned> CurrSetPressure;
|
|
|
|
/// Set of live registers.
|
|
LiveRegSet LiveRegs;
|
|
|
|
/// Set of vreg defs that start a live range.
|
|
SparseSet<unsigned, VirtReg2IndexFunctor> UntiedDefs;
|
|
/// Live-through pressure.
|
|
std::vector<unsigned> LiveThruPressure;
|
|
|
|
public:
|
|
RegPressureTracker(IntervalPressure &rp) :
|
|
MF(0), TRI(0), RCI(0), LIS(0), MBB(0), P(rp), RequireIntervals(true),
|
|
TrackUntiedDefs(false) {}
|
|
|
|
RegPressureTracker(RegionPressure &rp) :
|
|
MF(0), TRI(0), RCI(0), LIS(0), MBB(0), P(rp), RequireIntervals(false),
|
|
TrackUntiedDefs(false) {}
|
|
|
|
void init(const MachineFunction *mf, const RegisterClassInfo *rci,
|
|
const LiveIntervals *lis, const MachineBasicBlock *mbb,
|
|
MachineBasicBlock::const_iterator pos,
|
|
bool ShouldTrackUntiedDefs = false);
|
|
|
|
/// Force liveness of virtual registers or physical register
|
|
/// units. Particularly useful to initialize the livein/out state of the
|
|
/// tracker before the first call to advance/recede.
|
|
void addLiveRegs(ArrayRef<unsigned> Regs);
|
|
|
|
/// Get the MI position corresponding to this register pressure.
|
|
MachineBasicBlock::const_iterator getPos() const { return CurrPos; }
|
|
|
|
// Reset the MI position corresponding to the register pressure. This allows
|
|
// schedulers to move instructions above the RegPressureTracker's
|
|
// CurrPos. Since the pressure is computed before CurrPos, the iterator
|
|
// position changes while pressure does not.
|
|
void setPos(MachineBasicBlock::const_iterator Pos) { CurrPos = Pos; }
|
|
|
|
/// \brief Get the SlotIndex for the first nondebug instruction including or
|
|
/// after the current position.
|
|
SlotIndex getCurrSlot() const;
|
|
|
|
/// Recede across the previous instruction.
|
|
bool recede();
|
|
|
|
/// Advance across the current instruction.
|
|
bool advance();
|
|
|
|
/// Finalize the region boundaries and recored live ins and live outs.
|
|
void closeRegion();
|
|
|
|
/// Initialize the LiveThru pressure set based on the untied defs found in
|
|
/// RPTracker.
|
|
void initLiveThru(const RegPressureTracker &RPTracker);
|
|
|
|
/// Copy an existing live thru pressure result.
|
|
void initLiveThru(ArrayRef<unsigned> PressureSet) {
|
|
LiveThruPressure.assign(PressureSet.begin(), PressureSet.end());
|
|
}
|
|
|
|
ArrayRef<unsigned> getLiveThru() const { return LiveThruPressure; }
|
|
|
|
/// Get the resulting register pressure over the traversed region.
|
|
/// This result is complete if either advance() or recede() has returned true,
|
|
/// or if closeRegion() was explicitly invoked.
|
|
RegisterPressure &getPressure() { return P; }
|
|
const RegisterPressure &getPressure() const { return P; }
|
|
|
|
/// Get the register set pressure at the current position, which may be less
|
|
/// than the pressure across the traversed region.
|
|
std::vector<unsigned> &getRegSetPressureAtPos() { return CurrSetPressure; }
|
|
|
|
void discoverLiveOut(unsigned Reg);
|
|
void discoverLiveIn(unsigned Reg);
|
|
|
|
bool isTopClosed() const;
|
|
bool isBottomClosed() const;
|
|
|
|
void closeTop();
|
|
void closeBottom();
|
|
|
|
/// Consider the pressure increase caused by traversing this instruction
|
|
/// bottom-up. Find the pressure set with the most change beyond its pressure
|
|
/// limit based on the tracker's current pressure, and record the number of
|
|
/// excess register units of that pressure set introduced by this instruction.
|
|
void getMaxUpwardPressureDelta(const MachineInstr *MI,
|
|
RegPressureDelta &Delta,
|
|
ArrayRef<PressureElement> CriticalPSets,
|
|
ArrayRef<unsigned> MaxPressureLimit);
|
|
|
|
/// Consider the pressure increase caused by traversing this instruction
|
|
/// top-down. Find the pressure set with the most change beyond its pressure
|
|
/// limit based on the tracker's current pressure, and record the number of
|
|
/// excess register units of that pressure set introduced by this instruction.
|
|
void getMaxDownwardPressureDelta(const MachineInstr *MI,
|
|
RegPressureDelta &Delta,
|
|
ArrayRef<PressureElement> CriticalPSets,
|
|
ArrayRef<unsigned> MaxPressureLimit);
|
|
|
|
/// Find the pressure set with the most change beyond its pressure limit after
|
|
/// traversing this instruction either upward or downward depending on the
|
|
/// closed end of the current region.
|
|
void getMaxPressureDelta(const MachineInstr *MI, RegPressureDelta &Delta,
|
|
ArrayRef<PressureElement> CriticalPSets,
|
|
ArrayRef<unsigned> MaxPressureLimit) {
|
|
if (isTopClosed())
|
|
return getMaxDownwardPressureDelta(MI, Delta, CriticalPSets,
|
|
MaxPressureLimit);
|
|
|
|
assert(isBottomClosed() && "Uninitialized pressure tracker");
|
|
return getMaxUpwardPressureDelta(MI, Delta, CriticalPSets,
|
|
MaxPressureLimit);
|
|
}
|
|
|
|
/// Get the pressure of each PSet after traversing this instruction bottom-up.
|
|
void getUpwardPressure(const MachineInstr *MI,
|
|
std::vector<unsigned> &PressureResult,
|
|
std::vector<unsigned> &MaxPressureResult);
|
|
|
|
/// Get the pressure of each PSet after traversing this instruction top-down.
|
|
void getDownwardPressure(const MachineInstr *MI,
|
|
std::vector<unsigned> &PressureResult,
|
|
std::vector<unsigned> &MaxPressureResult);
|
|
|
|
void getPressureAfterInst(const MachineInstr *MI,
|
|
std::vector<unsigned> &PressureResult,
|
|
std::vector<unsigned> &MaxPressureResult) {
|
|
if (isTopClosed())
|
|
return getUpwardPressure(MI, PressureResult, MaxPressureResult);
|
|
|
|
assert(isBottomClosed() && "Uninitialized pressure tracker");
|
|
return getDownwardPressure(MI, PressureResult, MaxPressureResult);
|
|
}
|
|
|
|
bool hasUntiedDef(unsigned VirtReg) const {
|
|
return UntiedDefs.count(VirtReg);
|
|
}
|
|
|
|
void dump() const;
|
|
|
|
protected:
|
|
const LiveInterval *getInterval(unsigned Reg) const;
|
|
|
|
void increaseRegPressure(ArrayRef<unsigned> Regs);
|
|
void decreaseRegPressure(ArrayRef<unsigned> Regs);
|
|
|
|
void bumpUpwardPressure(const MachineInstr *MI);
|
|
void bumpDownwardPressure(const MachineInstr *MI);
|
|
};
|
|
|
|
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
|
void dumpRegSetPressure(ArrayRef<unsigned> SetPressure,
|
|
const TargetRegisterInfo *TRI);
|
|
#endif
|
|
} // end namespace llvm
|
|
|
|
#endif
|