1//===- RegisterInfoEmitter.cpp - Generate a Register File Desc. -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This tablegen backend is responsible for emitting a description of a target
10// register file for a code generator. It uses instances of the Register,
11// RegisterAliases, and RegisterClass classes to gather this information.
12//
13//===----------------------------------------------------------------------===//
14
15#include "Basic/SequenceToOffsetTable.h"
16#include "Common/CodeGenHwModes.h"
17#include "Common/CodeGenRegisters.h"
18#include "Common/CodeGenTarget.h"
19#include "Common/InfoByHwMode.h"
20#include "Common/Types.h"
21#include "llvm/ADT/ArrayRef.h"
22#include "llvm/ADT/BitVector.h"
23#include "llvm/ADT/DenseMap.h"
24#include "llvm/ADT/STLExtras.h"
25#include "llvm/ADT/SetVector.h"
26#include "llvm/ADT/SmallVector.h"
27#include "llvm/ADT/SparseBitVector.h"
28#include "llvm/ADT/Statistic.h"
29#include "llvm/ADT/Twine.h"
30#include "llvm/CodeGenTypes/MachineValueType.h"
31#include "llvm/Support/Casting.h"
32#include "llvm/Support/CommandLine.h"
33#include "llvm/Support/Format.h"
34#include "llvm/Support/FormatVariadic.h"
35#include "llvm/Support/Printable.h"
36#include "llvm/Support/raw_ostream.h"
37#include "llvm/TableGen/CodeGenHelpers.h"
38#include "llvm/TableGen/Error.h"
39#include "llvm/TableGen/Record.h"
40#include "llvm/TableGen/SetTheory.h"
41#include "llvm/TableGen/TGTimer.h"
42#include "llvm/TableGen/TableGenBackend.h"
43#include <algorithm>
44#include <cassert>
45#include <cstddef>
46#include <cstdint>
47#include <deque>
48#include <iterator>
49#include <set>
50#include <string>
51#include <vector>
52
53using namespace llvm;
54
55#define DEBUG_TYPE "register-info-emitter"
56
57STATISTIC(NumExplicitRegClasses, "Number of explicit register classes");
58STATISTIC(NumSynthesizedRegClasses, "Number of synthesized register classes");
59STATISTIC(NumRegPressureSets, "Number of register pressure sets");
60
61static cl::OptionCategory RegisterInfoCat("Options for -gen-register-info");
62
63static cl::opt<bool>
64 RegisterInfoDebug("register-info-debug", cl::init(Val: false),
65 cl::desc("Dump register information to help debugging"),
66 cl::cat(RegisterInfoCat));
67
68namespace {
69
70class RegisterInfoEmitter {
71 const RecordKeeper &Records;
72 const CodeGenTarget Target;
73 CodeGenRegBank &RegBank;
74
75 std::string MCRegisterClassStorageType;
76
77public:
78 RegisterInfoEmitter(const RecordKeeper &R)
79 : Records(R), Target(R), RegBank(Target.getRegBank()) {
80 RegBank.computeDerivedInfo();
81
82 const auto &RegClasses = RegBank.getRegClasses();
83 NumExplicitRegClasses =
84 llvm::count_if(Range: RegClasses, P: [](const CodeGenRegisterClass &RC) {
85 return RC.getDef() != nullptr;
86 });
87 NumSynthesizedRegClasses = RegClasses.size() - NumExplicitRegClasses;
88 NumRegPressureSets = RegBank.getNumRegPressureSets();
89 }
90
91 // runEnums - Print out enum values for all of the registers.
92 void runEnums(raw_ostream &OS, raw_ostream &MainOS, StringRef FilenamePrefix);
93
94 // runMCDesc - Print out MC register descriptions.
95 void runMCDesc(raw_ostream &OS, raw_ostream &MainOS,
96 StringRef FilenamePrefix);
97
98 // runTargetHeader - Emit a header fragment for the register info emitter.
99 void runTargetHeader(raw_ostream &OS, raw_ostream &MainOS,
100 StringRef FilenamePrefix);
101
102 // runTargetDesc - Output the target register and register file descriptions.
103 void runTargetDesc(raw_ostream &OS, raw_ostream &MainOS,
104 StringRef FilenamePrefix);
105
106 // run - Output the register file description.
107 TableGenOutputFiles run(StringRef FilenamePrefix);
108
109 template <typename InfoTy, typename FnTy>
110 Printable printByHwMode(const InfoByHwMode<InfoTy> &Info, FnTy Func);
111
112 void debugDump(raw_ostream &OS);
113
114private:
115 void EmitRegMapping(raw_ostream &OS, const std::deque<CodeGenRegister> &Regs,
116 bool isCtor);
117 void EmitRegMappingTables(raw_ostream &OS,
118 const std::deque<CodeGenRegister> &Regs,
119 bool isCtor);
120 void EmitRegUnitPressure(raw_ostream &OS, StringRef ClassName);
121 void emitComposeSubRegIndices(raw_ostream &OS, StringRef ClassName);
122 void emitComposeSubRegIndexLaneMask(raw_ostream &OS, StringRef ClassName);
123};
124
125} // end anonymous namespace
126
127static void emitInclude(StringRef FilenamePrefix, StringRef IncludeFile,
128 StringRef GuardMacro, raw_ostream &OS) {
129 IfDefEmitter IfDed(OS, GuardMacro);
130 OS << "#include \"" << FilenamePrefix << IncludeFile << "\"\n";
131}
132
133// runEnums - Print out enum values for all of the registers.
134void RegisterInfoEmitter::runEnums(raw_ostream &OS, raw_ostream &MainOS,
135 StringRef FilenamePrefix) {
136 emitInclude(FilenamePrefix, IncludeFile: "Enums.inc", GuardMacro: "GET_REGINFO_ENUM", OS&: MainOS);
137
138 const auto &Registers = RegBank.getRegisters();
139
140 // Register enums are stored as uint16_t in the tables. Make sure we'll fit.
141 assert(Registers.size() <= 0xffff && "Too many regs to fit in tables");
142
143 StringRef Namespace = Registers.front().TheDef->getValueAsString(FieldName: "Namespace");
144
145 emitSourceFileHeader(Desc: "Target Register Enum Values", OS);
146
147 NamespaceEmitter LlvmNS(OS, "llvm");
148
149 OS << "class MCRegisterClass;\n";
150 OS << "const MCRegisterClass &get" << Target.getName()
151 << "MCRegisterClass(unsigned RC);\n";
152
153 {
154 NamespaceEmitter RegNS(OS, Namespace);
155 OS << "enum : unsigned {\n NoRegister,\n";
156
157 for (const auto &Reg : Registers)
158 OS << " " << Reg.getName() << " = " << Reg.EnumValue << ",\n";
159 assert(Registers.size() == Registers.back().EnumValue &&
160 "Register enum value mismatch!");
161 OS << " NUM_TARGET_REGS // " << Registers.size() + 1 << "\n";
162 OS << "};\n";
163 }
164
165 const auto &RegisterClasses = RegBank.getRegClasses();
166 if (!RegisterClasses.empty()) {
167 // RegisterClass enums are stored as uint16_t in the tables.
168 assert(RegisterClasses.size() <= UINT16_MAX &&
169 "Too many register classes to fit in tables");
170
171 OS << "\n// Register classes\n\n";
172 NamespaceEmitter RegNS(OS, Namespace);
173 OS << "enum {\n";
174 for (const auto &RC : RegisterClasses)
175 OS << " " << RC.getIdName() << " = " << RC.EnumValue << ",\n";
176 OS << "\n};\n";
177 }
178
179 ArrayRef<const Record *> RegAltNameIndices = Target.getRegAltNameIndices();
180 // If the only definition is the default NoRegAltName, we don't need to
181 // emit anything.
182 if (RegAltNameIndices.size() > 1) {
183 OS << "\n// Register alternate name indices\n\n";
184 NamespaceEmitter RegNS(OS, Namespace);
185 OS << "enum {\n";
186 for (unsigned i = 0, e = RegAltNameIndices.size(); i != e; ++i)
187 OS << " " << RegAltNameIndices[i]->getName() << ",\t// " << i << "\n";
188 OS << " NUM_TARGET_REG_ALT_NAMES = " << RegAltNameIndices.size() << "\n";
189 OS << "};\n";
190 }
191
192 auto &SubRegIndices = RegBank.getSubRegIndices();
193 if (!SubRegIndices.empty()) {
194 OS << "\n// Subregister indices\n\n";
195 NamespaceEmitter SubRegNS(OS, SubRegIndices.front().getNamespace());
196 OS << "enum : uint16_t {\n NoSubRegister,\n";
197 unsigned i = 0;
198 for (const auto &Idx : SubRegIndices)
199 OS << " " << Idx.getName() << ",\t// " << ++i << "\n";
200 OS << " NUM_TARGET_SUBREGS\n};\n";
201 }
202
203 {
204 OS << "// Register pressure sets enum.\n";
205 NamespaceEmitter RegNS(OS, Namespace);
206 OS << "enum RegisterPressureSets {\n";
207 unsigned NumSets = RegBank.getNumRegPressureSets();
208 for (unsigned i = 0; i < NumSets; ++i) {
209 const RegUnitSet &RegUnits = RegBank.getRegSetAt(Order: i);
210 OS << " " << RegUnits.Name << " = " << i << ",\n";
211 }
212 OS << "};\n";
213 }
214
215 // Note: While these functions are not enums, we need to define them in the
216 // same place as <TARGET>::<REG>, so that the assembly parser can use them
217 // without having to include <TARGETT>RegisterInfo.h, which may not be
218 // possible due to build system structure.
219 ArrayRef<const Record *> RegisterByHwModeRecords =
220 Records.getAllDerivedDefinitions(ClassName: "RegisterByHwMode");
221 if (!RegisterByHwModeRecords.empty()) {
222 OS << "// Registers by HwMode\n";
223 OS << "class MCRegister;\n";
224 NamespaceEmitter RegClassNS(OS, Namespace + "::RegisterByHwMode");
225 // Define the getters for the RegisterByHwMode in one globally accessible
226 // location so they can be reused by all callers.
227 for (const Record *Rec : RegisterByHwModeRecords) {
228 OS << "LLVM_READONLY MCRegister get" << Rec->getName()
229 << "(unsigned HwMode);\n";
230 }
231 }
232}
233
234static void printInt(raw_ostream &OS, int Val) { OS << Val; }
235
236void RegisterInfoEmitter::EmitRegUnitPressure(raw_ostream &OS,
237 StringRef ClassName) {
238 unsigned NumRCs = RegBank.getRegClasses().size();
239 unsigned NumSets = RegBank.getNumRegPressureSets();
240 std::vector<std::pair<const CodeGenRegisterClass *, unsigned>> PSetRegClasses(
241 NumSets);
242
243 OS << "/// Get the weight in units of pressure for this register class.\n"
244 << "const RegClassWeight &" << ClassName << "::\n"
245 << "getRegClassWeight(const TargetRegisterClass *RC) const {\n"
246 << " static const RegClassWeight RCWeightTable[] = {\n";
247 for (const auto &[RCIdx, RC] : enumerate(First&: RegBank.getRegClasses())) {
248 const CodeGenRegister::Vec &Regs = RC.getMembers();
249 OS << " {" << RC.getWeight(RegBank) << ", ";
250 unsigned WeightLimit = 0;
251 if (Regs.empty() || RC.Artificial)
252 OS << '0';
253 else {
254 std::vector<unsigned> RegUnits;
255 RC.buildRegUnitSet(RegBank, RegUnits);
256 WeightLimit = RegBank.getRegUnitSetWeight(Units: RegUnits);
257 OS << WeightLimit;
258 }
259 OS << "}, \t// " << RC.getName() << "\n";
260 for (unsigned PSetID : RegBank.getRCPressureSetIDs(RCIdx)) {
261 unsigned PSetIdx = RegBank.getRegPressureSet(Idx: PSetID).Order;
262 auto &[LargestRC, LargestWeightLimit] = PSetRegClasses[PSetIdx];
263 if (!LargestRC || WeightLimit > LargestWeightLimit) {
264 LargestRC = &RC;
265 LargestWeightLimit = WeightLimit;
266 }
267 }
268 }
269 OS << " };\n"
270 << " return RCWeightTable[RC->getID()];\n"
271 << "}\n\n";
272
273 // Reasonable targets (not ARMv7) have unit weight for all units, so don't
274 // bother generating a table.
275 bool RegUnitsHaveUnitWeight = true;
276 for (unsigned UnitIdx = 0, UnitEnd = RegBank.getNumNativeRegUnits();
277 UnitIdx < UnitEnd; ++UnitIdx) {
278 if (RegBank.getRegUnit(RUID: UnitIdx).Weight > 1)
279 RegUnitsHaveUnitWeight = false;
280 }
281 OS << "/// Get the weight in units of pressure for this register unit.\n"
282 << "unsigned " << ClassName << "::\n"
283 << "getRegUnitWeight(MCRegUnit RegUnit) const {\n"
284 << " assert(static_cast<unsigned>(RegUnit) < "
285 << RegBank.getNumNativeRegUnits() << " && \"invalid register unit\");\n";
286 if (!RegUnitsHaveUnitWeight) {
287 OS << " static const uint8_t RUWeightTable[] = {\n ";
288 for (unsigned UnitIdx = 0, UnitEnd = RegBank.getNumNativeRegUnits();
289 UnitIdx < UnitEnd; ++UnitIdx) {
290 const RegUnit &RU = RegBank.getRegUnit(RUID: UnitIdx);
291 assert(RU.Weight < 256 && "RegUnit too heavy");
292 OS << RU.Weight << ", ";
293 }
294 OS << "};\n"
295 << " return RUWeightTable[static_cast<unsigned>(RegUnit)];\n";
296 } else {
297 OS << " // All register units have unit weight.\n"
298 << " return 1;\n";
299 }
300 OS << "}\n\n";
301
302 OS << "\n"
303 << "// Get the number of dimensions of register pressure.\n"
304 << "unsigned " << ClassName << "::getNumRegPressureSets() const {\n"
305 << " return " << NumSets << ";\n}\n\n";
306
307 OS << "// Get the name of this register unit pressure set.\n"
308 << "const char *" << ClassName << "::\n"
309 << "getRegPressureSetName(unsigned Idx) const {\n"
310 << " static const char *PressureNameTable[] = {\n";
311 unsigned MaxRegUnitWeight = 0;
312 for (unsigned i = 0; i < NumSets; ++i) {
313 const RegUnitSet &RegUnits = RegBank.getRegSetAt(Order: i);
314 MaxRegUnitWeight = std::max(a: MaxRegUnitWeight, b: RegUnits.Weight);
315 OS << " \"" << RegUnits.Name << "\",\n";
316 }
317 OS << " };\n"
318 << " return PressureNameTable[Idx];\n"
319 << "}\n\n";
320
321 OS << "// Get the register unit pressure limit for this dimension.\n"
322 << "// This limit must be adjusted dynamically for reserved registers.\n"
323 << "unsigned " << ClassName << "::\n"
324 << "getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const "
325 "{\n"
326 << " static const " << getMinimalTypeForRange(Range: MaxRegUnitWeight, MaxSize: 32)
327 << " PressureLimitTable[] = {\n";
328 for (unsigned i = 0; i < NumSets; ++i) {
329 const RegUnitSet &RegUnits = RegBank.getRegSetAt(Order: i);
330 OS << " " << RegUnits.Weight << ", \t// " << i << ": " << RegUnits.Name
331 << "\n";
332 }
333 OS << " };\n"
334 << " return PressureLimitTable[Idx];\n"
335 << "}\n\n";
336
337 OS << "/// Get the register class for this pressure set with the largest\n"
338 << "/// `RegClassWeight::WeightLimit`.\n"
339 << "const TargetRegisterClass *" << ClassName << "::\n"
340 << "getLargestRegClassForRegPressureSet(unsigned Idx) const {\n"
341 << " static const " << getMinimalTypeForRange(Range: NumRCs - 1, MaxSize: 32)
342 << " PSetRegClassTable[] = {\n";
343 for (unsigned i = 0; i < NumSets; ++i) {
344 const CodeGenRegisterClass *RC = PSetRegClasses[i].first;
345 assert(RC && "register pressure set has no register class");
346 OS << " " << RC->getQualifiedIdName() << ", \t// " << i << ": "
347 << RegBank.getRegSetAt(Order: i).Name << "\n";
348 }
349 OS << " };\n"
350 << " return getRegClass(PSetRegClassTable[Idx]);\n"
351 << "}\n\n";
352
353 SequenceToOffsetTable<std::vector<int>> PSetsSeqs(/*Terminator=*/-1);
354
355 // This table may be larger than NumRCs if some register units needed a list
356 // of unit sets that did not correspond to a register class.
357 unsigned NumRCUnitSets = RegBank.getNumRegClassPressureSetLists();
358 std::vector<std::vector<int>> PSets(NumRCUnitSets);
359
360 for (unsigned i = 0, e = NumRCUnitSets; i != e; ++i) {
361 ArrayRef<unsigned> PSetIDs = RegBank.getRCPressureSetIDs(RCIdx: i);
362 PSets[i].reserve(n: PSetIDs.size());
363 for (unsigned PSetID : PSetIDs) {
364 PSets[i].push_back(x: RegBank.getRegPressureSet(Idx: PSetID).Order);
365 }
366 llvm::sort(C&: PSets[i]);
367 PSetsSeqs.add(Seq: PSets[i]);
368 }
369
370 PSetsSeqs.layout();
371
372 OS << "/// Table of pressure sets per register class or unit.\n"
373 << "static const int RCSetsTable[] = {\n";
374 PSetsSeqs.emit(OS, Print: printInt);
375 OS << "};\n\n";
376
377 OS << "/// Get the dimensions of register pressure impacted by this "
378 << "register class.\n"
379 << "/// Returns a -1 terminated array of pressure set IDs\n"
380 << "const int *" << ClassName << "::\n"
381 << "getRegClassPressureSets(const TargetRegisterClass *RC) const {\n";
382 OS << " static const " << getMinimalTypeForRange(Range: PSetsSeqs.size() - 1, MaxSize: 32)
383 << " RCSetStartTable[] = {\n ";
384 for (unsigned i = 0, e = NumRCs; i != e; ++i) {
385 OS << PSetsSeqs.get(Seq: PSets[i]) << ",";
386 }
387 OS << "};\n"
388 << " return &RCSetsTable[RCSetStartTable[RC->getID()]];\n"
389 << "}\n\n";
390
391 OS << "/// Get the dimensions of register pressure impacted by this "
392 << "register unit.\n"
393 << "/// Returns a -1 terminated array of pressure set IDs\n"
394 << "const int *" << ClassName << "::\n"
395 << "getRegUnitPressureSets(MCRegUnit RegUnit) const {\n"
396 << " assert(static_cast<unsigned>(RegUnit) < "
397 << RegBank.getNumNativeRegUnits() << " && \"invalid register unit\");\n";
398 OS << " static const " << getMinimalTypeForRange(Range: PSetsSeqs.size() - 1, MaxSize: 32)
399 << " RUSetStartTable[] = {\n ";
400 for (unsigned UnitIdx = 0, UnitEnd = RegBank.getNumNativeRegUnits();
401 UnitIdx < UnitEnd; ++UnitIdx) {
402 OS << PSetsSeqs.get(Seq: PSets[RegBank.getRegUnit(RUID: UnitIdx).RegClassUnitSetsIdx])
403 << ",";
404 }
405 OS << "};\n"
406 << " return "
407 "&RCSetsTable[RUSetStartTable[static_cast<unsigned>(RegUnit)]];\n"
408 << "}\n\n";
409}
410
411using DwarfRegNumsMapPair = std::pair<const Record *, std::vector<int64_t>>;
412using DwarfRegNumsVecTy = std::vector<DwarfRegNumsMapPair>;
413
414static void finalizeDwarfRegNumsKeys(DwarfRegNumsVecTy &DwarfRegNums) {
415 // Sort and unique to get a map-like vector. We want the last assignment to
416 // match previous behaviour.
417 llvm::stable_sort(Range&: DwarfRegNums, C: on_first<LessRecordRegister>());
418 // Warn about duplicate assignments.
419 const Record *LastSeenReg = nullptr;
420 for (const auto &X : DwarfRegNums) {
421 const auto &Reg = X.first;
422 // The only way LessRecordRegister can return equal is if they're the same
423 // string. Use simple equality instead.
424 if (LastSeenReg && Reg->getName() == LastSeenReg->getName())
425 PrintWarning(WarningLoc: Reg->getLoc(), Msg: Twine("DWARF numbers for register ") +
426 getQualifiedName(R: Reg) +
427 "specified multiple times");
428 LastSeenReg = Reg;
429 }
430 auto Last = llvm::unique(R&: DwarfRegNums, P: [](const DwarfRegNumsMapPair &A,
431 const DwarfRegNumsMapPair &B) {
432 return A.first->getName() == B.first->getName();
433 });
434 DwarfRegNums.erase(first: Last, last: DwarfRegNums.end());
435}
436
437void RegisterInfoEmitter::EmitRegMappingTables(
438 raw_ostream &OS, const std::deque<CodeGenRegister> &Regs, bool isCtor) {
439 // Collect all information about dwarf register numbers
440 DwarfRegNumsVecTy DwarfRegNums;
441
442 // First, just pull all provided information to the map
443 unsigned maxLength = 0;
444 for (auto &RE : Regs) {
445 const Record *Reg = RE.TheDef;
446 std::vector<int64_t> RegNums = Reg->getValueAsListOfInts(FieldName: "DwarfNumbers");
447 maxLength = std::max(a: (size_t)maxLength, b: RegNums.size());
448 DwarfRegNums.emplace_back(args&: Reg, args: std::move(RegNums));
449 }
450 finalizeDwarfRegNumsKeys(DwarfRegNums);
451
452 if (!maxLength)
453 return;
454
455 // Now we know maximal length of number list. Append -1's, where needed
456 for (auto &DwarfRegNum : DwarfRegNums)
457 for (unsigned I = DwarfRegNum.second.size(), E = maxLength; I != E; ++I)
458 DwarfRegNum.second.push_back(x: -1);
459
460 StringRef Namespace = Regs.front().TheDef->getValueAsString(FieldName: "Namespace");
461
462 OS << "// " << Namespace << " Dwarf<->LLVM register mappings.\n";
463
464 // Emit reverse information about the dwarf register numbers.
465 for (unsigned j = 0; j < 2; ++j) {
466 for (unsigned I = 0, E = maxLength; I != E; ++I) {
467 OS << "extern const MCRegisterInfo::DwarfLLVMRegPair " << Namespace;
468 OS << (j == 0 ? "DwarfFlavour" : "EHFlavour");
469 OS << I << "Dwarf2L[]";
470
471 if (!isCtor) {
472 OS << " = {\n";
473
474 // Store the mapping sorted by the LLVM reg num so lookup can be done
475 // with a binary search.
476 std::map<uint64_t, const Record *> Dwarf2LMap;
477 for (auto &DwarfRegNum : DwarfRegNums) {
478 int DwarfRegNo = DwarfRegNum.second[I];
479 if (DwarfRegNo < 0)
480 continue;
481 Dwarf2LMap[DwarfRegNo] = DwarfRegNum.first;
482 }
483
484 for (auto &I : Dwarf2LMap)
485 OS << " { " << I.first << "U, " << getQualifiedName(R: I.second)
486 << " },\n";
487
488 OS << "};\n";
489 } else {
490 OS << ";\n";
491 }
492
493 // We have to store the size in a const global, it's used in multiple
494 // places.
495 OS << "extern const unsigned " << Namespace
496 << (j == 0 ? "DwarfFlavour" : "EHFlavour") << I << "Dwarf2LSize";
497 if (!isCtor)
498 OS << " = std::size(" << Namespace
499 << (j == 0 ? "DwarfFlavour" : "EHFlavour") << I << "Dwarf2L);\n\n";
500 else
501 OS << ";\n\n";
502 }
503 }
504
505 for (auto &RE : Regs) {
506 const Record *Reg = RE.TheDef;
507 const RecordVal *V = Reg->getValue(Name: "DwarfAlias");
508 if (!V)
509 continue;
510
511 const DefInit *DI = cast<DefInit>(Val: V->getValue());
512 const Record *Alias = DI->getDef();
513 const auto &AliasIter = llvm::lower_bound(
514 Range&: DwarfRegNums, Value&: Alias, C: [](const DwarfRegNumsMapPair &A, const Record *B) {
515 return LessRecordRegister()(A.first, B);
516 });
517 assert(AliasIter != DwarfRegNums.end() && AliasIter->first == Alias &&
518 "Expected Alias to be present in map");
519 const auto &RegIter = llvm::lower_bound(
520 Range&: DwarfRegNums, Value&: Reg, C: [](const DwarfRegNumsMapPair &A, const Record *B) {
521 return LessRecordRegister()(A.first, B);
522 });
523 assert(RegIter != DwarfRegNums.end() && RegIter->first == Reg &&
524 "Expected Reg to be present in map");
525 RegIter->second = AliasIter->second;
526 }
527
528 // Emit information about the dwarf register numbers.
529 for (unsigned j = 0; j < 2; ++j) {
530 for (unsigned i = 0, e = maxLength; i != e; ++i) {
531 OS << "extern const MCRegisterInfo::DwarfLLVMRegPair " << Namespace;
532 OS << (j == 0 ? "DwarfFlavour" : "EHFlavour");
533 OS << i << "L2Dwarf[]";
534 if (!isCtor) {
535 OS << " = {\n";
536 // Store the mapping sorted by the Dwarf reg num so lookup can be done
537 // with a binary search.
538 for (auto &DwarfRegNum : DwarfRegNums) {
539 int RegNo = DwarfRegNum.second[i];
540 if (RegNo == -1) // -1 is the default value, don't emit a mapping.
541 continue;
542
543 OS << " { " << getQualifiedName(R: DwarfRegNum.first) << ", " << RegNo
544 << "U },\n";
545 }
546 OS << "};\n";
547 } else {
548 OS << ";\n";
549 }
550
551 // We have to store the size in a const global, it's used in multiple
552 // places.
553 OS << "extern const unsigned " << Namespace
554 << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i << "L2DwarfSize";
555 if (!isCtor)
556 OS << " = std::size(" << Namespace
557 << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i << "L2Dwarf);\n\n";
558 else
559 OS << ";\n\n";
560 }
561 }
562}
563
564void RegisterInfoEmitter::EmitRegMapping(
565 raw_ostream &OS, const std::deque<CodeGenRegister> &Regs, bool isCtor) {
566 // Emit the initializer so the tables from EmitRegMappingTables get wired up
567 // to the MCRegisterInfo object.
568 unsigned maxLength = 0;
569 for (auto &RE : Regs) {
570 const Record *Reg = RE.TheDef;
571 maxLength = std::max(a: (size_t)maxLength,
572 b: Reg->getValueAsListOfInts(FieldName: "DwarfNumbers").size());
573 }
574
575 if (!maxLength)
576 return;
577
578 StringRef Namespace = Regs.front().TheDef->getValueAsString(FieldName: "Namespace");
579
580 // Emit reverse information about the dwarf register numbers.
581 for (unsigned j = 0; j < 2; ++j) {
582 OS << " switch (";
583 if (j == 0)
584 OS << "DwarfFlavour";
585 else
586 OS << "EHFlavour";
587 OS << ") {\n"
588 << " default:\n"
589 << " llvm_unreachable(\"Unknown DWARF flavour\");\n";
590
591 for (unsigned i = 0, e = maxLength; i != e; ++i) {
592 OS << " case " << i << ":\n";
593 OS << " ";
594 if (!isCtor)
595 OS << "RI->";
596 std::string Tmp;
597 raw_string_ostream(Tmp)
598 << Namespace << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i
599 << "Dwarf2L";
600 OS << "mapDwarfRegsToLLVMRegs(" << Tmp << ", " << Tmp << "Size, ";
601 if (j == 0)
602 OS << "false";
603 else
604 OS << "true";
605 OS << ");\n";
606 OS << " break;\n";
607 }
608 OS << " }\n";
609 }
610
611 // Emit information about the dwarf register numbers.
612 for (unsigned j = 0; j < 2; ++j) {
613 OS << " switch (";
614 if (j == 0)
615 OS << "DwarfFlavour";
616 else
617 OS << "EHFlavour";
618 OS << ") {\n"
619 << " default:\n"
620 << " llvm_unreachable(\"Unknown DWARF flavour\");\n";
621
622 for (unsigned i = 0, e = maxLength; i != e; ++i) {
623 OS << " case " << i << ":\n";
624 OS << " ";
625 if (!isCtor)
626 OS << "RI->";
627 std::string Tmp;
628 raw_string_ostream(Tmp)
629 << Namespace << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i
630 << "L2Dwarf";
631 OS << "mapLLVMRegsToDwarfRegs(" << Tmp << ", " << Tmp << "Size, ";
632 if (j == 0)
633 OS << "false";
634 else
635 OS << "true";
636 OS << ");\n";
637 OS << " break;\n";
638 }
639 OS << " }\n";
640 }
641}
642
643// Print a BitVector as a sequence of hex numbers using a little-endian mapping.
644// Width is the number of bits per hex number.
645static void printBitVectorAsHex(raw_ostream &OS, const BitVector &Bits,
646 unsigned Width) {
647 assert(Width <= 32 && "Width too large");
648 unsigned Digits = (Width + 3) / 4;
649 for (unsigned i = 0, e = Bits.size(); i < e; i += Width) {
650 unsigned Value = 0;
651 for (unsigned j = 0; j != Width && i + j != e; ++j)
652 Value |= Bits.test(Idx: i + j) << j;
653 OS << format(Fmt: "0x%0*x, ", Vals: Digits, Vals: Value);
654 }
655}
656
657// Helper to emit a set of bits into a constant byte array.
658class BitVectorEmitter {
659 BitVector Values;
660
661public:
662 void add(unsigned v) {
663 if (v >= Values.size())
664 Values.resize(N: ((v / 8) + 1) * 8); // Round up to the next byte.
665 Values[v] = true;
666 }
667
668 unsigned byteSize() const { return (Values.size() + 7) / 8; }
669
670 void print(raw_ostream &OS) { printBitVectorAsHex(OS, Bits: Values, Width: 8); }
671};
672
673static void printSimpleValueType(raw_ostream &OS, MVT VT) {
674 OS << getEnumName(T: VT);
675}
676
677static void printSubRegIndex(raw_ostream &OS, const CodeGenSubRegIndex *Idx) {
678 OS << (Idx ? Idx->EnumValue : 0);
679}
680
681// Differentially encoded register and regunit lists allow for better
682// compression on regular register banks. The sequence is computed from the
683// differential list as:
684//
685// out[0] = InitVal;
686// out[n+1] = out[n] + diff[n]; // n = 0, 1, ...
687//
688// The initial value depends on the specific list. The list is terminated by a
689// 0 differential which means we can't encode repeated elements.
690
691using DiffVec = SmallVector<int16_t, 4>;
692using MaskVec = SmallVector<LaneBitmask, 4>;
693
694// Fills V with differentials between every two consecutive elements of List.
695static DiffVec &diffEncode(DiffVec &V, SparseBitVector<> List) {
696 assert(V.empty() && "Clear DiffVec before diffEncode.");
697 V.reserve(N: List.count());
698 SparseBitVector<>::iterator I = List.begin(), E = List.end();
699 unsigned Val = *I;
700 while (++I != E) {
701 unsigned Cur = *I;
702 V.push_back(Elt: Cur - Val);
703 Val = Cur;
704 }
705 return V;
706}
707
708template <typename Iter>
709static DiffVec &diffEncode(DiffVec &V, unsigned InitVal, Iter Begin, Iter End) {
710 assert(V.empty() && "Clear DiffVec before diffEncode.");
711 V.reserve(N: std::distance(Begin, End));
712 unsigned Val = InitVal;
713 for (Iter I = Begin; I != End; ++I) {
714 unsigned Cur = (*I)->EnumValue;
715 V.push_back(Elt: Cur - Val);
716 Val = Cur;
717 }
718 return V;
719}
720
721static void printDiff16(raw_ostream &OS, int16_t Val) { OS << Val; }
722
723static void printMask(raw_ostream &OS, LaneBitmask Val) {
724 OS << "LaneBitmask(0x" << PrintLaneMask(LaneMask: Val) << ')';
725}
726
727// Print the offset of a register class storage member relative to the class
728// with the given index, as MCRegisterClass reads it.
729static void printStorageOffset(raw_ostream &OS, StringRef TargetName,
730 StringRef Member, unsigned DataIdx,
731 unsigned ClassIdx) {
732 OS << "offsetof(" << TargetName << "RegisterClassStorage, " << Member << "["
733 << DataIdx << "]) - " << ClassIdx << " * sizeof(MCRegisterClass)";
734}
735
736// Try to combine Idx's compose map into Vec if it is compatible.
737// Return false if it's not possible.
738static bool combine(const CodeGenSubRegIndex *Idx,
739 SmallVectorImpl<const CodeGenSubRegIndex *> &Vec) {
740 const CodeGenSubRegIndex::CompMap &Map = Idx->getComposites();
741 for (const auto &I : Map) {
742 const CodeGenSubRegIndex *&Entry = Vec[I.first->EnumValue - 1];
743 if (Entry && Entry != I.second)
744 return false;
745 }
746
747 // All entries are compatible. Make it so.
748 for (const auto &I : Map) {
749 const CodeGenSubRegIndex *&Entry = Vec[I.first->EnumValue - 1];
750 assert((!Entry || Entry == I.second) && "Expected EnumValue to be unique");
751 Entry = I.second;
752 }
753 return true;
754}
755
756void RegisterInfoEmitter::emitComposeSubRegIndices(raw_ostream &OS,
757 StringRef ClassName) {
758 const auto &SubRegIndices = RegBank.getSubRegIndices();
759
760 // Many sub-register indexes are composition-compatible, meaning that
761 //
762 // compose(IdxA, IdxB) == compose(IdxA', IdxB)
763 //
764 // for many IdxA, IdxA' pairs. Not all sub-register indexes can be composed.
765 // The illegal entries can be use as wildcards to compress the table further.
766
767 // Map each Sub-register index to a compatible table row.
768 SmallVector<unsigned, 4> RowMap;
769 SmallVector<SmallVector<const CodeGenSubRegIndex *, 4>, 4> Rows;
770
771 size_t SubRegIndicesSize = llvm::size(Range: SubRegIndices);
772 for (const auto &Idx : SubRegIndices) {
773 unsigned Found = ~0u;
774 for (unsigned r = 0, re = Rows.size(); r != re; ++r) {
775 if (combine(Idx: &Idx, Vec&: Rows[r])) {
776 Found = r;
777 break;
778 }
779 }
780 if (Found == ~0u) {
781 Found = Rows.size();
782 Rows.resize(N: Found + 1);
783 Rows.back().resize(N: SubRegIndicesSize);
784 combine(Idx: &Idx, Vec&: Rows.back());
785 }
786 RowMap.push_back(Elt: Found);
787 }
788
789 OS << "unsigned " << ClassName
790 << "::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {\n";
791
792 // Output the row map if there are multiple rows.
793 if (Rows.size() > 1) {
794 OS << " static const " << getMinimalTypeForRange(Range: Rows.size(), MaxSize: 32)
795 << " RowMap[" << SubRegIndicesSize << "] = {\n ";
796 for (unsigned i = 0, e = SubRegIndicesSize; i != e; ++i)
797 OS << RowMap[i] << ", ";
798 OS << "\n };\n";
799 }
800
801 // Output the rows.
802 OS << " static const " << getMinimalTypeForRange(Range: SubRegIndicesSize + 1, MaxSize: 32)
803 << " Rows[" << Rows.size() << "][" << SubRegIndicesSize << "] = {\n";
804 for (const auto &Row : Rows) {
805 OS << " { ";
806 for (const llvm::CodeGenSubRegIndex *Elem :
807 ArrayRef(&Row[0], SubRegIndicesSize))
808 if (Elem)
809 OS << Elem->getQualifiedName() << ", ";
810 else
811 OS << "0, ";
812 OS << "},\n";
813 }
814 OS << " };\n\n";
815
816 OS << " --IdxA; assert(IdxA < " << SubRegIndicesSize << "); (void) IdxA;\n"
817 << " --IdxB; assert(IdxB < " << SubRegIndicesSize << ");\n";
818 if (Rows.size() > 1)
819 OS << " return Rows[RowMap[IdxA]][IdxB];\n";
820 else
821 OS << " return Rows[0][IdxB];\n";
822 OS << "}\n\n";
823
824 // Generate the reverse case.
825 //
826 // FIXME: This is the brute force approach. Compress the table similar to the
827 // forward case.
828 OS << "unsigned " << ClassName
829 << "::reverseComposeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const "
830 "{\n";
831 OS << " static const " << getMinimalTypeForRange(Range: SubRegIndicesSize + 1, MaxSize: 32)
832 << " Table[" << SubRegIndicesSize << "][" << SubRegIndicesSize
833 << "] = {\n";
834
835 // Find values where composeSubReg(A, X) == B;
836 for (const auto &IdxA : SubRegIndices) {
837 OS << " { ";
838
839 SmallVectorImpl<const CodeGenSubRegIndex *> &Row =
840 Rows[RowMap[IdxA.EnumValue - 1]];
841 for (const auto &IdxB : SubRegIndices) {
842 const CodeGenSubRegIndex *FoundReverse = nullptr;
843
844 for (unsigned i = 0, e = SubRegIndicesSize; i != e; ++i) {
845 const CodeGenSubRegIndex *This = &SubRegIndices[i];
846 const CodeGenSubRegIndex *Composed = Row[i];
847 if (Composed == &IdxB) {
848 if (FoundReverse && FoundReverse != This) // Not unique
849 break;
850 FoundReverse = This;
851 }
852 }
853
854 if (FoundReverse) {
855 OS << FoundReverse->getQualifiedName() << ", ";
856 } else {
857 OS << "0, ";
858 }
859 }
860 OS << "},\n";
861 }
862
863 OS << " };\n\n";
864 OS << " --IdxA; assert(IdxA < " << SubRegIndicesSize << ");\n"
865 << " --IdxB; assert(IdxB < " << SubRegIndicesSize << ");\n";
866 OS << " return Table[IdxA][IdxB];\n";
867 OS << " }\n\n";
868}
869
870void RegisterInfoEmitter::emitComposeSubRegIndexLaneMask(raw_ostream &OS,
871 StringRef ClassName) {
872 // See the comments in computeSubRegLaneMasks() for our goal here.
873 const auto &SubRegIndices = RegBank.getSubRegIndices();
874
875 // Create a list of Mask+Rotate operations, with equivalent entries merged.
876 SmallVector<unsigned, 4> SubReg2SequenceIndexMap;
877 SmallVector<SmallVector<MaskRolPair, 1>, 4> Sequences;
878 for (const auto &Idx : SubRegIndices) {
879 const SmallVector<MaskRolPair, 1> &IdxSequence =
880 Idx.CompositionLaneMaskTransform;
881
882 unsigned Found = ~0u;
883 unsigned SIdx = 0;
884 unsigned NextSIdx;
885 for (size_t s = 0, se = Sequences.size(); s != se; ++s, SIdx = NextSIdx) {
886 SmallVectorImpl<MaskRolPair> &Sequence = Sequences[s];
887 NextSIdx = SIdx + Sequence.size() + 1;
888 if (Sequence == IdxSequence) {
889 Found = SIdx;
890 break;
891 }
892 }
893 if (Found == ~0u) {
894 Sequences.push_back(Elt: IdxSequence);
895 Found = SIdx;
896 }
897 SubReg2SequenceIndexMap.push_back(Elt: Found);
898 }
899
900 OS << " struct MaskRolOp {\n"
901 " LaneBitmask Mask;\n"
902 " uint8_t RotateLeft;\n"
903 " };\n"
904 " static const MaskRolOp LaneMaskComposeSequences[] = {\n";
905 unsigned Idx = 0;
906 for (size_t s = 0, se = Sequences.size(); s != se; ++s) {
907 OS << " ";
908 const SmallVectorImpl<MaskRolPair> &Sequence = Sequences[s];
909 for (const MaskRolPair &P : Sequence) {
910 printMask(OS&: OS << "{ ", Val: P.Mask);
911 OS << format(Fmt: ", %2u }, ", Vals: P.RotateLeft);
912 }
913 OS << "{ LaneBitmask::getNone(), 0 }";
914 if (s + 1 != se)
915 OS << ", ";
916 OS << " // Sequence " << Idx << "\n";
917 Idx += Sequence.size() + 1;
918 }
919 auto *IntType =
920 getMinimalTypeForRange(Range: *llvm::max_element(Range&: SubReg2SequenceIndexMap));
921 OS << " };\n"
922 " static const "
923 << IntType << " CompositeSequences[] = {\n";
924 for (size_t i = 0, e = SubRegIndices.size(); i != e; ++i) {
925 OS << " ";
926 OS << SubReg2SequenceIndexMap[i];
927 if (i + 1 != e)
928 OS << ",";
929 OS << " // to " << SubRegIndices[i].getName() << "\n";
930 }
931 OS << " };\n\n";
932
933 OS << "LaneBitmask " << ClassName
934 << "::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask)"
935 " const {\n"
936 " --IdxA; assert(IdxA < "
937 << SubRegIndices.size()
938 << " && \"Subregister index out of bounds\");\n"
939 " LaneBitmask Result;\n"
940 " for (const MaskRolOp *Ops =\n"
941 " &LaneMaskComposeSequences[CompositeSequences[IdxA]];\n"
942 " Ops->Mask.any(); ++Ops) {\n"
943 " LaneBitmask::Type M = LaneMask.getAsInteger() & "
944 "Ops->Mask.getAsInteger();\n"
945 " if (unsigned S = Ops->RotateLeft)\n"
946 " Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - "
947 "S)));\n"
948 " else\n"
949 " Result |= LaneBitmask(M);\n"
950 " }\n"
951 " return Result;\n"
952 "}\n\n";
953
954 OS << "LaneBitmask " << ClassName
955 << "::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA, "
956 " LaneBitmask LaneMask) const {\n"
957 " LaneMask &= getSubRegIndexLaneMask(IdxA);\n"
958 " --IdxA; assert(IdxA < "
959 << SubRegIndices.size()
960 << " && \"Subregister index out of bounds\");\n"
961 " LaneBitmask Result;\n"
962 " for (const MaskRolOp *Ops =\n"
963 " &LaneMaskComposeSequences[CompositeSequences[IdxA]];\n"
964 " Ops->Mask.any(); ++Ops) {\n"
965 " LaneBitmask::Type M = LaneMask.getAsInteger();\n"
966 " if (unsigned S = Ops->RotateLeft)\n"
967 " Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - "
968 "S)));\n"
969 " else\n"
970 " Result |= LaneBitmask(M);\n"
971 " }\n"
972 " return Result;\n"
973 "}\n\n";
974}
975
976//
977// runMCDesc - Print out MC register descriptions.
978//
979void RegisterInfoEmitter::runMCDesc(raw_ostream &OS, raw_ostream &MainOS,
980 StringRef FilenamePrefix) {
981 emitInclude(FilenamePrefix, IncludeFile: "MCDesc.inc", GuardMacro: "GET_REGINFO_MC_DESC", OS&: MainOS);
982
983 emitSourceFileHeader(Desc: "MC Register Information", OS);
984
985 const auto &Regs = RegBank.getRegisters();
986
987 auto &SubRegIndices = RegBank.getSubRegIndices();
988 // The lists of sub-registers and super-registers go in the same array. That
989 // allows us to share suffixes.
990 using RegVec = std::vector<const CodeGenRegister *>;
991
992 // Differentially encoded lists.
993 SequenceToOffsetTable<DiffVec> DiffSeqs;
994 SmallVector<DiffVec, 4> SubRegLists(Regs.size());
995 SmallVector<DiffVec, 4> SuperRegLists(Regs.size());
996 SmallVector<DiffVec, 4> RegUnitLists(Regs.size());
997
998 // List of lane masks accompanying register unit sequences.
999 SequenceToOffsetTable<MaskVec> LaneMaskSeqs(/*Terminator=*/std::nullopt);
1000 SmallVector<MaskVec, 4> RegUnitLaneMasks(Regs.size());
1001
1002 // Keep track of sub-register names as well. These are not differentially
1003 // encoded.
1004 using SubRegIdxVec = SmallVector<const CodeGenSubRegIndex *, 4>;
1005 SequenceToOffsetTable<SubRegIdxVec, deref<std::less<>>> SubRegIdxSeqs(
1006 /*Terminator=*/std::nullopt);
1007 SmallVector<SubRegIdxVec, 4> SubRegIdxLists(Regs.size());
1008
1009 SequenceToOffsetTable<std::string> RegStrings;
1010
1011 // Precompute register lists for the SequenceToOffsetTable.
1012 unsigned i = 0;
1013 for (auto I = Regs.begin(), E = Regs.end(); I != E; ++I, ++i) {
1014 const auto &Reg = *I;
1015 RegStrings.add(Seq: Reg.getName().str());
1016
1017 // Compute the ordered sub-register list.
1018 SetVector<const CodeGenRegister *> SR;
1019 SR.reserve(Size: Reg.getSubRegs().size());
1020 Reg.addSubRegsPreOrder(OSet&: SR, RegBank);
1021 diffEncode(V&: SubRegLists[i], InitVal: Reg.EnumValue, Begin: SR.begin(), End: SR.end());
1022 DiffSeqs.add(Seq: SubRegLists[i]);
1023
1024 // Compute the corresponding sub-register indexes.
1025 SubRegIdxVec &SRIs = SubRegIdxLists[i];
1026 SRIs.reserve(N: SR.size());
1027 for (const CodeGenRegister *S : SR)
1028 SRIs.push_back(Elt: Reg.getSubRegIndex(Reg: S));
1029 SubRegIdxSeqs.add(Seq: SRIs);
1030
1031 // Super-registers are already computed.
1032 const RegVec &SuperRegList = Reg.getSuperRegs();
1033 diffEncode(V&: SuperRegLists[i], InitVal: Reg.EnumValue, Begin: SuperRegList.begin(),
1034 End: SuperRegList.end());
1035 DiffSeqs.add(Seq: SuperRegLists[i]);
1036
1037 const SparseBitVector<> &RUs = Reg.getNativeRegUnits();
1038 DiffSeqs.add(Seq: diffEncode(V&: RegUnitLists[i], List: RUs));
1039
1040 const auto &RUMasks = Reg.getRegUnitLaneMasks();
1041 MaskVec &LaneMaskVec = RegUnitLaneMasks[i];
1042 assert(LaneMaskVec.empty());
1043 llvm::append_range(C&: LaneMaskVec, R: RUMasks);
1044 LaneMaskSeqs.add(Seq: LaneMaskVec);
1045 }
1046
1047 // Compute the final layout of the sequence table.
1048 DiffSeqs.layout();
1049 LaneMaskSeqs.layout();
1050 SubRegIdxSeqs.layout();
1051
1052 NamespaceEmitter LlvmNS(OS, "llvm");
1053
1054 StringRef TargetName = Target.getName();
1055
1056 // Emit the shared table of differential lists.
1057 OS << "extern const int16_t " << TargetName << "RegDiffLists[] = {\n";
1058 DiffSeqs.emit(OS, Print: printDiff16);
1059 OS << "};\n\n";
1060
1061 // Emit the shared table of regunit lane mask sequences.
1062 OS << "extern const LaneBitmask " << TargetName << "LaneMaskLists[] = {\n";
1063 LaneMaskSeqs.emit(OS, Print: printMask);
1064 OS << "};\n\n";
1065
1066 // Emit the table of sub-register indexes.
1067 OS << "extern const uint16_t " << TargetName << "SubRegIdxLists[] = {\n";
1068 SubRegIdxSeqs.emit(OS, Print: printSubRegIndex);
1069 OS << "};\n\n";
1070
1071 // Emit the string table.
1072 RegStrings.layout();
1073 RegStrings.emitStringLiteralDef(OS, Decl: Twine("extern const char ") + TargetName +
1074 "RegStrings[]");
1075
1076 OS << "extern const MCRegisterDesc " << TargetName
1077 << "RegDesc[] = { // Descriptors\n";
1078 OS << " { " << RegStrings.get(Seq: "") << ", 0, 0, 0, 0, 0, 0, 0 },\n";
1079
1080 // Emit the register descriptors now.
1081 i = 0;
1082 for (const auto &Reg : Regs) {
1083 unsigned FirstRU = Reg.getNativeRegUnits().find_first();
1084 unsigned Offset = DiffSeqs.get(Seq: RegUnitLists[i]);
1085 // The value must be kept in sync with MCRegisterInfo.h.
1086 constexpr unsigned RegUnitBits = 12;
1087 assert(isUInt<RegUnitBits>(FirstRU) && "Too many regunits");
1088 assert(isUInt<32 - RegUnitBits>(Offset) && "Offset is too big");
1089 OS << " { " << RegStrings.get(Seq: Reg.getName().str()) << ", "
1090 << DiffSeqs.get(Seq: SubRegLists[i]) << ", " << DiffSeqs.get(Seq: SuperRegLists[i])
1091 << ", " << SubRegIdxSeqs.get(Seq: SubRegIdxLists[i]) << ", "
1092 << (Offset << RegUnitBits | FirstRU) << ", "
1093 << LaneMaskSeqs.get(Seq: RegUnitLaneMasks[i]) << ", " << Reg.Constant << ", "
1094 << Reg.Artificial << " },\n";
1095 ++i;
1096 }
1097 OS << "};\n\n"; // End of register descriptors...
1098
1099 // Emit the table of register unit roots. Each regunit has one or two root
1100 // registers.
1101 OS << "extern const MCPhysReg " << TargetName << "RegUnitRoots[][2] = {\n";
1102 for (unsigned i = 0, e = RegBank.getNumNativeRegUnits(); i != e; ++i) {
1103 ArrayRef<const CodeGenRegister *> Roots = RegBank.getRegUnit(RUID: i).getRoots();
1104 assert(!Roots.empty() && "All regunits must have a root register.");
1105 assert(Roots.size() <= 2 && "More than two roots not supported yet.");
1106 OS << " { ";
1107 ListSeparator LS;
1108 for (const CodeGenRegister *R : Roots)
1109 OS << LS << getQualifiedName(R: R->TheDef);
1110 OS << " },\n";
1111 }
1112 OS << "};\n\n";
1113
1114 // Emit the table of register unit intervals.
1115 if (Target.getRegistersAreIntervals()) {
1116 OS << "extern const unsigned " << TargetName
1117 << "RegUnitIntervals[][2] = {\n";
1118 // Add entry for NoRegister
1119 OS << " { 0, 0 },\n";
1120 for (const CodeGenRegister &Reg : Regs) {
1121 const auto &Units = Reg.getNativeRegUnits();
1122 if (Units.empty()) {
1123 OS << " { 0, 0 },\n";
1124 } else {
1125 unsigned First = Units.find_first();
1126 unsigned Last = Units.find_last();
1127 OS << " { " << First << ", " << Last + 1 << " },\n";
1128 }
1129 }
1130 OS << "};\n\n";
1131 }
1132
1133 // Emit register class bit mask tables. The first bit mask emitted for a
1134 // register class, RC, is the set of sub-classes, including RC itself.
1135 //
1136 // If RC has super-registers, also create a list of subreg indices and bit
1137 // masks, (Idx, Mask). The bit mask has a bit for every superreg regclass,
1138 // SuperRC, that satisfies:
1139 //
1140 // For all SuperReg in SuperRC: SuperReg:Idx in RC
1141 //
1142 // The 0-terminated list of subreg indices starts at:
1143 //
1144 // RC->getSuperRegIndices() = SuperRegIdxSeqs + ...
1145 //
1146 // The corresponding bitmasks are reached through
1147 // RC->getSuperRegClassMaskOffsets(), whose entries are resolved by
1148 // RC->getSuperRegClassMaskAt(). Identical masks are emitted once and
1149 // shared, so they do not follow the sub-class mask in memory.
1150 //
1151 // Every bit mask present in the list has at least one bit set.
1152
1153 const auto &RegisterClasses = RegBank.getRegClasses();
1154
1155 OS << "// Register classes...\n";
1156
1157 SequenceToOffsetTable<std::string> RegClassStrings;
1158 // Start indices for per-reg-class info in the respective arrays.
1159 struct StartIndex {
1160 unsigned RegIdx;
1161 unsigned BitSetIdx;
1162 unsigned SubClassMaskIdx;
1163 unsigned SuperRegMaskOffsetIdx;
1164 unsigned SuperClassIdx;
1165 // Not strictly an index, but to avoid recomputation: cache reg set range.
1166 unsigned MinRegVal;
1167 unsigned RegSetSize;
1168 };
1169 SmallVector<StartIndex> StartIndices;
1170 StartIndices.reserve(N: RegisterClasses.size() + 1);
1171 StartIndices.push_back(Elt: StartIndex{.RegIdx: 0, .BitSetIdx: 0, .SubClassMaskIdx: 0, .SuperRegMaskOffsetIdx: 0, .SuperClassIdx: 0, .MinRegVal: 0, .RegSetSize: 0});
1172
1173 // Super-register class masks are emitted into one pool, with identical masks
1174 // stored once. The masks of a class are therefore not contiguous, and each
1175 // class carries an array of indices into the pool instead.
1176 SmallVector<BitVector> MaskPool;
1177 DenseMap<BitVector, unsigned> MaskPoolIndices;
1178 SmallVector<SmallVector<unsigned, 8>, 8> SuperRegMaskIndices(
1179 RegisterClasses.size());
1180
1181 auto GetMaskPoolIndex = [&](const BitVector &BV) {
1182 assert(BV.size() == RegisterClasses.size() &&
1183 "Super-register class mask size does not match the number of "
1184 "classes");
1185 auto [It, Inserted] = MaskPoolIndices.try_emplace(Key: BV, Args: MaskPool.size());
1186 if (Inserted)
1187 MaskPool.push_back(Elt: BV);
1188 return It->second;
1189 };
1190
1191 // For compressing the sub-reg index lists.
1192 using IdxList = std::vector<const CodeGenSubRegIndex *>;
1193 SmallVector<IdxList, 8> SuperRegIdxLists(RegisterClasses.size());
1194 SequenceToOffsetTable<IdxList, deref<std::less<>>> SuperRegIdxSeqs;
1195 BitVector MaskBV(RegisterClasses.size());
1196 for (const auto &RC : RegisterClasses) {
1197 ArrayRef<const Record *> Order = RC.getOrder();
1198 RegClassStrings.add(Seq: RC.getName());
1199
1200 unsigned MinRegVal = UINT_MAX, MaxRegVal = 0;
1201 for (const Record *Reg : Order) {
1202 MinRegVal = std::min(a: MinRegVal, b: RegBank.getReg(Reg)->EnumValue);
1203 MaxRegVal = std::max(a: MaxRegVal, b: RegBank.getReg(Reg)->EnumValue);
1204 }
1205
1206 IdxList &SRIList = SuperRegIdxLists[RC.EnumValue];
1207 SmallVector<unsigned, 8> &MaskIndices = SuperRegMaskIndices[RC.EnumValue];
1208 for (auto &Idx : SubRegIndices) {
1209 MaskBV.reset();
1210 RC.getSuperRegClasses(SubIdx: &Idx, RegBank, Out&: MaskBV);
1211 if (MaskBV.none())
1212 continue;
1213 SRIList.push_back(x: &Idx);
1214 MaskIndices.push_back(Elt: GetMaskPoolIndex(MaskBV));
1215 }
1216 SuperRegIdxSeqs.add(Seq: SRIList);
1217
1218 auto &Last = StartIndices.back();
1219 Last.MinRegVal = Order.empty() ? 0 : MinRegVal;
1220 Last.RegSetSize = Order.empty() ? 0 : MaxRegVal - MinRegVal + 1;
1221 StartIndices.push_back(Elt: StartIndex{
1222 .RegIdx: Last.RegIdx + unsigned(Order.size()),
1223 // Round to next byte size.
1224 .BitSetIdx: Last.BitSetIdx +
1225 (Order.empty() ? 0 : ((MaxRegVal - MinRegVal) / 8) + 1),
1226 .SubClassMaskIdx: Last.SubClassMaskIdx + unsigned((RC.getSubClasses().size() + 31) / 32),
1227 .SuperRegMaskOffsetIdx: Last.SuperRegMaskOffsetIdx + unsigned(MaskIndices.size()),
1228 .SuperClassIdx: Last.SuperClassIdx + unsigned(RC.getSuperClasses().size()),
1229 .MinRegVal: 0, // MinRegVal for next RegClass.
1230 .RegSetSize: 0, // RegSetSize for next RegClass.
1231 });
1232 }
1233
1234 // The pool follows the per-class sub-class masks in the SubClassMasks array.
1235 // Every mask has a bit for each register class, so they are all the same
1236 // number of words long and the pool entries are evenly spaced.
1237 unsigned RCMaskWords = (RegisterClasses.size() + 31) / 32;
1238 unsigned MaskPoolStart = StartIndices.back().SubClassMaskIdx;
1239 unsigned TotalSubClassMaskSize =
1240 MaskPoolStart + MaskPool.size() * RCMaskWords;
1241
1242 RegClassStrings.layout();
1243 RegClassStrings.emitStringLiteralDef(
1244 OS, Decl: Twine("extern const char ") + TargetName + "RegClassStrings[]");
1245
1246 SuperRegIdxSeqs.layout();
1247
1248 const auto &Totals = StartIndices.back();
1249 raw_string_ostream(MCRegisterClassStorageType)
1250 << "MCRegisterClassStorage<" << RegisterClasses.size() << ", "
1251 << Totals.RegIdx << ", " << Totals.BitSetIdx << ", "
1252 << TotalSubClassMaskSize << ", " << Totals.SuperRegMaskOffsetIdx << ", "
1253 << SuperRegIdxSeqs.size() << ", " << Totals.SuperClassIdx << ">";
1254 OS << "using " << TargetName
1255 << "RegisterClassStorage = " << MCRegisterClassStorageType << ";\n";
1256 OS << "inline constexpr " << MCRegisterClassStorageType << " " << TargetName
1257 << "MCRegisterClassStorage = {\n"
1258 << " {\n";
1259
1260 for (const auto &It : enumerate(First: RegisterClasses)) {
1261 const auto &RC = It.value();
1262 const auto &RCIndices = StartIndices[It.index()];
1263 uint32_t RegSize = 0;
1264 if (RC.RSI.isSimple())
1265 RegSize = RC.RSI.getSimple().RegSize;
1266
1267 OS << " {\n ";
1268 printStorageOffset(OS, TargetName, Member: "Regs", DataIdx: RCIndices.RegIdx, ClassIdx: It.index());
1269 OS << ",\n ";
1270 printStorageOffset(OS, TargetName, Member: "BitSets", DataIdx: RCIndices.BitSetIdx,
1271 ClassIdx: It.index());
1272 OS << ",\n " << RegClassStrings.get(Seq: RC.getName()) << ",\n "
1273 << RegSize << ",\n " << RC.getOrder().size() << ",\n "
1274 << RCIndices.MinRegVal << ", /* MinRegVal */\n "
1275 << RCIndices.RegSetSize << ", /* RegSetSize */\n "
1276 << RC.getQualifiedIdName() << ",\n "
1277 << static_cast<unsigned>(RC.CopyCost) << ", /* CopyCost */\n "
1278 << (RC.Allocatable ? "true" : "false") << ", /* Allocatable */\n "
1279 << (RC.getBaseClassOrder() ? "true" : "false") << ",\n ";
1280 printStorageOffset(OS, TargetName, Member: "SubClassMasks",
1281 DataIdx: RCIndices.SubClassMaskIdx, ClassIdx: It.index());
1282 OS << ",\n ";
1283 printStorageOffset(OS, TargetName, Member: "SuperRegMaskOffsets",
1284 DataIdx: RCIndices.SuperRegMaskOffsetIdx, ClassIdx: It.index());
1285 OS << ",\n ";
1286 printStorageOffset(OS, TargetName, Member: "SuperRegIdxSeqs",
1287 DataIdx: SuperRegIdxSeqs.get(Seq: SuperRegIdxLists[RC.EnumValue]),
1288 ClassIdx: It.index());
1289 OS << ",\n ";
1290 printMask(OS, Val: RC.LaneMask);
1291 OS << ",\n " << (unsigned)RC.AllocationPriority << ",\n "
1292 << (RC.GlobalPriority ? "true" : "false") << ",\n "
1293 << format(Fmt: "0x%02x", Vals: RC.TSFlags) << ", /* TSFlags */\n "
1294 << (unsigned)RC.SpillStackID << ", /* SpillStackID */\n "
1295 << (RC.HasDisjunctSubRegs ? "true" : "false")
1296 << ", /* HasDisjunctSubRegs */\n "
1297 << (RC.CoveredBySubRegs ? "true" : "false")
1298 << ", /* CoveredBySubRegs */\n ";
1299 printStorageOffset(OS, TargetName, Member: "SuperClasses", DataIdx: RCIndices.SuperClassIdx,
1300 ClassIdx: It.index());
1301 OS << ",\n " << RC.getSuperClasses().size() << "\n },\n";
1302 }
1303
1304 OS << " },\n {\n";
1305
1306 // Emit registers.
1307 // TODO: these sequences often have overlaps which could be deduplicated.
1308 for (const auto &[Idx, RC] : enumerate(First: RegisterClasses)) {
1309 ArrayRef<const Record *> Order = RC.getOrder();
1310 if (Order.empty())
1311 continue;
1312 OS << " /* " << StartIndices[Idx].RegIdx << " */ ";
1313 for (const Record *Reg : Order)
1314 OS << getQualifiedName(R: Reg) << ", ";
1315 OS << "\n";
1316 }
1317
1318 OS << " },\n {\n";
1319
1320 // Emit register bit sets.
1321 for (const auto &[Idx, RC] : enumerate(First: RegisterClasses)) {
1322 ArrayRef<const Record *> Order = RC.getOrder();
1323 if (!Order.empty()) {
1324 OS << " /* " << StartIndices[Idx].BitSetIdx << " */ ";
1325 BitVectorEmitter BVE;
1326 for (const Record *Reg : Order)
1327 BVE.add(v: RegBank.getReg(Reg)->EnumValue - StartIndices[Idx].MinRegVal);
1328 BVE.print(OS);
1329 OS << "\n";
1330 }
1331 }
1332 OS << " },\n {\n";
1333
1334 // Emit subclass masks.
1335 for (const auto &[Idx, RC] : enumerate(First: RegisterClasses)) {
1336 OS << " // " << StartIndices[Idx].SubClassMaskIdx << " " << RC.getName()
1337 << "\n ";
1338 printBitVectorAsHex(OS, Bits: RC.getSubClasses(), Width: 32);
1339 OS << "\n";
1340 }
1341
1342 // Emit the pool of super-reg class masks, shared by all the classes that
1343 // project into the same set of classes under some sub-register index.
1344 for (const auto &[Idx, Mask] : enumerate(First&: MaskPool)) {
1345 OS << " /* " << MaskPoolStart + Idx * RCMaskWords << " */ ";
1346 printBitVectorAsHex(OS, Bits: Mask, Width: 32);
1347 OS << "\n";
1348 }
1349 OS << " },\n {\n";
1350
1351 // Emit, for each class, the offset of each of its super-reg class masks.
1352 for (const auto &[Idx, RC] : enumerate(First: RegisterClasses)) {
1353 ArrayRef<unsigned> MaskIndices = SuperRegMaskIndices[RC.EnumValue];
1354 if (MaskIndices.empty())
1355 continue;
1356 OS << " /* " << StartIndices[Idx].SuperRegMaskOffsetIdx << " "
1357 << RC.getName() << " */ ";
1358 for (unsigned MaskIdx : MaskIndices) {
1359 printStorageOffset(OS, TargetName, Member: "SubClassMasks",
1360 DataIdx: MaskPoolStart + MaskIdx * RCMaskWords, ClassIdx: Idx);
1361 OS << ", ";
1362 }
1363 OS << "\n";
1364 }
1365 OS << " },\n {\n";
1366
1367 // Emit SubRegIdxSeqs.
1368 SuperRegIdxSeqs.emit(OS, Print: printSubRegIndex);
1369 OS << " },\n {\n";
1370
1371 // Emit super-class lists.
1372 for (const auto &[Idx, RC] : enumerate(First: RegisterClasses)) {
1373 ArrayRef<CodeGenRegisterClass *> Supers = RC.getSuperClasses();
1374 OS << " /* " << StartIndices[Idx].SuperClassIdx << " " << RC.getName()
1375 << " */ ";
1376 for (const auto *Super : Supers)
1377 OS << Super->getQualifiedIdName() << ", ";
1378 OS << "\n";
1379 }
1380
1381 OS << " }\n};\n\n";
1382 OS << "const MCRegisterClass &get" << Target.getName()
1383 << "MCRegisterClass(unsigned RC) {\n"
1384 << " return " << Target.getName()
1385 << "MCRegisterClassStorage.Classes[RC];\n"
1386 << "}\n\n";
1387
1388 EmitRegMappingTables(OS, Regs, isCtor: false);
1389
1390 // Emit Reg encoding table
1391 OS << "extern const uint16_t " << TargetName;
1392 OS << "RegEncodingTable[] = {\n";
1393 // Add entry for NoRegister
1394 OS << " 0,\n";
1395 for (const auto &RE : Regs) {
1396 const Record *Reg = RE.TheDef;
1397 const BitsInit *BI = Reg->getValueAsBitsInit(FieldName: "HWEncoding");
1398 uint64_t Value = BI->convertKnownBitsToInt();
1399 OS << " " << Value << ",\n";
1400 }
1401 OS << "};\n"; // End of HW encoding table
1402
1403 // MCRegisterInfo initialization routine.
1404 OS << "static inline void Init" << TargetName
1405 << "MCRegisterInfo(MCRegisterInfo *RI, unsigned RA, "
1406 << "unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) "
1407 "{\n"
1408 << " RI->InitMCRegisterInfo(" << TargetName << "RegDesc, "
1409 << Regs.size() + 1 << ", RA, PC, " << TargetName
1410 << "MCRegisterClassStorage.Classes, " << RegisterClasses.size() << ", "
1411 << TargetName << "RegUnitRoots, " << RegBank.getNumNativeRegUnits() << ", "
1412 << TargetName << "RegDiffLists, " << TargetName << "LaneMaskLists, "
1413 << TargetName << "RegStrings, " << TargetName << "RegClassStrings, "
1414 << TargetName << "SubRegIdxLists, " << (llvm::size(Range: SubRegIndices) + 1)
1415 << ",\n"
1416 << TargetName << "RegEncodingTable, "
1417 << (Target.getRegistersAreIntervals() ? TargetName + "RegUnitIntervals"
1418 : "nullptr")
1419 << ");\n\n";
1420
1421 EmitRegMapping(OS, Regs, isCtor: false);
1422
1423 OS << "}\n\n";
1424
1425 // Emit the register by HwMode (if present).
1426 ArrayRef<const Record *> RegisterByHwModeRecords =
1427 Records.getAllDerivedDefinitions(ClassName: "RegisterByHwMode");
1428 if (!RegisterByHwModeRecords.empty()) {
1429 OS << "// Registers by HwMode\n";
1430 NamespaceEmitter RegClassNS(OS, RegisterClasses.front().Namespace +
1431 "::RegisterByHwMode");
1432
1433 unsigned NumModes = Target.getHwModes().getNumModeIds();
1434 for (const Record *Rec : RegisterByHwModeRecords) {
1435 RegisterByHwMode RegByMode(Rec, RegBank);
1436 OS << "LLVM_READONLY MCRegister get" << Rec->getName()
1437 << "(unsigned HwMode) {\n";
1438 OS << indent(2) << "switch (HwMode) {\n";
1439 for (unsigned M = 0; M < NumModes; ++M) {
1440 if (RegByMode.hasMode(M)) {
1441 const CodeGenRegister *R = RegByMode.get(Mode: M);
1442 OS << indent(2) << "case " << M << ": return "
1443 << getQualifiedName(R: R->TheDef) << "; // "
1444 << Target.getHwModes().getModeName(Id: M, IncludeDefault: true) << "\n";
1445 }
1446 }
1447 OS << indent(2)
1448 << "default: llvm_unreachable(\"Unhandled HwMode for Register "
1449 << Rec->getName() << "\");\n"
1450 << indent(2) << "}\n"
1451 << "}\n";
1452 }
1453 }
1454}
1455
1456void RegisterInfoEmitter::runTargetHeader(raw_ostream &OS, raw_ostream &MainOS,
1457 StringRef FilenamePrefix) {
1458 emitInclude(FilenamePrefix, IncludeFile: "Header.inc", GuardMacro: "GET_REGINFO_HEADER", OS&: MainOS);
1459
1460 emitSourceFileHeader(Desc: "Register Information Header Fragment", OS);
1461
1462 const std::string &TargetName = Target.getName().str();
1463 std::string ClassName = TargetName + "GenRegisterInfo";
1464
1465 OS << "#include \"llvm/CodeGen/TargetRegisterInfo.h\"\n\n";
1466
1467 NamespaceEmitter LlvmNS(OS, "llvm");
1468
1469 OS << "class " << TargetName << "FrameLowering;\n\n";
1470
1471 OS << "extern const " << MCRegisterClassStorageType << " " << TargetName
1472 << "MCRegisterClassStorage;\n\n";
1473
1474 OS << "struct " << ClassName << " : public TargetRegisterInfo {\n"
1475 << " explicit " << ClassName
1476 << "(unsigned RA, unsigned D = 0, unsigned E = 0,\n"
1477 << " unsigned PC = 0, unsigned HwMode = 0);\n";
1478 if (!RegBank.getSubRegIndices().empty()) {
1479 OS << " unsigned composeSubRegIndicesImpl"
1480 << "(unsigned, unsigned) const override;\n"
1481 << " unsigned reverseComposeSubRegIndicesImpl"
1482 << "(unsigned, unsigned) const override;\n"
1483 << " LaneBitmask composeSubRegIndexLaneMaskImpl"
1484 << "(unsigned, LaneBitmask) const override;\n"
1485 << " LaneBitmask reverseComposeSubRegIndexLaneMaskImpl"
1486 << "(unsigned, LaneBitmask) const override;\n"
1487 << " const TargetRegisterClass *getSubClassWithSubReg"
1488 << "(const TargetRegisterClass *, unsigned) const override;\n"
1489 << " const TargetRegisterClass *getSubRegisterClass"
1490 << "(const TargetRegisterClass *, unsigned) const override;\n";
1491 }
1492 OS << " const RegClassWeight &getRegClassWeight("
1493 << "const TargetRegisterClass *RC) const override;\n"
1494 << " unsigned getRegUnitWeight(MCRegUnit RegUnit) const override;\n"
1495 << " unsigned getNumRegPressureSets() const override;\n"
1496 << " const char *getRegPressureSetName(unsigned Idx) const override;\n"
1497 << " unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned "
1498 "Idx) const override;\n"
1499 << " const TargetRegisterClass *getLargestRegClassForRegPressureSet("
1500 "unsigned Idx) const override;\n"
1501 << " const int *getRegClassPressureSets("
1502 << "const TargetRegisterClass *RC) const override;\n"
1503 << " const int *getRegUnitPressureSets("
1504 << "MCRegUnit RegUnit) const override;\n"
1505 << " ArrayRef<const char *> getRegMaskNames() const override;\n"
1506 << " ArrayRef<const uint32_t *> getRegMasks() const override;\n"
1507 << " bool isGeneralPurposeRegister(const MachineFunction &, "
1508 << "MCRegister) const override;\n"
1509 << " bool isGeneralPurposeRegisterClass(const TargetRegisterClass *RC)"
1510 << " const override;\n"
1511 << " bool isFixedRegister(const MachineFunction &, "
1512 << "MCRegister) const override;\n"
1513 << " bool isArgumentRegister(const MachineFunction &, "
1514 << "MCRegister) const override;\n"
1515 << " bool isConstantPhysReg(MCRegister PhysReg) const override final;\n"
1516 << " /// Devirtualized TargetFrameLowering.\n"
1517 << " static const " << TargetName << "FrameLowering *getFrameLowering(\n"
1518 << " const MachineFunction &MF);\n";
1519
1520 const auto &RegisterClasses = RegBank.getRegClasses();
1521 if (llvm::any_of(Range: RegisterClasses,
1522 P: [](const auto &RC) { return !RC.AltOrderSelect.empty(); })) {
1523 OS << " ArrayRef<MCPhysReg> getRawAllocationOrder("
1524 "const TargetRegisterClass &RC, const MachineFunction &MF, bool Rev) "
1525 "const override;\n";
1526 }
1527 if (llvm::any_of(Range: RegisterClasses,
1528 P: [](const auto &RC) { return RC.getBaseClassOrder(); })) {
1529 OS << " const TargetRegisterClass *getPhysRegBaseClass(MCRegister Reg) "
1530 "const override;\n";
1531 }
1532 if (!RegisterClasses.empty()) {
1533 OS << " const TargetRegisterClass *getMinimalPhysRegClass("
1534 "MCRegister Reg) const override;\n";
1535 }
1536
1537 OS << "};\n\n";
1538
1539 if (!RegisterClasses.empty()) {
1540 NamespaceEmitter RegClassNS(OS, RegisterClasses.front().Namespace);
1541 OS << "// Register classes\n";
1542
1543 for (const auto &RC : RegisterClasses) {
1544 // Output the extern for the instance.
1545 OS << "static constexpr const TargetRegisterClass &" << RC.getName()
1546 << "RegClass = " << TargetName << "MCRegisterClassStorage.Classes["
1547 << RC.EnumValue << "];\n";
1548 }
1549 }
1550}
1551
1552//
1553// runTargetDesc - Output the target register and register file descriptions.
1554//
1555void RegisterInfoEmitter::runTargetDesc(raw_ostream &OS, raw_ostream &MainOS,
1556 StringRef FilenamePrefix) {
1557 emitInclude(FilenamePrefix, IncludeFile: "TargetDesc.inc", GuardMacro: "GET_REGINFO_TARGET_DESC",
1558 OS&: MainOS);
1559
1560 emitSourceFileHeader(Desc: "Target Register and Register Classes Information", OS);
1561
1562 NamespaceEmitter LlvmNS(OS, "llvm");
1563
1564 // Get access to MCRegisterClass data.
1565 OS << "extern const " << MCRegisterClassStorageType << " " << Target.getName()
1566 << "MCRegisterClassStorage;\n";
1567
1568 // Start out by emitting each of the register classes.
1569 const auto &RegisterClasses = RegBank.getRegClasses();
1570 const auto &SubRegIndices = RegBank.getSubRegIndices();
1571
1572 // Collect all registers belonging to any allocatable class.
1573 std::set<const Record *> AllocatableRegs;
1574
1575 // Collect allocatable registers.
1576 for (const auto &RC : RegisterClasses) {
1577 ArrayRef<const Record *> Order = RC.getOrder();
1578
1579 if (RC.Allocatable)
1580 AllocatableRegs.insert(first: Order.begin(), last: Order.end());
1581 }
1582
1583 const CodeGenHwModes &CGH = Target.getHwModes();
1584 unsigned NumModes = CGH.getNumModeIds();
1585 StringRef TargetName = Target.getName();
1586
1587 // Build a shared array of value types.
1588 SequenceToOffsetTable<std::vector<MVT>> VTSeqs(
1589 /*Terminator=*/MVT::Other);
1590 for (unsigned M = 0; M < NumModes; ++M) {
1591 for (const auto &RC : RegisterClasses) {
1592 std::vector<MVT> S;
1593 for (const ValueTypeByHwMode &VVT : RC.VTs)
1594 if (VVT.hasDefault() || VVT.hasMode(M))
1595 S.push_back(x: VVT.get(Mode: M));
1596 VTSeqs.add(Seq: S);
1597 }
1598 }
1599 VTSeqs.layout();
1600 OS << "\nstatic const MVT::SimpleValueType " << TargetName
1601 << "VTLists[] = {\n";
1602 VTSeqs.emit(OS, Print: printSimpleValueType);
1603 OS << "};\n";
1604
1605 // Emit SubRegIndex names, skipping 0.
1606 SequenceToOffsetTable<std::string> SubRegIndexStrings;
1607 for (const auto &Idx : SubRegIndices)
1608 SubRegIndexStrings.add(Seq: Idx.getName());
1609 SubRegIndexStrings.layout();
1610
1611 SubRegIndexStrings.emitStringLiteralDef(OS, Decl: Twine("static constexpr char ") +
1612 TargetName +
1613 "SubRegIndexStrings[]");
1614
1615 OS << "\nstatic constexpr uint32_t " << TargetName
1616 << "SubRegIndexNameOffsets[] = {\n";
1617 for (const auto &Idx : SubRegIndices)
1618 OS << " " << SubRegIndexStrings.get(Seq: Idx.getName()) << ", \n";
1619 if (SubRegIndices.empty())
1620 OS << " /* dummy */ 0\n";
1621 OS << "};\n\n";
1622
1623 // Emit the table of sub-register index sizes.
1624 OS << "static const TargetRegisterInfo::SubRegCoveredBits " << TargetName
1625 << "SubRegIdxRangeTable[] = {\n";
1626 for (unsigned M = 0; M < NumModes; ++M) {
1627 OS << " { " << (uint32_t)-1 << ", " << (uint32_t)-1 << " },\n";
1628 for (const auto &Idx : SubRegIndices) {
1629 const SubRegRange &Range = Idx.Range.get(Mode: M);
1630 OS << " { " << Range.Offset << ", " << Range.Size << " },\t// "
1631 << Idx.getName() << "\n";
1632 }
1633 }
1634 OS << "};\n\n";
1635
1636 // Emit SubRegIndex lane masks, including 0.
1637 OS << "\nstatic const LaneBitmask " << TargetName
1638 << "SubRegIndexLaneMaskTable[] = {\n "
1639 "LaneBitmask::getAll(),\n";
1640 for (const auto &Idx : SubRegIndices) {
1641 printMask(OS&: OS << " ", Val: Idx.LaneMask);
1642 OS << ", // " << Idx.getName() << '\n';
1643 }
1644 OS << " };\n\n";
1645
1646 OS << "\n";
1647
1648 // Now that all of the structs have been emitted, emit the instances.
1649 if (!RegisterClasses.empty()) {
1650 OS << "\nstatic const TargetRegisterInfo::RegClassInfo " << TargetName
1651 << "RegClassInfos[]" << " = {\n";
1652 for (unsigned M = 0; M < NumModes; ++M) {
1653 unsigned EV = 0;
1654 OS << " // Mode = " << M << " ("
1655 << CGH.getModeName(Id: M, /*IncludeDefault=*/true) << ")\n";
1656 for (const auto &RC : RegisterClasses) {
1657 assert(RC.EnumValue == EV && "Unexpected order of register classes");
1658 ++EV;
1659 (void)EV;
1660 const RegSizeInfo &RI = RC.RSI.get(Mode: M);
1661 OS << " { " << RI.RegSize << ", " << RI.SpillSize << ", "
1662 << RI.SpillAlignment;
1663 std::vector<MVT> VTs;
1664 for (const ValueTypeByHwMode &VVT : RC.VTs)
1665 if (VVT.hasDefault() || VVT.hasMode(M))
1666 VTs.push_back(x: VVT.get(Mode: M));
1667 OS << ", /*" << TargetName << "VTLists+*/" << VTSeqs.get(Seq: VTs)
1668 << " }, // " << RC.getName() << '\n';
1669 }
1670 }
1671 OS << "};\n";
1672
1673 // Emit methods.
1674 for (const auto &RC : RegisterClasses) {
1675 if (!RC.AltOrderSelect.empty()) {
1676 OS << "\nstatic inline unsigned " << RC.getName()
1677 << "AltOrderSelect(const MachineFunction &MF, bool Rev) {"
1678 << RC.AltOrderSelect << "}\n\n"
1679 << "static ArrayRef<MCPhysReg> " << RC.getName()
1680 << "GetRawAllocationOrder(const TargetRegisterClass &RC, "
1681 << "const MachineFunction &MF, bool Rev) {\n";
1682 for (unsigned oi = 1, oe = RC.getNumOrders(); oi != oe; ++oi) {
1683 ArrayRef<const Record *> Elems = RC.getOrder(No: oi);
1684 if (!Elems.empty()) {
1685 OS << " static const MCPhysReg AltOrder" << oi << "[] = {";
1686 for (unsigned elem = 0; elem != Elems.size(); ++elem)
1687 OS << (elem ? ", " : " ") << getQualifiedName(R: Elems[elem]);
1688 OS << " };\n";
1689 }
1690 }
1691 OS << " const ArrayRef<MCPhysReg> Order[] = {\n"
1692 << " RC.getRegisters(";
1693 for (unsigned oi = 1, oe = RC.getNumOrders(); oi != oe; ++oi)
1694 if (RC.getOrder(No: oi).empty())
1695 OS << "),\n ArrayRef<MCPhysReg>(";
1696 else
1697 OS << "),\n ArrayRef(AltOrder" << oi;
1698 OS << ")\n };\n const unsigned Select = " << RC.getName()
1699 << "AltOrderSelect(MF, Rev);\n assert(Select < "
1700 << RC.getNumOrders() << ");\n return Order[Select];\n}\n";
1701 }
1702 }
1703 }
1704
1705 // Emit extra information about registers.
1706 const auto &Regs = RegBank.getRegisters();
1707 unsigned NumRegCosts = 1;
1708 for (const auto &Reg : Regs)
1709 NumRegCosts = std::max(a: (size_t)NumRegCosts, b: Reg.CostPerUse.size());
1710
1711 std::vector<unsigned> AllRegCostPerUse;
1712 llvm::BitVector InAllocClass(Regs.size() + 1, false);
1713 AllRegCostPerUse.insert(position: AllRegCostPerUse.end(), n: NumRegCosts, x: 0);
1714
1715 // Populate the vector RegCosts with the CostPerUse list of the registers
1716 // in the order they are read. Have at most NumRegCosts entries for
1717 // each register. Fill with zero for values which are not explicitly given.
1718 for (const auto &Reg : Regs) {
1719 auto Costs = Reg.CostPerUse;
1720 llvm::append_range(C&: AllRegCostPerUse, R&: Costs);
1721 if (NumRegCosts > Costs.size())
1722 AllRegCostPerUse.insert(position: AllRegCostPerUse.end(),
1723 n: NumRegCosts - Costs.size(), x: 0);
1724
1725 if (AllocatableRegs.count(x: Reg.TheDef))
1726 InAllocClass.set(Reg.EnumValue);
1727 }
1728
1729 // Emit the cost values as a 1D-array after grouping them by their indices,
1730 // i.e. the costs for all registers corresponds to index 0, 1, 2, etc.
1731 // Size of the emitted array should be NumRegCosts * (Regs.size() + 1).
1732 OS << "\nstatic const uint8_t " << TargetName << "CostPerUseTable[] = { \n";
1733 for (unsigned int I = 0; I < NumRegCosts; ++I) {
1734 for (unsigned J = I, E = AllRegCostPerUse.size(); J < E; J += NumRegCosts)
1735 OS << AllRegCostPerUse[J] << ", ";
1736 }
1737 OS << "};\n\n";
1738
1739 OS << "\nstatic const bool " << TargetName
1740 << "InAllocatableClassTable[] = { \n";
1741 for (unsigned I = 0, E = InAllocClass.size(); I < E; ++I) {
1742 OS << (InAllocClass[I] ? "true" : "false") << ", ";
1743 }
1744 OS << "};\n\n";
1745
1746 OS << "\nstatic const TargetRegisterInfoDesc " << TargetName
1747 << "RegInfoDesc = { // Extra Descriptors\n";
1748 OS << TargetName << "CostPerUseTable, " << NumRegCosts << ", " << TargetName
1749 << "InAllocatableClassTable";
1750 OS << "};\n\n"; // End of register descriptors.
1751
1752 std::string ClassName = Target.getName().str() + "GenRegisterInfo";
1753
1754 size_t SubRegIndicesSize = llvm::size(Range: SubRegIndices);
1755
1756 if (!SubRegIndices.empty()) {
1757 emitComposeSubRegIndices(OS, ClassName);
1758 emitComposeSubRegIndexLaneMask(OS, ClassName);
1759 }
1760
1761 if (!SubRegIndices.empty()) {
1762 // Emit getSubClassWithSubReg.
1763 OS << "const TargetRegisterClass *" << ClassName
1764 << "::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx)"
1765 << " const {\n";
1766 // Use the smallest type that can hold a regclass ID with room for a
1767 // sentinel.
1768 const size_t NumRegClasses = RegisterClasses.size();
1769 const char *RegClassTy = getMinimalTypeForRange(Range: NumRegClasses + 1);
1770 auto EmitTableLookup = [&]() {
1771 OS << formatv(Fmt: R"(
1772 };
1773 assert(RC && "Missing regclass");
1774 if (!Idx) return RC;
1775 --Idx;
1776 assert(Idx < {} && "Bad subreg");
1777 unsigned TV = Table[RC->getID()][Idx];
1778 return TV ? getRegClass(TV - 1) : nullptr;
1779})",
1780 Vals&: SubRegIndicesSize);
1781 };
1782
1783 OS << formatv(Fmt: " static constexpr {} Table[{}][{}] = {{\n", Vals&: RegClassTy,
1784 Vals: NumRegClasses, Vals&: SubRegIndicesSize);
1785 for (const auto &RC : RegisterClasses) {
1786 OS << " {\t// " << RC.getName() << "\n";
1787 for (auto &Idx : SubRegIndices) {
1788 if (CodeGenRegisterClass *SRC = RC.getSubClassWithSubReg(SubIdx: &Idx))
1789 OS << " " << SRC->EnumValue + 1 << ",\t// " << Idx.getName()
1790 << " -> " << SRC->getName() << "\n";
1791 else
1792 OS << " 0,\t// " << Idx.getName() << "\n";
1793 }
1794 OS << " },\n";
1795 }
1796 EmitTableLookup();
1797
1798 // Emit getSubRegisterClass.
1799 OS << "const TargetRegisterClass *" << ClassName
1800 << "::getSubRegisterClass(const TargetRegisterClass *RC, unsigned Idx)"
1801 << " const {\n";
1802
1803 OS << formatv(Fmt: " static constexpr {} Table[{}][{}] = {{\n", Vals&: RegClassTy,
1804 Vals: NumRegClasses, Vals&: SubRegIndicesSize);
1805 for (const auto &RC : RegisterClasses) {
1806 OS << " {\t// " << RC.getName() << '\n';
1807 for (auto &Idx : SubRegIndices) {
1808 std::optional<std::pair<CodeGenRegisterClass *, CodeGenRegisterClass *>>
1809 MatchingSubClass = RC.getMatchingSubClassWithSubRegs(RegBank, SubIdx: &Idx);
1810
1811 unsigned EnumValue = 0;
1812 if (MatchingSubClass) {
1813 CodeGenRegisterClass *SubRegClass = MatchingSubClass->second;
1814 EnumValue = SubRegClass->EnumValue + 1;
1815 }
1816
1817 OS << " " << EnumValue << ",\t// " << RC.getName() << ':'
1818 << Idx.getName();
1819
1820 if (MatchingSubClass) {
1821 CodeGenRegisterClass *SubRegClass = MatchingSubClass->second;
1822 OS << " -> " << SubRegClass->getName();
1823 }
1824
1825 OS << '\n';
1826 }
1827
1828 OS << " },\n";
1829 }
1830 EmitTableLookup();
1831 }
1832
1833 EmitRegUnitPressure(OS, ClassName);
1834
1835 if (llvm::any_of(Range: RegisterClasses,
1836 P: [](const auto &RC) { return !RC.AltOrderSelect.empty(); })) {
1837 OS << "ArrayRef<MCPhysReg> " << ClassName
1838 << "::getRawAllocationOrder("
1839 "const TargetRegisterClass &RC, const MachineFunction &MF, bool Rev) "
1840 "const {\n";
1841 OS << " switch (RC.getID()) {\n";
1842 for (const auto &RC : RegisterClasses) {
1843 if (RC.AltOrderSelect.empty())
1844 continue;
1845 OS << " case " << RC.getQualifiedIdName() << ":\n"
1846 << " return " << RC.getName()
1847 << "GetRawAllocationOrder(RC, MF, Rev);\n";
1848 ;
1849 }
1850 OS << " }\n";
1851 OS << " return RC.getRegisters();\n";
1852 OS << "}\n\n";
1853 }
1854
1855 // Emit register base class mapper
1856 if (!RegisterClasses.empty()) {
1857 // Collect base classes
1858 SmallVector<const CodeGenRegisterClass *> BaseClasses;
1859 for (const auto &RC : RegisterClasses) {
1860 if (RC.getBaseClassOrder())
1861 BaseClasses.push_back(Elt: &RC);
1862 }
1863 if (!BaseClasses.empty()) {
1864 assert(BaseClasses.size() < UINT16_MAX &&
1865 "Too many base register classes");
1866
1867 // Apply order
1868 struct BaseClassOrdering {
1869 bool operator()(const CodeGenRegisterClass *LHS,
1870 const CodeGenRegisterClass *RHS) const {
1871 return std::pair(*LHS->getBaseClassOrder(), LHS->EnumValue) <
1872 std::pair(*RHS->getBaseClassOrder(), RHS->EnumValue);
1873 }
1874 };
1875 llvm::stable_sort(Range&: BaseClasses, C: BaseClassOrdering());
1876
1877 OS << "\n// Register to base register class mapping\n\n";
1878 OS << "\n";
1879 OS << "const TargetRegisterClass *" << ClassName
1880 << "::getPhysRegBaseClass(MCRegister Reg)"
1881 << " const {\n";
1882 OS << " static const uint16_t InvalidRegClassID = UINT16_MAX;\n\n";
1883 OS << " static const uint16_t Mapping[" << Regs.size() + 1 << "] = {\n";
1884 OS << " InvalidRegClassID, // NoRegister\n";
1885 for (const CodeGenRegister &Reg : Regs) {
1886 const CodeGenRegisterClass *BaseRC = nullptr;
1887 for (const CodeGenRegisterClass *RC : BaseClasses) {
1888 if (RC->contains(&Reg)) {
1889 BaseRC = RC;
1890 break;
1891 }
1892 }
1893
1894 OS << " "
1895 << (BaseRC ? BaseRC->getQualifiedIdName() : "InvalidRegClassID")
1896 << ", // " << Reg.getName() << "\n";
1897 }
1898 OS << " };\n\n"
1899 " assert(Reg < ArrayRef(Mapping).size());\n"
1900 " unsigned RCID = Mapping[Reg.id()];\n"
1901 " if (RCID == InvalidRegClassID)\n"
1902 " return nullptr;\n"
1903 " return &"
1904 << TargetName
1905 << "MCRegisterClassStorage.Classes[RCID];\n"
1906 "}\n";
1907 }
1908 }
1909
1910 if (!RegisterClasses.empty()) {
1911 assert(RegisterClasses.size() < UINT16_MAX &&
1912 "Too many minimal register classes");
1913
1914 OS << "\n// Register to minimal register class mapping\n\n";
1915 OS << "const TargetRegisterClass *" << ClassName
1916 << "::getMinimalPhysRegClass(MCRegister Reg)" << " const {\n";
1917 OS << " static const uint16_t InvalidRegClassID = UINT16_MAX;\n\n";
1918 OS << " static const uint16_t Mapping[" << Regs.size() + 1 << "] = {\n";
1919 OS << " InvalidRegClassID, // NoRegister\n";
1920 for (const CodeGenRegister &Reg : Regs) {
1921 const CodeGenRegisterClass *MinimalRC = nullptr;
1922 for (const auto &RC : RegisterClasses) {
1923 if (RC.contains(&Reg) && (!MinimalRC || MinimalRC->hasSubClass(RC: &RC)))
1924 MinimalRC = &RC;
1925 }
1926
1927 OS << " "
1928 << (MinimalRC ? MinimalRC->getQualifiedIdName() : "InvalidRegClassID")
1929 << ", // " << Reg.getName() << "\n";
1930 }
1931 OS << " };\n\n"
1932 " assert(Reg < ArrayRef(Mapping).size());\n"
1933 " unsigned RCID = Mapping[Reg.id()];\n"
1934 " if (RCID == InvalidRegClassID)\n"
1935 " return nullptr;\n"
1936 " return &"
1937 << TargetName
1938 << "MCRegisterClassStorage.Classes[RCID];\n"
1939 "}\n";
1940 }
1941
1942 // Emit the constructor of the class...
1943 OS << "extern const MCRegisterDesc " << TargetName << "RegDesc[];\n";
1944 OS << "extern const int16_t " << TargetName << "RegDiffLists[];\n";
1945 OS << "extern const LaneBitmask " << TargetName << "LaneMaskLists[];\n";
1946 OS << "extern const char " << TargetName << "RegStrings[];\n";
1947 OS << "extern const char " << TargetName << "RegClassStrings[];\n";
1948 OS << "extern const MCPhysReg " << TargetName << "RegUnitRoots[][2];\n";
1949 OS << "extern const uint16_t " << TargetName << "SubRegIdxLists[];\n";
1950 OS << "extern const uint16_t " << TargetName << "RegEncodingTable[];\n";
1951 if (Target.getRegistersAreIntervals())
1952 OS << "extern const unsigned " << TargetName << "RegUnitIntervals[][2];\n";
1953
1954 EmitRegMappingTables(OS, Regs, isCtor: true);
1955
1956 OS << formatv(Fmt: R"(
1957{0}::
1958{0}(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour,
1959 unsigned PC, unsigned HwMode)
1960 : TargetRegisterInfo(&{1}RegInfoDesc,
1961 {1}SubRegIndexStrings, {1}SubRegIndexNameOffsets,
1962 {1}SubRegIdxRangeTable, {1}SubRegIndexLaneMaskTable,
1963
1964 )",
1965 Vals&: ClassName, Vals&: TargetName);
1966 printMask(OS, Val: RegBank.CoveringLanes);
1967 OS << formatv(Fmt: R"(, {0}RegClassInfos, {0}VTLists, HwMode) {{
1968 InitMCRegisterInfo({0}RegDesc, {1}, RA, PC,
1969 &get{0}MCRegisterClass(0), {2}, {0}RegUnitRoots, {3}, {0}RegDiffLists,
1970 {0}LaneMaskLists, {0}RegStrings, {0}RegClassStrings, {0}SubRegIdxLists, {4},
1971 {0}RegEncodingTable, {5});
1972
1973)",
1974 Vals&: TargetName, Vals: Regs.size() + 1, Vals: RegisterClasses.size(),
1975 Vals: RegBank.getNumNativeRegUnits(), Vals: SubRegIndicesSize + 1,
1976 Vals: Target.getRegistersAreIntervals()
1977 ? TargetName + "RegUnitIntervals"
1978 : Twine("nullptr"));
1979 EmitRegMapping(OS, Regs, isCtor: true);
1980
1981 OS << "}\n\n";
1982
1983 // Emit CalleeSavedRegs information.
1984 ArrayRef<const Record *> CSRSets =
1985 Records.getAllDerivedDefinitions(ClassName: "CalleeSavedRegs");
1986 for (const Record *CSRSet : CSRSets) {
1987 const SetTheory::RecVec *Regs = RegBank.getSets().expand(Set: CSRSet);
1988 assert(Regs && "Cannot expand CalleeSavedRegs instance");
1989
1990 // Emit the *_SaveList list of callee-saved registers.
1991 OS << "static const MCPhysReg " << CSRSet->getName() << "_SaveList[] = { ";
1992 for (const Record *Reg : *Regs)
1993 OS << getQualifiedName(R: Reg) << ", ";
1994 OS << "0 };\n";
1995
1996 // Emit the *_RegMask bit mask of call-preserved registers.
1997 BitVector Covered = RegBank.computeCoveredRegisters(Regs: *Regs);
1998
1999 // Check for an optional OtherPreserved set.
2000 // Add those registers to RegMask, but not to SaveList.
2001 if (const DagInit *OPDag =
2002 dyn_cast<DagInit>(Val: CSRSet->getValueInit(FieldName: "OtherPreserved"))) {
2003 SetTheory::RecSet OPSet;
2004 RegBank.getSets().evaluate(Expr: OPDag, Elts&: OPSet, Loc: CSRSet->getLoc());
2005 Covered |= RegBank.computeCoveredRegisters(Regs: OPSet.getArrayRef());
2006 }
2007
2008 // Add all constant physical registers to the preserved mask:
2009 SetTheory::RecSet ConstantSet;
2010 for (const auto &Reg : RegBank.getRegisters()) {
2011 if (Reg.Constant)
2012 ConstantSet.insert(X: Reg.TheDef);
2013 }
2014 Covered |= RegBank.computeCoveredRegisters(Regs: ConstantSet.getArrayRef());
2015
2016 OS << "static const uint32_t " << CSRSet->getName() << "_RegMask[] = { ";
2017 printBitVectorAsHex(OS, Bits: Covered, Width: 32);
2018 OS << "};\n";
2019 }
2020 OS << "\n\n";
2021
2022 OS << "ArrayRef<const uint32_t *> " << ClassName
2023 << "::getRegMasks() const {\n";
2024 if (!CSRSets.empty()) {
2025 OS << " static const uint32_t *const Masks[] = {\n";
2026 for (const Record *CSRSet : CSRSets)
2027 OS << " " << CSRSet->getName() << "_RegMask,\n";
2028 OS << " };\n";
2029 OS << " return ArrayRef(Masks);\n";
2030 } else {
2031 OS << " return {};\n";
2032 }
2033 OS << "}\n\n";
2034
2035 const std::list<CodeGenRegisterCategory> &RegCategories =
2036 RegBank.getRegCategories();
2037 OS << "bool " << ClassName << "::\n"
2038 << "isGeneralPurposeRegister(const MachineFunction &MF, "
2039 << "MCRegister PhysReg) const {\n"
2040 << " return\n";
2041 for (const CodeGenRegisterCategory &Category : RegCategories)
2042 if (Category.getName() == "GeneralPurposeRegisters") {
2043 for (const CodeGenRegisterClass *RC : Category.getClasses())
2044 OS << " " << RC->getQualifiedName()
2045 << "RegClass.contains(PhysReg) ||\n";
2046 break;
2047 }
2048 OS << " false;\n";
2049 OS << "}\n\n";
2050
2051 OS << "bool " << ClassName << "::\n"
2052 << "isGeneralPurposeRegisterClass(const TargetRegisterClass *RC)"
2053 << " const {\n"
2054 << " return\n";
2055 for (const CodeGenRegisterCategory &Category : RegCategories)
2056 if (Category.getName() == "GeneralPurposeRegisters") {
2057 for (const CodeGenRegisterClass *RC : Category.getClasses())
2058 OS << " " << RC->getQualifiedName()
2059 << "RegClass.hasSubClassEq(RC) ||\n";
2060 break;
2061 }
2062 OS << " false;\n";
2063 OS << "}\n\n";
2064
2065 OS << "bool " << ClassName << "::\n"
2066 << "isFixedRegister(const MachineFunction &MF, "
2067 << "MCRegister PhysReg) const {\n"
2068 << " return\n";
2069 for (const CodeGenRegisterCategory &Category : RegCategories)
2070 if (Category.getName() == "FixedRegisters") {
2071 for (const CodeGenRegisterClass *RC : Category.getClasses())
2072 OS << " " << RC->getQualifiedName()
2073 << "RegClass.contains(PhysReg) ||\n";
2074 break;
2075 }
2076 OS << " false;\n";
2077 OS << "}\n\n";
2078
2079 OS << "bool " << ClassName << "::\n"
2080 << "isArgumentRegister(const MachineFunction &MF, "
2081 << "MCRegister PhysReg) const {\n"
2082 << " return\n";
2083 for (const CodeGenRegisterCategory &Category : RegCategories)
2084 if (Category.getName() == "ArgumentRegisters") {
2085 for (const CodeGenRegisterClass *RC : Category.getClasses())
2086 OS << " " << RC->getQualifiedName()
2087 << "RegClass.contains(PhysReg) ||\n";
2088 break;
2089 }
2090 OS << " false;\n";
2091 OS << "}\n\n";
2092
2093 OS << "bool " << ClassName << "::\n"
2094 << "isConstantPhysReg(MCRegister PhysReg) const {\n"
2095 << " return\n";
2096 for (const auto &Reg : Regs)
2097 if (Reg.Constant)
2098 OS << " PhysReg == " << getQualifiedName(R: Reg.TheDef) << " ||\n";
2099 OS << " false;\n";
2100 OS << "}\n\n";
2101
2102 OS << "ArrayRef<const char *> " << ClassName
2103 << "::getRegMaskNames() const {\n";
2104 if (!CSRSets.empty()) {
2105 OS << " static const char *Names[] = {\n";
2106 for (const Record *CSRSet : CSRSets)
2107 OS << " " << '"' << CSRSet->getName() << '"' << ",\n";
2108 OS << " };\n";
2109 OS << " return ArrayRef(Names);\n";
2110 } else {
2111 OS << " return {};\n";
2112 }
2113 OS << "}\n\n";
2114
2115 OS << "const " << TargetName << "FrameLowering *\n"
2116 << TargetName
2117 << "GenRegisterInfo::getFrameLowering(const MachineFunction &MF) {\n"
2118 << " return static_cast<const " << TargetName << "FrameLowering *>(\n"
2119 << " MF.getSubtarget().getFrameLowering());\n"
2120 << "}\n\n";
2121}
2122
2123TableGenOutputFiles RegisterInfoEmitter::run(StringRef FilenamePrefix) {
2124 TGTimer &Timer = Records.getTimer();
2125 Timer.startTimer(Name: "Print enums");
2126 std::string Main;
2127 raw_string_ostream MainOS(Main);
2128 std::string Enums;
2129 raw_string_ostream EnumsOS(Enums);
2130 runEnums(OS&: EnumsOS, MainOS, FilenamePrefix);
2131
2132 Timer.startTimer(Name: "Print MC registers");
2133 std::string MCDesc;
2134 raw_string_ostream MCDescOS(MCDesc);
2135 runMCDesc(OS&: MCDescOS, MainOS, FilenamePrefix);
2136
2137 Timer.startTimer(Name: "Print header fragment");
2138 std::string Header;
2139 raw_string_ostream HeaderOS(Header);
2140 runTargetHeader(OS&: HeaderOS, MainOS, FilenamePrefix);
2141
2142 Timer.startTimer(Name: "Print target registers");
2143 std::string TargetDesc;
2144 raw_string_ostream TargetDescOS(TargetDesc);
2145 runTargetDesc(OS&: TargetDescOS, MainOS, FilenamePrefix);
2146
2147 if (RegisterInfoDebug)
2148 debugDump(OS&: errs());
2149
2150 // The suffixes should be in sync with the tablegen function in
2151 // llvm/cmake/modules/TableGen.cmake.
2152 return {.MainFile: std::move(Main),
2153 .AdditionalFiles: {{"Enums.inc", Enums},
2154 {"MCDesc.inc", MCDesc},
2155 {"Header.inc", Header},
2156 {"TargetDesc.inc", TargetDesc}}};
2157}
2158
2159template <typename InfoTy, typename FnTy>
2160Printable RegisterInfoEmitter::printByHwMode(const InfoByHwMode<InfoTy> &Info,
2161 FnTy Func) {
2162 return Printable([&](raw_ostream &OS) {
2163 if (Info.isSimple()) {
2164 OS << Func(Info.getSimple());
2165 return;
2166 }
2167
2168 const CodeGenHwModes &CGH = Target.getHwModes();
2169
2170 OS << "{";
2171 for (unsigned M = 0, E = CGH.getNumModeIds(); M != E; ++M)
2172 OS << ' ' << CGH.getModeName(Id: M, /*IncludeDefault=*/true) << ':'
2173 << Func(Info.get(M));
2174 OS << " }";
2175 });
2176}
2177
2178void RegisterInfoEmitter::debugDump(raw_ostream &OS) {
2179 for (const CodeGenRegisterClass &RC : RegBank.getRegClasses()) {
2180 OS << "RegisterClass " << RC.getName() << ":\n";
2181 OS << "\tSpillSize: " << printByHwMode(Info: RC.RSI, Func: [](const RegSizeInfo &Info) {
2182 return Info.SpillSize;
2183 }) << '\n';
2184 OS << "\tSpillAlignment: "
2185 << printByHwMode(
2186 Info: RC.RSI,
2187 Func: [](const RegSizeInfo &Info) { return Info.SpillAlignment; })
2188 << '\n';
2189 OS << "\tNumRegs: " << RC.getMembers().size() << '\n';
2190 OS << "\tLaneMask: " << PrintLaneMask(LaneMask: RC.LaneMask) << '\n';
2191 OS << "\tHasDisjunctSubRegs: " << RC.HasDisjunctSubRegs << '\n';
2192 OS << "\tCoveredBySubRegs: " << RC.CoveredBySubRegs << '\n';
2193 OS << "\tAllocatable: " << RC.Allocatable << '\n';
2194 OS << "\tAllocationPriority: " << unsigned(RC.AllocationPriority) << '\n';
2195 OS << "\tWeight: " << RC.getWeight(RegBank) << '\n';
2196 OS << "\tBaseClassOrder: " << RC.getBaseClassOrder() << '\n';
2197 OS << "\tRegs:";
2198 for (const CodeGenRegister *R : RC.getMembers()) {
2199 OS << " " << R->getName();
2200 }
2201 OS << '\n';
2202 OS << "\tSubClasses:";
2203 const BitVector &SubClasses = RC.getSubClasses();
2204 for (const CodeGenRegisterClass &SRC : RegBank.getRegClasses()) {
2205 if (!SubClasses.test(Idx: SRC.EnumValue))
2206 continue;
2207 OS << " " << SRC.getName();
2208 }
2209 OS << '\n';
2210 OS << "\tSuperClasses:";
2211 for (const CodeGenRegisterClass *SRC : RC.getSuperClasses()) {
2212 OS << " " << SRC->getName();
2213 }
2214 OS << '\n';
2215 if (RC.Artificial)
2216 OS << "\tArtificial: 1\n";
2217 }
2218
2219 for (const CodeGenSubRegIndex &SRI : RegBank.getSubRegIndices()) {
2220 OS << "SubRegIndex " << SRI.getName() << ":\n";
2221 OS << "\tLaneMask: " << PrintLaneMask(LaneMask: SRI.LaneMask) << '\n';
2222 OS << "\tAllSuperRegsCovered: " << SRI.AllSuperRegsCovered << '\n';
2223 OS << "\tOffset: " << printByHwMode(Info: SRI.Range, Func: [](const SubRegRange &Info) {
2224 return Info.Offset;
2225 }) << '\n';
2226 OS << "\tSize: " << printByHwMode(Info: SRI.Range, Func: [](const SubRegRange &Info) {
2227 return Info.Size;
2228 }) << '\n';
2229 if (SRI.Artificial)
2230 OS << "\tArtificial: 1\n";
2231 }
2232
2233 for (const CodeGenRegister &R : RegBank.getRegisters()) {
2234 OS << "Register " << R.getName() << ":\n";
2235 OS << "\tCostPerUse: ";
2236 for (const auto &Cost : R.CostPerUse)
2237 OS << Cost << " ";
2238 OS << '\n';
2239 OS << "\tCoveredBySubregs: " << R.CoveredBySubRegs << '\n';
2240 OS << "\tHasDisjunctSubRegs: " << R.HasDisjunctSubRegs << '\n';
2241 for (auto &[SubIdx, SubReg] : R.getSubRegs()) {
2242 OS << "\tSubReg " << SubIdx->getName() << " = " << SubReg->getName()
2243 << '\n';
2244 }
2245 for (unsigned U : R.getNativeRegUnits())
2246 OS << "\tRegUnit " << U << '\n';
2247 if (R.Artificial)
2248 OS << "\tArtificial: 1\n";
2249 }
2250}
2251
2252static TableGen::Emitter::MultiFileOptClass<RegisterInfoEmitter>
2253 X("gen-register-info", "Generate registers and register classes info");
2254