13112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner//===- RegisterInfoEmitter.cpp - Generate a Register File Desc. -*- C++ -*-===// 23da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman// 301d45827a1e512f3b19ba857772bf02baa3c0c4eJohn Criswell// The LLVM Compiler Infrastructure 401d45827a1e512f3b19ba857772bf02baa3c0c4eJohn Criswell// 53060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// This file is distributed under the University of Illinois Open Source 63060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// License. See LICENSE.TXT for details. 73da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman// 801d45827a1e512f3b19ba857772bf02baa3c0c4eJohn Criswell//===----------------------------------------------------------------------===// 93112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner// 103112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner// This tablegen backend is responsible for emitting a description of a target 113112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner// register file for a code generator. It uses instances of the Register, 123112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner// RegisterAliases, and RegisterClass classes to gather this information. 133112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner// 143112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner//===----------------------------------------------------------------------===// 153112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner 1626693113201f4c9d441678e50d96f38d3288798eChris Lattner#include "CodeGenRegisters.h" 176f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen#include "CodeGenTarget.h" 180d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen#include "SequenceToOffsetTable.h" 199df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer#include "llvm/ADT/BitVector.h" 20551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/ADT/STLExtras.h" 216f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen#include "llvm/ADT/StringExtras.h" 22bfb4327baa5bbab78f0da4c8c069482878660a04Jim Grosbach#include "llvm/ADT/Twine.h" 234091b059ec9568228f50fd67a1a81ee35c234787Jakob Stoklund Olesen#include "llvm/Support/Format.h" 246f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen#include "llvm/TableGen/Error.h" 256f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen#include "llvm/TableGen/Record.h" 266f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen#include "llvm/TableGen/TableGenBackend.h" 27cc51c3195374645b18918458bac02e85b8c27db6Chuck Rose III#include <algorithm> 281a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar#include <set> 296f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen#include <vector> 302082ebe8b3a5db302748828ab4f79a36d239c1d9Chris Lattnerusing namespace llvm; 31d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 326f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesennamespace { 336f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesenclass RegisterInfoEmitter { 346f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen RecordKeeper &Records; 356f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesenpublic: 366f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen RegisterInfoEmitter(RecordKeeper &R) : Records(R) {} 376f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 386f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen // runEnums - Print out enum values for all of the registers. 396f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void runEnums(raw_ostream &o, CodeGenTarget &Target, CodeGenRegBank &Bank); 406f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 416f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen // runMCDesc - Print out MC register descriptions. 426f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void runMCDesc(raw_ostream &o, CodeGenTarget &Target, CodeGenRegBank &Bank); 436f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 446f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen // runTargetHeader - Emit a header fragment for the register info emitter. 456f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void runTargetHeader(raw_ostream &o, CodeGenTarget &Target, 466f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen CodeGenRegBank &Bank); 476f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 486f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen // runTargetDesc - Output the target register and register file descriptions. 496f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void runTargetDesc(raw_ostream &o, CodeGenTarget &Target, 506f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen CodeGenRegBank &Bank); 516f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 526f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen // run - Output the register file description. 536f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void run(raw_ostream &o); 546f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 556f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesenprivate: 566f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void EmitRegMapping(raw_ostream &o, 576f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen const std::vector<CodeGenRegister*> &Regs, bool isCtor); 586f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void EmitRegMappingTables(raw_ostream &o, 596f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen const std::vector<CodeGenRegister*> &Regs, 606f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen bool isCtor); 616f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void EmitRegClasses(raw_ostream &OS, CodeGenTarget &Target); 626f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 636f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen void EmitRegUnitPressure(raw_ostream &OS, const CodeGenRegBank &RegBank, 646f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen const std::string &ClassName); 656f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen}; 666f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen} // End anonymous namespace 676f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 6854d156d33324b7715453993f21684915a28e310aChris Lattner// runEnums - Print out enum values for all of the registers. 69723fc11f91240e267dd748b467b43b6c00498e4bJim Grosbachvoid RegisterInfoEmitter::runEnums(raw_ostream &OS, 70723fc11f91240e267dd748b467b43b6c00498e4bJim Grosbach CodeGenTarget &Target, CodeGenRegBank &Bank) { 71abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen const std::vector<CodeGenRegister*> &Registers = Bank.getRegisters(); 7254d156d33324b7715453993f21684915a28e310aChris Lattner 735bd9e0dd028202f94391a394a12a6b8c69ee52e3Jim Grosbach // Register enums are stored as uint16_t in the tables. Make sure we'll fit. 74904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper assert(Registers.size() <= 0xffff && "Too many regs to fit in tables"); 75904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper 76abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen std::string Namespace = Registers[0]->TheDef->getValueAsString("Namespace"); 7754d156d33324b7715453993f21684915a28e310aChris Lattner 786f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen emitSourceFileHeader("Target Register Enum Values", OS); 7973f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 8073f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "\n#ifdef GET_REGINFO_ENUM\n"; 8173f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "#undef GET_REGINFO_ENUM\n"; 8273f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 832c38413b3f5420f45f2f8220b21862246d446dd0Chris Lattner OS << "namespace llvm {\n\n"; 8454d156d33324b7715453993f21684915a28e310aChris Lattner 855de728cfe1a922ac9b13546dca94526b2fa693b6Evan Cheng OS << "class MCRegisterClass;\n" 861a2f9886a2a60dbd41216468a240446bbfed3e76Benjamin Kramer << "extern const MCRegisterClass " << Namespace 871a2f9886a2a60dbd41216468a240446bbfed3e76Benjamin Kramer << "MCRegisterClasses[];\n\n"; 885de728cfe1a922ac9b13546dca94526b2fa693b6Evan Cheng 8954d156d33324b7715453993f21684915a28e310aChris Lattner if (!Namespace.empty()) 9054d156d33324b7715453993f21684915a28e310aChris Lattner OS << "namespace " << Namespace << " {\n"; 9173ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen OS << "enum {\n NoRegister,\n"; 9254d156d33324b7715453993f21684915a28e310aChris Lattner 9354d156d33324b7715453993f21684915a28e310aChris Lattner for (unsigned i = 0, e = Registers.size(); i != e; ++i) 94abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen OS << " " << Registers[i]->getName() << " = " << 95abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen Registers[i]->EnumValue << ",\n"; 96abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen assert(Registers.size() == Registers[Registers.size()-1]->EnumValue && 9717fad045cccf34822d3163ada9e70a8f4528746eJim Grosbach "Register enum value mismatch!"); 9873ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen OS << " NUM_TARGET_REGS \t// " << Registers.size()+1 << "\n"; 9973ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen OS << "};\n"; 10054d156d33324b7715453993f21684915a28e310aChris Lattner if (!Namespace.empty()) 10154d156d33324b7715453993f21684915a28e310aChris Lattner OS << "}\n"; 10273ea7bf4509663267317ec3911aac00ca35a2f2cJakob Stoklund Olesen 10329f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> RegisterClasses = Bank.getRegClasses(); 10473f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng if (!RegisterClasses.empty()) { 105904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper 106904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper // RegisterClass enums are stored as uint16_t in the tables. 107904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper assert(RegisterClasses.size() <= 0xffff && 108904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper "Too many register classes to fit in tables"); 109904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper 11073f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "\n// Register classes\n"; 1114987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng if (!Namespace.empty()) 1124987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << "namespace " << Namespace << " {\n"; 11373f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "enum {\n"; 11473f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) { 11573f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng if (i) OS << ",\n"; 11629f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen OS << " " << RegisterClasses[i]->getName() << "RegClassID"; 11773f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << " = " << i; 11873f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng } 11973f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "\n };\n"; 1204987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng if (!Namespace.empty()) 1214987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << "}\n"; 1224987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng } 1234987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng 1244987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng const std::vector<Record*> RegAltNameIndices = Target.getRegAltNameIndices(); 1254987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng // If the only definition is the default NoRegAltName, we don't need to 1264987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng // emit anything. 1274987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng if (RegAltNameIndices.size() > 1) { 1284987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << "\n// Register alternate name indices\n"; 1294987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng if (!Namespace.empty()) 1304987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << "namespace " << Namespace << " {\n"; 1314987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << "enum {\n"; 1324987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng for (unsigned i = 0, e = RegAltNameIndices.size(); i != e; ++i) 1334987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << " " << RegAltNameIndices[i]->getName() << ",\t// " << i << "\n"; 1344987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << " NUM_TARGET_REG_ALT_NAMES = " << RegAltNameIndices.size() << "\n"; 1354987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << "};\n"; 1364987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng if (!Namespace.empty()) 1374987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng OS << "}\n"; 13873f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng } 13973f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 1405d9651df892afb0bb4036827c327b8effe87060cJim Grosbach ArrayRef<CodeGenSubRegIndex*> SubRegIndices = Bank.getSubRegIndices(); 1415d9651df892afb0bb4036827c327b8effe87060cJim Grosbach if (!SubRegIndices.empty()) { 1425d9651df892afb0bb4036827c327b8effe87060cJim Grosbach OS << "\n// Subregister indices\n"; 1435d9651df892afb0bb4036827c327b8effe87060cJim Grosbach std::string Namespace = 1445d9651df892afb0bb4036827c327b8effe87060cJim Grosbach SubRegIndices[0]->getNamespace(); 1455d9651df892afb0bb4036827c327b8effe87060cJim Grosbach if (!Namespace.empty()) 1465d9651df892afb0bb4036827c327b8effe87060cJim Grosbach OS << "namespace " << Namespace << " {\n"; 1475d9651df892afb0bb4036827c327b8effe87060cJim Grosbach OS << "enum {\n NoSubRegister,\n"; 148c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen for (unsigned i = 0, e = SubRegIndices.size(); i != e; ++i) 1495d9651df892afb0bb4036827c327b8effe87060cJim Grosbach OS << " " << SubRegIndices[i]->getName() << ",\t// " << i+1 << "\n"; 150c97eda2c9e34f4c491f59bbac81af2fd63fef49dJakob Stoklund Olesen OS << " NUM_TARGET_SUBREGS\n};\n"; 1515d9651df892afb0bb4036827c327b8effe87060cJim Grosbach if (!Namespace.empty()) 1525d9651df892afb0bb4036827c327b8effe87060cJim Grosbach OS << "}\n"; 1535d9651df892afb0bb4036827c327b8effe87060cJim Grosbach } 1544987033fbd8e774e67903f50a8bd20d539c4dca5Evan Cheng 1552c38413b3f5420f45f2f8220b21862246d446dd0Chris Lattner OS << "} // End llvm namespace \n"; 15673f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "#endif // GET_REGINFO_ENUM\n\n"; 15754d156d33324b7715453993f21684915a28e310aChris Lattner} 15854d156d33324b7715453993f21684915a28e310aChris Lattner 159176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trickvoid RegisterInfoEmitter:: 160176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew TrickEmitRegUnitPressure(raw_ostream &OS, const CodeGenRegBank &RegBank, 161176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick const std::string &ClassName) { 162176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick unsigned NumRCs = RegBank.getRegClasses().size(); 163176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick unsigned NumSets = RegBank.getNumRegPressureSets(); 164176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 165176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << "/// Get the weight in units of pressure for this register class.\n" 166ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick << "const RegClassWeight &" << ClassName << "::\n" 167176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "getRegClassWeight(const TargetRegisterClass *RC) const {\n" 168ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick << " static const RegClassWeight RCWeightTable[] = {\n"; 169176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick for (unsigned i = 0, e = NumRCs; i != e; ++i) { 170176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick const CodeGenRegisterClass &RC = *RegBank.getRegClasses()[i]; 171176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick const CodeGenRegister::Set &Regs = RC.getMembers(); 172176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick if (Regs.empty()) 173ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick OS << " {0, 0"; 174ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick else { 175ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick std::vector<unsigned> RegUnits; 176ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick RC.buildRegUnitSet(RegUnits); 177ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick OS << " {" << (*Regs.begin())->getWeight(RegBank) 178ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick << ", " << RegBank.getRegUnitSetWeight(RegUnits); 179ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick } 180ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick OS << "}, \t// " << RC.getName() << "\n"; 181176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 182ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick OS << " {0, 0} };\n" 183176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " return RCWeightTable[RC->getID()];\n" 184176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "}\n\n"; 185176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 186176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << "\n" 187176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "// Get the number of dimensions of register pressure.\n" 188176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "unsigned " << ClassName << "::getNumRegPressureSets() const {\n" 189176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " return " << NumSets << ";\n}\n\n"; 190176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 1917c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick OS << "// Get the name of this register unit pressure set.\n" 1927c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick << "const char *" << ClassName << "::\n" 1937c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick << "getRegPressureSetName(unsigned Idx) const {\n" 1947c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick << " static const char *PressureNameTable[] = {\n"; 1957c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick for (unsigned i = 0; i < NumSets; ++i ) { 1967c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick OS << " \"" << RegBank.getRegPressureSet(i).Name << "\",\n"; 1977c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick } 1987c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick OS << " 0 };\n" 1997c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick << " return PressureNameTable[Idx];\n" 2007c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick << "}\n\n"; 2017c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick 202176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << "// Get the register unit pressure limit for this dimension.\n" 203176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "// This limit must be adjusted dynamically for reserved registers.\n" 204176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "unsigned " << ClassName << "::\n" 205176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "getRegPressureSetLimit(unsigned Idx) const {\n" 206176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " static const unsigned PressureLimitTable[] = {\n"; 207176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick for (unsigned i = 0; i < NumSets; ++i ) { 208680363b5fdf7ce6e188d4c8c7508fc819061ba6dAndrew Trick const RegUnitSet &RegUnits = RegBank.getRegPressureSet(i); 209ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick OS << " " << RegBank.getRegUnitSetWeight(RegUnits.Units) 2107c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick << ", \t// " << i << ": " << RegUnits.Name << "\n"; 211176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 212176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << " 0 };\n" 213176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " return PressureLimitTable[Idx];\n" 214176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "}\n\n"; 215176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 216176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << "/// Get the dimensions of register pressure " 217176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "impacted by this register class.\n" 218176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "/// Returns a -1 terminated array of pressure set IDs\n" 219176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "const int* " << ClassName << "::\n" 220176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "getRegClassPressureSets(const TargetRegisterClass *RC) const {\n" 221176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " static const int RCSetsTable[] = {\n "; 222176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick std::vector<unsigned> RCSetStarts(NumRCs); 223176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick for (unsigned i = 0, StartIdx = 0, e = NumRCs; i != e; ++i) { 224176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick RCSetStarts[i] = StartIdx; 225176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick ArrayRef<unsigned> PSetIDs = RegBank.getRCPressureSetIDs(i); 226176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick for (ArrayRef<unsigned>::iterator PSetI = PSetIDs.begin(), 227176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick PSetE = PSetIDs.end(); PSetI != PSetE; ++PSetI) { 228176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << *PSetI << ", "; 229176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick ++StartIdx; 230176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 231176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << "-1, \t// " << RegBank.getRegClasses()[i]->getName() << "\n "; 232176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick ++StartIdx; 233176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 234176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << "-1 };\n"; 235176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << " static const unsigned RCSetStartTable[] = {\n "; 236176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick for (unsigned i = 0, e = NumRCs; i != e; ++i) { 237176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << RCSetStarts[i] << ","; 238176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick } 239176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick OS << "0 };\n" 240176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " unsigned SetListStart = RCSetStartTable[RC->getID()];\n" 241176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " return &RCSetsTable[SetListStart];\n" 242176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "}\n\n"; 243176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick} 2440e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 245243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramervoid 246243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin KramerRegisterInfoEmitter::EmitRegMappingTables(raw_ostream &OS, 247243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer const std::vector<CodeGenRegister*> &Regs, 248243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer bool isCtor) { 2490e6a052331f674dd70e28af41f654a7874405eabEvan Cheng // Collect all information about dwarf register numbers 2500e6a052331f674dd70e28af41f654a7874405eabEvan Cheng typedef std::map<Record*, std::vector<int64_t>, LessRecord> DwarfRegNumsMapTy; 2510e6a052331f674dd70e28af41f654a7874405eabEvan Cheng DwarfRegNumsMapTy DwarfRegNums; 2520e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 2530e6a052331f674dd70e28af41f654a7874405eabEvan Cheng // First, just pull all provided information to the map 2540e6a052331f674dd70e28af41f654a7874405eabEvan Cheng unsigned maxLength = 0; 2550e6a052331f674dd70e28af41f654a7874405eabEvan Cheng for (unsigned i = 0, e = Regs.size(); i != e; ++i) { 2560e6a052331f674dd70e28af41f654a7874405eabEvan Cheng Record *Reg = Regs[i]->TheDef; 2570e6a052331f674dd70e28af41f654a7874405eabEvan Cheng std::vector<int64_t> RegNums = Reg->getValueAsListOfInts("DwarfNumbers"); 2580e6a052331f674dd70e28af41f654a7874405eabEvan Cheng maxLength = std::max((size_t)maxLength, RegNums.size()); 2590e6a052331f674dd70e28af41f654a7874405eabEvan Cheng if (DwarfRegNums.count(Reg)) 260bfb4327baa5bbab78f0da4c8c069482878660a04Jim Grosbach PrintWarning(Reg->getLoc(), Twine("DWARF numbers for register ") + 2613cbcffc4e5990209ce80a54e615f55245fe3b824Benjamin Kramer getQualifiedName(Reg) + "specified multiple times"); 2620e6a052331f674dd70e28af41f654a7874405eabEvan Cheng DwarfRegNums[Reg] = RegNums; 2630e6a052331f674dd70e28af41f654a7874405eabEvan Cheng } 2640e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 2650e6a052331f674dd70e28af41f654a7874405eabEvan Cheng if (!maxLength) 2660e6a052331f674dd70e28af41f654a7874405eabEvan Cheng return; 2670e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 2680e6a052331f674dd70e28af41f654a7874405eabEvan Cheng // Now we know maximal length of number list. Append -1's, where needed 2690e6a052331f674dd70e28af41f654a7874405eabEvan Cheng for (DwarfRegNumsMapTy::iterator 2700e6a052331f674dd70e28af41f654a7874405eabEvan Cheng I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I) 2710e6a052331f674dd70e28af41f654a7874405eabEvan Cheng for (unsigned i = I->second.size(), e = maxLength; i != e; ++i) 2720e6a052331f674dd70e28af41f654a7874405eabEvan Cheng I->second.push_back(-1); 2730e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 274243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer std::string Namespace = Regs[0]->TheDef->getValueAsString("Namespace"); 275243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 276243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "// " << Namespace << " Dwarf<->LLVM register mappings.\n"; 277243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 278243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // Emit reverse information about the dwarf register numbers. 279243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (unsigned j = 0; j < 2; ++j) { 280243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (unsigned i = 0, e = maxLength; i != e; ++i) { 281243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "extern const MCRegisterInfo::DwarfLLVMRegPair " << Namespace; 282243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << (j == 0 ? "DwarfFlavour" : "EHFlavour"); 283243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << i << "Dwarf2L[]"; 284243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 285243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (!isCtor) { 286243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << " = {\n"; 287243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 288243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // Store the mapping sorted by the LLVM reg num so lookup can be done 289243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // with a binary search. 290243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer std::map<uint64_t, Record*> Dwarf2LMap; 291243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (DwarfRegNumsMapTy::iterator 292243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I) { 293243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer int DwarfRegNo = I->second[i]; 294243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (DwarfRegNo < 0) 295243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer continue; 296243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer Dwarf2LMap[DwarfRegNo] = I->first; 297243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 298243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 299243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (std::map<uint64_t, Record*>::iterator 300243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer I = Dwarf2LMap.begin(), E = Dwarf2LMap.end(); I != E; ++I) 301243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << " { " << I->first << "U, " << getQualifiedName(I->second) 302243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << " },\n"; 303243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 304243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "};\n"; 305243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } else { 306243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << ";\n"; 307243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 308243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 309243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // We have to store the size in a const global, it's used in multiple 310243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // places. 311243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "extern const unsigned " << Namespace 312243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i << "Dwarf2LSize"; 313243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (!isCtor) 314243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << " = sizeof(" << Namespace 315243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i 316243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << "Dwarf2L)/sizeof(MCRegisterInfo::DwarfLLVMRegPair);\n\n"; 317243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer else 318243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << ";\n\n"; 319243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 320243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 321243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 322243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (unsigned i = 0, e = Regs.size(); i != e; ++i) { 323243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer Record *Reg = Regs[i]->TheDef; 324243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer const RecordVal *V = Reg->getValue("DwarfAlias"); 325243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (!V || !V->getValue()) 326243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer continue; 327243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 328243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer DefInit *DI = dynamic_cast<DefInit*>(V->getValue()); 329243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer Record *Alias = DI->getDef(); 330243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer DwarfRegNums[Reg] = DwarfRegNums[Alias]; 331243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 332243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 333243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // Emit information about the dwarf register numbers. 334243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (unsigned j = 0; j < 2; ++j) { 335243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (unsigned i = 0, e = maxLength; i != e; ++i) { 336243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "extern const MCRegisterInfo::DwarfLLVMRegPair " << Namespace; 337243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << (j == 0 ? "DwarfFlavour" : "EHFlavour"); 338243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << i << "L2Dwarf[]"; 339243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (!isCtor) { 340243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << " = {\n"; 341243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // Store the mapping sorted by the Dwarf reg num so lookup can be done 342243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // with a binary search. 343243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (DwarfRegNumsMapTy::iterator 344243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I) { 345243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer int RegNo = I->second[i]; 346243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (RegNo == -1) // -1 is the default value, don't emit a mapping. 347243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer continue; 348243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 349243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << " { " << getQualifiedName(I->first) << ", " << RegNo 350243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << "U },\n"; 351243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 352243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "};\n"; 353243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } else { 354243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << ";\n"; 355243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 356243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 357243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // We have to store the size in a const global, it's used in multiple 358243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // places. 359243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "extern const unsigned " << Namespace 360243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i << "L2DwarfSize"; 361243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (!isCtor) 362243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << " = sizeof(" << Namespace 363243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i 364243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << "L2Dwarf)/sizeof(MCRegisterInfo::DwarfLLVMRegPair);\n\n"; 365243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer else 366243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << ";\n\n"; 367243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 368243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 369243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer} 370243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 371243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramervoid 372243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin KramerRegisterInfoEmitter::EmitRegMapping(raw_ostream &OS, 373243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer const std::vector<CodeGenRegister*> &Regs, 374243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer bool isCtor) { 375243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // Emit the initializer so the tables from EmitRegMappingTables get wired up 376243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer // to the MCRegisterInfo object. 377243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer unsigned maxLength = 0; 378243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer for (unsigned i = 0, e = Regs.size(); i != e; ++i) { 379243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer Record *Reg = Regs[i]->TheDef; 380243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer maxLength = std::max((size_t)maxLength, 381243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer Reg->getValueAsListOfInts("DwarfNumbers").size()); 382243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer } 383243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 384243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (!maxLength) 385243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer return; 386243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 387243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer std::string Namespace = Regs[0]->TheDef->getValueAsString("Namespace"); 388243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 3890e6a052331f674dd70e28af41f654a7874405eabEvan Cheng // Emit reverse information about the dwarf register numbers. 3900e6a052331f674dd70e28af41f654a7874405eabEvan Cheng for (unsigned j = 0; j < 2; ++j) { 3910e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << " switch ("; 3920e6a052331f674dd70e28af41f654a7874405eabEvan Cheng if (j == 0) 3930e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "DwarfFlavour"; 3940e6a052331f674dd70e28af41f654a7874405eabEvan Cheng else 3950e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "EHFlavour"; 3960e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << ") {\n" 3970e6a052331f674dd70e28af41f654a7874405eabEvan Cheng << " default:\n" 398655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper << " llvm_unreachable(\"Unknown DWARF flavour\");\n"; 3990e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 4000e6a052331f674dd70e28af41f654a7874405eabEvan Cheng for (unsigned i = 0, e = maxLength; i != e; ++i) { 4010e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << " case " << i << ":\n"; 402243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << " "; 403243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (!isCtor) 404243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "RI->"; 405243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer std::string Tmp; 406243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer raw_string_ostream(Tmp) << Namespace 407243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i 408243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << "Dwarf2L"; 409243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "mapDwarfRegsToLLVMRegs(" << Tmp << ", " << Tmp << "Size, "; 410243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (j == 0) 4110e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "false"; 4120e6a052331f674dd70e28af41f654a7874405eabEvan Cheng else 4130e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "true"; 414243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << ");\n"; 4150e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << " break;\n"; 4160e6a052331f674dd70e28af41f654a7874405eabEvan Cheng } 4170e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << " }\n"; 4180e6a052331f674dd70e28af41f654a7874405eabEvan Cheng } 4190e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 4200e6a052331f674dd70e28af41f654a7874405eabEvan Cheng // Emit information about the dwarf register numbers. 4210e6a052331f674dd70e28af41f654a7874405eabEvan Cheng for (unsigned j = 0; j < 2; ++j) { 4220e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << " switch ("; 4230e6a052331f674dd70e28af41f654a7874405eabEvan Cheng if (j == 0) 4240e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "DwarfFlavour"; 4250e6a052331f674dd70e28af41f654a7874405eabEvan Cheng else 4260e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "EHFlavour"; 4270e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << ") {\n" 4280e6a052331f674dd70e28af41f654a7874405eabEvan Cheng << " default:\n" 429655b8de7b2ab773a977e0c524307e71354d8af29Craig Topper << " llvm_unreachable(\"Unknown DWARF flavour\");\n"; 4300e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 4310e6a052331f674dd70e28af41f654a7874405eabEvan Cheng for (unsigned i = 0, e = maxLength; i != e; ++i) { 4320e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << " case " << i << ":\n"; 433243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << " "; 434243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (!isCtor) 435243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "RI->"; 436243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer std::string Tmp; 437243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer raw_string_ostream(Tmp) << Namespace 438243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i 439243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer << "L2Dwarf"; 440243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << "mapLLVMRegsToDwarfRegs(" << Tmp << ", " << Tmp << "Size, "; 441243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer if (j == 0) 4420e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "false"; 4430e6a052331f674dd70e28af41f654a7874405eabEvan Cheng else 4440e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "true"; 445243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer OS << ");\n"; 4460e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << " break;\n"; 4470e6a052331f674dd70e28af41f654a7874405eabEvan Cheng } 4480e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << " }\n"; 4490e6a052331f674dd70e28af41f654a7874405eabEvan Cheng } 4500e6a052331f674dd70e28af41f654a7874405eabEvan Cheng} 4510e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 452b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen// Print a BitVector as a sequence of hex numbers using a little-endian mapping. 453b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen// Width is the number of bits per hex number. 454b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesenstatic void printBitVectorAsHex(raw_ostream &OS, 455b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen const BitVector &Bits, 456b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen unsigned Width) { 457b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen assert(Width <= 32 && "Width too large"); 458b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen unsigned Digits = (Width + 3) / 4; 459b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen for (unsigned i = 0, e = Bits.size(); i < e; i += Width) { 460b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen unsigned Value = 0; 461b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen for (unsigned j = 0; j != Width && i + j != e; ++j) 462b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen Value |= Bits.test(i + j) << j; 463b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen OS << format("0x%0*x, ", Digits, Value); 464b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen } 465b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen} 466b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen 4679df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer// Helper to emit a set of bits into a constant byte array. 4689df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramerclass BitVectorEmitter { 4699df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer BitVector Values; 4709df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramerpublic: 471a397a11c7c60e500baa36eea59a46a9aa2e5f35bBenjamin Kramer void add(unsigned v) { 472a397a11c7c60e500baa36eea59a46a9aa2e5f35bBenjamin Kramer if (v >= Values.size()) 473a397a11c7c60e500baa36eea59a46a9aa2e5f35bBenjamin Kramer Values.resize(((v/8)+1)*8); // Round up to the next byte. 474a397a11c7c60e500baa36eea59a46a9aa2e5f35bBenjamin Kramer Values[v] = true; 4759df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer } 4769df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer 4779df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer void print(raw_ostream &OS) { 478b7359e384f7d15d3e24b3763ed66546e497fe213Jakob Stoklund Olesen printBitVectorAsHex(OS, Values, 8); 4799df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer } 4809df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer}; 4819df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer 4820d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesenstatic void printSimpleValueType(raw_ostream &OS, MVT::SimpleValueType VT) { 4830d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen OS << getEnumName(VT); 4840d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen} 4850d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen 486f92be238d6370fbab58f035a5bd0c6db7e207094Jakob Stoklund Olesenstatic void printSubRegIndex(raw_ostream &OS, const CodeGenSubRegIndex *Idx) { 4870371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen OS << Idx->EnumValue; 488f92be238d6370fbab58f035a5bd0c6db7e207094Jakob Stoklund Olesen} 489f92be238d6370fbab58f035a5bd0c6db7e207094Jakob Stoklund Olesen 490f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// Differentially encoded register and regunit lists allow for better 491f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// compression on regular register banks. The sequence is computed from the 492f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// differential list as: 493f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// 494f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// out[0] = InitVal; 495f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// out[n+1] = out[n] + diff[n]; // n = 0, 1, ... 496f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// 497f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// The initial value depends on the specific list. The list is terminated by a 498f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// 0 differential which means we can't encode repeated elements. 499f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 500f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesentypedef SmallVector<uint16_t, 4> DiffVec; 501f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 502f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// Differentially encode a sequence of numbers into V. The starting value and 503f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen// terminating 0 are not added to V, so it will have the same size as List. 504b2a6d8100cfb8a4f9ee251fb274c2d6688b27963Jakob Stoklund Olesenstatic 505f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund OlesenDiffVec &diffEncode(DiffVec &V, unsigned InitVal, ArrayRef<unsigned> List) { 506f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen assert(V.empty() && "Clear DiffVec before diffEncode."); 507f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen uint16_t Val = uint16_t(InitVal); 508f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen for (unsigned i = 0; i != List.size(); ++i) { 509f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen uint16_t Cur = List[i]; 510f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen V.push_back(Cur - Val); 511f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen Val = Cur; 512f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen } 513f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen return V; 514f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen} 515f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 516303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesentemplate<typename Iter> 517303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesenstatic 518303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund OlesenDiffVec &diffEncode(DiffVec &V, unsigned InitVal, Iter Begin, Iter End) { 519303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen assert(V.empty() && "Clear DiffVec before diffEncode."); 520303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen uint16_t Val = uint16_t(InitVal); 521303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen for (Iter I = Begin; I != End; ++I) { 522303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen uint16_t Cur = (*I)->EnumValue; 523303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen V.push_back(Cur - Val); 524303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen Val = Cur; 525303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen } 526303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen return V; 527303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen} 528303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen 529f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesenstatic void printDiff16(raw_ostream &OS, uint16_t Val) { 530ff09e56cda85c1740ac1689018dfe0d3cf49ae6cJakob Stoklund Olesen OS << Val; 531f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen} 532f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 5334091b059ec9568228f50fd67a1a81ee35c234787Jakob Stoklund Olesen// 53473f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng// runMCDesc - Print out MC register descriptions. 53554d156d33324b7715453993f21684915a28e310aChris Lattner// 53673f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Chengvoid 53773f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan ChengRegisterInfoEmitter::runMCDesc(raw_ostream &OS, CodeGenTarget &Target, 53873f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng CodeGenRegBank &RegBank) { 5396f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen emitSourceFileHeader("MC Register Information", OS); 54073f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 54173f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "\n#ifdef GET_REGINFO_MC_DESC\n"; 54273f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "#undef GET_REGINFO_MC_DESC\n"; 54373f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 5440d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen const std::vector<CodeGenRegister*> &Regs = RegBank.getRegisters(); 54573f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 5460d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen // The lists of sub-registers, super-registers, and overlaps all go in the 5470d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen // same array. That allows us to share suffixes. 5480d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen typedef std::vector<const CodeGenRegister*> RegVec; 549902af25abdc9e6d25b898310c1e4716bbe768fb9Craig Topper 550f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // Differentially encoded lists. 551f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen SequenceToOffsetTable<DiffVec> DiffSeqs; 552303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen SmallVector<DiffVec, 4> SubRegLists(Regs.size()); 553303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen SmallVector<DiffVec, 4> SuperRegLists(Regs.size()); 554303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen SmallVector<DiffVec, 4> OverlapLists(Regs.size()); 555f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen SmallVector<DiffVec, 4> RegUnitLists(Regs.size()); 556f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen SmallVector<unsigned, 4> RegUnitInitScale(Regs.size()); 557f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 5580371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen // Keep track of sub-register names as well. These are not differentially 5590371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen // encoded. 5600371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen typedef SmallVector<const CodeGenSubRegIndex*, 4> SubRegIdxVec; 5610371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen SequenceToOffsetTable<SubRegIdxVec> SubRegIdxSeqs; 5620371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen SmallVector<SubRegIdxVec, 4> SubRegIdxLists(Regs.size()); 5630371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen 564d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen SequenceToOffsetTable<std::string> RegStrings; 565d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen 5660d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen // Precompute register lists for the SequenceToOffsetTable. 56773f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng for (unsigned i = 0, e = Regs.size(); i != e; ++i) { 56873f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng const CodeGenRegister *Reg = Regs[i]; 56973f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 570d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen RegStrings.add(Reg->getName()); 571d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen 5720d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen // Compute the ordered sub-register list. 573c6a96ff6aeeb77e1007364e5603b72f3ab4cc7bdJakob Stoklund Olesen SetVector<const CodeGenRegister*> SR; 5740d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen Reg->addSubRegsPreOrder(SR, RegBank); 575303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen diffEncode(SubRegLists[i], Reg->EnumValue, SR.begin(), SR.end()); 576303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen DiffSeqs.add(SubRegLists[i]); 5770d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen 5780371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen // Compute the corresponding sub-register indexes. 5790371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen SubRegIdxVec &SRIs = SubRegIdxLists[i]; 5800371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen for (unsigned j = 0, je = SR.size(); j != je; ++j) 5810371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen SRIs.push_back(Reg->getSubRegIndex(SR[j])); 5820371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen SubRegIdxSeqs.add(SRIs); 5830371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen 5840d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen // Super-registers are already computed. 5850d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen const RegVec &SuperRegList = Reg->getSuperRegs(); 586303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen diffEncode(SuperRegLists[i], Reg->EnumValue, 587303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen SuperRegList.begin(), SuperRegList.end()); 588303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen DiffSeqs.add(SuperRegLists[i]); 5890d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen 590303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen // The list of overlaps doesn't need to have any particular order, and Reg 591303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen // itself must be omitted. 592303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen DiffVec &OverlapList = OverlapLists[i]; 5933778aeb74864390bf763424c45cc355ac330fbc9Jakob Stoklund Olesen CodeGenRegister::Set OSet; 5943778aeb74864390bf763424c45cc355ac330fbc9Jakob Stoklund Olesen Reg->computeOverlaps(OSet, RegBank); 595303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen OSet.erase(Reg); 596303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen diffEncode(OverlapList, Reg->EnumValue, OSet.begin(), OSet.end()); 597303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen DiffSeqs.add(OverlapList); 598f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 599f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // Differentially encode the register unit list, seeded by register number. 600f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // First compute a scale factor that allows more diff-lists to be reused: 601f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // 602f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // D0 -> (S0, S1) 603f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // D1 -> (S2, S3) 604f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // 605f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // A scale factor of 2 allows D0 and D1 to share a diff-list. The initial 606f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // value for the differential decoder is the register number multiplied by 607f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // the scale. 608f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // 609f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // Check the neighboring registers for arithmetic progressions. 610f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen unsigned ScaleA = ~0u, ScaleB = ~0u; 611f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen ArrayRef<unsigned> RUs = Reg->getNativeRegUnits(); 612f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen if (i > 0 && Regs[i-1]->getNativeRegUnits().size() == RUs.size()) 613f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen ScaleB = RUs.front() - Regs[i-1]->getNativeRegUnits().front(); 614f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen if (i+1 != Regs.size() && 615f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen Regs[i+1]->getNativeRegUnits().size() == RUs.size()) 616f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen ScaleA = Regs[i+1]->getNativeRegUnits().front() - RUs.front(); 617f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen unsigned Scale = std::min(ScaleB, ScaleA); 618f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // Default the scale to 0 if it can't be encoded in 4 bits. 619f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen if (Scale >= 16) 620f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen Scale = 0; 621f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen RegUnitInitScale[i] = Scale; 622f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen DiffSeqs.add(diffEncode(RegUnitLists[i], Scale * Reg->EnumValue, RUs)); 62373f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng } 62473f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 6250d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen // Compute the final layout of the sequence table. 626f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen DiffSeqs.layout(); 6270371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen SubRegIdxSeqs.layout(); 6280d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen 6290d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen OS << "namespace llvm {\n\n"; 6300d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen 6310d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen const std::string &TargetName = Target.getName(); 6320d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen 633f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen // Emit the shared table of differential lists. 634f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen OS << "extern const uint16_t " << TargetName << "RegDiffLists[] = {\n"; 635f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen DiffSeqs.emit(OS, printDiff16); 636f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen OS << "};\n\n"; 637f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen 6380371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen // Emit the table of sub-register indexes. 6390371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen OS << "extern const uint16_t " << TargetName << "SubRegIdxLists[] = {\n"; 6400371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen SubRegIdxSeqs.emit(OS, printSubRegIndex); 6410371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen OS << "};\n\n"; 6420371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen 643d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen // Emit the string table. 644d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen RegStrings.layout(); 645d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen OS << "extern const char " << TargetName << "RegStrings[] = {\n"; 646d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen RegStrings.emit(OS, printChar); 647d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen OS << "};\n\n"; 648d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen 649902af25abdc9e6d25b898310c1e4716bbe768fb9Craig Topper OS << "extern const MCRegisterDesc " << TargetName 65073f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng << "RegDesc[] = { // Descriptors\n"; 6510371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen OS << " { " << RegStrings.get("") << ", 0, 0, 0, 0, 0 },\n"; 65273f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 6530d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen // Emit the register descriptors now. 65473f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng for (unsigned i = 0, e = Regs.size(); i != e; ++i) { 655902af25abdc9e6d25b898310c1e4716bbe768fb9Craig Topper const CodeGenRegister *Reg = Regs[i]; 656d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen OS << " { " << RegStrings.get(Reg->getName()) << ", " 657303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen << DiffSeqs.get(OverlapLists[i]) << ", " 658303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen << DiffSeqs.get(SubRegLists[i]) << ", " 659303c909d5bb014fbeec395090eb467d724969195Jakob Stoklund Olesen << DiffSeqs.get(SuperRegLists[i]) << ", " 6600371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << SubRegIdxSeqs.get(SubRegIdxLists[i]) << ", " 661f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen << (DiffSeqs.get(RegUnitLists[i])*16 + RegUnitInitScale[i]) << " },\n"; 66273f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng } 663c60f9b752381baa6c4b80c0739034660f1748c84Evan Cheng OS << "};\n\n"; // End of register descriptors... 66473f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 665f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen // Emit the table of register unit roots. Each regunit has one or two root 666f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen // registers. 667f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen OS << "extern const uint16_t " << TargetName << "RegUnitRoots[][2] = {\n"; 668f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen for (unsigned i = 0, e = RegBank.getNumNativeRegUnits(); i != e; ++i) { 669f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen ArrayRef<const CodeGenRegister*> Roots = RegBank.getRegUnit(i).getRoots(); 670f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen assert(!Roots.empty() && "All regunits must have a root register."); 671f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen assert(Roots.size() <= 2 && "More than two roots not supported yet."); 672f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen OS << " { " << getQualifiedName(Roots.front()->TheDef); 673f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen for (unsigned r = 1; r != Roots.size(); ++r) 674f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen OS << ", " << getQualifiedName(Roots[r]->TheDef); 675f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen OS << " },\n"; 676f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen } 677f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen OS << "};\n\n"; 678f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen 67929f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> RegisterClasses = RegBank.getRegClasses(); 6808ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer 6818ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer // Loop over all of the register classes... emitting each one. 6828ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer OS << "namespace { // Register classes...\n"; 6838ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer 6848ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer // Emit the register enum value arrays for each RegisterClass 6858ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) { 68629f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen const CodeGenRegisterClass &RC = *RegisterClasses[rc]; 6878ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer ArrayRef<Record*> Order = RC.getOrder(); 6888ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer 6898ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer // Give the register class a legal C name if it's anonymous. 6908ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer std::string Name = RC.getName(); 6918ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer 6928ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer // Emit the register list now. 6938ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer OS << " // " << Name << " Register Class...\n" 694b6632ba380cf624e60fe16b03d6e21b05dd07724Craig Topper << " const uint16_t " << Name 6958ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer << "[] = {\n "; 6968ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer for (unsigned i = 0, e = Order.size(); i != e; ++i) { 6978ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer Record *Reg = Order[i]; 6988ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer OS << getQualifiedName(Reg) << ", "; 6998ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer } 7008ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer OS << "\n };\n\n"; 7019df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer 7029df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer OS << " // " << Name << " Bit set.\n" 703b6632ba380cf624e60fe16b03d6e21b05dd07724Craig Topper << " const uint8_t " << Name 7049df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer << "Bits[] = {\n "; 705a397a11c7c60e500baa36eea59a46a9aa2e5f35bBenjamin Kramer BitVectorEmitter BVE; 7069df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer for (unsigned i = 0, e = Order.size(); i != e; ++i) { 7079df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer Record *Reg = Order[i]; 7089df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer BVE.add(Target.getRegBank().getReg(Reg)->EnumValue); 7099df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer } 7109df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer BVE.print(OS); 7119df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer OS << "\n };\n\n"; 7129df8567548e15c6cd91e8a5851784574c4f09528Benjamin Kramer 7138ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer } 7148ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer OS << "}\n\n"; 7158ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer 7161a2f9886a2a60dbd41216468a240446bbfed3e76Benjamin Kramer OS << "extern const MCRegisterClass " << TargetName 7171a2f9886a2a60dbd41216468a240446bbfed3e76Benjamin Kramer << "MCRegisterClasses[] = {\n"; 7188ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer 7198ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) { 72029f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen const CodeGenRegisterClass &RC = *RegisterClasses[rc]; 721904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper 722904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper // Asserts to make sure values will fit in table assuming types from 723904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper // MCRegisterInfo.h 724904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper assert((RC.SpillSize/8) <= 0xffff && "SpillSize too large."); 725904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper assert((RC.SpillAlignment/8) <= 0xffff && "SpillAlignment too large."); 726904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper assert(RC.CopyCost >= -128 && RC.CopyCost <= 127 && "Copy cost too large."); 727904a01820c86dd1e2bc7aef2950ed75a2c9c2640Craig Topper 72852b89dd303424582d054e18417099f3a7e343b41Craig Topper OS << " { " << '\"' << RC.getName() << "\", " 72952b89dd303424582d054e18417099f3a7e343b41Craig Topper << RC.getName() << ", " << RC.getName() << "Bits, " 73052b89dd303424582d054e18417099f3a7e343b41Craig Topper << RC.getOrder().size() << ", sizeof(" << RC.getName() << "Bits), " 73152b89dd303424582d054e18417099f3a7e343b41Craig Topper << RC.getQualifiedName() + "RegClassID" << ", " 7328ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer << RC.SpillSize/8 << ", " 7338ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer << RC.SpillAlignment/8 << ", " 7348ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer << RC.CopyCost << ", " 73552b89dd303424582d054e18417099f3a7e343b41Craig Topper << RC.Allocatable << " },\n"; 7368ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer } 7378ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer 7388ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer OS << "};\n\n"; 7398ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer 740b3acdcc00c9dfb01663780e858e586cc5f04423fJim Grosbach ArrayRef<CodeGenSubRegIndex*> SubRegIndices = RegBank.getSubRegIndices(); 741b3acdcc00c9dfb01663780e858e586cc5f04423fJim Grosbach 742243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer EmitRegMappingTables(OS, Regs, false); 743243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 7440ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach // Emit Reg encoding table 7450ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach OS << "extern const uint16_t " << TargetName; 7460ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach OS << "RegEncodingTable[] = {\n"; 7470ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach // Add entry for NoRegister 7480ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach OS << " 0,\n"; 7490ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach for (unsigned i = 0, e = Regs.size(); i != e; ++i) { 7500ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach Record *Reg = Regs[i]->TheDef; 7510ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach BitsInit *BI = Reg->getValueAsBitsInit("HWEncoding"); 7520ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach uint64_t Value = 0; 7530ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach for (unsigned b = 0, be = BI->getNumBits(); b != be; ++b) { 7540ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(b))) 7550ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach Value |= (uint64_t)B->getValue() << b; 7560ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach } 7570ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach OS << " " << Value << ",\n"; 7580ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach } 7590ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach OS << "};\n"; // End of HW encoding table 7600ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach 76173f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng // MCRegisterInfo initialization routine. 76273f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "static inline void Init" << TargetName 7630e6a052331f674dd70e28af41f654a7874405eabEvan Cheng << "MCRegisterInfo(MCRegisterInfo *RI, unsigned RA, " 7640371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << "unsigned DwarfFlavour = 0, unsigned EHFlavour = 0) {\n" 7650371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << " RI->InitMCRegisterInfo(" << TargetName << "RegDesc, " 7668ca9a862038e8c4e9a2ca73b3b75e1be3425155fBenjamin Kramer << Regs.size()+1 << ", RA, " << TargetName << "MCRegisterClasses, " 767f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen << RegisterClasses.size() << ", " 768f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen << TargetName << "RegUnitRoots, " 769f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen << RegBank.getNumNativeRegUnits() << ", " 770f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen << TargetName << "RegDiffLists, " 7710371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << TargetName << "RegStrings, " 7720371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << TargetName << "SubRegIdxLists, " 7730371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << SubRegIndices.size() << ",\n" 7740371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << " " << TargetName << "RegEncodingTable);\n\n"; 7750e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 7760e6a052331f674dd70e28af41f654a7874405eabEvan Cheng EmitRegMapping(OS, Regs, false); 7770e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 7780e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "}\n\n"; 7790e6a052331f674dd70e28af41f654a7874405eabEvan Cheng 78073f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "} // End llvm namespace \n"; 78173f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "#endif // GET_REGINFO_MC_DESC\n\n"; 78273f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng} 783026dc223aeef2579d63f395007491e37d6cde3a0Jakob Stoklund Olesen 784ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Chengvoid 785ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan ChengRegisterInfoEmitter::runTargetHeader(raw_ostream &OS, CodeGenTarget &Target, 786ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng CodeGenRegBank &RegBank) { 7876f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen emitSourceFileHeader("Register Information Header Fragment", OS); 788ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 789ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng OS << "\n#ifdef GET_REGINFO_HEADER\n"; 790ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng OS << "#undef GET_REGINFO_HEADER\n"; 791ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 792ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng const std::string &TargetName = Target.getName(); 793ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng std::string ClassName = TargetName + "GenRegisterInfo"; 794ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 7959b1b25f0631b22cd09c2fa7383ce28721fa3e212Craig Topper OS << "#include \"llvm/Target/TargetRegisterInfo.h\"\n\n"; 796ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 797ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng OS << "namespace llvm {\n\n"; 798ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 799ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng OS << "struct " << ClassName << " : public TargetRegisterInfo {\n" 8000e6a052331f674dd70e28af41f654a7874405eabEvan Cheng << " explicit " << ClassName 8010e6a052331f674dd70e28af41f654a7874405eabEvan Cheng << "(unsigned RA, unsigned D = 0, unsigned E = 0);\n" 802ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng << " virtual bool needsStackRealignment(const MachineFunction &) const\n" 803309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << " { return false; }\n"; 804309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen if (!RegBank.getSubRegIndices().empty()) { 805309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen OS << " unsigned composeSubRegIndices(unsigned, unsigned) const;\n" 806309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << " const TargetRegisterClass *" 807dd63a063e2df0d0bc52b50732e3462fd58a636c0Jakob Stoklund Olesen "getSubClassWithSubReg(const TargetRegisterClass*, unsigned) const;\n"; 808309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen } 809309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen OS << " const RegClassWeight &getRegClassWeight(" 810ec14cd7ddc66d47cd7927f18d8c11844c400367eAndrew Trick << "const TargetRegisterClass *RC) const;\n" 811176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " unsigned getNumRegPressureSets() const;\n" 8127c0903a924b110dad0648e0b6cbdd2f38496fe28Andrew Trick << " const char *getRegPressureSetName(unsigned Idx) const;\n" 813176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " unsigned getRegPressureSetLimit(unsigned Idx) const;\n" 814176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << " const int *getRegClassPressureSets(" 815176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick << "const TargetRegisterClass *RC) const;\n" 816ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng << "};\n\n"; 817ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 81829f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> RegisterClasses = RegBank.getRegClasses(); 819ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 820ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng if (!RegisterClasses.empty()) { 82129f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen OS << "namespace " << RegisterClasses[0]->Namespace 822ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng << " { // Register classes\n"; 823ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 824ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) { 82529f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen const CodeGenRegisterClass &RC = *RegisterClasses[i]; 826ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng const std::string &Name = RC.getName(); 827ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 828ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng // Output the extern for the instance. 829ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << " extern const TargetRegisterClass " << Name << "RegClass;\n"; 830ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng } 831ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng OS << "} // end of namespace " << TargetName << "\n\n"; 832ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng } 833ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng OS << "} // End llvm namespace \n"; 834ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng OS << "#endif // GET_REGINFO_HEADER\n\n"; 835ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng} 836ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng 83773f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng// 83873f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng// runTargetDesc - Output the target register and register file descriptions. 83973f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng// 84073f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Chengvoid 84173f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan ChengRegisterInfoEmitter::runTargetDesc(raw_ostream &OS, CodeGenTarget &Target, 84273f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng CodeGenRegBank &RegBank){ 8436f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen emitSourceFileHeader("Target Register and Register Classes Information", OS); 84473f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng 84573f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "\n#ifdef GET_REGINFO_TARGET_DESC\n"; 84673f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "#undef GET_REGINFO_TARGET_DESC\n"; 84754d156d33324b7715453993f21684915a28e310aChris Lattner 8482c38413b3f5420f45f2f8220b21862246d446dd0Chris Lattner OS << "namespace llvm {\n\n"; 8492c38413b3f5420f45f2f8220b21862246d446dd0Chris Lattner 850f496d68493acf8d178afbbe8c3146ea09bd7776bBenjamin Kramer // Get access to MCRegisterClass data. 8511a2f9886a2a60dbd41216468a240446bbfed3e76Benjamin Kramer OS << "extern const MCRegisterClass " << Target.getName() 8521a2f9886a2a60dbd41216468a240446bbfed3e76Benjamin Kramer << "MCRegisterClasses[];\n"; 853f496d68493acf8d178afbbe8c3146ea09bd7776bBenjamin Kramer 854f462e3fac7ac67503657d63dc35330d0b19359b3Jakob Stoklund Olesen // Start out by emitting each of the register classes. 85529f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> RegisterClasses = RegBank.getRegClasses(); 8566a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen ArrayRef<CodeGenSubRegIndex*> SubRegIndices = RegBank.getSubRegIndices(); 8576a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen 858f462e3fac7ac67503657d63dc35330d0b19359b3Jakob Stoklund Olesen // Collect all registers belonging to any allocatable class. 859f462e3fac7ac67503657d63dc35330d0b19359b3Jakob Stoklund Olesen std::set<Record*> AllocatableRegs; 860f462e3fac7ac67503657d63dc35330d0b19359b3Jakob Stoklund Olesen 861f496d68493acf8d178afbbe8c3146ea09bd7776bBenjamin Kramer // Collect allocatable registers. 86254d156d33324b7715453993f21684915a28e310aChris Lattner for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) { 86329f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen const CodeGenRegisterClass &RC = *RegisterClasses[rc]; 864ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen ArrayRef<Record*> Order = RC.getOrder(); 865c7df109b6c4f7cbf8cc4dbee90291d4e452c7d56Chris Lattner 866f462e3fac7ac67503657d63dc35330d0b19359b3Jakob Stoklund Olesen if (RC.Allocatable) 867ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen AllocatableRegs.insert(Order.begin(), Order.end()); 86842de581b2f28985ec0c8fcbb26ab4d78c684247fChris Lattner } 8698d58e6a9be0ced7ad260449e882c5d2dcb5f4990Evan Cheng 8700d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen // Build a shared array of value types. 8710d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen SequenceToOffsetTable<std::vector<MVT::SimpleValueType> > VTSeqs; 8720d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) 8730d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen VTSeqs.add(RegisterClasses[rc]->VTs); 8740d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen VTSeqs.layout(); 8750d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen OS << "\nstatic const MVT::SimpleValueType VTLists[] = {\n"; 8760d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen VTSeqs.emit(OS, printSimpleValueType, "MVT::Other"); 8770d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen OS << "};\n"; 8785d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 8796a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // Emit SubRegIndex names, skipping 0 8806a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "\nstatic const char *const SubRegIndexTable[] = { \""; 8816a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen for (unsigned i = 0, e = SubRegIndices.size(); i != e; ++i) { 8826a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << SubRegIndices[i]->getName(); 8836a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen if (i+1 != e) 8846a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "\", \""; 8856a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen } 8866a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "\" };\n\n"; 8876a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen 8886a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "\n"; 8896a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen 89042de581b2f28985ec0c8fcbb26ab4d78c684247fChris Lattner // Now that all of the structs have been emitted, emit the instances. 89142de581b2f28985ec0c8fcbb26ab4d78c684247fChris Lattner if (!RegisterClasses.empty()) { 892ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << "\nstatic const TargetRegisterClass *const " 893ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer << "NullRegClasses[] = { NULL };\n\n"; 8941367fd09cb021bae61e7dd2ee208f76574c8e789Christopher Lamb 8956a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // Emit register class bit mask tables. The first bit mask emitted for a 8966a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // register class, RC, is the set of sub-classes, including RC itself. 8976a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // 8986a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // If RC has super-registers, also create a list of subreg indices and bit 8996a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // masks, (Idx, Mask). The bit mask has a bit for every superreg regclass, 9006a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // SuperRC, that satisfies: 9016a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // 9026a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // For all SuperReg in SuperRC: SuperReg:Idx in RC 9036a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // 9046a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // The 0-terminated list of subreg indices starts at: 9056a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // 9061a2a19dd3ce2b163837b5f0a1ea474c72527cad6Jakob Stoklund Olesen // RC->getSuperRegIndices() = SuperRegIdxSeqs + ... 9076a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // 9086a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // The corresponding bitmasks follow the sub-class mask in memory. Each 9096a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // mask has RCMaskWords uint32_t entries. 9106a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // 9116a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // Every bit mask present in the list has at least one bit set. 9128d58e6a9be0ced7ad260449e882c5d2dcb5f4990Evan Cheng 9136a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // Compress the sub-reg index lists. 9146a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen typedef std::vector<const CodeGenSubRegIndex*> IdxList; 9156a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen SmallVector<IdxList, 8> SuperRegIdxLists(RegisterClasses.size()); 9166a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen SequenceToOffsetTable<IdxList> SuperRegIdxSeqs; 9176a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen BitVector MaskBV(RegisterClasses.size()); 9188d58e6a9be0ced7ad260449e882c5d2dcb5f4990Evan Cheng 9196a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) { 9206a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen const CodeGenRegisterClass &RC = *RegisterClasses[rc]; 9216a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "static const uint32_t " << RC.getName() << "SubClassMask[] = {\n "; 922c8e2bb68bbc4a71cc10084c8f89565b9f05e12efJakob Stoklund Olesen printBitVectorAsHex(OS, RC.getSubClasses(), 32); 9236a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen 9246a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // Emit super-reg class masks for any relevant SubRegIndices that can 9256a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen // project into RC. 9266a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen IdxList &SRIList = SuperRegIdxLists[rc]; 9276a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen for (unsigned sri = 0, sre = SubRegIndices.size(); sri != sre; ++sri) { 9286a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen CodeGenSubRegIndex *Idx = SubRegIndices[sri]; 9296a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen MaskBV.reset(); 9306a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen RC.getSuperRegClasses(Idx, MaskBV); 9316a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen if (MaskBV.none()) 9326a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen continue; 9336a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen SRIList.push_back(Idx); 9346a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "\n "; 9356a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen printBitVectorAsHex(OS, MaskBV, 32); 9366a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "// " << Idx->getName(); 9376a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen } 9386a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen SuperRegIdxSeqs.add(SRIList); 939ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << "\n};\n\n"; 9408d58e6a9be0ced7ad260449e882c5d2dcb5f4990Evan Cheng } 9418d58e6a9be0ced7ad260449e882c5d2dcb5f4990Evan Cheng 9426a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "static const uint16_t SuperRegIdxSeqs[] = {\n"; 9436a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen SuperRegIdxSeqs.layout(); 9446a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen SuperRegIdxSeqs.emit(OS, printSubRegIndex); 9456a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen OS << "};\n\n"; 9466a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen 947f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // Emit NULL terminated super-class lists. 9482ca0efd71a5a25c1f3fa8b30dc5459fdaf8cd2a9Evan Cheng for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) { 94929f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen const CodeGenRegisterClass &RC = *RegisterClasses[rc]; 950f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen ArrayRef<CodeGenRegisterClass*> Supers = RC.getSuperClasses(); 9512ca0efd71a5a25c1f3fa8b30dc5459fdaf8cd2a9Evan Cheng 952f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen // Skip classes without supers. We can reuse NullRegClasses. 953f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen if (Supers.empty()) 954f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen continue; 9552ca0efd71a5a25c1f3fa8b30dc5459fdaf8cd2a9Evan Cheng 956ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << "static const TargetRegisterClass *const " 957f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen << RC.getName() << "Superclasses[] = {\n"; 958f9a4bb78dadc12c7c1e604c6f17b63a71305c2caJakob Stoklund Olesen for (unsigned i = 0; i != Supers.size(); ++i) 959ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << " &" << Supers[i]->getQualifiedName() << "RegClass,\n"; 960ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << " NULL\n};\n\n"; 9612ca0efd71a5a25c1f3fa8b30dc5459fdaf8cd2a9Evan Cheng } 9622ca0efd71a5a25c1f3fa8b30dc5459fdaf8cd2a9Evan Cheng 963b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen // Emit methods. 96460200e5d32f63b4e54575f5cbec348f3f9baeb5dChris Lattner for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) { 96529f018cee616e4082e5005bc9adee4dc777e621cJakob Stoklund Olesen const CodeGenRegisterClass &RC = *RegisterClasses[i]; 966b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen if (!RC.AltOrderSelect.empty()) { 967b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen OS << "\nstatic inline unsigned " << RC.getName() 968b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen << "AltOrderSelect(const MachineFunction &MF) {" 969ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer << RC.AltOrderSelect << "}\n\n" 970b6632ba380cf624e60fe16b03d6e21b05dd07724Craig Topper << "static ArrayRef<uint16_t> " << RC.getName() 971ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer << "GetRawAllocationOrder(const MachineFunction &MF) {\n"; 972b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen for (unsigned oi = 1 , oe = RC.getNumOrders(); oi != oe; ++oi) { 973b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen ArrayRef<Record*> Elems = RC.getOrder(oi); 974f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen if (!Elems.empty()) { 975b6632ba380cf624e60fe16b03d6e21b05dd07724Craig Topper OS << " static const uint16_t AltOrder" << oi << "[] = {"; 976f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen for (unsigned elem = 0; elem != Elems.size(); ++elem) 977f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen OS << (elem ? ", " : " ") << getQualifiedName(Elems[elem]); 978f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen OS << " };\n"; 979f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen } 980b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen } 981f496d68493acf8d178afbbe8c3146ea09bd7776bBenjamin Kramer OS << " const MCRegisterClass &MCR = " << Target.getName() 982f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen << "MCRegisterClasses[" << RC.getQualifiedName() + "RegClassID];\n" 983b6632ba380cf624e60fe16b03d6e21b05dd07724Craig Topper << " const ArrayRef<uint16_t> Order[] = {\n" 984f496d68493acf8d178afbbe8c3146ea09bd7776bBenjamin Kramer << " makeArrayRef(MCR.begin(), MCR.getNumRegs()"; 985b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen for (unsigned oi = 1, oe = RC.getNumOrders(); oi != oe; ++oi) 986f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen if (RC.getOrder(oi).empty()) 987b6632ba380cf624e60fe16b03d6e21b05dd07724Craig Topper OS << "),\n ArrayRef<uint16_t>("; 988f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen else 989f18a9a2314542ad3b7a601b86969073519e19b0dJakob Stoklund Olesen OS << "),\n makeArrayRef(AltOrder" << oi; 990b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen OS << ")\n };\n const unsigned Select = " << RC.getName() 991b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen << "AltOrderSelect(MF);\n assert(Select < " << RC.getNumOrders() 992b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen << ");\n return Order[Select];\n}\n"; 993b4c704877d1600852a55ab7bef2918a7c0af5e0dJakob Stoklund Olesen } 99460200e5d32f63b4e54575f5cbec348f3f9baeb5dChris Lattner } 9955d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 996ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer // Now emit the actual value-initialized register class instances. 997ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << "namespace " << RegisterClasses[0]->Namespace 998ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer << " { // Register class instances\n"; 999ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer 1000ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) { 1001ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer const CodeGenRegisterClass &RC = *RegisterClasses[i]; 1002ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << " extern const TargetRegisterClass " 1003ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer << RegisterClasses[i]->getName() << "RegClass = {\n " 1004ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer << '&' << Target.getName() << "MCRegisterClasses[" << RC.getName() 1005ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer << "RegClassID],\n " 10060d4e2ea00eac5d51a74a54dd504a8f34580041d7Jakob Stoklund Olesen << "VTLists + " << VTSeqs.get(RC.VTs) << ",\n " 10071a2a19dd3ce2b163837b5f0a1ea474c72527cad6Jakob Stoklund Olesen << RC.getName() << "SubClassMask,\n SuperRegIdxSeqs + " 10081a2a19dd3ce2b163837b5f0a1ea474c72527cad6Jakob Stoklund Olesen << SuperRegIdxSeqs.get(SuperRegIdxLists[i]) << ",\n "; 1009ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer if (RC.getSuperClasses().empty()) 1010ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << "NullRegClasses,\n "; 1011ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer else 1012ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << RC.getName() << "Superclasses,\n "; 1013ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer if (RC.AltOrderSelect.empty()) 1014ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << "0\n"; 1015ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer else 1016ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << RC.getName() << "GetRawAllocationOrder\n"; 1017ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer OS << " };\n\n"; 1018ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer } 1019ccc8d3ba06408feff0ca6e58973c20d15010e3fcBenjamin Kramer 102042de581b2f28985ec0c8fcbb26ab4d78c684247fChris Lattner OS << "}\n"; 10219fff8919eefa377936918eec763b392e59049353Chris Lattner } 10229fff8919eefa377936918eec763b392e59049353Chris Lattner 102342de581b2f28985ec0c8fcbb26ab4d78c684247fChris Lattner OS << "\nnamespace {\n"; 10249fff8919eefa377936918eec763b392e59049353Chris Lattner OS << " const TargetRegisterClass* const RegisterClasses[] = {\n"; 102542de581b2f28985ec0c8fcbb26ab4d78c684247fChris Lattner for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) 10266fea31e7300fe012b0b2984d6bc0338d02b054d3Jakob Stoklund Olesen OS << " &" << RegisterClasses[i]->getQualifiedName() 102760200e5d32f63b4e54575f5cbec348f3f9baeb5dChris Lattner << "RegClass,\n"; 10289fff8919eefa377936918eec763b392e59049353Chris Lattner OS << " };\n"; 1029c60f9b752381baa6c4b80c0739034660f1748c84Evan Cheng OS << "}\n"; // End of anonymous namespace... 103054d156d33324b7715453993f21684915a28e310aChris Lattner 1031a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng // Emit extra information about registers. 10326844f7bcdec8c2691c8d1067d90e4a02cf658c27Evan Cheng const std::string &TargetName = Target.getName(); 10339b1b25f0631b22cd09c2fa7383ce28721fa3e212Craig Topper OS << "\nstatic const TargetRegisterInfoDesc " 10349b1b25f0631b22cd09c2fa7383ce28721fa3e212Craig Topper << TargetName << "RegInfoDesc[] = { // Extra Descriptors\n"; 10359b1b25f0631b22cd09c2fa7383ce28721fa3e212Craig Topper OS << " { 0, 0 },\n"; 103626693113201f4c9d441678e50d96f38d3288798eChris Lattner 1037a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng const std::vector<CodeGenRegister*> &Regs = RegBank.getRegisters(); 103876f0ad7bf5c05d6056b3bf335d0c3fb7e72de5d6Jakob Stoklund Olesen for (unsigned i = 0, e = Regs.size(); i != e; ++i) { 1039abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen const CodeGenRegister &Reg = *Regs[i]; 10409b1b25f0631b22cd09c2fa7383ce28721fa3e212Craig Topper OS << " { "; 1041a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng OS << Reg.CostPerUse << ", " 1042f462e3fac7ac67503657d63dc35330d0b19359b3Jakob Stoklund Olesen << int(AllocatableRegs.count(Reg.TheDef)) << " },\n"; 10439fff8919eefa377936918eec763b392e59049353Chris Lattner } 10449b1b25f0631b22cd09c2fa7383ce28721fa3e212Craig Topper OS << "};\n"; // End of register descriptors... 10451fc8e759a767077726f9be35b93767e68bdf101fJakob Stoklund Olesen 1046a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng 10477884b750c33b750177b3f22af75c874c97f728d8Chris Lattner std::string ClassName = Target.getName() + "GenRegisterInfo"; 10483da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 10497c9a6e328407d681414aa66f3e80f92c3d35ad5cJakob Stoklund Olesen // Emit composeSubRegIndices 1050309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen if (!SubRegIndices.empty()) { 1051309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen OS << "unsigned " << ClassName 1052309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << "::composeSubRegIndices(unsigned IdxA, unsigned IdxB) const {\n" 1053309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << " switch (IdxA) {\n" 1054309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << " default:\n return IdxB;\n"; 1055309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen for (unsigned i = 0, e = SubRegIndices.size(); i != e; ++i) { 1056309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen bool Open = false; 1057309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen for (unsigned j = 0; j != e; ++j) { 1058309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen if (CodeGenSubRegIndex *Comp = 105990498b195ba759cf4f2a98da4e46fb9a2b580396Jakob Stoklund Olesen SubRegIndices[i]->compose(SubRegIndices[j])) { 1060309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen if (!Open) { 1061309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen OS << " case " << SubRegIndices[i]->getQualifiedName() 1062309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << ": switch(IdxB) {\n default: return IdxB;\n"; 1063309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen Open = true; 1064309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen } 1065309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen OS << " case " << SubRegIndices[j]->getQualifiedName() 1066309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << ": return " << Comp->getQualifiedName() << ";\n"; 10677c9a6e328407d681414aa66f3e80f92c3d35ad5cJakob Stoklund Olesen } 10687c9a6e328407d681414aa66f3e80f92c3d35ad5cJakob Stoklund Olesen } 1069309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen if (Open) 1070309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen OS << " }\n"; 10717c9a6e328407d681414aa66f3e80f92c3d35ad5cJakob Stoklund Olesen } 1072309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen OS << " }\n}\n\n"; 10737c9a6e328407d681414aa66f3e80f92c3d35ad5cJakob Stoklund Olesen } 10747c9a6e328407d681414aa66f3e80f92c3d35ad5cJakob Stoklund Olesen 1075845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen // Emit getSubClassWithSubReg. 1076309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen if (!SubRegIndices.empty()) { 1077309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen OS << "const TargetRegisterClass *" << ClassName 1078309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << "::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx)" 1079309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << " const {\n"; 1080845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen // Use the smallest type that can hold a regclass ID with room for a 1081845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen // sentinel. 1082845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen if (RegisterClasses.size() < UINT8_MAX) 1083845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen OS << " static const uint8_t Table["; 1084845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen else if (RegisterClasses.size() < UINT16_MAX) 1085845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen OS << " static const uint16_t Table["; 1086845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen else 1087845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen throw "Too many register classes."; 1088845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen OS << RegisterClasses.size() << "][" << SubRegIndices.size() << "] = {\n"; 1089845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen for (unsigned rci = 0, rce = RegisterClasses.size(); rci != rce; ++rci) { 1090845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen const CodeGenRegisterClass &RC = *RegisterClasses[rci]; 1091845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen OS << " {\t// " << RC.getName() << "\n"; 1092845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen for (unsigned sri = 0, sre = SubRegIndices.size(); sri != sre; ++sri) { 10935fcc156344e0d38fa5f5eab3d9193b859b27b45eJakob Stoklund Olesen CodeGenSubRegIndex *Idx = SubRegIndices[sri]; 1094845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen if (CodeGenRegisterClass *SRC = RC.getSubClassWithSubReg(Idx)) 1095845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen OS << " " << SRC->EnumValue + 1 << ",\t// " << Idx->getName() 1096845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen << " -> " << SRC->getName() << "\n"; 1097845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen else 1098845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen OS << " 0,\t// " << Idx->getName() << "\n"; 1099845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen } 1100845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen OS << " },\n"; 1101845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen } 1102845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen OS << " };\n assert(RC && \"Missing regclass\");\n" 1103845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen << " if (!Idx) return RC;\n --Idx;\n" 1104845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen << " assert(Idx < " << SubRegIndices.size() << " && \"Bad subreg\");\n" 1105845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen << " unsigned TV = Table[RC->getID()][Idx];\n" 1106309076ff76c61e03ddd3a0fbbfded3042d2da2e5Jakob Stoklund Olesen << " return TV ? getRegClass(TV - 1) : 0;\n}\n\n"; 1107845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen } 1108845d2c0c776abce551d16f7b1b7dc1f4d4df1a27Jakob Stoklund Olesen 1109176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick EmitRegUnitPressure(OS, RegBank, ClassName); 1110176194d4ee2774bc135ababc5bd6c6c9f606b2a5Andrew Trick 11119fff8919eefa377936918eec763b392e59049353Chris Lattner // Emit the constructor of the class... 11121a2f9886a2a60dbd41216468a240446bbfed3e76Benjamin Kramer OS << "extern const MCRegisterDesc " << TargetName << "RegDesc[];\n"; 1113f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen OS << "extern const uint16_t " << TargetName << "RegDiffLists[];\n"; 1114d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen OS << "extern const char " << TargetName << "RegStrings[];\n"; 1115f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen OS << "extern const uint16_t " << TargetName << "RegUnitRoots[][2];\n"; 11160371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen OS << "extern const uint16_t " << TargetName << "SubRegIdxLists[];\n"; 11170ee07e013095e8c298fbcc5203e0bc9f334e15e1Jim Grosbach OS << "extern const uint16_t " << TargetName << "RegEncodingTable[];\n"; 1118c60f9b752381baa6c4b80c0739034660f1748c84Evan Cheng 1119243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer EmitRegMappingTables(OS, Regs, true); 1120243018ffcf764e4dde2968f909f4a2e578aafe86Benjamin Kramer 1121b3acdcc00c9dfb01663780e858e586cc5f04423fJim Grosbach OS << ClassName << "::\n" << ClassName 11220e6a052331f674dd70e28af41f654a7874405eabEvan Cheng << "(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour)\n" 11236844f7bcdec8c2691c8d1067d90e4a02cf658c27Evan Cheng << " : TargetRegisterInfo(" << TargetName << "RegInfoDesc" 11241fc8e759a767077726f9be35b93767e68bdf101fJakob Stoklund Olesen << ", RegisterClasses, RegisterClasses+" << RegisterClasses.size() <<",\n" 11256a0ed18532425d637ecc1cc851c559db446ec4e8Jakob Stoklund Olesen << " SubRegIndexTable) {\n" 11266844f7bcdec8c2691c8d1067d90e4a02cf658c27Evan Cheng << " InitMCRegisterInfo(" << TargetName << "RegDesc, " 1127b3acdcc00c9dfb01663780e858e586cc5f04423fJim Grosbach << Regs.size()+1 << ", RA,\n " << TargetName 1128b3acdcc00c9dfb01663780e858e586cc5f04423fJim Grosbach << "MCRegisterClasses, " << RegisterClasses.size() << ",\n" 1129f5d4e5158fcbec26d1c243daa725878ca1ae560bJakob Stoklund Olesen << " " << TargetName << "RegUnitRoots,\n" 1130f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen << " " << RegBank.getNumNativeRegUnits() << ",\n" 1131f52baf72c116d9cf8680d25a8e751ce354c7d44bJakob Stoklund Olesen << " " << TargetName << "RegDiffLists,\n" 1132d5ce3ffa67698b9d21f58011f370a210a214d301Jakob Stoklund Olesen << " " << TargetName << "RegStrings,\n" 11330371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << " " << TargetName << "SubRegIdxLists,\n" 11340371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << " " << SubRegIndices.size() << ",\n" 11350371cd8b1c0d2101295ca9381a0b437e1f2d8fa2Jakob Stoklund Olesen << " " << TargetName << "RegEncodingTable);\n\n"; 11365d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 11370e6a052331f674dd70e28af41f654a7874405eabEvan Cheng EmitRegMapping(OS, Regs, true); 11385d4314ef720630e6547fe41efec1608d4c14c78eJim Grosbach 11390e6a052331f674dd70e28af41f654a7874405eabEvan Cheng OS << "}\n\n"; 11404794797f1213c4096a6f5ff2b6841dd5866b22baChris Lattner 1141ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen 1142ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // Emit CalleeSavedRegs information. 1143ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen std::vector<Record*> CSRSets = 1144ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen Records.getAllDerivedDefinitions("CalleeSavedRegs"); 1145ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen for (unsigned i = 0, e = CSRSets.size(); i != e; ++i) { 1146ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen Record *CSRSet = CSRSets[i]; 1147ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen const SetTheory::RecVec *Regs = RegBank.getSets().expand(CSRSet); 1148ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen assert(Regs && "Cannot expand CalleeSavedRegs instance"); 1149ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen 1150ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // Emit the *_SaveList list of callee-saved registers. 1151015f228861ef9b337366f92f637d4e8d624bb006Craig Topper OS << "static const uint16_t " << CSRSet->getName() 1152ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen << "_SaveList[] = { "; 1153ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen for (unsigned r = 0, re = Regs->size(); r != re; ++r) 1154ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen OS << getQualifiedName((*Regs)[r]) << ", "; 1155ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen OS << "0 };\n"; 1156ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen 1157ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen // Emit the *_RegMask bit mask of call-preserved registers. 1158ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen OS << "static const uint32_t " << CSRSet->getName() 1159ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen << "_RegMask[] = { "; 1160ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen printBitVectorAsHex(OS, RegBank.computeCoveredRegisters(*Regs), 32); 1161ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen OS << "};\n"; 1162ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen } 1163ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen OS << "\n\n"; 1164ec572539dd5660f9ca42027ac04df3a3f8c0cab1Jakob Stoklund Olesen 11652c38413b3f5420f45f2f8220b21862246d446dd0Chris Lattner OS << "} // End llvm namespace \n"; 116673f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng OS << "#endif // GET_REGINFO_TARGET_DESC\n\n"; 11673112326c88b7090f770c4ff8a1546ef84fd2e8bbChris Lattner} 1168a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng 116973f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Chengvoid RegisterInfoEmitter::run(raw_ostream &OS) { 1170a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng CodeGenTarget Target(Records); 1171a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng CodeGenRegBank &RegBank = Target.getRegBank(); 1172a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng RegBank.computeDerivedInfo(); 1173a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng 117473f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng runEnums(OS, Target, RegBank); 117573f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng runMCDesc(OS, Target, RegBank); 1176ebbbfd0e2eeeb5b1a15f0e655a0a2119510713d4Evan Cheng runTargetHeader(OS, Target, RegBank); 117773f50d9bc3bd46cc0abeba9bb0d46977ba1aea42Evan Cheng runTargetDesc(OS, Target, RegBank); 1178a347f85dbeee37a7f2bb68df1a7d4cdfbb7b576dEvan Cheng} 11796f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 11806f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesennamespace llvm { 11816f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 11826f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesenvoid EmitRegisterInfo(RecordKeeper &RK, raw_ostream &OS) { 11836f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen RegisterInfoEmitter(RK).run(OS); 11846f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen} 11856f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen 11866f36fa981a59461466e12e5056ba209d289b81b1Jakob Stoklund Olesen} // End llvm namespace 1187