mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-19 19:30:10 +00:00
bc001b24a1
info (since multiple reg types may share the same reg class).
(2) Remove machine-specific regalloc. methods that are no longer needed.
In particular, arguments and return value from a call do not need
machine-specific code for allocation.
(3) Rename TargetRegInfo::getRegType variants to avoid unintentional
overloading when an include file is omitted.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7329 91177308-0d34-0410-b5e6-96231b3b80d8
134 lines
4.2 KiB
C++
134 lines
4.2 KiB
C++
/* Title: RegClass.h -*- C++ -*-
|
|
Author: Ruchira Sasanka
|
|
Date: Aug 20, 01
|
|
Purpose: Contains machine independent methods for register coloring.
|
|
|
|
*/
|
|
|
|
#ifndef REG_CLASS_H
|
|
#define REG_CLASS_H
|
|
|
|
#include "llvm/Target/TargetRegInfo.h"
|
|
#include "InterferenceGraph.h"
|
|
#include <stack>
|
|
class TargetRegClassInfo;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Class RegClass
|
|
//
|
|
// Implements a machine independant register class.
|
|
//
|
|
// This is the class that contains all data structures and common algos
|
|
// for coloring a particular register class (e.g., int class, fp class).
|
|
// This class is hardware independent. This class accepts a hardware
|
|
// dependent description of machine registers (TargetRegInfo class) to
|
|
// get hardware specific info and to color an individual IG node.
|
|
//
|
|
// This class contains the InterferenceGraph (IG).
|
|
// Also it contains an IGNode stack that can be used for coloring.
|
|
// The class provides some easy access methods to the IG methods, since these
|
|
// methods are called thru a register class.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class RegClass {
|
|
const Function *const Meth; // Function we are working on
|
|
const TargetRegInfo *MRI; // Machine register information
|
|
const TargetRegClassInfo *const MRC; // Machine reg. class for this RegClass
|
|
const unsigned RegClassID; // my int ID
|
|
|
|
InterferenceGraph IG; // Interference graph - constructed by
|
|
// buildInterferenceGraph
|
|
std::stack<IGNode *> IGNodeStack; // the stack used for coloring
|
|
|
|
// IsColorUsedArr - An array used for coloring each node. This array must be
|
|
// of size MRC->getNumOfAllRegs(). Allocated once in the constructor for
|
|
// efficiency.
|
|
//
|
|
std::vector<bool> IsColorUsedArr;
|
|
|
|
|
|
|
|
//--------------------------- private methods ------------------------------
|
|
|
|
void pushAllIGNodes();
|
|
|
|
bool pushUnconstrainedIGNodes();
|
|
|
|
IGNode * getIGNodeWithMinSpillCost();
|
|
|
|
void colorIGNode(IGNode *const Node);
|
|
|
|
// This directly marks the colors used by a particular register number
|
|
// within the register class. External users should use the public
|
|
// versions of this function below.
|
|
inline void markColorUsed(unsigned classRegNum) {
|
|
assert(classRegNum < IsColorUsedArr.size() && "Invalid register used?");
|
|
IsColorUsedArr[classRegNum] = true;
|
|
}
|
|
|
|
inline bool isColorUsed(unsigned regNum) const {
|
|
assert(regNum < IsColorUsedArr.size() && "Invalid register used?");
|
|
return IsColorUsedArr[regNum];
|
|
}
|
|
|
|
public:
|
|
|
|
RegClass(const Function *M,
|
|
const TargetRegInfo *_MRI_,
|
|
const TargetRegClassInfo *_MRC_);
|
|
|
|
inline void createInterferenceGraph() { IG.createGraph(); }
|
|
|
|
inline InterferenceGraph &getIG() { return IG; }
|
|
|
|
inline const unsigned getID() const { return RegClassID; }
|
|
|
|
inline const TargetRegClassInfo* getTargetRegClass() const { return MRC; }
|
|
|
|
// main method called for coloring regs
|
|
//
|
|
void colorAllRegs();
|
|
|
|
inline unsigned getNumOfAvailRegs() const
|
|
{ return MRC->getNumOfAvailRegs(); }
|
|
|
|
|
|
// --- following methods are provided to access the IG contained within this
|
|
// ---- RegClass easilly.
|
|
|
|
inline void addLRToIG(LiveRange *const LR)
|
|
{ IG.addLRToIG(LR); }
|
|
|
|
inline void setInterference(const LiveRange *const LR1,
|
|
const LiveRange *const LR2)
|
|
{ IG.setInterference(LR1, LR2); }
|
|
|
|
inline unsigned getInterference(const LiveRange *const LR1,
|
|
const LiveRange *const LR2) const
|
|
{ return IG.getInterference(LR1, LR2); }
|
|
|
|
inline void mergeIGNodesOfLRs(const LiveRange *const LR1,
|
|
LiveRange *const LR2)
|
|
{ IG.mergeIGNodesOfLRs(LR1, LR2); }
|
|
|
|
|
|
inline void clearColorsUsed() {
|
|
IsColorUsedArr.clear();
|
|
IsColorUsedArr.resize(MRC->getNumOfAllRegs());
|
|
}
|
|
inline void markColorsUsed(unsigned ClassRegNum,
|
|
int UserRegType,
|
|
int RegTypeWanted) {
|
|
MRC->markColorsUsed(ClassRegNum, UserRegType, RegTypeWanted,IsColorUsedArr);
|
|
}
|
|
inline int getUnusedColor(int machineRegType) const {
|
|
return MRC->findUnusedColor(machineRegType, IsColorUsedArr);
|
|
}
|
|
|
|
void printIGNodeList() const;
|
|
void printIG();
|
|
};
|
|
|
|
#endif
|