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; 38c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen std::string Name; 39c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen std::string Namespace; 405fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 415fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen public: 42b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen const unsigned EnumValue; 43b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 445fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex(Record *R, unsigned Enum); 45c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen CodeGenSubRegIndex(StringRef N, StringRef Nspace, unsigned Enum); 465fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 47c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen const std::string &getName() const { return Name; } 48c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen const std::string &getNamespace() const { return Namespace; } 495fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen std::string getQualifiedName() const; 505fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 515fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen // Order CodeGenSubRegIndex pointers by EnumValue. 525fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen struct Less { 535fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen bool operator()(const CodeGenSubRegIndex *A, 545fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen const CodeGenSubRegIndex *B) const { 555fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen assert(A && B); 565fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen return A->EnumValue < B->EnumValue; 575fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen } 585fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen }; 5990498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 6090498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Map of composite subreg indices. 6190498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen typedef std::map<CodeGenSubRegIndex*, CodeGenSubRegIndex*, Less> CompMap; 6290498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 6390498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Returns the subreg index that results from composing this with Idx. 6490498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Returns NULL if this and Idx don't compose. 6590498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CodeGenSubRegIndex *compose(CodeGenSubRegIndex *Idx) const { 6690498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CompMap::const_iterator I = Composed.find(Idx); 6790498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen return I == Composed.end() ? 0 : I->second; 6890498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen } 6990498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 7090498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Add a composite subreg index: this+A = B. 7190498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Return a conflicting composite, or NULL 7290498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CodeGenSubRegIndex *addComposite(CodeGenSubRegIndex *A, 7390498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CodeGenSubRegIndex *B) { 74fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen assert(A && B); 7590498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen std::pair<CompMap::iterator, bool> Ins = 7690498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen Composed.insert(std::make_pair(A, B)); 7790498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen return (Ins.second || Ins.first->second == B) ? 0 : Ins.first->second; 7890498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen } 7990498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 80b5af2d943ed568f2f4cac545b6dfb150ae9d73aaJakob Stoklund Olesen // Update the composite maps of components specified in 'ComposedOf'. 81b5af2d943ed568f2f4cac545b6dfb150ae9d73aaJakob Stoklund Olesen void updateComponents(CodeGenRegBank&); 82b5af2d943ed568f2f4cac545b6dfb150ae9d73aaJakob Stoklund Olesen 8390498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Clean out redundant composite mappings. 8490498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen void cleanComposites(); 8590498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 8690498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen // Return the map of composites. 8790498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen const CompMap &getComposites() const { return Composed; } 8890498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen 8990498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen private: 9090498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CompMap Composed; 915fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen }; 925fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 938dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner /// CodeGenRegister - Represents a register definition. 948dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner struct CodeGenRegister { 958dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner Record *TheDef; 9617fad045cccf34822d3163ada9e70a8f4528746eJim Grosbach unsigned EnumValue; 976bfba2e5af163442a1c6b11fe14aa9df9101cfd7Jakob Stoklund Olesen unsigned CostPerUse; 9831867660cb81ea2b1d1a6ffa7d09c91acb754a8bJakob Stoklund Olesen bool CoveredBySubRegs; 99b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 100b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Map SubRegIndex -> Register. 1015fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen typedef std::map<CodeGenSubRegIndex*, CodeGenRegister*, 1025fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex::Less> SubRegMap; 103b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 104b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen CodeGenRegister(Record *R, unsigned Enum); 105b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 106b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen const std::string &getName() const; 107b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 108148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen // Extract more information from TheDef. This is used to build an object 109148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen // graph after all CodeGenRegister objects have been created. 110148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen void buildObjectGraph(CodeGenRegBank&); 111148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen 112da2be824346c316c6fc840de7b8493e3d587e785Jakob Stoklund Olesen // Lazily compute a map of all sub-registers. 113b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // This includes unique entries for all sub-sub-registers. 114da2be824346c316c6fc840de7b8493e3d587e785Jakob Stoklund Olesen const SubRegMap &computeSubRegs(CodeGenRegBank&); 115b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 116fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // Compute extra sub-registers by combining the existing sub-registers. 117fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen void computeSecondarySubRegs(CodeGenRegBank&); 118fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 11979e2045531cb4d1978be42591e9254c38a463d30Jakob Stoklund Olesen // Add this as a super-register to all sub-registers after the sub-register 12079e2045531cb4d1978be42591e9254c38a463d30Jakob Stoklund Olesen // graph has been built. 121b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen void computeSuperRegs(CodeGenRegBank&); 12279e2045531cb4d1978be42591e9254c38a463d30Jakob Stoklund Olesen 123b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen const SubRegMap &getSubRegs() const { 124b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen assert(SubRegsComplete && "Must precompute sub-registers"); 125b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen return SubRegs; 126b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen } 127b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 128026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // Add sub-registers to OSet following a pre-order defined by the .td file. 129c6a96ff6aeeb77e1007364e5603b72f3ab4cc7bdJakob Stoklund Olesen void addSubRegsPreOrder(SetVector<const CodeGenRegister*> &OSet, 1305fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenRegBank&) const; 131026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 132ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen // Return the sub-register index naming Reg as a sub-register of this 133ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen // register. Returns NULL if Reg is not a sub-register. 134ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen CodeGenSubRegIndex *getSubRegIndex(const CodeGenRegister *Reg) const { 135ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen return SubReg2Idx.lookup(Reg); 136ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen } 137ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen 138c6a96ff6aeeb77e1007364e5603b72f3ab4cc7bdJakob Stoklund Olesen typedef std::vector<const CodeGenRegister*> SuperRegList; 139026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 140fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // Get the list of super-registers in topological order, small to large. 141fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // This is valid after computeSubRegs visits all registers during RegBank 142fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // construction. 143026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen const SuperRegList &getSuperRegs() const { 144026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen assert(SubRegsComplete && "Must precompute sub-registers"); 145026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen return SuperRegs; 146026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen } 147026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 14831d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen // Get the list of ad hoc aliases. The graph is symmetric, so the list 14931d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen // contains all registers in 'Aliases', and all registers that mention this 15031d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen // register in 'Aliases'. 15131d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen ArrayRef<CodeGenRegister*> getExplicitAliases() const { 15231d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen return ExplicitAliases; 15331d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen } 15431d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen 155b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Get the topological signature of this register. This is a small integer 156b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // less than RegBank.getNumTopoSigs(). Registers with the same TopoSig have 157b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // identical sub-register structure. That is, they support the same set of 158b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // sub-register indices mapping to the same kind of sub-registers 159b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // (TopoSig-wise). 160b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen unsigned getTopoSig() const { 161b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen assert(SuperRegsComplete && "TopoSigs haven't been computed yet."); 162b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen return TopoSig; 163b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen } 164b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 165dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick // List of register units in ascending order. 166dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick typedef SmallVector<unsigned, 16> RegUnitList; 167dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick 168f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // How many entries in RegUnitList are native? 169f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen unsigned NumNativeRegUnits; 170f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 171dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick // Get the list of register units. 172f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // This is only valid after computeSubRegs() completes. 173dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick const RegUnitList &getRegUnits() const { return RegUnits; } 174dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick 175f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // Get the native register units. This is a prefix of getRegUnits(). 176f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen ArrayRef<unsigned> getNativeRegUnits() const { 177f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen return makeArrayRef(RegUnits).slice(0, NumNativeRegUnits); 178f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen } 179f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 180d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Inherit register units from subregisters. 181d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Return true if the RegUnits changed. 182d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick bool inheritRegUnits(CodeGenRegBank &RegBank); 183d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 184d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Adopt a register unit for pressure tracking. 185d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // A unit is adopted iff its unit number is >= NumNativeRegUnits. 186d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick void adoptRegUnit(unsigned RUID) { RegUnits.push_back(RUID); } 187d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 188d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Get the sum of this register's register unit weights. 189d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned getWeight(const CodeGenRegBank &RegBank) const; 190d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 191026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // Order CodeGenRegister pointers by EnumValue. 192026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen struct Less { 193ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen bool operator()(const CodeGenRegister *A, 194ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen const CodeGenRegister *B) const { 195babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen assert(A && B); 196026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen return A->EnumValue < B->EnumValue; 197026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen } 198026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen }; 199026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 200026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen // Canonically ordered set. 201ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen typedef std::set<const CodeGenRegister*, Less> Set; 202026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 2033778aeb74864390bf763424c45cc355ac330fbc9Jakob Stoklund Olesen // Compute the set of registers overlapping this. 2043778aeb74864390bf763424c45cc355ac330fbc9Jakob Stoklund Olesen void computeOverlaps(Set &Overlaps, const CodeGenRegBank&) const; 2053778aeb74864390bf763424c45cc355ac330fbc9Jakob Stoklund Olesen 206b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen private: 207b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen bool SubRegsComplete; 20879e2045531cb4d1978be42591e9254c38a463d30Jakob Stoklund Olesen bool SuperRegsComplete; 209b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen unsigned TopoSig; 210148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen 211148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen // The sub-registers explicit in the .td file form a tree. 212148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen SmallVector<CodeGenSubRegIndex*, 8> ExplicitSubRegIndices; 213148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen SmallVector<CodeGenRegister*, 8> ExplicitSubRegs; 214148f392195dec8772ab4c5ac0d0c3b85fba0e5f8Jakob Stoklund Olesen 21531d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen // Explicit ad hoc aliases, symmetrized to form an undirected graph. 21631d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen SmallVector<CodeGenRegister*, 8> ExplicitAliases; 21731d938a6b1173c642f975d78417459d4d8cd3677Jakob Stoklund Olesen 218fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // Super-registers where this is the first explicit sub-register. 219fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen SuperRegList LeadingSuperRegs; 220fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 221b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen SubRegMap SubRegs; 222026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen SuperRegList SuperRegs; 223ca313e1efa98910a7a5e7f4bf2ac1a70adb6e4feJakob Stoklund Olesen DenseMap<const CodeGenRegister*, CodeGenSubRegIndex*> SubReg2Idx; 224dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick RegUnitList RegUnits; 2258dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner }; 2268dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 2278dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 228ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen class CodeGenRegisterClass { 229ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen CodeGenRegister::Set Members; 230cc0c975b7db95ce6bc865c56a3016bf0d4f83304Jakob Stoklund Olesen // Allocation orders. Order[0] always contains all registers in Members. 231cc0c975b7db95ce6bc865c56a3016bf0d4f83304Jakob Stoklund Olesen std::vector<SmallVector<Record*, 16> > Orders; 232203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen // Bit mask of sub-classes including this, indexed by their EnumValue. 233203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen BitVector SubClasses; 234f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // List of super-classes, topologocally ordered to have the larger classes 235f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // first. This is the same as sorting by EnumValue. 236f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen SmallVector<CodeGenRegisterClass*, 4> SuperClasses; 237056afeface2ac98664ed8fa4799b46178a4a6fe3Chris Lattner Record *TheDef; 2386fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen std::string Name; 239babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 240babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // For a synthesized class, inherit missing properties from the nearest 241babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // super-class. 242babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen void inheritProperties(CodeGenRegBank&); 243babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 244570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // Map SubRegIndex -> sub-class. This is the largest sub-class where all 245570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // registers have a SubRegIndex sub-register. 2465fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen DenseMap<CodeGenSubRegIndex*, CodeGenRegisterClass*> SubClassWithSubReg; 247845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen 248570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // Map SubRegIndex -> set of super-reg classes. This is all register 249570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // classes SuperRC such that: 250570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // 251570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // R:SubRegIndex in this RC for all R in SuperRC. 252570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // 2535fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen DenseMap<CodeGenSubRegIndex*, 2545fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen SmallPtrSet<CodeGenRegisterClass*, 8> > SuperRegClasses; 255176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 256b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Bit vector of TopoSigs for the registers in this class. This will be 257b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // very sparse on regular architectures. 258b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen BitVector TopoSigs; 259b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 2606fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen public: 2617dcaa5b0fb56468e774044d3b887c21b2d484a1cJakob Stoklund Olesen unsigned EnumValue; 262c67c18fd2378fd2394c42f12b67897e7eba02d5cChris Lattner std::string Namespace; 263825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson std::vector<MVT::SimpleValueType> VTs; 264056afeface2ac98664ed8fa4799b46178a4a6fe3Chris Lattner unsigned SpillSize; 265056afeface2ac98664ed8fa4799b46178a4a6fe3Chris Lattner unsigned SpillAlignment; 266a3ca3149f2b59c512c50aab330b5a0d8efddeffaEvan Cheng int CopyCost; 267f462e3fac7ac67503657d63dc35330d0b19359b3Jakob Stoklund Olesen bool Allocatable; 26854c47c1ce94b9e549ef768e80fd004788d13ce85Jakob Stoklund Olesen std::string AltOrderSelect; 269056afeface2ac98664ed8fa4799b46178a4a6fe3Chris Lattner 2706fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen // Return the Record that defined this class, or NULL if the class was 2716fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen // created by TableGen. 2726fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen Record *getDef() const { return TheDef; } 2736fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen 2746fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen const std::string &getName() const { return Name; } 2756fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen std::string getQualifiedName() const; 276825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson const std::vector<MVT::SimpleValueType> &getValueTypes() const {return VTs;} 2775c4736a3da04795ba8d04e152e151afd6942e2f1Chris Lattner unsigned getNumValueTypes() const { return VTs.size(); } 2785d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 279825b72b0571821bf2d378749f69d6c4cfb52d2f9Owen Anderson MVT::SimpleValueType getValueTypeNum(unsigned VTNum) const { 2806510b22cec7de4f0acc9965ec24c3668a6a8a87eNate Begeman if (VTNum < VTs.size()) 2816510b22cec7de4f0acc9965ec24c3668a6a8a87eNate Begeman return VTs[VTNum]; 282655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper llvm_unreachable("VTNum greater than number of ValueTypes in RegClass!"); 2836510b22cec7de4f0acc9965ec24c3668a6a8a87eNate Begeman } 2845d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 285ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen // Return true if this this class contains the register. 286ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen bool contains(const CodeGenRegister*) const; 2875d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 288ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen // Returns true if RC is a subclass. 289a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // RC is a sub-class of this class if it is a valid replacement for any 2905d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach // instruction operand where a register of this classis required. It must 291a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // satisfy these conditions: 292a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 293a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 1. All RC registers are also in this. 294a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 2. The RC spill size must not be smaller than our spill size. 295a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 3. RC spill alignment must be compatible with ours. 296a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher // 29752e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen bool hasSubClass(const CodeGenRegisterClass *RC) const { 29852e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen return SubClasses.test(RC->EnumValue); 29952e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen } 300a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher 301845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen // getSubClassWithSubReg - Returns the largest sub-class where all 302845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen // registers have a SubIdx sub-register. 3035fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenRegisterClass* 3045fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen getSubClassWithSubReg(CodeGenSubRegIndex *SubIdx) const { 305845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen return SubClassWithSubReg.lookup(SubIdx); 306845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen } 307845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen 3085fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen void setSubClassWithSubReg(CodeGenSubRegIndex *SubIdx, 3095fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenRegisterClass *SubRC) { 310845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen SubClassWithSubReg[SubIdx] = SubRC; 311845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen } 312845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen 313570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // getSuperRegClasses - Returns a bit vector of all register classes 314570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // containing only SubIdx super-registers of this class. 3155fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen void getSuperRegClasses(CodeGenSubRegIndex *SubIdx, BitVector &Out) const; 316570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen 317570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen // addSuperRegClass - Add a class containing only SudIdx super-registers. 3185fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen void addSuperRegClass(CodeGenSubRegIndex *SubIdx, 3195fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenRegisterClass *SuperRC) { 320570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen SuperRegClasses[SubIdx].insert(SuperRC); 321570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen } 322570f9a972e02830d1ca223743dd6b4cc4fdf9549Jakob Stoklund Olesen 323f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // getSubClasses - Returns a constant BitVector of subclasses indexed by 324f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // EnumValue. 325f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // The SubClasses vector includs an entry for this class. 326830378f6628ad3af1d0293a0b605065532f99e43Eli Friedman const BitVector &getSubClasses() const { return SubClasses; } 327f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen 328f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // getSuperClasses - Returns a list of super classes ordered by EnumValue. 329f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // The array does not include an entry for this class. 330f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> getSuperClasses() const { 331f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen return SuperClasses; 332f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen } 333f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen 334ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen // Returns an ordered list of class members. 335ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen // The order of registers is the same as in the .td file. 336b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen // No = 0 is the default allocation order, No = 1 is the first alternative. 337b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen ArrayRef<Record*> getOrder(unsigned No = 0) const { 338cc0c975b7db95ce6bc865c56a3016bf0d4f83304Jakob Stoklund Olesen return Orders[No]; 339a2c9188560eb9a7d494960fefd28cf0998d9a78fEric Christopher } 3406510b22cec7de4f0acc9965ec24c3668a6a8a87eNate Begeman 341b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen // Return the total number of allocation orders available. 342cc0c975b7db95ce6bc865c56a3016bf0d4f83304Jakob Stoklund Olesen unsigned getNumOrders() const { return Orders.size(); } 343b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen 34452e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen // Get the set of registers. This set contains the same registers as 34552e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen // getOrder(0). 34652e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen const CodeGenRegister::Set &getMembers() const { return Members; } 34752e7dfadc65257f05480de6e70da00373a8954d1Jakob Stoklund Olesen 348b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Get a bit vector of TopoSigs present in this register class. 349b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen const BitVector &getTopoSigs() const { return TopoSigs; } 350b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 351ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick // Populate a unique sorted list of units from a register set. 352ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick void buildRegUnitSet(std::vector<unsigned> &RegUnits) const; 353ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick 354ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen CodeGenRegisterClass(CodeGenRegBank&, Record *R); 355203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen 356babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // A key representing the parts of a register class used for forming 357babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // sub-classes. Note the ordering provided by this key is not the same as 358babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // the topological order used for the EnumValues. 359babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen struct Key { 360babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen const CodeGenRegister::Set *Members; 361babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen unsigned SpillSize; 362babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen unsigned SpillAlignment; 363babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 364babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen Key(const Key &O) 365babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen : Members(O.Members), 366babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen SpillSize(O.SpillSize), 367babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen SpillAlignment(O.SpillAlignment) {} 368babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 369babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen Key(const CodeGenRegister::Set *M, unsigned S = 0, unsigned A = 0) 370babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen : Members(M), SpillSize(S), SpillAlignment(A) {} 371babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 372babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen Key(const CodeGenRegisterClass &RC) 373babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen : Members(&RC.getMembers()), 374babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen SpillSize(RC.SpillSize), 375babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen SpillAlignment(RC.SpillAlignment) {} 376babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 377babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Lexicographical order of (Members, SpillSize, SpillAlignment). 378babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen bool operator<(const Key&) const; 379babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen }; 380babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 381babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Create a non-user defined register class. 382a9fdbbc55f640fecd3bb8df12fd205694c2f71a2Jakob Stoklund Olesen CodeGenRegisterClass(CodeGenRegBank&, StringRef Name, Key Props); 383babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 384203e0b17dd6049d64cb4ed7c4da09747204e6463Jakob Stoklund Olesen // Called by CodeGenRegBank::CodeGenRegBank(). 385babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen static void computeSubClasses(CodeGenRegBank&); 3868dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner }; 387dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 38840c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // Register units are used to model interference and register pressure. 38940c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // Every register is assigned one or more register units such that two 39040c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // registers overlap if and only if they have a register unit in common. 39140c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // 39240c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // Normally, one register unit is created per leaf register. Non-leaf 39340c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // registers inherit the units of their sub-registers. 39440c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen struct RegUnit { 39540c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // Weight assigned to this RegUnit for estimating register pressure. 39640c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // This is useful when equalizing weights in register classes with mixed 39740c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // register topologies. 39840c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen unsigned Weight; 39940c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen 40040c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // Each native RegUnit corresponds to one or two root registers. The full 40140c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // set of registers containing this unit can be computed as the union of 40240c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // these two registers and their super-registers. 40340c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen const CodeGenRegister *Roots[2]; 40440c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen 40540c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen RegUnit() : Weight(0) { Roots[0] = Roots[1] = 0; } 40640c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen 40740c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen ArrayRef<const CodeGenRegister*> getRoots() const { 40840c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen assert(!(Roots[1] && !Roots[0]) && "Invalid roots array"); 40940c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen return makeArrayRef(Roots, !!Roots[0] + !!Roots[1]); 41040c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen } 41140c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen }; 41240c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen 413176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Each RegUnitSet is a sorted vector with a name. 414176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick struct RegUnitSet { 415176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick typedef std::vector<unsigned>::const_iterator iterator; 416176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 417176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::string Name; 418176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::vector<unsigned> Units; 419176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick }; 420176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 421b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Base vector for identifying TopoSigs. The contents uniquely identify a 422b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // TopoSig, only computeSuperRegs needs to know how. 423b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen typedef SmallVector<unsigned, 16> TopoSigId; 424b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 425dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen // CodeGenRegBank - Represent a target's registers and the relations between 426dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen // them. 427dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen class CodeGenRegBank { 42859f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen SetTheory Sets; 42959f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen 4305fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen // SubRegIndices. 4315fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen std::vector<CodeGenSubRegIndex*> SubRegIndices; 4325fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen DenseMap<Record*, CodeGenSubRegIndex*> Def2SubRegIdx; 433c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen 434c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen CodeGenSubRegIndex *createSubRegIndex(StringRef Name, StringRef NameSpace); 4355fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen 436fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen typedef std::map<SmallVector<CodeGenSubRegIndex*, 8>, 437fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen CodeGenSubRegIndex*> ConcatIdxMap; 438fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen ConcatIdxMap ConcatIdx; 439fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 4405fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen // Registers. 441abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen std::vector<CodeGenRegister*> Registers; 442b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen DenseMap<Record*, CodeGenRegister*> Def2Reg; 443d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned NumNativeRegUnits; 444d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 445b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen std::map<TopoSigId, unsigned> TopoSigs; 446b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 44740c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // Includes native (0..NumNativeRegUnits-1) and adopted register units. 44840c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen SmallVector<RegUnit, 8> RegUnits; 449b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 450babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Register classes. 45129f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen std::vector<CodeGenRegisterClass*> RegClasses; 4527b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen DenseMap<Record*, CodeGenRegisterClass*> Def2RC; 453babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen typedef std::map<CodeGenRegisterClass::Key, CodeGenRegisterClass*> RCKeyMap; 454babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen RCKeyMap Key2RC; 455babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 456176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Remember each unique set of register units. Initially, this contains a 457176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // unique set for each register class. Simliar sets are coalesced with 458176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // pruneUnitSets and new supersets are inferred during computeRegUnitSets. 459176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::vector<RegUnitSet> RegUnitSets; 460176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 461176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Map RegisterClass index to the index of the RegUnitSet that contains the 462176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // class's units and any inferred RegUnit supersets. 463176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::vector<std::vector<unsigned> > RegClassUnitSets; 464176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 465babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Add RC to *2RC maps. 466babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen void addToMaps(CodeGenRegisterClass*); 467babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen 4681b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen // Create a synthetic sub-class if it is missing. 4691b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen CodeGenRegisterClass *getOrCreateSubClass(const CodeGenRegisterClass *RC, 4701b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen const CodeGenRegister::Set *Membs, 4711b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen StringRef Name); 4721b3d218880a7147caeb58f2604af1df26a409f7dJakob Stoklund Olesen 473babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen // Infer missing register classes. 474babf0569e2e4f204f9a304416cc4acc349d8f836Jakob Stoklund Olesen void computeInferredRegisterClasses(); 4757e56831a6804812b2295c5446a05f4ec457b6b3eJakob Stoklund Olesen void inferCommonSubClass(CodeGenRegisterClass *RC); 476fec33444c5ca22e0338fdac0fcaee2644bd756afJakob Stoklund Olesen void inferSubClassWithSubReg(CodeGenRegisterClass *RC); 477a9f65b9a1f57dcf546399ac32bf89d71d20df5b9Jakob Stoklund Olesen void inferMatchingSuperRegClass(CodeGenRegisterClass *RC, 478a9f65b9a1f57dcf546399ac32bf89d71d20df5b9Jakob Stoklund Olesen unsigned FirstSubRegRC = 0); 4797b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen 480176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Iteratively prune unit sets. 481176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick void pruneUnitSets(); 482176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 483d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Compute a weight for each register unit created during getSubRegs. 484d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick void computeRegUnitWeights(); 485d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 486176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Create a RegUnitSet for each RegClass and infer superclasses. 487176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick void computeRegUnitSets(); 488176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 489b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Populate the Composite map from sub-register relationships. 490b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen void computeComposites(); 491dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 492dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen public: 493dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen CodeGenRegBank(RecordKeeper&); 494dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 49559f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen SetTheory &getSets() { return Sets; } 49659f26aadce1bb985b9befe841fc106c891e1c728Jakob Stoklund Olesen 497b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Sub-register indices. The first NumNamedIndices are defined by the user 498b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // in the .td files. The rest are synthesized such that all sub-registers 499b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // have a unique name. 5005fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen ArrayRef<CodeGenSubRegIndex*> getSubRegIndices() { return SubRegIndices; } 501dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 5025fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen // Find a SubRegIndex form its Record def. 5035fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex *getSubRegIdx(Record*); 504dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen 505b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Find or create a sub-register index representing the A+B composition. 5065fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex *getCompositeSubRegIndex(CodeGenSubRegIndex *A, 50790498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen CodeGenSubRegIndex *B); 508b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 509fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // Find or create a sub-register index representing the concatenation of 510fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen // non-overlapping sibling indices. 511fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen CodeGenSubRegIndex * 512fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen getConcatSubRegIndex(const SmallVector<CodeGenSubRegIndex*, 8>&); 513fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 514fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen void 515fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen addConcatSubRegIndex(const SmallVector<CodeGenSubRegIndex*, 8> &Parts, 516fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen CodeGenSubRegIndex *Idx) { 517fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen ConcatIdx.insert(std::make_pair(Parts, Idx)); 518fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen } 519fcad79671f22c8994663c6780862b9c38d3609c3Jakob Stoklund Olesen 520abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen const std::vector<CodeGenRegister*> &getRegisters() { return Registers; } 521b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 522b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Find a register from its Record def. 523b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen CodeGenRegister *getReg(Record*); 524b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen 525d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Get a Register's index into the Registers array. 526d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned getRegIndex(const CodeGenRegister *Reg) const { 527d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick return Reg->EnumValue - 1; 528d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 529d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 530b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Return the number of allocated TopoSigs. The first TopoSig representing 531b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // leaf registers is allocated number 0. 532b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen unsigned getNumTopoSigs() const { 533b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen return TopoSigs.size(); 534b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen } 535b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 536b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Find or create a TopoSig for the given TopoSigId. 537b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // This function is only for use by CodeGenRegister::computeSuperRegs(). 538b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen // Others should simply use Reg->getTopoSig(). 539b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen unsigned getTopoSig(const TopoSigId &Id) { 540b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen return TopoSigs.insert(std::make_pair(Id, TopoSigs.size())).first->second; 541b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen } 542b81cbc271faed9fa633920436cd7ae49750a9a42Jakob Stoklund Olesen 54340c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // Create a native register unit that is associated with one or two root 54440c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen // registers. 54540c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen unsigned newRegUnit(CodeGenRegister *R0, CodeGenRegister *R1 = 0) { 54640c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen RegUnits.resize(RegUnits.size() + 1); 54740c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen RegUnits.back().Roots[0] = R0; 54840c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen RegUnits.back().Roots[1] = R1; 54940c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen return RegUnits.size() - 1; 55040c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen } 55140c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen 552d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // Create a new non-native register unit that can be adopted by a register 553d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick // to increase its pressure. Note that NumNativeRegUnits is not increased. 554d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick unsigned newRegUnit(unsigned Weight) { 55540c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen RegUnits.resize(RegUnits.size() + 1); 55640c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen RegUnits.back().Weight = Weight; 55740c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen return RegUnits.size() - 1; 558d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 559d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 560176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Native units are the singular unit of a leaf register. Register aliasing 561176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // is completely characterized by native units. Adopted units exist to give 562176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // register additional weight but don't affect aliasing. 563d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick bool isNativeUnit(unsigned RUID) { 564d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick return RUID < NumNativeRegUnits; 565d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 566dd9a50196cd75dbcb2bd604754cd62f8c1f30357Andrew Trick 567f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen unsigned getNumNativeRegUnits() const { 568f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen return NumNativeRegUnits; 569dee3be60292ecfafe584baf4ed84b634b8f4c7c7Benjamin Kramer } 570f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 57140c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen RegUnit &getRegUnit(unsigned RUID) { return RegUnits[RUID]; } 57240c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen const RegUnit &getRegUnit(unsigned RUID) const { return RegUnits[RUID]; } 57340c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen 57429f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> getRegClasses() const { 5757b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen return RegClasses; 5767b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen } 5777b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen 5787b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen // Find a register class from its def. 5797b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen CodeGenRegisterClass *getRegClass(Record*); 5807b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen 5817b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// getRegisterClassForRegister - Find the register class that contains the 5827b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// specified physical register. If the register is not in a register 5837b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// class, return null. If the register is in multiple classes, and the 5847b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// classes have a superset-subset relationship and the same set of types, 5857b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen /// return the superclass. Otherwise return null. 5867b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen const CodeGenRegisterClass* getRegClassForRegister(Record *R); 5877b9cafde5e3faec22bbfbbc90cca0876968abad9Jakob Stoklund Olesen 588ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick // Get the sum of unit weights. 589ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick unsigned getRegUnitSetWeight(const std::vector<unsigned> &Units) const { 590ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick unsigned Weight = 0; 591ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick for (std::vector<unsigned>::const_iterator 592ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick I = Units.begin(), E = Units.end(); I != E; ++I) 59340c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen Weight += getRegUnit(*I).Weight; 594ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick return Weight; 595ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick } 596ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick 597176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Increase a RegUnitWeight. 598d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick void increaseRegUnitWeight(unsigned RUID, unsigned Inc) { 59940c6fb397d1e485aef8b4e1729ba9804784990c1Jakob Stoklund Olesen getRegUnit(RUID).Weight += Inc; 600d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick } 601d35ac3c8bc37ab383b10a04b9c8b1087d6b2bc45Andrew Trick 602176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Get the number of register pressure dimensions. 603176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick unsigned getNumRegPressureSets() const { return RegUnitSets.size(); } 604176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 605176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Get a set of register unit IDs for a given dimension of pressure. 606176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick RegUnitSet getRegPressureSet(unsigned Idx) const { 607176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick return RegUnitSets[Idx]; 608176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 609176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 610176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // Get a list of pressure set IDs for a register class. Liveness of a 611176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // register in this class impacts each pressure set in this list by the 612176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // weight of the register. An exact solution requires all registers in a 613176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick // class to have the same class, but it is not strictly guaranteed. 614176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick ArrayRef<unsigned> getRCPressureSetIDs(unsigned RCIdx) const { 615176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick return RegClassUnitSets[RCIdx]; 616176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 617176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 618b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen // Computed derived records such as missing sub-register indices. 619b5923db192d2aa938ff3c12aaac87d80ab649625Jakob Stoklund Olesen void computeDerivedInfo(); 620026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 621ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // Compute the set of registers completely covered by the registers in Regs. 622ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // The returned BitVector will have a bit set for each register in Regs, 623ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // all sub-registers, and all super-registers that are covered by the 624ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // registers in Regs. 625ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // 626ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // This is used to compute the mask of call-preserved registers from a list 627ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // of callee-saves. 628ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen BitVector computeCoveredRegisters(ArrayRef<Record*> Regs); 629dc29c447136aabf05f48a7119e48065c3b4cee9bJakob Stoklund Olesen }; 6308dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner} 6318dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner 6328dab6ca9c638709e7b60b942107ab88b3ef7d06dChris Lattner#endif 633