CodeGenRegisters.h revision 31d938a6b1173c642f975d78417459d4d8cd3677
18dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner//===- CodeGenRegisters.h - Register and RegisterClass Info -----*- C++ -*-===// 23da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman// 38dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner// The LLVM Compiler Infrastructure 48dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner// 53060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// This file is distributed under the University of Illinois Open Source 63060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// License. See LICENSE.TXT for details. 73da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman// 88dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner//===----------------------------------------------------------------------===// 98dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner// 108dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner// This file defines structures to encapsulate information gleaned from the 118dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner// target register and register class definitions. 128dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner// 138dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner//===----------------------------------------------------------------------===// 148dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 158dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner#ifndef CODEGEN_REGISTERS_H 168dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner#define CODEGEN_REGISTERS_H 178dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 1859f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen#include "SetTheory.h" 197c788888872233748da10a8177a9a1eb176c1bc8Peter Collingbourne#include "llvm/TableGen/Record.h" 20ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov#include "llvm/CodeGen/ValueTypes.h" 21ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen#include "llvm/ADT/ArrayRef.h" 22203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen#include "llvm/ADT/BitVector.h" 2309bc0298650c76db1a06e20ca84c1dcb34071600Jakob Stoklund Olesen#include "llvm/ADT/DenseMap.h" 24026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen#include "llvm/ADT/SetVector.h" 25655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper#include "llvm/Support/ErrorHandling.h" 26b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen#include <cstdlib> 27b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen#include <map> 288dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner#include <string> 29a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher#include <set> 30b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen#include <vector> 318dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 328dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattnernamespace llvm { 33b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen class CodeGenRegBank; 348dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 355fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen /// CodeGenSubRegIndex - Represents a sub-register index. 365fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen class CodeGenSubRegIndex { 375fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen Record *const TheDef; 385fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 395fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen public: 40b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen const unsigned EnumValue; 41b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 425fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex(Record *R, unsigned Enum); 435fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 445fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen const std::string &getName() const; 455fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen std::string getNamespace() const; 465fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen std::string getQualifiedName() const; 475fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 485fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen // Order CodeGenSubRegIndex pointers by EnumValue. 495fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen struct Less { 505fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen bool operator()(const CodeGenSubRegIndex *A, 515fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen const CodeGenSubRegIndex *B) const { 525fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen assert(A && B); 535fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen return A->EnumValue < B->EnumValue; 545fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen } 555fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen }; 5690498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 5790498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Map of composite subreg indices. 5890498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen typedef std::map<CodeGenSubRegIndex*, CodeGenSubRegIndex*, Less> CompMap; 5990498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 6090498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Returns the subreg index that results from composing this with Idx. 6190498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Returns NULL if this and Idx don't compose. 6290498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CodeGenSubRegIndex *compose(CodeGenSubRegIndex *Idx) const { 6390498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CompMap::const_iterator I = Composed.find(Idx); 6490498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen return I == Composed.end() ? 0 : I->second; 6590498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen } 6690498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 6790498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Add a composite subreg index: this+A = B. 6890498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Return a conflicting composite, or NULL 6990498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CodeGenSubRegIndex *addComposite(CodeGenSubRegIndex *A, 7090498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CodeGenSubRegIndex *B) { 71fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen assert(A && B); 7290498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen std::pair<CompMap::iterator, bool> Ins = 7390498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen Composed.insert(std::make_pair(A, B)); 7490498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen return (Ins.second || Ins.first->second == B) ? 0 : Ins.first->second; 7590498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen } 7690498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 77b5af2d943ed568f2f4cac545b6dfb150ae9d73aaJakob Stoklund Olesen // Update the composite maps of components specified in 'ComposedOf'. 78b5af2d943ed568f2f4cac545b6dfb150ae9d73aaJakob Stoklund Olesen void updateComponents(CodeGenRegBank&); 79b5af2d943ed568f2f4cac545b6dfb150ae9d73aaJakob Stoklund Olesen 8090498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Clean out redundant composite mappings. 8190498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen void cleanComposites(); 8290498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 8390498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Return the map of composites. 8490498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen const CompMap &getComposites() const { return Composed; } 8590498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 8690498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen private: 8790498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CompMap Composed; 885fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen }; 895fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 908dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner /// CodeGenRegister - Represents a register definition. 918dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner struct CodeGenRegister { 928dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner Record *TheDef; 9317fad045cccf34822d3163ada9e70a8f4528746eJim Grosbach unsigned EnumValue; 946bfba2e5af163442a1c6b11fe14aa9df9101cfd7Jakob Stoklund Olesen unsigned CostPerUse; 9531867660cb81ea2b1d1a6ffa7d09c91acb754a8bJakob Stoklund Olesen bool CoveredBySubRegs; 96b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 97b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Map SubRegIndex -> Register. 985fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen typedef std::map<CodeGenSubRegIndex*, CodeGenRegister*, 995fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex::Less> SubRegMap; 100b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 101b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen CodeGenRegister(Record *R, unsigned Enum); 102b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 103b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen const std::string &getName() const; 104b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 105148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen // Extract more information from TheDef. This is used to build an object 106148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen // graph after all CodeGenRegister objects have been created. 107148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen void buildObjectGraph(CodeGenRegBank&); 108148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen 109da2be824346c316c6fc840de7b8493e3d587e785Jakob Stoklund Olesen // Lazily compute a map of all sub-registers. 110b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // This includes unique entries for all sub-sub-registers. 111da2be824346c316c6fc840de7b8493e3d587e785Jakob Stoklund Olesen const SubRegMap &computeSubRegs(CodeGenRegBank&); 112b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 113fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // Compute extra sub-registers by combining the existing sub-registers. 114fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen void computeSecondarySubRegs(CodeGenRegBank&); 115fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 11679e2045531cb4d1978be42591e9254c38a463d30Jakob Stoklund Olesen // Add this as a super-register to all sub-registers after the sub-register 11779e2045531cb4d1978be42591e9254c38a463d30Jakob Stoklund Olesen // graph has been built. 118b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen void computeSuperRegs(CodeGenRegBank&); 11979e2045531cb4d1978be42591e9254c38a463d30Jakob Stoklund Olesen 120b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen const SubRegMap &getSubRegs() const { 121b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen assert(SubRegsComplete && "Must precompute sub-registers"); 122b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen return SubRegs; 123b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen } 124b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 125026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // Add sub-registers to OSet following a pre-order defined by the .td file. 126c6a96ff6aeeb77e1007364e5603b72f3ab4cc7bdJakob Stoklund Olesen void addSubRegsPreOrder(SetVector<const CodeGenRegister*> &OSet, 1275fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenRegBank&) const; 128026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 129ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen // Return the sub-register index naming Reg as a sub-register of this 130ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen // register. Returns NULL if Reg is not a sub-register. 131ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen CodeGenSubRegIndex *getSubRegIndex(const CodeGenRegister *Reg) const { 132ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen return SubReg2Idx.lookup(Reg); 133ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen } 134ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen 135c6a96ff6aeeb77e1007364e5603b72f3ab4cc7bdJakob Stoklund Olesen typedef std::vector<const CodeGenRegister*> SuperRegList; 136026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 137fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // Get the list of super-registers in topological order, small to large. 138fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // This is valid after computeSubRegs visits all registers during RegBank 139fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // construction. 140026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen const SuperRegList &getSuperRegs() const { 141026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen assert(SubRegsComplete && "Must precompute sub-registers"); 142026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen return SuperRegs; 143026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen } 144026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 14531d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen // Get the list of ad hoc aliases. The graph is symmetric, so the list 14631d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen // contains all registers in 'Aliases', and all registers that mention this 14731d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen // register in 'Aliases'. 14831d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen ArrayRef<CodeGenRegister*> getExplicitAliases() const { 14931d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen return ExplicitAliases; 15031d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen } 15131d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen 152b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Get the topological signature of this register. This is a small integer 153b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // less than RegBank.getNumTopoSigs(). Registers with the same TopoSig have 154b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // identical sub-register structure. That is, they support the same set of 155b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // sub-register indices mapping to the same kind of sub-registers 156b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // (TopoSig-wise). 157b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen unsigned getTopoSig() const { 158b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen assert(SuperRegsComplete && "TopoSigs haven't been computed yet."); 159b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen return TopoSig; 160b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen } 161b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 162dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick // List of register units in ascending order. 163dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick typedef SmallVector<unsigned, 16> RegUnitList; 164dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick 165dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick // Get the list of register units. 166dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick // This is only valid after getSubRegs() completes. 167dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick const RegUnitList &getRegUnits() const { return RegUnits; } 168dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick 169d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Inherit register units from subregisters. 170d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Return true if the RegUnits changed. 171d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick bool inheritRegUnits(CodeGenRegBank &RegBank); 172d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 173d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Adopt a register unit for pressure tracking. 174d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // A unit is adopted iff its unit number is >= NumNativeRegUnits. 175d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick void adoptRegUnit(unsigned RUID) { RegUnits.push_back(RUID); } 176d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 177d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Get the sum of this register's register unit weights. 178d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned getWeight(const CodeGenRegBank &RegBank) const; 179d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 180026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // Order CodeGenRegister pointers by EnumValue. 181026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen struct Less { 182ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen bool operator()(const CodeGenRegister *A, 183ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen const CodeGenRegister *B) const { 184babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen assert(A && B); 185026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen return A->EnumValue < B->EnumValue; 186026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen } 187026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen }; 188026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 189026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // Canonically ordered set. 190ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen typedef std::set<const CodeGenRegister*, Less> Set; 191026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 192b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen private: 193b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen bool SubRegsComplete; 19479e2045531cb4d1978be42591e9254c38a463d30Jakob Stoklund Olesen bool SuperRegsComplete; 195b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen unsigned TopoSig; 196148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen 197148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen // The sub-registers explicit in the .td file form a tree. 198148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen SmallVector<CodeGenSubRegIndex*, 8> ExplicitSubRegIndices; 199148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen SmallVector<CodeGenRegister*, 8> ExplicitSubRegs; 200148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen 20131d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen // Explicit ad hoc aliases, symmetrized to form an undirected graph. 20231d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen SmallVector<CodeGenRegister*, 8> ExplicitAliases; 20331d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen 204fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // Super-registers where this is the first explicit sub-register. 205fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen SuperRegList LeadingSuperRegs; 206fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 207b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen SubRegMap SubRegs; 208026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen SuperRegList SuperRegs; 209ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen DenseMap<const CodeGenRegister*, CodeGenSubRegIndex*> SubReg2Idx; 210dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick RegUnitList RegUnits; 2118dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner }; 2128dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 2138dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 214ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen class CodeGenRegisterClass { 215ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen CodeGenRegister::Set Members; 216cc0c975b7db95ce6bc865c56a3016bf0d4f83304Jakob Stoklund Olesen // Allocation orders. Order[0] always contains all registers in Members. 217cc0c975b7db95ce6bc865c56a3016bf0d4f83304Jakob Stoklund Olesen std::vector<SmallVector<Record*, 16> > Orders; 218203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen // Bit mask of sub-classes including this, indexed by their EnumValue. 219203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen BitVector SubClasses; 220f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // List of super-classes, topologocally ordered to have the larger classes 221f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // first. This is the same as sorting by EnumValue. 222f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen SmallVector<CodeGenRegisterClass*, 4> SuperClasses; 223056afeface2ac98664ed8fa4799b46178a4a6fe3Chris Lattner Record *TheDef; 2246fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen std::string Name; 225babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 226babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // For a synthesized class, inherit missing properties from the nearest 227babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // super-class. 228babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen void inheritProperties(CodeGenRegBank&); 229babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 230570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // Map SubRegIndex -> sub-class. This is the largest sub-class where all 231570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // registers have a SubRegIndex sub-register. 2325fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen DenseMap<CodeGenSubRegIndex*, CodeGenRegisterClass*> SubClassWithSubReg; 233845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen 234570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // Map SubRegIndex -> set of super-reg classes. This is all register 235570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // classes SuperRC such that: 236570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // 237570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // R:SubRegIndex in this RC for all R in SuperRC. 238570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // 2395fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen DenseMap<CodeGenSubRegIndex*, 2405fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen SmallPtrSet<CodeGenRegisterClass*, 8> > SuperRegClasses; 241176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 242b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Bit vector of TopoSigs for the registers in this class. This will be 243b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // very sparse on regular architectures. 244b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen BitVector TopoSigs; 245b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 2466fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen public: 2477dcaa5b0fb56468e774044d3b887c21b2d484a1cJakob Stoklund Olesen unsigned EnumValue; 248c67c18fd2378fd2394c42f12b67897e7eba02d5cChris Lattner std::string Namespace; 249825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson std::vector<MVT::SimpleValueType> VTs; 250056afeface2ac98664ed8fa4799b46178a4a6fe3Chris Lattner unsigned SpillSize; 251056afeface2ac98664ed8fa4799b46178a4a6fe3Chris Lattner unsigned SpillAlignment; 252a3ca3149f2b59c512c50aab330b5a0d8efddeffaEvan Cheng int CopyCost; 253f462e3fac7ac67503657d63dc35330d0b19359b3Jakob Stoklund Olesen bool Allocatable; 25454c47c1ce94b9e549ef768e80fd004788d13ce85Jakob Stoklund Olesen std::string AltOrderSelect; 255056afeface2ac98664ed8fa4799b46178a4a6fe3Chris Lattner 2566fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen // Return the Record that defined this class, or NULL if the class was 2576fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen // created by TableGen. 2586fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen Record *getDef() const { return TheDef; } 2596fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen 2606fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen const std::string &getName() const { return Name; } 2616fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen std::string getQualifiedName() const; 262825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson const std::vector<MVT::SimpleValueType> &getValueTypes() const {return VTs;} 2635c4736a3da04795ba8d04e152e151afd6942e2f1Chris Lattner unsigned getNumValueTypes() const { return VTs.size(); } 2645d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 265825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType getValueTypeNum(unsigned VTNum) const { 2666510b22cec7de4f0acc9965ec24c3668a6a8a87eNate Begeman if (VTNum < VTs.size()) 2676510b22cec7de4f0acc9965ec24c3668a6a8a87eNate Begeman return VTs[VTNum]; 268655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper llvm_unreachable("VTNum greater than number of ValueTypes in RegClass!"); 2696510b22cec7de4f0acc9965ec24c3668a6a8a87eNate Begeman } 2705d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 271ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen // Return true if this this class contains the register. 272ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen bool contains(const CodeGenRegister*) const; 2735d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 274ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen // Returns true if RC is a subclass. 275a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // RC is a sub-class of this class if it is a valid replacement for any 2765d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach // instruction operand where a register of this classis required. It must 277a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // satisfy these conditions: 278a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 279a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 1. All RC registers are also in this. 280a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 2. The RC spill size must not be smaller than our spill size. 281a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 3. RC spill alignment must be compatible with ours. 282a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 28352e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen bool hasSubClass(const CodeGenRegisterClass *RC) const { 28452e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen return SubClasses.test(RC->EnumValue); 28552e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen } 286a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher 287845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen // getSubClassWithSubReg - Returns the largest sub-class where all 288845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen // registers have a SubIdx sub-register. 2895fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenRegisterClass* 2905fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen getSubClassWithSubReg(CodeGenSubRegIndex *SubIdx) const { 291845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen return SubClassWithSubReg.lookup(SubIdx); 292845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen } 293845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen 2945fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen void setSubClassWithSubReg(CodeGenSubRegIndex *SubIdx, 2955fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenRegisterClass *SubRC) { 296845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen SubClassWithSubReg[SubIdx] = SubRC; 297845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen } 298845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen 299570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // getSuperRegClasses - Returns a bit vector of all register classes 300570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // containing only SubIdx super-registers of this class. 3015fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen void getSuperRegClasses(CodeGenSubRegIndex *SubIdx, BitVector &Out) const; 302570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen 303570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // addSuperRegClass - Add a class containing only SudIdx super-registers. 3045fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen void addSuperRegClass(CodeGenSubRegIndex *SubIdx, 3055fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenRegisterClass *SuperRC) { 306570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen SuperRegClasses[SubIdx].insert(SuperRC); 307570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen } 308570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen 309f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // getSubClasses - Returns a constant BitVector of subclasses indexed by 310f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // EnumValue. 311f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // The SubClasses vector includs an entry for this class. 312830378f6628ad3af1d0293a0b605065532f99e43Eli Friedman const BitVector &getSubClasses() const { return SubClasses; } 313f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen 314f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // getSuperClasses - Returns a list of super classes ordered by EnumValue. 315f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // The array does not include an entry for this class. 316f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> getSuperClasses() const { 317f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen return SuperClasses; 318f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen } 319f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen 320ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen // Returns an ordered list of class members. 321ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen // The order of registers is the same as in the .td file. 322b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen // No = 0 is the default allocation order, No = 1 is the first alternative. 323b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen ArrayRef<Record*> getOrder(unsigned No = 0) const { 324cc0c975b7db95ce6bc865c56a3016bf0d4f83304Jakob Stoklund Olesen return Orders[No]; 325a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher } 3266510b22cec7de4f0acc9965ec24c3668a6a8a87eNate Begeman 327b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen // Return the total number of allocation orders available. 328cc0c975b7db95ce6bc865c56a3016bf0d4f83304Jakob Stoklund Olesen unsigned getNumOrders() const { return Orders.size(); } 329b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen 33052e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen // Get the set of registers. This set contains the same registers as 33152e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen // getOrder(0). 33252e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen const CodeGenRegister::Set &getMembers() const { return Members; } 33352e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen 334b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Get a bit vector of TopoSigs present in this register class. 335b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen const BitVector &getTopoSigs() const { return TopoSigs; } 336b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 337ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick // Populate a unique sorted list of units from a register set. 338ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick void buildRegUnitSet(std::vector<unsigned> &RegUnits) const; 339ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick 340ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen CodeGenRegisterClass(CodeGenRegBank&, Record *R); 341203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen 342babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // A key representing the parts of a register class used for forming 343babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // sub-classes. Note the ordering provided by this key is not the same as 344babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // the topological order used for the EnumValues. 345babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen struct Key { 346babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen const CodeGenRegister::Set *Members; 347babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen unsigned SpillSize; 348babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen unsigned SpillAlignment; 349babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 350babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen Key(const Key &O) 351babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen : Members(O.Members), 352babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen SpillSize(O.SpillSize), 353babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen SpillAlignment(O.SpillAlignment) {} 354babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 355babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen Key(const CodeGenRegister::Set *M, unsigned S = 0, unsigned A = 0) 356babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen : Members(M), SpillSize(S), SpillAlignment(A) {} 357babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 358babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen Key(const CodeGenRegisterClass &RC) 359babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen : Members(&RC.getMembers()), 360babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen SpillSize(RC.SpillSize), 361babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen SpillAlignment(RC.SpillAlignment) {} 362babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 363babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Lexicographical order of (Members, SpillSize, SpillAlignment). 364babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen bool operator<(const Key&) const; 365babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen }; 366babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 367babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Create a non-user defined register class. 368babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen CodeGenRegisterClass(StringRef Name, Key Props); 369babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 370203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen // Called by CodeGenRegBank::CodeGenRegBank(). 371babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen static void computeSubClasses(CodeGenRegBank&); 3728dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner }; 373dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 374176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Each RegUnitSet is a sorted vector with a name. 375176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick struct RegUnitSet { 376176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick typedef std::vector<unsigned>::const_iterator iterator; 377176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 378176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::string Name; 379176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::vector<unsigned> Units; 380176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick }; 381176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 382b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Base vector for identifying TopoSigs. The contents uniquely identify a 383b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // TopoSig, only computeSuperRegs needs to know how. 384b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen typedef SmallVector<unsigned, 16> TopoSigId; 385b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 386dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen // CodeGenRegBank - Represent a target's registers and the relations between 387dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen // them. 388dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen class CodeGenRegBank { 389dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen RecordKeeper &Records; 39059f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen SetTheory Sets; 39159f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen 3925fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen // SubRegIndices. 3935fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen std::vector<CodeGenSubRegIndex*> SubRegIndices; 3945fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen DenseMap<Record*, CodeGenSubRegIndex*> Def2SubRegIdx; 395dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen unsigned NumNamedIndices; 3965fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 397fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen typedef std::map<SmallVector<CodeGenSubRegIndex*, 8>, 398fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen CodeGenSubRegIndex*> ConcatIdxMap; 399fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen ConcatIdxMap ConcatIdx; 400fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 4015fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen // Registers. 402abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen std::vector<CodeGenRegister*> Registers; 403b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen DenseMap<Record*, CodeGenRegister*> Def2Reg; 404d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned NumNativeRegUnits; 405d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned NumRegUnits; // # native + adopted register units. 406d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 407b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen std::map<TopoSigId, unsigned> TopoSigs; 408b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 409d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Map each register unit to a weight (for register pressure). 410d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Includes native and adopted register units. 411d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick std::vector<unsigned> RegUnitWeights; 412b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 413babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Register classes. 41429f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen std::vector<CodeGenRegisterClass*> RegClasses; 4157b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen DenseMap<Record*, CodeGenRegisterClass*> Def2RC; 416babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen typedef std::map<CodeGenRegisterClass::Key, CodeGenRegisterClass*> RCKeyMap; 417babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen RCKeyMap Key2RC; 418babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 419176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Remember each unique set of register units. Initially, this contains a 420176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // unique set for each register class. Simliar sets are coalesced with 421176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // pruneUnitSets and new supersets are inferred during computeRegUnitSets. 422176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::vector<RegUnitSet> RegUnitSets; 423176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 424176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Map RegisterClass index to the index of the RegUnitSet that contains the 425176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // class's units and any inferred RegUnit supersets. 426176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::vector<std::vector<unsigned> > RegClassUnitSets; 427176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 428babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Add RC to *2RC maps. 429babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen void addToMaps(CodeGenRegisterClass*); 430babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 4311b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen // Create a synthetic sub-class if it is missing. 4321b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen CodeGenRegisterClass *getOrCreateSubClass(const CodeGenRegisterClass *RC, 4331b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen const CodeGenRegister::Set *Membs, 4341b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen StringRef Name); 4351b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen 436babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Infer missing register classes. 437babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen void computeInferredRegisterClasses(); 4387e56831a6804812b2295c5446a05f4ec457b6b3eJakob Stoklund Olesen void inferCommonSubClass(CodeGenRegisterClass *RC); 439fec33444c5ca22e0338fdac0fcaee2644bd756afJakob Stoklund Olesen void inferSubClassWithSubReg(CodeGenRegisterClass *RC); 440a9f65b9a1f57dcf546399ac32bf89d71d20df5b9Jakob Stoklund Olesen void inferMatchingSuperRegClass(CodeGenRegisterClass *RC, 441a9f65b9a1f57dcf546399ac32bf89d71d20df5b9Jakob Stoklund Olesen unsigned FirstSubRegRC = 0); 4427b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen 443176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Iteratively prune unit sets. 444176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick void pruneUnitSets(); 445176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 446d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Compute a weight for each register unit created during getSubRegs. 447d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick void computeRegUnitWeights(); 448d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 449176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Create a RegUnitSet for each RegClass and infer superclasses. 450176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick void computeRegUnitSets(); 451176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 452b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Populate the Composite map from sub-register relationships. 453b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen void computeComposites(); 454dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 455dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen public: 456dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen CodeGenRegBank(RecordKeeper&); 457dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 45859f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen SetTheory &getSets() { return Sets; } 45959f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen 460b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Sub-register indices. The first NumNamedIndices are defined by the user 461b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // in the .td files. The rest are synthesized such that all sub-registers 462b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // have a unique name. 4635fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen ArrayRef<CodeGenSubRegIndex*> getSubRegIndices() { return SubRegIndices; } 464dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen unsigned getNumNamedIndices() { return NumNamedIndices; } 465dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 4665fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen // Find a SubRegIndex form its Record def. 4675fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex *getSubRegIdx(Record*); 468dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 469b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Find or create a sub-register index representing the A+B composition. 4705fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex *getCompositeSubRegIndex(CodeGenSubRegIndex *A, 47190498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CodeGenSubRegIndex *B); 472b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 473fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // Find or create a sub-register index representing the concatenation of 474fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // non-overlapping sibling indices. 475fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen CodeGenSubRegIndex * 476fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen getConcatSubRegIndex(const SmallVector<CodeGenSubRegIndex*, 8>&); 477fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 478fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen void 479fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen addConcatSubRegIndex(const SmallVector<CodeGenSubRegIndex*, 8> &Parts, 480fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen CodeGenSubRegIndex *Idx) { 481fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen ConcatIdx.insert(std::make_pair(Parts, Idx)); 482fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen } 483fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 484abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen const std::vector<CodeGenRegister*> &getRegisters() { return Registers; } 485b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 486b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Find a register from its Record def. 487b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen CodeGenRegister *getReg(Record*); 488b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 489d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Get a Register's index into the Registers array. 490d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned getRegIndex(const CodeGenRegister *Reg) const { 491d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick return Reg->EnumValue - 1; 492d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 493d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 494b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Return the number of allocated TopoSigs. The first TopoSig representing 495b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // leaf registers is allocated number 0. 496b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen unsigned getNumTopoSigs() const { 497b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen return TopoSigs.size(); 498b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen } 499b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 500b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Find or create a TopoSig for the given TopoSigId. 501b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // This function is only for use by CodeGenRegister::computeSuperRegs(). 502b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Others should simply use Reg->getTopoSig(). 503b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen unsigned getTopoSig(const TopoSigId &Id) { 504b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen return TopoSigs.insert(std::make_pair(Id, TopoSigs.size())).first->second; 505b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen } 506b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 507d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Create a new non-native register unit that can be adopted by a register 508d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // to increase its pressure. Note that NumNativeRegUnits is not increased. 509d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned newRegUnit(unsigned Weight) { 510d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick if (!RegUnitWeights.empty()) { 511176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick assert(Weight && "should only add allocatable units"); 512d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick RegUnitWeights.resize(NumRegUnits+1); 513d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick RegUnitWeights[NumRegUnits] = Weight; 514d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 515d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick return NumRegUnits++; 516d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 517d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 518176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Native units are the singular unit of a leaf register. Register aliasing 519176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // is completely characterized by native units. Adopted units exist to give 520176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // register additional weight but don't affect aliasing. 521d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick bool isNativeUnit(unsigned RUID) { 522d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick return RUID < NumNativeRegUnits; 523d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 524dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick 52529f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> getRegClasses() const { 5267b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen return RegClasses; 5277b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen } 5287b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen 5297b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen // Find a register class from its def. 5307b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen CodeGenRegisterClass *getRegClass(Record*); 5317b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen 5327b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// getRegisterClassForRegister - Find the register class that contains the 5337b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// specified physical register. If the register is not in a register 5347b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// class, return null. If the register is in multiple classes, and the 5357b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// classes have a superset-subset relationship and the same set of types, 5367b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// return the superclass. Otherwise return null. 5377b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen const CodeGenRegisterClass* getRegClassForRegister(Record *R); 5387b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen 539176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Get a register unit's weight. Zero for unallocatable registers. 540d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned getRegUnitWeight(unsigned RUID) const { 541d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick return RegUnitWeights[RUID]; 542d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 543d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 544ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick // Get the sum of unit weights. 545ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick unsigned getRegUnitSetWeight(const std::vector<unsigned> &Units) const { 546ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick unsigned Weight = 0; 547ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick for (std::vector<unsigned>::const_iterator 548ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick I = Units.begin(), E = Units.end(); I != E; ++I) 549ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick Weight += getRegUnitWeight(*I); 550ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick return Weight; 551ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick } 552ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick 553176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Increase a RegUnitWeight. 554d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick void increaseRegUnitWeight(unsigned RUID, unsigned Inc) { 555d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick RegUnitWeights[RUID] += Inc; 556d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 557d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 558176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Get the number of register pressure dimensions. 559176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick unsigned getNumRegPressureSets() const { return RegUnitSets.size(); } 560176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 561176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Get a set of register unit IDs for a given dimension of pressure. 562176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick RegUnitSet getRegPressureSet(unsigned Idx) const { 563176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick return RegUnitSets[Idx]; 564176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 565176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 566176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Get a list of pressure set IDs for a register class. Liveness of a 567176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // register in this class impacts each pressure set in this list by the 568176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // weight of the register. An exact solution requires all registers in a 569176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // class to have the same class, but it is not strictly guaranteed. 570176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick ArrayRef<unsigned> getRCPressureSetIDs(unsigned RCIdx) const { 571176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick return RegClassUnitSets[RCIdx]; 572176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 573176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 574b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Computed derived records such as missing sub-register indices. 575b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen void computeDerivedInfo(); 576026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 577026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // Compute full overlap sets for every register. These sets include the 578026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // rarely used aliases that are neither sub nor super-registers. 579026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // 580026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // Map[R1].count(R2) is reflexive and symmetric, but not transitive. 581026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // 582026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // If R1 is a sub-register of R2, Map[R1] is a subset of Map[R2]. 583026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen void computeOverlaps(std::map<const CodeGenRegister*, 584026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen CodeGenRegister::Set> &Map); 585ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen 586ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // Compute the set of registers completely covered by the registers in Regs. 587ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // The returned BitVector will have a bit set for each register in Regs, 588ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // all sub-registers, and all super-registers that are covered by the 589ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // registers in Regs. 590ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // 591ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // This is used to compute the mask of call-preserved registers from a list 592ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // of callee-saves. 593ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen BitVector computeCoveredRegisters(ArrayRef<Record*> Regs); 594dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen }; 5958dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner} 5968dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 5978dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner#endif 598