mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-29 10:32:47 +00:00
9d60e0ff0a
A broken hint is a copy where both ends are assigned different colors. When a variable gets evicted in the neighborhood of such copies, it is likely we can reconcile some of them. ** Context ** Copies are inserted during the register allocation via splitting. These split points are required to relax the constraints on the allocation problem. When such a point is inserted, both ends of the copy would not share the same color with respect to the current allocation problem. When variables get evicted, the allocation problem becomes different and some split point may not be required anymore. However, the related variables may already have been colored. This usually shows up in the assembly with pattern like this: def A ... save A to B def A use A restore A from B ... use B Whereas we could simply have done: def B ... def A use A ... use B ** Proposed Solution ** A variable having a broken hint is marked for late recoloring if and only if selecting a register for it evict another variable. Indeed, if no eviction happens this is pointless to look for recoloring opportunities as it means the situation was the same as the initial allocation problem where we had to break the hint. Finally, when everything has been allocated, we look for recoloring opportunities for all the identified candidates. The recoloring is performed very late to rely on accurate copy cost (all involved variables are allocated). The recoloring is simple unlike the last change recoloring. It propagates the color of the broken hint to all its copy-related variables. If the color is available for them, the recoloring uses it, otherwise it gives up on that hint even if a more complex coloring would have worked. The recoloring happens only if it is profitable. The profitability is evaluated using the expected frequency of the copies of the currently recolored variable with a) its current color and b) with the target color. If a) is greater or equal than b), then it is profitable and the recoloring happen. ** Example ** Consider the following example: BB1: a = b = BB2: ... = b = a Let us assume b gets split: BB1: a = b = BB2: c = b ... d = c = d = a Because of how the allocation work, b, c, and d may be assigned different colors. Now, if a gets evicted to make room for c, assuming b and d were assigned to something different than a. We end up with: BB1: a = st a, SpillSlot b = BB2: c = b ... d = c = d e = ld SpillSlot = e This is likely that we can assign the same register for b, c, and d, getting rid of 2 copies. ** Performances ** Both ARM64 and x86_64 show performance improvements of up to 3% for the llvm-testsuite + externals with Os and O3. There are a few regressions too that comes from the (in)accuracy of the block frequency estimate. <rdar://problem/18312047> git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225422 91177308-0d34-0410-b5e6-96231b3b80d8
113 lines
4.0 KiB
C++
113 lines
4.0 KiB
C++
//===-- RegAllocBase.h - basic regalloc interface and driver --*- 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 RegAllocBase class, which is the skeleton of a basic
|
|
// register allocation algorithm and interface for extending it. It provides the
|
|
// building blocks on which to construct other experimental allocators and test
|
|
// the validity of two principles:
|
|
//
|
|
// - If virtual and physical register liveness is modeled using intervals, then
|
|
// on-the-fly interference checking is cheap. Furthermore, interferences can be
|
|
// lazily cached and reused.
|
|
//
|
|
// - Register allocation complexity, and generated code performance is
|
|
// determined by the effectiveness of live range splitting rather than optimal
|
|
// coloring.
|
|
//
|
|
// Following the first principle, interfering checking revolves around the
|
|
// LiveIntervalUnion data structure.
|
|
//
|
|
// To fulfill the second principle, the basic allocator provides a driver for
|
|
// incremental splitting. It essentially punts on the problem of register
|
|
// coloring, instead driving the assignment of virtual to physical registers by
|
|
// the cost of splitting. The basic allocator allows for heuristic reassignment
|
|
// of registers, if a more sophisticated allocator chooses to do that.
|
|
//
|
|
// This framework provides a way to engineer the compile time vs. code
|
|
// quality trade-off without relying on a particular theoretical solver.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_CODEGEN_REGALLOCBASE_H
|
|
#define LLVM_LIB_CODEGEN_REGALLOCBASE_H
|
|
|
|
#include "llvm/CodeGen/LiveInterval.h"
|
|
#include "llvm/CodeGen/RegisterClassInfo.h"
|
|
|
|
namespace llvm {
|
|
|
|
template<typename T> class SmallVectorImpl;
|
|
class TargetRegisterInfo;
|
|
class VirtRegMap;
|
|
class LiveIntervals;
|
|
class LiveRegMatrix;
|
|
class Spiller;
|
|
|
|
/// RegAllocBase provides the register allocation driver and interface that can
|
|
/// be extended to add interesting heuristics.
|
|
///
|
|
/// Register allocators must override the selectOrSplit() method to implement
|
|
/// live range splitting. They must also override enqueue/dequeue to provide an
|
|
/// assignment order.
|
|
class RegAllocBase {
|
|
virtual void anchor();
|
|
protected:
|
|
const TargetRegisterInfo *TRI;
|
|
MachineRegisterInfo *MRI;
|
|
VirtRegMap *VRM;
|
|
LiveIntervals *LIS;
|
|
LiveRegMatrix *Matrix;
|
|
RegisterClassInfo RegClassInfo;
|
|
|
|
RegAllocBase()
|
|
: TRI(nullptr), MRI(nullptr), VRM(nullptr), LIS(nullptr), Matrix(nullptr) {}
|
|
|
|
virtual ~RegAllocBase() {}
|
|
|
|
// A RegAlloc pass should call this before allocatePhysRegs.
|
|
void init(VirtRegMap &vrm, LiveIntervals &lis, LiveRegMatrix &mat);
|
|
|
|
// The top-level driver. The output is a VirtRegMap that us updated with
|
|
// physical register assignments.
|
|
void allocatePhysRegs();
|
|
|
|
// Get a temporary reference to a Spiller instance.
|
|
virtual Spiller &spiller() = 0;
|
|
|
|
/// enqueue - Add VirtReg to the priority queue of unassigned registers.
|
|
virtual void enqueue(LiveInterval *LI) = 0;
|
|
|
|
/// dequeue - Return the next unassigned register, or NULL.
|
|
virtual LiveInterval *dequeue() = 0;
|
|
|
|
// A RegAlloc pass should override this to provide the allocation heuristics.
|
|
// Each call must guarantee forward progess by returning an available PhysReg
|
|
// or new set of split live virtual registers. It is up to the splitter to
|
|
// converge quickly toward fully spilled live ranges.
|
|
virtual unsigned selectOrSplit(LiveInterval &VirtReg,
|
|
SmallVectorImpl<unsigned> &splitLVRs) = 0;
|
|
|
|
// Use this group name for NamedRegionTimer.
|
|
static const char TimerGroupName[];
|
|
|
|
/// Method called when the allocator is about to remove a LiveInterval.
|
|
virtual void aboutToRemoveInterval(LiveInterval &LI) {}
|
|
|
|
public:
|
|
/// VerifyEnabled - True when -verify-regalloc is given.
|
|
static bool VerifyEnabled;
|
|
|
|
private:
|
|
void seedLiveRegs();
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|