1 //===- RegisterInfoEmitter.cpp - Generate a Register File Desc. -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This tablegen backend is responsible for emitting a description of a target
11 // register file for a code generator. It uses instances of the Register,
12 // RegisterAliases, and RegisterClass classes to gather this information.
14 //===----------------------------------------------------------------------===//
16 #include "RegisterInfoEmitter.h"
17 #include "CodeGenTarget.h"
18 #include "CodeGenRegisters.h"
20 #include "llvm/ADT/StringExtras.h"
21 #include "llvm/ADT/STLExtras.h"
25 // runEnums - Print out enum values for all of the registers.
26 void RegisterInfoEmitter::runEnums(std::ostream &OS) {
28 const std::vector<CodeGenRegister> &Registers = Target.getRegisters();
30 std::string Namespace = Registers[0].TheDef->getValueAsString("Namespace");
32 EmitSourceFileHeader("Target Register Enum Values", OS);
33 OS << "namespace llvm {\n\n";
35 if (!Namespace.empty())
36 OS << "namespace " << Namespace << " {\n";
37 OS << " enum {\n NoRegister,\n";
39 for (unsigned i = 0, e = Registers.size(); i != e; ++i)
40 OS << " " << Registers[i].getName() << ", \t// " << i+1 << "\n";
43 if (!Namespace.empty())
45 OS << "} // End llvm namespace \n";
48 void RegisterInfoEmitter::runHeader(std::ostream &OS) {
49 EmitSourceFileHeader("Register Information Header Fragment", OS);
51 const std::string &TargetName = Target.getName();
52 std::string ClassName = TargetName + "GenRegisterInfo";
54 OS << "#include \"llvm/Target/MRegisterInfo.h\"\n";
55 OS << "#include <string>\n\n";
57 OS << "namespace llvm {\n\n";
59 OS << "struct " << ClassName << " : public MRegisterInfo {\n"
61 << "(int CallFrameSetupOpcode = -1, int CallFrameDestroyOpcode = -1);\n"
62 << " const unsigned* getCalleeSaveRegs() const;\n"
63 << " const TargetRegisterClass* const *getCalleeSaveRegClasses() const;\n"
64 << " int getDwarfRegNum(unsigned RegNum) const;\n"
67 const std::vector<CodeGenRegisterClass> &RegisterClasses =
68 Target.getRegisterClasses();
70 if (!RegisterClasses.empty()) {
71 OS << "namespace " << RegisterClasses[0].Namespace
72 << " { // Register classes\n";
73 for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) {
74 const std::string &Name = RegisterClasses[i].getName();
76 // Output the register class definition.
77 OS << " struct " << Name << "Class : public TargetRegisterClass {\n"
78 << " " << Name << "Class();\n"
79 << RegisterClasses[i].MethodProtos << " };\n";
81 // Output the extern for the instance.
82 OS << " extern " << Name << "Class\t" << Name << "RegClass;\n";
83 // Output the extern for the pointer to the instance (should remove).
84 OS << " static TargetRegisterClass * const "<< Name <<"RegisterClass = &"
85 << Name << "RegClass;\n";
87 OS << "} // end of namespace " << TargetName << "\n\n";
89 OS << "} // End llvm namespace \n";
92 bool isSubRegisterClass(const CodeGenRegisterClass &RC,
93 std::set<Record*> &RegSet) {
94 for (unsigned i = 0, e = RC.Elements.size(); i != e; ++i) {
95 Record *Reg = RC.Elements[i];
96 if (!RegSet.count(Reg))
102 // RegisterInfoEmitter::run - Main register file description emitter.
104 void RegisterInfoEmitter::run(std::ostream &OS) {
105 CodeGenTarget Target;
106 EmitSourceFileHeader("Register Information Source Fragment", OS);
108 OS << "namespace llvm {\n\n";
110 // Start out by emitting each of the register classes... to do this, we build
111 // a set of registers which belong to a register class, this is to ensure that
112 // each register is only in a single register class.
114 const std::vector<CodeGenRegisterClass> &RegisterClasses =
115 Target.getRegisterClasses();
117 // Loop over all of the register classes... emitting each one.
118 OS << "namespace { // Register classes...\n";
120 // RegClassesBelongedTo - Keep track of which register classes each reg
122 std::multimap<Record*, const CodeGenRegisterClass*> RegClassesBelongedTo;
124 // Emit the register enum value arrays for each RegisterClass
125 for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
126 const CodeGenRegisterClass &RC = RegisterClasses[rc];
128 // Give the register class a legal C name if it's anonymous.
129 std::string Name = RC.TheDef->getName();
131 // Emit the register list now.
132 OS << " // " << Name << " Register Class...\n const unsigned " << Name
134 for (unsigned i = 0, e = RC.Elements.size(); i != e; ++i) {
135 Record *Reg = RC.Elements[i];
136 OS << getQualifiedName(Reg) << ", ";
138 // Keep track of which regclasses this register is in.
139 RegClassesBelongedTo.insert(std::make_pair(Reg, &RC));
144 // Emit the ValueType arrays for each RegisterClass
145 for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
146 const CodeGenRegisterClass &RC = RegisterClasses[rc];
148 // Give the register class a legal C name if it's anonymous.
149 std::string Name = RC.TheDef->getName() + "VTs";
151 // Emit the register list now.
153 << " Register Class Value Types...\n const MVT::ValueType " << Name
155 for (unsigned i = 0, e = RC.VTs.size(); i != e; ++i)
156 OS << "MVT::" << RC.VTs[i] << ", ";
157 OS << "MVT::Other\n };\n\n";
159 OS << "} // end anonymous namespace\n\n";
161 // Now that all of the structs have been emitted, emit the instances.
162 if (!RegisterClasses.empty()) {
163 OS << "namespace " << RegisterClasses[0].Namespace
164 << " { // Register class instances\n";
165 for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i)
166 OS << " " << RegisterClasses[i].getName() << "Class\t"
167 << RegisterClasses[i].getName() << "RegClass;\n";
169 std::map<unsigned, std::set<unsigned> > SuperClassMap;
171 // Emit the sub-classes array for each RegisterClass
172 for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
173 const CodeGenRegisterClass &RC = RegisterClasses[rc];
175 // Give the register class a legal C name if it's anonymous.
176 std::string Name = RC.TheDef->getName();
178 std::set<Record*> RegSet;
179 for (unsigned i = 0, e = RC.Elements.size(); i != e; ++i) {
180 Record *Reg = RC.Elements[i];
185 << " Register Class sub-classes...\n const TargetRegisterClass* "
186 << Name << "Subclasses [] = {\n ";
189 for (unsigned rc2 = 0, e2 = RegisterClasses.size(); rc2 != e2; ++rc2) {
190 const CodeGenRegisterClass &RC2 = RegisterClasses[rc2];
191 if (rc == rc2 || RC2.Elements.size() > RC.Elements.size() ||
192 RC.SpillSize != RC2.SpillSize || !isSubRegisterClass(RC2, RegSet))
195 if (!Empty) OS << ", ";
196 OS << "&" << getQualifiedName(RC2.TheDef) << "RegClass";
199 std::map<unsigned, std::set<unsigned> >::iterator SCMI =
200 SuperClassMap.find(rc2);
201 if (SCMI == SuperClassMap.end()) {
202 SuperClassMap.insert(std::make_pair(rc2, std::set<unsigned>()));
203 SCMI = SuperClassMap.find(rc2);
205 SCMI->second.insert(rc);
208 OS << (!Empty ? ", " : "") << "NULL";
212 for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
213 const CodeGenRegisterClass &RC = RegisterClasses[rc];
215 // Give the register class a legal C name if it's anonymous.
216 std::string Name = RC.TheDef->getName();
219 << " Register Class super-classes...\n const TargetRegisterClass* "
220 << Name << "Superclasses [] = {\n ";
223 std::map<unsigned, std::set<unsigned> >::iterator I =
224 SuperClassMap.find(rc);
225 if (I != SuperClassMap.end()) {
226 for (std::set<unsigned>::iterator II = I->second.begin(),
227 EE = I->second.end(); II != EE; ++II) {
228 const CodeGenRegisterClass &RC2 = RegisterClasses[*II];
229 if (!Empty) OS << ", ";
230 OS << "&" << getQualifiedName(RC2.TheDef) << "RegClass";
235 OS << (!Empty ? ", " : "") << "NULL";
240 for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) {
241 const CodeGenRegisterClass &RC = RegisterClasses[i];
242 OS << RC.MethodBodies << "\n";
243 OS << RC.getName() << "Class::" << RC.getName()
244 << "Class() : TargetRegisterClass("
245 << RC.getName() + "VTs" << ", "
246 << RC.getName() + "Subclasses" << ", "
247 << RC.getName() + "Superclasses" << ", "
248 << RC.SpillSize/8 << ", "
249 << RC.SpillAlignment/8 << ", " << RC.getName() << ", "
250 << RC.getName() << " + " << RC.Elements.size() << ") {}\n";
256 OS << "\nnamespace {\n";
257 OS << " const TargetRegisterClass* const RegisterClasses[] = {\n";
258 for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i)
259 OS << " &" << getQualifiedName(RegisterClasses[i].TheDef)
263 // Emit register class aliases...
264 std::map<Record*, std::set<Record*> > RegisterAliases;
265 const std::vector<CodeGenRegister> &Regs = Target.getRegisters();
267 for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
268 Record *R = Regs[i].TheDef;
269 std::vector<Record*> LI = Regs[i].TheDef->getValueAsListOfDefs("Aliases");
270 // Add information that R aliases all of the elements in the list... and
271 // that everything in the list aliases R.
272 for (unsigned j = 0, e = LI.size(); j != e; ++j) {
274 if (RegisterAliases[R].count(Reg))
275 std::cerr << "Warning: register alias between " << getQualifiedName(R)
276 << " and " << getQualifiedName(Reg)
277 << " specified multiple times!\n";
278 RegisterAliases[R].insert(Reg);
280 if (RegisterAliases[Reg].count(R))
281 std::cerr << "Warning: register alias between " << getQualifiedName(R)
282 << " and " << getQualifiedName(Reg)
283 << " specified multiple times!\n";
284 RegisterAliases[Reg].insert(R);
288 if (!RegisterAliases.empty())
289 OS << "\n\n // Register Alias Sets...\n";
291 // Emit the empty alias list
292 OS << " const unsigned Empty_AliasSet[] = { 0 };\n";
293 // Loop over all of the registers which have aliases, emitting the alias list
295 for (std::map<Record*, std::set<Record*> >::iterator
296 I = RegisterAliases.begin(), E = RegisterAliases.end(); I != E; ++I) {
297 OS << " const unsigned " << I->first->getName() << "_AliasSet[] = { ";
298 for (std::set<Record*>::iterator ASI = I->second.begin(),
299 E = I->second.end(); ASI != E; ++ASI)
300 OS << getQualifiedName(*ASI) << ", ";
304 OS<<"\n const TargetRegisterDesc RegisterDescriptors[] = { // Descriptors\n";
305 OS << " { \"NOREG\",\t0 },\n";
308 // Now that register alias sets have been emitted, emit the register
310 const std::vector<CodeGenRegister> &Registers = Target.getRegisters();
311 for (unsigned i = 0, e = Registers.size(); i != e; ++i) {
312 const CodeGenRegister &Reg = Registers[i];
314 if (!Reg.TheDef->getValueAsString("Name").empty())
315 OS << Reg.TheDef->getValueAsString("Name");
319 if (RegisterAliases.count(Reg.TheDef))
320 OS << Reg.getName() << "_AliasSet },\n";
322 OS << "Empty_AliasSet },\n";
324 OS << " };\n"; // End of register descriptors...
325 OS << "}\n\n"; // End of anonymous namespace...
327 std::string ClassName = Target.getName() + "GenRegisterInfo";
329 // Emit the constructor of the class...
330 OS << ClassName << "::" << ClassName
331 << "(int CallFrameSetupOpcode, int CallFrameDestroyOpcode)\n"
332 << " : MRegisterInfo(RegisterDescriptors, " << Registers.size()+1
333 << ", RegisterClasses, RegisterClasses+" << RegisterClasses.size() <<",\n "
334 << " CallFrameSetupOpcode, CallFrameDestroyOpcode) {}\n\n";
336 // Emit the getCalleeSaveRegs method.
337 OS << "const unsigned* " << ClassName << "::getCalleeSaveRegs() const {\n"
338 << " static const unsigned CalleeSaveRegs[] = {\n ";
340 const std::vector<Record*> &CSR = Target.getCalleeSavedRegisters();
341 for (unsigned i = 0, e = CSR.size(); i != e; ++i)
342 OS << getQualifiedName(CSR[i]) << ", ";
343 OS << " 0\n };\n return CalleeSaveRegs;\n}\n\n";
345 // Emit information about the callee saved register classes.
346 OS << "const TargetRegisterClass* const*\n" << ClassName
347 << "::getCalleeSaveRegClasses() const {\n"
348 << " static const TargetRegisterClass * const "
349 << "CalleeSaveRegClasses[] = {\n ";
351 for (unsigned i = 0, e = CSR.size(); i != e; ++i) {
353 std::multimap<Record*, const CodeGenRegisterClass*>::iterator I, E;
354 tie(I, E) = RegClassesBelongedTo.equal_range(R);
356 throw "Callee saved register '" + R->getName() +
357 "' must belong to a register class for spilling.\n";
358 const CodeGenRegisterClass *RC = (I++)->second;
360 if (RC->SpillSize < I->second->SpillSize)
362 OS << "&" << getQualifiedName(RC->TheDef) << "RegClass, ";
364 OS << " 0\n };\n return CalleeSaveRegClasses;\n}\n\n";
366 // Emit information about the dwarf register numbers.
367 OS << "int " << ClassName << "::getDwarfRegNum(unsigned RegNum) const {\n";
368 OS << " static const int DwarfRegNums[] = { -1, // NoRegister";
369 for (unsigned i = 0, e = Registers.size(); i != e; ++i) {
370 if (!(i % 16)) OS << "\n ";
371 const CodeGenRegister &Reg = Registers[i];
372 int DwarfRegNum = Reg.TheDef->getValueAsInt("DwarfNumber");
374 if ((i + 1) != e) OS << ", ";
377 OS << " assert(RegNum < (sizeof(DwarfRegNums)/sizeof(int)) &&\n";
378 OS << " \"RegNum exceeds number of registers\");\n";
379 OS << " return DwarfRegNums[RegNum];\n";
382 OS << "} // End llvm namespace \n";