contrib/llvm/utils/TableGen/RegisterInfoEmitter.cpp

   1 //===- RegisterInfoEmitter.cpp - Generate a Register File Desc. -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  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.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "CodeGenRegisters.h"
  17 #include "CodeGenTarget.h"
  18 #include "Types.h"
  19 #include "SequenceToOffsetTable.h"
  20 #include "llvm/ADT/ArrayRef.h"
  21 #include "llvm/ADT/BitVector.h"
  22 #include "llvm/ADT/SetVector.h"
  23 #include "llvm/ADT/SmallVector.h"
  24 #include "llvm/ADT/SparseBitVector.h"
  25 #include "llvm/ADT/STLExtras.h"
  26 #include "llvm/ADT/Twine.h"
  27 #include "llvm/CodeGen/MachineValueType.h"
  28 #include "llvm/Support/Casting.h"
  29 #include "llvm/Support/Format.h"
  30 #include "llvm/Support/raw_ostream.h"
  31 #include "llvm/TableGen/Error.h"
  32 #include "llvm/TableGen/Record.h"
  33 #include "llvm/TableGen/SetTheory.h"
  34 #include "llvm/TableGen/TableGenBackend.h"
  35 #include <algorithm>
  36 #include <cassert>
  37 #include <cstddef>
  38 #include <cstdint>
  39 #include <deque>
  40 #include <iterator>
  41 #include <set>
  42 #include <string>
  43 #include <vector>
  44
  45 using namespace llvm;
  46
  47 namespace {
  48
  49 class RegisterInfoEmitter {
  50   RecordKeeper &Records;
  51
  52 public:
  53   RegisterInfoEmitter(RecordKeeper &R) : Records(R) {}
  54
  55   // runEnums - Print out enum values for all of the registers.
  56   void runEnums(raw_ostream &o, CodeGenTarget &Target, CodeGenRegBank &Bank);
  57
  58   // runMCDesc - Print out MC register descriptions.
  59   void runMCDesc(raw_ostream &o, CodeGenTarget &Target, CodeGenRegBank &Bank);
  60
  61   // runTargetHeader - Emit a header fragment for the register info emitter.
  62   void runTargetHeader(raw_ostream &o, CodeGenTarget &Target,
  63                        CodeGenRegBank &Bank);
  64
  65   // runTargetDesc - Output the target register and register file descriptions.
  66   void runTargetDesc(raw_ostream &o, CodeGenTarget &Target,
  67                      CodeGenRegBank &Bank);
  68
  69   // run - Output the register file description.
  70   void run(raw_ostream &o);
  71
  72 private:
  73   void EmitRegMapping(raw_ostream &o, const std::deque<CodeGenRegister> &Regs,
  74                       bool isCtor);
  75   void EmitRegMappingTables(raw_ostream &o,
  76                             const std::deque<CodeGenRegister> &Regs,
  77                             bool isCtor);
  78   void EmitRegUnitPressure(raw_ostream &OS, const CodeGenRegBank &RegBank,
  79                            const std::string &ClassName);
  80   void emitComposeSubRegIndices(raw_ostream &OS, CodeGenRegBank &RegBank,
  81                                 const std::string &ClassName);
  82   void emitComposeSubRegIndexLaneMask(raw_ostream &OS, CodeGenRegBank &RegBank,
  83                                       const std::string &ClassName);
  84 };
  85
  86 } // end anonymous namespace
  87
  88 // runEnums - Print out enum values for all of the registers.
  89 void RegisterInfoEmitter::runEnums(raw_ostream &OS,
  90                                    CodeGenTarget &Target, CodeGenRegBank &Bank) {
  91   const auto &Registers = Bank.getRegisters();
  92
  93   // Register enums are stored as uint16_t in the tables. Make sure we'll fit.
  94   assert(Registers.size() <= 0xffff && "Too many regs to fit in tables");
  95
  96   std::string Namespace =
  97       Registers.front().TheDef->getValueAsString("Namespace");
  98
  99   emitSourceFileHeader("Target Register Enum Values", OS);
 100
 101   OS << "\n#ifdef GET_REGINFO_ENUM\n";
 102   OS << "#undef GET_REGINFO_ENUM\n\n";
 103
 104   OS << "namespace llvm {\n\n";
 105
 106   OS << "class MCRegisterClass;\n"
 107      << "extern const MCRegisterClass " << Target.getName()
 108      << "MCRegisterClasses[];\n\n";
 109
 110   if (!Namespace.empty())
 111     OS << "namespace " << Namespace << " {\n";
 112   OS << "enum {\n  NoRegister,\n";
 113
 114   for (const auto &Reg : Registers)
 115     OS << "  " << Reg.getName() << " = " << Reg.EnumValue << ",\n";
 116   assert(Registers.size() == Registers.back().EnumValue &&
 117          "Register enum value mismatch!");
 118   OS << "  NUM_TARGET_REGS \t// " << Registers.size()+1 << "\n";
 119   OS << "};\n";
 120   if (!Namespace.empty())
 121     OS << "} // end namespace " << Namespace << "\n";
 122
 123   const auto &RegisterClasses = Bank.getRegClasses();
 124   if (!RegisterClasses.empty()) {
 125
 126     // RegisterClass enums are stored as uint16_t in the tables.
 127     assert(RegisterClasses.size() <= 0xffff &&
 128            "Too many register classes to fit in tables");
 129
 130     OS << "\n// Register classes\n\n";
 131     if (!Namespace.empty())
 132       OS << "namespace " << Namespace << " {\n";
 133     OS << "enum {\n";
 134     for (const auto &RC : RegisterClasses)
 135       OS << "  " << RC.getName() << "RegClassID"
 136          << " = " << RC.EnumValue << ",\n";
 137     OS << "\n  };\n";
 138     if (!Namespace.empty())
 139       OS << "} // end namespace " << Namespace << "\n\n";
 140   }
 141
 142   const std::vector<Record*> &RegAltNameIndices = Target.getRegAltNameIndices();
 143   // If the only definition is the default NoRegAltName, we don't need to
 144   // emit anything.
 145   if (RegAltNameIndices.size() > 1) {
 146     OS << "\n// Register alternate name indices\n\n";
 147     if (!Namespace.empty())
 148       OS << "namespace " << Namespace << " {\n";
 149     OS << "enum {\n";
 150     for (unsigned i = 0, e = RegAltNameIndices.size(); i != e; ++i)
 151       OS << "  " << RegAltNameIndices[i]->getName() << ",\t// " << i << "\n";
 152     OS << "  NUM_TARGET_REG_ALT_NAMES = " << RegAltNameIndices.size() << "\n";
 153     OS << "};\n";
 154     if (!Namespace.empty())
 155       OS << "} // end namespace " << Namespace << "\n\n";
 156   }
 157
 158   auto &SubRegIndices = Bank.getSubRegIndices();
 159   if (!SubRegIndices.empty()) {
 160     OS << "\n// Subregister indices\n\n";
 161     std::string Namespace = SubRegIndices.front().getNamespace();
 162     if (!Namespace.empty())
 163       OS << "namespace " << Namespace << " {\n";
 164     OS << "enum {\n  NoSubRegister,\n";
 165     unsigned i = 0;
 166     for (const auto &Idx : SubRegIndices)
 167       OS << "  " << Idx.getName() << ",\t// " << ++i << "\n";
 168     OS << "  NUM_TARGET_SUBREGS\n};\n";
 169     if (!Namespace.empty())
 170       OS << "} // end namespace " << Namespace << "\n\n";
 171   }
 172
 173   OS << "} // end namespace llvm\n\n";
 174   OS << "#endif // GET_REGINFO_ENUM\n\n";
 175 }
 176
 177 static void printInt(raw_ostream &OS, int Val) {
 178   OS << Val;
 179 }
 180
 181 void RegisterInfoEmitter::
 182 EmitRegUnitPressure(raw_ostream &OS, const CodeGenRegBank &RegBank,
 183                     const std::string &ClassName) {
 184   unsigned NumRCs = RegBank.getRegClasses().size();
 185   unsigned NumSets = RegBank.getNumRegPressureSets();
 186
 187   OS << "/// Get the weight in units of pressure for this register class.\n"
 188      << "const RegClassWeight &" << ClassName << "::\n"
 189      << "getRegClassWeight(const TargetRegisterClass *RC) const {\n"
 190      << "  static const RegClassWeight RCWeightTable[] = {\n";
 191   for (const auto &RC : RegBank.getRegClasses()) {
 192     const CodeGenRegister::Vec &Regs = RC.getMembers();
 193     if (Regs.empty())
 194       OS << "    {0, 0";
 195     else {
 196       std::vector<unsigned> RegUnits;
 197       RC.buildRegUnitSet(RegUnits);
 198       OS << "    {" << (*Regs.begin())->getWeight(RegBank)
 199          << ", " << RegBank.getRegUnitSetWeight(RegUnits);
 200     }
 201     OS << "},  \t// " << RC.getName() << "\n";
 202   }
 203   OS << "  };\n"
 204      << "  return RCWeightTable[RC->getID()];\n"
 205      << "}\n\n";
 206
 207   // Reasonable targets (not ARMv7) have unit weight for all units, so don't
 208   // bother generating a table.
 209   bool RegUnitsHaveUnitWeight = true;
 210   for (unsigned UnitIdx = 0, UnitEnd = RegBank.getNumNativeRegUnits();
 211        UnitIdx < UnitEnd; ++UnitIdx) {
 212     if (RegBank.getRegUnit(UnitIdx).Weight > 1)
 213       RegUnitsHaveUnitWeight = false;
 214   }
 215   OS << "/// Get the weight in units of pressure for this register unit.\n"
 216      << "unsigned " << ClassName << "::\n"
 217      << "getRegUnitWeight(unsigned RegUnit) const {\n"
 218      << "  assert(RegUnit < " << RegBank.getNumNativeRegUnits()
 219      << " && \"invalid register unit\");\n";
 220   if (!RegUnitsHaveUnitWeight) {
 221     OS << "  static const uint8_t RUWeightTable[] = {\n    ";
 222     for (unsigned UnitIdx = 0, UnitEnd = RegBank.getNumNativeRegUnits();
 223          UnitIdx < UnitEnd; ++UnitIdx) {
 224       const RegUnit &RU = RegBank.getRegUnit(UnitIdx);
 225       assert(RU.Weight < 256 && "RegUnit too heavy");
 226       OS << RU.Weight << ", ";
 227     }
 228     OS << "};\n"
 229        << "  return RUWeightTable[RegUnit];\n";
 230   }
 231   else {
 232     OS << "  // All register units have unit weight.\n"
 233        << "  return 1;\n";
 234   }
 235   OS << "}\n\n";
 236
 237   OS << "\n"
 238      << "// Get the number of dimensions of register pressure.\n"
 239      << "unsigned " << ClassName << "::getNumRegPressureSets() const {\n"
 240      << "  return " << NumSets << ";\n}\n\n";
 241
 242   OS << "// Get the name of this register unit pressure set.\n"
 243      << "const char *" << ClassName << "::\n"
 244      << "getRegPressureSetName(unsigned Idx) const {\n"
 245      << "  static const char *const PressureNameTable[] = {\n";
 246   unsigned MaxRegUnitWeight = 0;
 247   for (unsigned i = 0; i < NumSets; ++i ) {
 248     const RegUnitSet &RegUnits = RegBank.getRegSetAt(i);
 249     MaxRegUnitWeight = std::max(MaxRegUnitWeight, RegUnits.Weight);
 250     OS << "    \"" << RegUnits.Name << "\",\n";
 251   }
 252   OS << "  };\n"
 253      << "  return PressureNameTable[Idx];\n"
 254      << "}\n\n";
 255
 256   OS << "// Get the register unit pressure limit for this dimension.\n"
 257      << "// This limit must be adjusted dynamically for reserved registers.\n"
 258      << "unsigned " << ClassName << "::\n"
 259      << "getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const "
 260         "{\n"
 261      << "  static const " << getMinimalTypeForRange(MaxRegUnitWeight, 32)
 262      << " PressureLimitTable[] = {\n";
 263   for (unsigned i = 0; i < NumSets; ++i ) {
 264     const RegUnitSet &RegUnits = RegBank.getRegSetAt(i);
 265     OS << "    " << RegUnits.Weight << ",  \t// " << i << ": "
 266        << RegUnits.Name << "\n";
 267   }
 268   OS << "  };\n"
 269      << "  return PressureLimitTable[Idx];\n"
 270      << "}\n\n";
 271
 272   SequenceToOffsetTable<std::vector<int>> PSetsSeqs;
 273
 274   // This table may be larger than NumRCs if some register units needed a list
 275   // of unit sets that did not correspond to a register class.
 276   unsigned NumRCUnitSets = RegBank.getNumRegClassPressureSetLists();
 277   std::vector<std::vector<int>> PSets(NumRCUnitSets);
 278
 279   for (unsigned i = 0, e = NumRCUnitSets; i != e; ++i) {
 280     ArrayRef<unsigned> PSetIDs = RegBank.getRCPressureSetIDs(i);
 281     PSets[i].reserve(PSetIDs.size());
 282     for (ArrayRef<unsigned>::iterator PSetI = PSetIDs.begin(),
 283            PSetE = PSetIDs.end(); PSetI != PSetE; ++PSetI) {
 284       PSets[i].push_back(RegBank.getRegPressureSet(*PSetI).Order);
 285     }
 286     std::sort(PSets[i].begin(), PSets[i].end());
 287     PSetsSeqs.add(PSets[i]);
 288   }
 289
 290   PSetsSeqs.layout();
 291
 292   OS << "/// Table of pressure sets per register class or unit.\n"
 293      << "static const int RCSetsTable[] = {\n";
 294   PSetsSeqs.emit(OS, printInt, "-1");
 295   OS << "};\n\n";
 296
 297   OS << "/// Get the dimensions of register pressure impacted by this "
 298      << "register class.\n"
 299      << "/// Returns a -1 terminated array of pressure set IDs\n"
 300      << "const int* " << ClassName << "::\n"
 301      << "getRegClassPressureSets(const TargetRegisterClass *RC) const {\n";
 302   OS << "  static const " << getMinimalTypeForRange(PSetsSeqs.size() - 1, 32)
 303      << " RCSetStartTable[] = {\n    ";
 304   for (unsigned i = 0, e = NumRCs; i != e; ++i) {
 305     OS << PSetsSeqs.get(PSets[i]) << ",";
 306   }
 307   OS << "};\n"
 308      << "  return &RCSetsTable[RCSetStartTable[RC->getID()]];\n"
 309      << "}\n\n";
 310
 311   OS << "/// Get the dimensions of register pressure impacted by this "
 312      << "register unit.\n"
 313      << "/// Returns a -1 terminated array of pressure set IDs\n"
 314      << "const int* " << ClassName << "::\n"
 315      << "getRegUnitPressureSets(unsigned RegUnit) const {\n"
 316      << "  assert(RegUnit < " << RegBank.getNumNativeRegUnits()
 317      << " && \"invalid register unit\");\n";
 318   OS << "  static const " << getMinimalTypeForRange(PSetsSeqs.size() - 1, 32)
 319      << " RUSetStartTable[] = {\n    ";
 320   for (unsigned UnitIdx = 0, UnitEnd = RegBank.getNumNativeRegUnits();
 321        UnitIdx < UnitEnd; ++UnitIdx) {
 322     OS << PSetsSeqs.get(PSets[RegBank.getRegUnit(UnitIdx).RegClassUnitSetsIdx])
 323        << ",";
 324   }
 325   OS << "};\n"
 326      << "  return &RCSetsTable[RUSetStartTable[RegUnit]];\n"
 327      << "}\n\n";
 328 }
 329
 330 void RegisterInfoEmitter::EmitRegMappingTables(
 331     raw_ostream &OS, const std::deque<CodeGenRegister> &Regs, bool isCtor) {
 332   // Collect all information about dwarf register numbers
 333   typedef std::map<Record*, std::vector<int64_t>, LessRecordRegister> DwarfRegNumsMapTy;
 334   DwarfRegNumsMapTy DwarfRegNums;
 335
 336   // First, just pull all provided information to the map
 337   unsigned maxLength = 0;
 338   for (auto &RE : Regs) {
 339     Record *Reg = RE.TheDef;
 340     std::vector<int64_t> RegNums = Reg->getValueAsListOfInts("DwarfNumbers");
 341     maxLength = std::max((size_t)maxLength, RegNums.size());
 342     if (DwarfRegNums.count(Reg))
 343       PrintWarning(Reg->getLoc(), Twine("DWARF numbers for register ") +
 344                    getQualifiedName(Reg) + "specified multiple times");
 345     DwarfRegNums[Reg] = RegNums;
 346   }
 347
 348   if (!maxLength)
 349     return;
 350
 351   // Now we know maximal length of number list. Append -1's, where needed
 352   for (DwarfRegNumsMapTy::iterator
 353        I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I)
 354     for (unsigned i = I->second.size(), e = maxLength; i != e; ++i)
 355       I->second.push_back(-1);
 356
 357   std::string Namespace = Regs.front().TheDef->getValueAsString("Namespace");
 358
 359   OS << "// " << Namespace << " Dwarf<->LLVM register mappings.\n";
 360
 361   // Emit reverse information about the dwarf register numbers.
 362   for (unsigned j = 0; j < 2; ++j) {
 363     for (unsigned i = 0, e = maxLength; i != e; ++i) {
 364       OS << "extern const MCRegisterInfo::DwarfLLVMRegPair " << Namespace;
 365       OS << (j == 0 ? "DwarfFlavour" : "EHFlavour");
 366       OS << i << "Dwarf2L[]";
 367
 368       if (!isCtor) {
 369         OS << " = {\n";
 370
 371         // Store the mapping sorted by the LLVM reg num so lookup can be done
 372         // with a binary search.
 373         std::map<uint64_t, Record*> Dwarf2LMap;
 374         for (DwarfRegNumsMapTy::iterator
 375                I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I) {
 376           int DwarfRegNo = I->second[i];
 377           if (DwarfRegNo < 0)
 378             continue;
 379           Dwarf2LMap[DwarfRegNo] = I->first;
 380         }
 381
 382         for (std::map<uint64_t, Record*>::iterator
 383                I = Dwarf2LMap.begin(), E = Dwarf2LMap.end(); I != E; ++I)
 384           OS << "  { " << I->first << "U, " << getQualifiedName(I->second)
 385              << " },\n";
 386
 387         OS << "};\n";
 388       } else {
 389         OS << ";\n";
 390       }
 391
 392       // We have to store the size in a const global, it's used in multiple
 393       // places.
 394       OS << "extern const unsigned " << Namespace
 395          << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i << "Dwarf2LSize";
 396       if (!isCtor)
 397         OS << " = array_lengthof(" << Namespace
 398            << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i
 399            << "Dwarf2L);\n\n";
 400       else
 401         OS << ";\n\n";
 402     }
 403   }
 404
 405   for (auto &RE : Regs) {
 406     Record *Reg = RE.TheDef;
 407     const RecordVal *V = Reg->getValue("DwarfAlias");
 408     if (!V || !V->getValue())
 409       continue;
 410
 411     DefInit *DI = cast<DefInit>(V->getValue());
 412     Record *Alias = DI->getDef();
 413     DwarfRegNums[Reg] = DwarfRegNums[Alias];
 414   }
 415
 416   // Emit information about the dwarf register numbers.
 417   for (unsigned j = 0; j < 2; ++j) {
 418     for (unsigned i = 0, e = maxLength; i != e; ++i) {
 419       OS << "extern const MCRegisterInfo::DwarfLLVMRegPair " << Namespace;
 420       OS << (j == 0 ? "DwarfFlavour" : "EHFlavour");
 421       OS << i << "L2Dwarf[]";
 422       if (!isCtor) {
 423         OS << " = {\n";
 424         // Store the mapping sorted by the Dwarf reg num so lookup can be done
 425         // with a binary search.
 426         for (DwarfRegNumsMapTy::iterator
 427                I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I) {
 428           int RegNo = I->second[i];
 429           if (RegNo == -1) // -1 is the default value, don't emit a mapping.
 430             continue;
 431
 432           OS << "  { " << getQualifiedName(I->first) << ", " << RegNo
 433              << "U },\n";
 434         }
 435         OS << "};\n";
 436       } else {
 437         OS << ";\n";
 438       }
 439
 440       // We have to store the size in a const global, it's used in multiple
 441       // places.
 442       OS << "extern const unsigned " << Namespace
 443          << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i << "L2DwarfSize";
 444       if (!isCtor)
 445         OS << " = array_lengthof(" << Namespace
 446            << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i << "L2Dwarf);\n\n";
 447       else
 448         OS << ";\n\n";
 449     }
 450   }
 451 }
 452
 453 void RegisterInfoEmitter::EmitRegMapping(
 454     raw_ostream &OS, const std::deque<CodeGenRegister> &Regs, bool isCtor) {
 455   // Emit the initializer so the tables from EmitRegMappingTables get wired up
 456   // to the MCRegisterInfo object.
 457   unsigned maxLength = 0;
 458   for (auto &RE : Regs) {
 459     Record *Reg = RE.TheDef;
 460     maxLength = std::max((size_t)maxLength,
 461                          Reg->getValueAsListOfInts("DwarfNumbers").size());
 462   }
 463
 464   if (!maxLength)
 465     return;
 466
 467   std::string Namespace = Regs.front().TheDef->getValueAsString("Namespace");
 468
 469   // Emit reverse information about the dwarf register numbers.
 470   for (unsigned j = 0; j < 2; ++j) {
 471     OS << "  switch (";
 472     if (j == 0)
 473       OS << "DwarfFlavour";
 474     else
 475       OS << "EHFlavour";
 476     OS << ") {\n"
 477      << "  default:\n"
 478      << "    llvm_unreachable(\"Unknown DWARF flavour\");\n";
 479
 480     for (unsigned i = 0, e = maxLength; i != e; ++i) {
 481       OS << "  case " << i << ":\n";
 482       OS << "    ";
 483       if (!isCtor)
 484         OS << "RI->";
 485       std::string Tmp;
 486       raw_string_ostream(Tmp) << Namespace
 487                               << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i
 488                               << "Dwarf2L";
 489       OS << "mapDwarfRegsToLLVMRegs(" << Tmp << ", " << Tmp << "Size, ";
 490       if (j == 0)
 491           OS << "false";
 492         else
 493           OS << "true";
 494       OS << ");\n";
 495       OS << "    break;\n";
 496     }
 497     OS << "  }\n";
 498   }
 499
 500   // Emit information about the dwarf register numbers.
 501   for (unsigned j = 0; j < 2; ++j) {
 502     OS << "  switch (";
 503     if (j == 0)
 504       OS << "DwarfFlavour";
 505     else
 506       OS << "EHFlavour";
 507     OS << ") {\n"
 508        << "  default:\n"
 509        << "    llvm_unreachable(\"Unknown DWARF flavour\");\n";
 510
 511     for (unsigned i = 0, e = maxLength; i != e; ++i) {
 512       OS << "  case " << i << ":\n";
 513       OS << "    ";
 514       if (!isCtor)
 515         OS << "RI->";
 516       std::string Tmp;
 517       raw_string_ostream(Tmp) << Namespace
 518                               << (j == 0 ? "DwarfFlavour" : "EHFlavour") << i
 519                               << "L2Dwarf";
 520       OS << "mapLLVMRegsToDwarfRegs(" << Tmp << ", " << Tmp << "Size, ";
 521       if (j == 0)
 522           OS << "false";
 523         else
 524           OS << "true";
 525       OS << ");\n";
 526       OS << "    break;\n";
 527     }
 528     OS << "  }\n";
 529   }
 530 }
 531
 532 // Print a BitVector as a sequence of hex numbers using a little-endian mapping.
 533 // Width is the number of bits per hex number.
 534 static void printBitVectorAsHex(raw_ostream &OS,
 535                                 const BitVector &Bits,
 536                                 unsigned Width) {
 537   assert(Width <= 32 && "Width too large");
 538   unsigned Digits = (Width + 3) / 4;
 539   for (unsigned i = 0, e = Bits.size(); i < e; i += Width) {
 540     unsigned Value = 0;
 541     for (unsigned j = 0; j != Width && i + j != e; ++j)
 542       Value |= Bits.test(i + j) << j;
 543     OS << format("0x%0*x, ", Digits, Value);
 544   }
 545 }
 546
 547 // Helper to emit a set of bits into a constant byte array.
 548 class BitVectorEmitter {
 549   BitVector Values;
 550 public:
 551   void add(unsigned v) {
 552     if (v >= Values.size())
 553       Values.resize(((v/8)+1)*8); // Round up to the next byte.
 554     Values[v] = true;
 555   }
 556
 557   void print(raw_ostream &OS) {
 558     printBitVectorAsHex(OS, Values, 8);
 559   }
 560 };
 561
 562 static void printSimpleValueType(raw_ostream &OS, MVT::SimpleValueType VT) {
 563   OS << getEnumName(VT);
 564 }
 565
 566 static void printSubRegIndex(raw_ostream &OS, const CodeGenSubRegIndex *Idx) {
 567   OS << Idx->EnumValue;
 568 }
 569
 570 // Differentially encoded register and regunit lists allow for better
 571 // compression on regular register banks. The sequence is computed from the
 572 // differential list as:
 573 //
 574 //   out[0] = InitVal;
 575 //   out[n+1] = out[n] + diff[n]; // n = 0, 1, ...
 576 //
 577 // The initial value depends on the specific list. The list is terminated by a
 578 // 0 differential which means we can't encode repeated elements.
 579
 580 typedef SmallVector<uint16_t, 4> DiffVec;
 581 typedef SmallVector<LaneBitmask, 4> MaskVec;
 582
 583 // Differentially encode a sequence of numbers into V. The starting value and
 584 // terminating 0 are not added to V, so it will have the same size as List.
 585 static
 586 DiffVec &diffEncode(DiffVec &V, unsigned InitVal, SparseBitVector<> List) {
 587   assert(V.empty() && "Clear DiffVec before diffEncode.");
 588   uint16_t Val = uint16_t(InitVal);
 589
 590   for (uint16_t Cur : List) {
 591     V.push_back(Cur - Val);
 592     Val = Cur;
 593   }
 594   return V;
 595 }
 596
 597 template<typename Iter>
 598 static
 599 DiffVec &diffEncode(DiffVec &V, unsigned InitVal, Iter Begin, Iter End) {
 600   assert(V.empty() && "Clear DiffVec before diffEncode.");
 601   uint16_t Val = uint16_t(InitVal);
 602   for (Iter I = Begin; I != End; ++I) {
 603     uint16_t Cur = (*I)->EnumValue;
 604     V.push_back(Cur - Val);
 605     Val = Cur;
 606   }
 607   return V;
 608 }
 609
 610 static void printDiff16(raw_ostream &OS, uint16_t Val) {
 611   OS << Val;
 612 }
 613
 614 static void printMask(raw_ostream &OS, LaneBitmask Val) {
 615   OS << "LaneBitmask(0x" << PrintLaneMask(Val) << ')';
 616 }
 617
 618 // Try to combine Idx's compose map into Vec if it is compatible.
 619 // Return false if it's not possible.
 620 static bool combine(const CodeGenSubRegIndex *Idx,
 621                     SmallVectorImpl<CodeGenSubRegIndex*> &Vec) {
 622   const CodeGenSubRegIndex::CompMap &Map = Idx->getComposites();
 623   for (const auto &I : Map) {
 624     CodeGenSubRegIndex *&Entry = Vec[I.first->EnumValue - 1];
 625     if (Entry && Entry != I.second)
 626       return false;
 627   }
 628
 629   // All entries are compatible. Make it so.
 630   for (const auto &I : Map) {
 631     auto *&Entry = Vec[I.first->EnumValue - 1];
 632     assert((!Entry || Entry == I.second) &&
 633            "Expected EnumValue to be unique");
 634     Entry = I.second;
 635   }
 636   return true;
 637 }
 638
 639 void
 640 RegisterInfoEmitter::emitComposeSubRegIndices(raw_ostream &OS,
 641                                               CodeGenRegBank &RegBank,
 642                                               const std::string &ClName) {
 643   const auto &SubRegIndices = RegBank.getSubRegIndices();
 644   OS << "unsigned " << ClName
 645      << "::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {\n";
 646
 647   // Many sub-register indexes are composition-compatible, meaning that
 648   //
 649   //   compose(IdxA, IdxB) == compose(IdxA', IdxB)
 650   //
 651   // for many IdxA, IdxA' pairs. Not all sub-register indexes can be composed.
 652   // The illegal entries can be use as wildcards to compress the table further.
 653
 654   // Map each Sub-register index to a compatible table row.
 655   SmallVector<unsigned, 4> RowMap;
 656   SmallVector<SmallVector<CodeGenSubRegIndex*, 4>, 4> Rows;
 657
 658   auto SubRegIndicesSize =
 659       std::distance(SubRegIndices.begin(), SubRegIndices.end());
 660   for (const auto &Idx : SubRegIndices) {
 661     unsigned Found = ~0u;
 662     for (unsigned r = 0, re = Rows.size(); r != re; ++r) {
 663       if (combine(&Idx, Rows[r])) {
 664         Found = r;
 665         break;
 666       }
 667     }
 668     if (Found == ~0u) {
 669       Found = Rows.size();
 670       Rows.resize(Found + 1);
 671       Rows.back().resize(SubRegIndicesSize);
 672       combine(&Idx, Rows.back());
 673     }
 674     RowMap.push_back(Found);
 675   }
 676
 677   // Output the row map if there is multiple rows.
 678   if (Rows.size() > 1) {
 679     OS << "  static const " << getMinimalTypeForRange(Rows.size(), 32)
 680        << " RowMap[" << SubRegIndicesSize << "] = {\n    ";
 681     for (unsigned i = 0, e = SubRegIndicesSize; i != e; ++i)
 682       OS << RowMap[i] << ", ";
 683     OS << "\n  };\n";
 684   }
 685
 686   // Output the rows.
 687   OS << "  static const " << getMinimalTypeForRange(SubRegIndicesSize + 1, 32)
 688      << " Rows[" << Rows.size() << "][" << SubRegIndicesSize << "] = {\n";
 689   for (unsigned r = 0, re = Rows.size(); r != re; ++r) {
 690     OS << "    { ";
 691     for (unsigned i = 0, e = SubRegIndicesSize; i != e; ++i)
 692       if (Rows[r][i])
 693         OS << Rows[r][i]->EnumValue << ", ";
 694       else
 695         OS << "0, ";
 696     OS << "},\n";
 697   }
 698   OS << "  };\n\n";
 699
 700   OS << "  --IdxA; assert(IdxA < " << SubRegIndicesSize << ");\n"
 701      << "  --IdxB; assert(IdxB < " << SubRegIndicesSize << ");\n";
 702   if (Rows.size() > 1)
 703     OS << "  return Rows[RowMap[IdxA]][IdxB];\n";
 704   else
 705     OS << "  return Rows[0][IdxB];\n";
 706   OS << "}\n\n";
 707 }
 708
 709 void
 710 RegisterInfoEmitter::emitComposeSubRegIndexLaneMask(raw_ostream &OS,
 711                                                     CodeGenRegBank &RegBank,
 712                                                     const std::string &ClName) {
 713   // See the comments in computeSubRegLaneMasks() for our goal here.
 714   const auto &SubRegIndices = RegBank.getSubRegIndices();
 715
 716   // Create a list of Mask+Rotate operations, with equivalent entries merged.
 717   SmallVector<unsigned, 4> SubReg2SequenceIndexMap;
 718   SmallVector<SmallVector<MaskRolPair, 1>, 4> Sequences;
 719   for (const auto &Idx : SubRegIndices) {
 720     const SmallVector<MaskRolPair, 1> &IdxSequence
 721       = Idx.CompositionLaneMaskTransform;
 722
 723     unsigned Found = ~0u;
 724     unsigned SIdx = 0;
 725     unsigned NextSIdx;
 726     for (size_t s = 0, se = Sequences.size(); s != se; ++s, SIdx = NextSIdx) {
 727       SmallVectorImpl<MaskRolPair> &Sequence = Sequences[s];
 728       NextSIdx = SIdx + Sequence.size() + 1;
 729       if (Sequence == IdxSequence) {
 730         Found = SIdx;
 731         break;
 732       }
 733     }
 734     if (Found == ~0u) {
 735       Sequences.push_back(IdxSequence);
 736       Found = SIdx;
 737     }
 738     SubReg2SequenceIndexMap.push_back(Found);
 739   }
 740
 741   OS << "  struct MaskRolOp {\n"
 742         "    LaneBitmask Mask;\n"
 743         "    uint8_t  RotateLeft;\n"
 744         "  };\n"
 745         "  static const MaskRolOp LaneMaskComposeSequences[] = {\n";
 746   unsigned Idx = 0;
 747   for (size_t s = 0, se = Sequences.size(); s != se; ++s) {
 748     OS << "    ";
 749     const SmallVectorImpl<MaskRolPair> &Sequence = Sequences[s];
 750     for (size_t p = 0, pe = Sequence.size(); p != pe; ++p) {
 751       const MaskRolPair &P = Sequence[p];
 752       printMask(OS << "{ ", P.Mask);
 753       OS << format(", %2u }, ", P.RotateLeft);
 754     }
 755     OS << "{ LaneBitmask::getNone(), 0 }";
 756     if (s+1 != se)
 757       OS << ", ";
 758     OS << "  // Sequence " << Idx << "\n";
 759     Idx += Sequence.size() + 1;
 760   }
 761   OS << "  };\n"
 762         "  static const MaskRolOp *const CompositeSequences[] = {\n";
 763   for (size_t i = 0, e = SubRegIndices.size(); i != e; ++i) {
 764     OS << "    ";
 765     unsigned Idx = SubReg2SequenceIndexMap[i];
 766     OS << format("&LaneMaskComposeSequences[%u]", Idx);
 767     if (i+1 != e)
 768       OS << ",";
 769     OS << " // to " << SubRegIndices[i].getName() << "\n";
 770   }
 771   OS << "  };\n\n";
 772
 773   OS << "LaneBitmask " << ClName
 774      << "::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask)"
 775         " const {\n"
 776         "  --IdxA; assert(IdxA < " << SubRegIndices.size()
 777      << " && \"Subregister index out of bounds\");\n"
 778         "  LaneBitmask Result;\n"
 779         "  for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {\n"
 780         "    LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();\n"
 781         "    if (unsigned S = Ops->RotateLeft)\n"
 782         "      Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));\n"
 783         "    else\n"
 784         "      Result |= LaneBitmask(M);\n"
 785         "  }\n"
 786         "  return Result;\n"
 787         "}\n\n";
 788
 789   OS << "LaneBitmask " << ClName
 790      << "::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA, "
 791         " LaneBitmask LaneMask) const {\n"
 792         "  LaneMask &= getSubRegIndexLaneMask(IdxA);\n"
 793         "  --IdxA; assert(IdxA < " << SubRegIndices.size()
 794      << " && \"Subregister index out of bounds\");\n"
 795         "  LaneBitmask Result;\n"
 796         "  for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {\n"
 797         "    LaneBitmask::Type M = LaneMask.getAsInteger();\n"
 798         "    if (unsigned S = Ops->RotateLeft)\n"
 799         "      Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));\n"
 800         "    else\n"
 801         "      Result |= LaneBitmask(M);\n"
 802         "  }\n"
 803         "  return Result;\n"
 804         "}\n\n";
 805 }
 806
 807 //
 808 // runMCDesc - Print out MC register descriptions.
 809 //
 810 void
 811 RegisterInfoEmitter::runMCDesc(raw_ostream &OS, CodeGenTarget &Target,
 812                                CodeGenRegBank &RegBank) {
 813   emitSourceFileHeader("MC Register Information", OS);
 814
 815   OS << "\n#ifdef GET_REGINFO_MC_DESC\n";
 816   OS << "#undef GET_REGINFO_MC_DESC\n\n";
 817
 818   const auto &Regs = RegBank.getRegisters();
 819
 820   auto &SubRegIndices = RegBank.getSubRegIndices();
 821   // The lists of sub-registers and super-registers go in the same array.  That
 822   // allows us to share suffixes.
 823   typedef std::vector<const CodeGenRegister*> RegVec;
 824
 825   // Differentially encoded lists.
 826   SequenceToOffsetTable<DiffVec> DiffSeqs;
 827   SmallVector<DiffVec, 4> SubRegLists(Regs.size());
 828   SmallVector<DiffVec, 4> SuperRegLists(Regs.size());
 829   SmallVector<DiffVec, 4> RegUnitLists(Regs.size());
 830   SmallVector<unsigned, 4> RegUnitInitScale(Regs.size());
 831
 832   // List of lane masks accompanying register unit sequences.
 833   SequenceToOffsetTable<MaskVec> LaneMaskSeqs;
 834   SmallVector<MaskVec, 4> RegUnitLaneMasks(Regs.size());
 835
 836   // Keep track of sub-register names as well. These are not differentially
 837   // encoded.
 838   typedef SmallVector<const CodeGenSubRegIndex*, 4> SubRegIdxVec;
 839   SequenceToOffsetTable<SubRegIdxVec, deref<llvm::less>> SubRegIdxSeqs;
 840   SmallVector<SubRegIdxVec, 4> SubRegIdxLists(Regs.size());
 841
 842   SequenceToOffsetTable<std::string> RegStrings;
 843
 844   // Precompute register lists for the SequenceToOffsetTable.
 845   unsigned i = 0;
 846   for (auto I = Regs.begin(), E = Regs.end(); I != E; ++I, ++i) {
 847     const auto &Reg = *I;
 848     RegStrings.add(Reg.getName());
 849
 850     // Compute the ordered sub-register list.
 851     SetVector<const CodeGenRegister*> SR;
 852     Reg.addSubRegsPreOrder(SR, RegBank);
 853     diffEncode(SubRegLists[i], Reg.EnumValue, SR.begin(), SR.end());
 854     DiffSeqs.add(SubRegLists[i]);
 855
 856     // Compute the corresponding sub-register indexes.
 857     SubRegIdxVec &SRIs = SubRegIdxLists[i];
 858     for (unsigned j = 0, je = SR.size(); j != je; ++j)
 859       SRIs.push_back(Reg.getSubRegIndex(SR[j]));
 860     SubRegIdxSeqs.add(SRIs);
 861
 862     // Super-registers are already computed.
 863     const RegVec &SuperRegList = Reg.getSuperRegs();
 864     diffEncode(SuperRegLists[i], Reg.EnumValue, SuperRegList.begin(),
 865                SuperRegList.end());
 866     DiffSeqs.add(SuperRegLists[i]);
 867
 868     // Differentially encode the register unit list, seeded by register number.
 869     // First compute a scale factor that allows more diff-lists to be reused:
 870     //
 871     //   D0 -> (S0, S1)
 872     //   D1 -> (S2, S3)
 873     //
 874     // A scale factor of 2 allows D0 and D1 to share a diff-list. The initial
 875     // value for the differential decoder is the register number multiplied by
 876     // the scale.
 877     //
 878     // Check the neighboring registers for arithmetic progressions.
 879     unsigned ScaleA = ~0u, ScaleB = ~0u;
 880     SparseBitVector<> RUs = Reg.getNativeRegUnits();
 881     if (I != Regs.begin() &&
 882         std::prev(I)->getNativeRegUnits().count() == RUs.count())
 883       ScaleB = *RUs.begin() - *std::prev(I)->getNativeRegUnits().begin();
 884     if (std::next(I) != Regs.end() &&
 885         std::next(I)->getNativeRegUnits().count() == RUs.count())
 886       ScaleA = *std::next(I)->getNativeRegUnits().begin() - *RUs.begin();
 887     unsigned Scale = std::min(ScaleB, ScaleA);
 888     // Default the scale to 0 if it can't be encoded in 4 bits.
 889     if (Scale >= 16)
 890       Scale = 0;
 891     RegUnitInitScale[i] = Scale;
 892     DiffSeqs.add(diffEncode(RegUnitLists[i], Scale * Reg.EnumValue, RUs));
 893
 894     const auto &RUMasks = Reg.getRegUnitLaneMasks();
 895     MaskVec &LaneMaskVec = RegUnitLaneMasks[i];
 896     assert(LaneMaskVec.empty());
 897     LaneMaskVec.insert(LaneMaskVec.begin(), RUMasks.begin(), RUMasks.end());
 898     // Terminator mask should not be used inside of the list.
 899 #ifndef NDEBUG
 900     for (LaneBitmask M : LaneMaskVec) {
 901       assert(!M.all() && "terminator mask should not be part of the list");
 902     }
 903 #endif
 904     LaneMaskSeqs.add(LaneMaskVec);
 905   }
 906
 907   // Compute the final layout of the sequence table.
 908   DiffSeqs.layout();
 909   LaneMaskSeqs.layout();
 910   SubRegIdxSeqs.layout();
 911
 912   OS << "namespace llvm {\n\n";
 913
 914   const std::string &TargetName = Target.getName();
 915
 916   // Emit the shared table of differential lists.
 917   OS << "extern const MCPhysReg " << TargetName << "RegDiffLists[] = {\n";
 918   DiffSeqs.emit(OS, printDiff16);
 919   OS << "};\n\n";
 920
 921   // Emit the shared table of regunit lane mask sequences.
 922   OS << "extern const LaneBitmask " << TargetName << "LaneMaskLists[] = {\n";
 923   LaneMaskSeqs.emit(OS, printMask, "LaneBitmask::getAll()");
 924   OS << "};\n\n";
 925
 926   // Emit the table of sub-register indexes.
 927   OS << "extern const uint16_t " << TargetName << "SubRegIdxLists[] = {\n";
 928   SubRegIdxSeqs.emit(OS, printSubRegIndex);
 929   OS << "};\n\n";
 930
 931   // Emit the table of sub-register index sizes.
 932   OS << "extern const MCRegisterInfo::SubRegCoveredBits "
 933      << TargetName << "SubRegIdxRanges[] = {\n";
 934   OS << "  { " << (uint16_t)-1 << ", " << (uint16_t)-1 << " },\n";
 935   for (const auto &Idx : SubRegIndices) {
 936     OS << "  { " << Idx.Offset << ", " << Idx.Size << " },\t// "
 937        << Idx.getName() << "\n";
 938   }
 939   OS << "};\n\n";
 940
 941   // Emit the string table.
 942   RegStrings.layout();
 943   OS << "extern const char " << TargetName << "RegStrings[] = {\n";
 944   RegStrings.emit(OS, printChar);
 945   OS << "};\n\n";
 946
 947   OS << "extern const MCRegisterDesc " << TargetName
 948      << "RegDesc[] = { // Descriptors\n";
 949   OS << "  { " << RegStrings.get("") << ", 0, 0, 0, 0, 0 },\n";
 950
 951   // Emit the register descriptors now.
 952   i = 0;
 953   for (const auto &Reg : Regs) {
 954     OS << "  { " << RegStrings.get(Reg.getName()) << ", "
 955        << DiffSeqs.get(SubRegLists[i]) << ", " << DiffSeqs.get(SuperRegLists[i])
 956        << ", " << SubRegIdxSeqs.get(SubRegIdxLists[i]) << ", "
 957        << (DiffSeqs.get(RegUnitLists[i]) * 16 + RegUnitInitScale[i]) << ", "
 958        << LaneMaskSeqs.get(RegUnitLaneMasks[i]) << " },\n";
 959     ++i;
 960   }
 961   OS << "};\n\n";      // End of register descriptors...
 962
 963   // Emit the table of register unit roots. Each regunit has one or two root
 964   // registers.
 965   OS << "extern const MCPhysReg " << TargetName << "RegUnitRoots[][2] = {\n";
 966   for (unsigned i = 0, e = RegBank.getNumNativeRegUnits(); i != e; ++i) {
 967     ArrayRef<const CodeGenRegister*> Roots = RegBank.getRegUnit(i).getRoots();
 968     assert(!Roots.empty() && "All regunits must have a root register.");
 969     assert(Roots.size() <= 2 && "More than two roots not supported yet.");
 970     OS << "  { " << getQualifiedName(Roots.front()->TheDef);
 971     for (unsigned r = 1; r != Roots.size(); ++r)
 972       OS << ", " << getQualifiedName(Roots[r]->TheDef);
 973     OS << " },\n";
 974   }
 975   OS << "};\n\n";
 976
 977   const auto &RegisterClasses = RegBank.getRegClasses();
 978
 979   // Loop over all of the register classes... emitting each one.
 980   OS << "namespace {     // Register classes...\n";
 981
 982   SequenceToOffsetTable<std::string> RegClassStrings;
 983
 984   // Emit the register enum value arrays for each RegisterClass
 985   for (const auto &RC : RegisterClasses) {
 986     ArrayRef<Record*> Order = RC.getOrder();
 987
 988     // Give the register class a legal C name if it's anonymous.
 989     const std::string &Name = RC.getName();
 990
 991     RegClassStrings.add(Name);
 992
 993     // Emit the register list now.
 994     OS << "  // " << Name << " Register Class...\n"
 995        << "  const MCPhysReg " << Name
 996        << "[] = {\n    ";
 997     for (unsigned i = 0, e = Order.size(); i != e; ++i) {
 998       Record *Reg = Order[i];
 999       OS << getQualifiedName(Reg) << ", ";
1000     }
1001     OS << "\n  };\n\n";
1002
1003     OS << "  // " << Name << " Bit set.\n"
1004        << "  const uint8_t " << Name
1005        << "Bits[] = {\n    ";
1006     BitVectorEmitter BVE;
1007     for (unsigned i = 0, e = Order.size(); i != e; ++i) {
1008       Record *Reg = Order[i];
1009       BVE.add(Target.getRegBank().getReg(Reg)->EnumValue);
1010     }
1011     BVE.print(OS);
1012     OS << "\n  };\n\n";
1013
1014   }
1015   OS << "} // end anonymous namespace\n\n";
1016
1017   RegClassStrings.layout();
1018   OS << "extern const char " << TargetName << "RegClassStrings[] = {\n";
1019   RegClassStrings.emit(OS, printChar);
1020   OS << "};\n\n";
1021
1022   OS << "extern const MCRegisterClass " << TargetName
1023      << "MCRegisterClasses[] = {\n";
1024
1025   for (const auto &RC : RegisterClasses) {
1026     // Asserts to make sure values will fit in table assuming types from
1027     // MCRegisterInfo.h
1028     assert((RC.SpillSize/8) <= 0xffff && "SpillSize too large.");
1029     assert((RC.SpillAlignment/8) <= 0xffff && "SpillAlignment too large.");
1030     assert(RC.CopyCost >= -128 && RC.CopyCost <= 127 && "Copy cost too large.");
1031
1032     OS << "  { " << RC.getName() << ", " << RC.getName() << "Bits, "
1033        << RegClassStrings.get(RC.getName()) << ", "
1034        << RC.getOrder().size() << ", sizeof(" << RC.getName() << "Bits), "
1035        << RC.getQualifiedName() + "RegClassID" << ", "
1036        << RC.SpillSize/8 << ", "
1037        << RC.SpillAlignment/8 << ", "
1038        << RC.CopyCost << ", "
1039        << ( RC.Allocatable ? "true" : "false" ) << " },\n";
1040   }
1041
1042   OS << "};\n\n";
1043
1044   EmitRegMappingTables(OS, Regs, false);
1045
1046   // Emit Reg encoding table
1047   OS << "extern const uint16_t " << TargetName;
1048   OS << "RegEncodingTable[] = {\n";
1049   // Add entry for NoRegister
1050   OS << "  0,\n";
1051   for (const auto &RE : Regs) {
1052     Record *Reg = RE.TheDef;
1053     BitsInit *BI = Reg->getValueAsBitsInit("HWEncoding");
1054     uint64_t Value = 0;
1055     for (unsigned b = 0, be = BI->getNumBits(); b != be; ++b) {
1056       if (BitInit *B = dyn_cast<BitInit>(BI->getBit(b)))
1057         Value |= (uint64_t)B->getValue() << b;
1058     }
1059     OS << "  " << Value << ",\n";
1060   }
1061   OS << "};\n";       // End of HW encoding table
1062
1063   // MCRegisterInfo initialization routine.
1064   OS << "static inline void Init" << TargetName
1065      << "MCRegisterInfo(MCRegisterInfo *RI, unsigned RA, "
1066      << "unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) "
1067         "{\n"
1068      << "  RI->InitMCRegisterInfo(" << TargetName << "RegDesc, "
1069      << Regs.size() + 1 << ", RA, PC, " << TargetName << "MCRegisterClasses, "
1070      << RegisterClasses.size() << ", " << TargetName << "RegUnitRoots, "
1071      << RegBank.getNumNativeRegUnits() << ", " << TargetName << "RegDiffLists, "
1072      << TargetName << "LaneMaskLists, " << TargetName << "RegStrings, "
1073      << TargetName << "RegClassStrings, " << TargetName << "SubRegIdxLists, "
1074      << (std::distance(SubRegIndices.begin(), SubRegIndices.end()) + 1) << ",\n"
1075      << TargetName << "SubRegIdxRanges, " << TargetName
1076      << "RegEncodingTable);\n\n";
1077
1078   EmitRegMapping(OS, Regs, false);
1079
1080   OS << "}\n\n";
1081
1082   OS << "} // end namespace llvm\n\n";
1083   OS << "#endif // GET_REGINFO_MC_DESC\n\n";
1084 }
1085
1086 void
1087 RegisterInfoEmitter::runTargetHeader(raw_ostream &OS, CodeGenTarget &Target,
1088                                      CodeGenRegBank &RegBank) {
1089   emitSourceFileHeader("Register Information Header Fragment", OS);
1090
1091   OS << "\n#ifdef GET_REGINFO_HEADER\n";
1092   OS << "#undef GET_REGINFO_HEADER\n\n";
1093
1094   const std::string &TargetName = Target.getName();
1095   std::string ClassName = TargetName + "GenRegisterInfo";
1096
1097   OS << "#include \"llvm/Target/TargetRegisterInfo.h\"\n\n";
1098
1099   OS << "namespace llvm {\n\n";
1100
1101   OS << "class " << TargetName << "FrameLowering;\n\n";
1102
1103   OS << "struct " << ClassName << " : public TargetRegisterInfo {\n"
1104      << "  explicit " << ClassName
1105      << "(unsigned RA, unsigned D = 0, unsigned E = 0, unsigned PC = 0);\n";
1106   if (!RegBank.getSubRegIndices().empty()) {
1107     OS << "  unsigned composeSubRegIndicesImpl"
1108        << "(unsigned, unsigned) const override;\n"
1109        << "  LaneBitmask composeSubRegIndexLaneMaskImpl"
1110        << "(unsigned, LaneBitmask) const override;\n"
1111        << "  LaneBitmask reverseComposeSubRegIndexLaneMaskImpl"
1112        << "(unsigned, LaneBitmask) const override;\n"
1113        << "  const TargetRegisterClass *getSubClassWithSubReg"
1114        << "(const TargetRegisterClass*, unsigned) const override;\n";
1115   }
1116   OS << "  const RegClassWeight &getRegClassWeight("
1117      << "const TargetRegisterClass *RC) const override;\n"
1118      << "  unsigned getRegUnitWeight(unsigned RegUnit) const override;\n"
1119      << "  unsigned getNumRegPressureSets() const override;\n"
1120      << "  const char *getRegPressureSetName(unsigned Idx) const override;\n"
1121      << "  unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned "
1122         "Idx) const override;\n"
1123      << "  const int *getRegClassPressureSets("
1124      << "const TargetRegisterClass *RC) const override;\n"
1125      << "  const int *getRegUnitPressureSets("
1126      << "unsigned RegUnit) const override;\n"
1127      << "  ArrayRef<const char *> getRegMaskNames() const override;\n"
1128      << "  ArrayRef<const uint32_t *> getRegMasks() const override;\n"
1129      << "  /// Devirtualized TargetFrameLowering.\n"
1130      << "  static const " << TargetName << "FrameLowering *getFrameLowering(\n"
1131      << "      const MachineFunction &MF);\n"
1132      << "};\n\n";
1133
1134   const auto &RegisterClasses = RegBank.getRegClasses();
1135
1136   if (!RegisterClasses.empty()) {
1137     OS << "namespace " << RegisterClasses.front().Namespace
1138        << " { // Register classes\n";
1139
1140     for (const auto &RC : RegisterClasses) {
1141       const std::string &Name = RC.getName();
1142
1143       // Output the extern for the instance.
1144       OS << "  extern const TargetRegisterClass " << Name << "RegClass;\n";
1145     }
1146     OS << "} // end namespace " << RegisterClasses.front().Namespace << "\n\n";
1147   }
1148   OS << "} // end namespace llvm\n\n";
1149   OS << "#endif // GET_REGINFO_HEADER\n\n";
1150 }
1151
1152 //
1153 // runTargetDesc - Output the target register and register file descriptions.
1154 //
1155 void
1156 RegisterInfoEmitter::runTargetDesc(raw_ostream &OS, CodeGenTarget &Target,
1157                                    CodeGenRegBank &RegBank){
1158   emitSourceFileHeader("Target Register and Register Classes Information", OS);
1159
1160   OS << "\n#ifdef GET_REGINFO_TARGET_DESC\n";
1161   OS << "#undef GET_REGINFO_TARGET_DESC\n\n";
1162
1163   OS << "namespace llvm {\n\n";
1164
1165   // Get access to MCRegisterClass data.
1166   OS << "extern const MCRegisterClass " << Target.getName()
1167      << "MCRegisterClasses[];\n";
1168
1169   // Start out by emitting each of the register classes.
1170   const auto &RegisterClasses = RegBank.getRegClasses();
1171   const auto &SubRegIndices = RegBank.getSubRegIndices();
1172
1173   // Collect all registers belonging to any allocatable class.
1174   std::set<Record*> AllocatableRegs;
1175
1176   // Collect allocatable registers.
1177   for (const auto &RC : RegisterClasses) {
1178     ArrayRef<Record*> Order = RC.getOrder();
1179
1180     if (RC.Allocatable)
1181       AllocatableRegs.insert(Order.begin(), Order.end());
1182   }
1183
1184   // Build a shared array of value types.
1185   SequenceToOffsetTable<SmallVector<MVT::SimpleValueType, 4> > VTSeqs;
1186   for (const auto &RC : RegisterClasses)
1187     VTSeqs.add(RC.VTs);
1188   VTSeqs.layout();
1189   OS << "\nstatic const MVT::SimpleValueType VTLists[] = {\n";
1190   VTSeqs.emit(OS, printSimpleValueType, "MVT::Other");
1191   OS << "};\n";
1192
1193   // Emit SubRegIndex names, skipping 0.
1194   OS << "\nstatic const char *const SubRegIndexNameTable[] = { \"";
1195
1196   for (const auto &Idx : SubRegIndices) {
1197     OS << Idx.getName();
1198     OS << "\", \"";
1199   }
1200   OS << "\" };\n\n";
1201
1202   // Emit SubRegIndex lane masks, including 0.
1203   OS << "\nstatic const LaneBitmask SubRegIndexLaneMaskTable[] = {\n  LaneBitmask::getAll(),\n";
1204   for (const auto &Idx : SubRegIndices) {
1205     printMask(OS << "  ", Idx.LaneMask);
1206     OS << ", // " << Idx.getName() << '\n';
1207   }
1208   OS << " };\n\n";
1209
1210   OS << "\n";
1211
1212   // Now that all of the structs have been emitted, emit the instances.
1213   if (!RegisterClasses.empty()) {
1214     OS << "\nstatic const TargetRegisterClass *const "
1215        << "NullRegClasses[] = { nullptr };\n\n";
1216
1217     // Emit register class bit mask tables. The first bit mask emitted for a
1218     // register class, RC, is the set of sub-classes, including RC itself.
1219     //
1220     // If RC has super-registers, also create a list of subreg indices and bit
1221     // masks, (Idx, Mask). The bit mask has a bit for every superreg regclass,
1222     // SuperRC, that satisfies:
1223     //
1224     //   For all SuperReg in SuperRC: SuperReg:Idx in RC
1225     //
1226     // The 0-terminated list of subreg indices starts at:
1227     //
1228     //   RC->getSuperRegIndices() = SuperRegIdxSeqs + ...
1229     //
1230     // The corresponding bitmasks follow the sub-class mask in memory. Each
1231     // mask has RCMaskWords uint32_t entries.
1232     //
1233     // Every bit mask present in the list has at least one bit set.
1234
1235     // Compress the sub-reg index lists.
1236     typedef std::vector<const CodeGenSubRegIndex*> IdxList;
1237     SmallVector<IdxList, 8> SuperRegIdxLists(RegisterClasses.size());
1238     SequenceToOffsetTable<IdxList, deref<llvm::less>> SuperRegIdxSeqs;
1239     BitVector MaskBV(RegisterClasses.size());
1240
1241     for (const auto &RC : RegisterClasses) {
1242       OS << "static const uint32_t " << RC.getName() << "SubClassMask[] = {\n  ";
1243       printBitVectorAsHex(OS, RC.getSubClasses(), 32);
1244
1245       // Emit super-reg class masks for any relevant SubRegIndices that can
1246       // project into RC.
1247       IdxList &SRIList = SuperRegIdxLists[RC.EnumValue];
1248       for (auto &Idx : SubRegIndices) {
1249         MaskBV.reset();
1250         RC.getSuperRegClasses(&Idx, MaskBV);
1251         if (MaskBV.none())
1252           continue;
1253         SRIList.push_back(&Idx);
1254         OS << "\n  ";
1255         printBitVectorAsHex(OS, MaskBV, 32);
1256         OS << "// " << Idx.getName();
1257       }
1258       SuperRegIdxSeqs.add(SRIList);
1259       OS << "\n};\n\n";
1260     }
1261
1262     OS << "static const uint16_t SuperRegIdxSeqs[] = {\n";
1263     SuperRegIdxSeqs.layout();
1264     SuperRegIdxSeqs.emit(OS, printSubRegIndex);
1265     OS << "};\n\n";
1266
1267     // Emit NULL terminated super-class lists.
1268     for (const auto &RC : RegisterClasses) {
1269       ArrayRef<CodeGenRegisterClass*> Supers = RC.getSuperClasses();
1270
1271       // Skip classes without supers.  We can reuse NullRegClasses.
1272       if (Supers.empty())
1273         continue;
1274
1275       OS << "static const TargetRegisterClass *const "
1276          << RC.getName() << "Superclasses[] = {\n";
1277       for (const auto *Super : Supers)
1278         OS << "  &" << Super->getQualifiedName() << "RegClass,\n";
1279       OS << "  nullptr\n};\n\n";
1280     }
1281
1282     // Emit methods.
1283     for (const auto &RC : RegisterClasses) {
1284       if (!RC.AltOrderSelect.empty()) {
1285         OS << "\nstatic inline unsigned " << RC.getName()
1286            << "AltOrderSelect(const MachineFunction &MF) {"
1287            << RC.AltOrderSelect << "}\n\n"
1288            << "static ArrayRef<MCPhysReg> " << RC.getName()
1289            << "GetRawAllocationOrder(const MachineFunction &MF) {\n";
1290         for (unsigned oi = 1 , oe = RC.getNumOrders(); oi != oe; ++oi) {
1291           ArrayRef<Record*> Elems = RC.getOrder(oi);
1292           if (!Elems.empty()) {
1293             OS << "  static const MCPhysReg AltOrder" << oi << "[] = {";
1294             for (unsigned elem = 0; elem != Elems.size(); ++elem)
1295               OS << (elem ? ", " : " ") << getQualifiedName(Elems[elem]);
1296             OS << " };\n";
1297           }
1298         }
1299         OS << "  const MCRegisterClass &MCR = " << Target.getName()
1300            << "MCRegisterClasses[" << RC.getQualifiedName() + "RegClassID];\n"
1301            << "  const ArrayRef<MCPhysReg> Order[] = {\n"
1302            << "    makeArrayRef(MCR.begin(), MCR.getNumRegs()";
1303         for (unsigned oi = 1, oe = RC.getNumOrders(); oi != oe; ++oi)
1304           if (RC.getOrder(oi).empty())
1305             OS << "),\n    ArrayRef<MCPhysReg>(";
1306           else
1307             OS << "),\n    makeArrayRef(AltOrder" << oi;
1308         OS << ")\n  };\n  const unsigned Select = " << RC.getName()
1309            << "AltOrderSelect(MF);\n  assert(Select < " << RC.getNumOrders()
1310            << ");\n  return Order[Select];\n}\n";
1311       }
1312     }
1313
1314     // Now emit the actual value-initialized register class instances.
1315     OS << "\nnamespace " << RegisterClasses.front().Namespace
1316        << " {   // Register class instances\n";
1317
1318     for (const auto &RC : RegisterClasses) {
1319       OS << "  extern const TargetRegisterClass " << RC.getName()
1320          << "RegClass = {\n    " << '&' << Target.getName()
1321          << "MCRegisterClasses[" << RC.getName() << "RegClassID],\n    "
1322          << "VTLists + " << VTSeqs.get(RC.VTs) << ",\n    " << RC.getName()
1323          << "SubClassMask,\n    SuperRegIdxSeqs + "
1324          << SuperRegIdxSeqs.get(SuperRegIdxLists[RC.EnumValue]) << ",\n    ";
1325       printMask(OS, RC.LaneMask);
1326       OS << ",\n    " << (unsigned)RC.AllocationPriority << ",\n    "
1327          << (RC.HasDisjunctSubRegs?"true":"false")
1328          << ", /* HasDisjunctSubRegs */\n    "
1329          << (RC.CoveredBySubRegs?"true":"false")
1330          << ", /* CoveredBySubRegs */\n    ";
1331       if (RC.getSuperClasses().empty())
1332         OS << "NullRegClasses,\n    ";
1333       else
1334         OS << RC.getName() << "Superclasses,\n    ";
1335       if (RC.AltOrderSelect.empty())
1336         OS << "nullptr\n";
1337       else
1338         OS << RC.getName() << "GetRawAllocationOrder\n";
1339       OS << "  };\n\n";
1340     }
1341
1342     OS << "} // end namespace " << RegisterClasses.front().Namespace << "\n";
1343   }
1344
1345   OS << "\nnamespace {\n";
1346   OS << "  const TargetRegisterClass* const RegisterClasses[] = {\n";
1347   for (const auto &RC : RegisterClasses)
1348     OS << "    &" << RC.getQualifiedName() << "RegClass,\n";
1349   OS << "  };\n";
1350   OS << "} // end anonymous namespace\n";
1351
1352   // Emit extra information about registers.
1353   const std::string &TargetName = Target.getName();
1354   OS << "\nstatic const TargetRegisterInfoDesc "
1355      << TargetName << "RegInfoDesc[] = { // Extra Descriptors\n";
1356   OS << "  { 0, false },\n";
1357
1358   const auto &Regs = RegBank.getRegisters();
1359   for (const auto &Reg : Regs) {
1360     OS << "  { ";
1361     OS << Reg.CostPerUse << ", "
1362        << ( AllocatableRegs.count(Reg.TheDef) != 0 ? "true" : "false" )
1363        << " },\n";
1364   }
1365   OS << "};\n";      // End of register descriptors...
1366
1367
1368   std::string ClassName = Target.getName().str() + "GenRegisterInfo";
1369
1370   auto SubRegIndicesSize =
1371       std::distance(SubRegIndices.begin(), SubRegIndices.end());
1372
1373   if (!SubRegIndices.empty()) {
1374     emitComposeSubRegIndices(OS, RegBank, ClassName);
1375     emitComposeSubRegIndexLaneMask(OS, RegBank, ClassName);
1376   }
1377
1378   // Emit getSubClassWithSubReg.
1379   if (!SubRegIndices.empty()) {
1380     OS << "const TargetRegisterClass *" << ClassName
1381        << "::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx)"
1382        << " const {\n";
1383     // Use the smallest type that can hold a regclass ID with room for a
1384     // sentinel.
1385     if (RegisterClasses.size() < UINT8_MAX)
1386       OS << "  static const uint8_t Table[";
1387     else if (RegisterClasses.size() < UINT16_MAX)
1388       OS << "  static const uint16_t Table[";
1389     else
1390       PrintFatalError("Too many register classes.");
1391     OS << RegisterClasses.size() << "][" << SubRegIndicesSize << "] = {\n";
1392     for (const auto &RC : RegisterClasses) {
1393       OS << "    {\t// " << RC.getName() << "\n";
1394       for (auto &Idx : SubRegIndices) {
1395         if (CodeGenRegisterClass *SRC = RC.getSubClassWithSubReg(&Idx))
1396           OS << "      " << SRC->EnumValue + 1 << ",\t// " << Idx.getName()
1397              << " -> " << SRC->getName() << "\n";
1398         else
1399           OS << "      0,\t// " << Idx.getName() << "\n";
1400       }
1401       OS << "    },\n";
1402     }
1403     OS << "  };\n  assert(RC && \"Missing regclass\");\n"
1404        << "  if (!Idx) return RC;\n  --Idx;\n"
1405        << "  assert(Idx < " << SubRegIndicesSize << " && \"Bad subreg\");\n"
1406        << "  unsigned TV = Table[RC->getID()][Idx];\n"
1407        << "  return TV ? getRegClass(TV - 1) : nullptr;\n}\n\n";
1408   }
1409
1410   EmitRegUnitPressure(OS, RegBank, ClassName);
1411
1412   // Emit the constructor of the class...
1413   OS << "extern const MCRegisterDesc " << TargetName << "RegDesc[];\n";
1414   OS << "extern const MCPhysReg " << TargetName << "RegDiffLists[];\n";
1415   OS << "extern const LaneBitmask " << TargetName << "LaneMaskLists[];\n";
1416   OS << "extern const char " << TargetName << "RegStrings[];\n";
1417   OS << "extern const char " << TargetName << "RegClassStrings[];\n";
1418   OS << "extern const MCPhysReg " << TargetName << "RegUnitRoots[][2];\n";
1419   OS << "extern const uint16_t " << TargetName << "SubRegIdxLists[];\n";
1420   OS << "extern const MCRegisterInfo::SubRegCoveredBits "
1421      << TargetName << "SubRegIdxRanges[];\n";
1422   OS << "extern const uint16_t " << TargetName << "RegEncodingTable[];\n";
1423
1424   EmitRegMappingTables(OS, Regs, true);
1425
1426   OS << ClassName << "::\n" << ClassName
1427      << "(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour, unsigned PC)\n"
1428      << "  : TargetRegisterInfo(" << TargetName << "RegInfoDesc"
1429      << ", RegisterClasses, RegisterClasses+" << RegisterClasses.size() <<",\n"
1430      << "             SubRegIndexNameTable, SubRegIndexLaneMaskTable, ";
1431   printMask(OS, RegBank.CoveringLanes);
1432   OS << ") {\n"
1433      << "  InitMCRegisterInfo(" << TargetName << "RegDesc, " << Regs.size() + 1
1434      << ", RA, PC,\n                     " << TargetName
1435      << "MCRegisterClasses, " << RegisterClasses.size() << ",\n"
1436      << "                     " << TargetName << "RegUnitRoots,\n"
1437      << "                     " << RegBank.getNumNativeRegUnits() << ",\n"
1438      << "                     " << TargetName << "RegDiffLists,\n"
1439      << "                     " << TargetName << "LaneMaskLists,\n"
1440      << "                     " << TargetName << "RegStrings,\n"
1441      << "                     " << TargetName << "RegClassStrings,\n"
1442      << "                     " << TargetName << "SubRegIdxLists,\n"
1443      << "                     " << SubRegIndicesSize + 1 << ",\n"
1444      << "                     " << TargetName << "SubRegIdxRanges,\n"
1445      << "                     " << TargetName << "RegEncodingTable);\n\n";
1446
1447   EmitRegMapping(OS, Regs, true);
1448
1449   OS << "}\n\n";
1450
1451   // Emit CalleeSavedRegs information.
1452   std::vector<Record*> CSRSets =
1453     Records.getAllDerivedDefinitions("CalleeSavedRegs");
1454   for (unsigned i = 0, e = CSRSets.size(); i != e; ++i) {
1455     Record *CSRSet = CSRSets[i];
1456     const SetTheory::RecVec *Regs = RegBank.getSets().expand(CSRSet);
1457     assert(Regs && "Cannot expand CalleeSavedRegs instance");
1458
1459     // Emit the *_SaveList list of callee-saved registers.
1460     OS << "static const MCPhysReg " << CSRSet->getName()
1461        << "_SaveList[] = { ";
1462     for (unsigned r = 0, re = Regs->size(); r != re; ++r)
1463       OS << getQualifiedName((*Regs)[r]) << ", ";
1464     OS << "0 };\n";
1465
1466     // Emit the *_RegMask bit mask of call-preserved registers.
1467     BitVector Covered = RegBank.computeCoveredRegisters(*Regs);
1468
1469     // Check for an optional OtherPreserved set.
1470     // Add those registers to RegMask, but not to SaveList.
1471     if (DagInit *OPDag =
1472         dyn_cast<DagInit>(CSRSet->getValueInit("OtherPreserved"))) {
1473       SetTheory::RecSet OPSet;
1474       RegBank.getSets().evaluate(OPDag, OPSet, CSRSet->getLoc());
1475       Covered |= RegBank.computeCoveredRegisters(
1476         ArrayRef<Record*>(OPSet.begin(), OPSet.end()));
1477     }
1478
1479     OS << "static const uint32_t " << CSRSet->getName()
1480        << "_RegMask[] = { ";
1481     printBitVectorAsHex(OS, Covered, 32);
1482     OS << "};\n";
1483   }
1484   OS << "\n\n";
1485
1486   OS << "ArrayRef<const uint32_t *> " << ClassName
1487      << "::getRegMasks() const {\n";
1488   if (!CSRSets.empty()) {
1489     OS << "  static const uint32_t *const Masks[] = {\n";
1490     for (Record *CSRSet : CSRSets)
1491       OS << "    " << CSRSet->getName() << "_RegMask,\n";
1492     OS << "  };\n";
1493     OS << "  return makeArrayRef(Masks);\n";
1494   } else {
1495     OS << "  return None;\n";
1496   }
1497   OS << "}\n\n";
1498
1499   OS << "ArrayRef<const char *> " << ClassName
1500      << "::getRegMaskNames() const {\n";
1501   if (!CSRSets.empty()) {
1502   OS << "  static const char *const Names[] = {\n";
1503     for (Record *CSRSet : CSRSets)
1504       OS << "    " << '"' << CSRSet->getName() << '"' << ",\n";
1505     OS << "  };\n";
1506     OS << "  return makeArrayRef(Names);\n";
1507   } else {
1508     OS << "  return None;\n";
1509   }
1510   OS << "}\n\n";
1511
1512   OS << "const " << TargetName << "FrameLowering *\n" << TargetName
1513      << "GenRegisterInfo::getFrameLowering(const MachineFunction &MF) {\n"
1514      << "  return static_cast<const " << TargetName << "FrameLowering *>(\n"
1515      << "      MF.getSubtarget().getFrameLowering());\n"
1516      << "}\n\n";
1517
1518   OS << "} // end namespace llvm\n\n";
1519   OS << "#endif // GET_REGINFO_TARGET_DESC\n\n";
1520 }
1521
1522 void RegisterInfoEmitter::run(raw_ostream &OS) {
1523   CodeGenTarget Target(Records);
1524   CodeGenRegBank &RegBank = Target.getRegBank();
1525   RegBank.computeDerivedInfo();
1526
1527   runEnums(OS, Target, RegBank);
1528   runMCDesc(OS, Target, RegBank);
1529   runTargetHeader(OS, Target, RegBank);
1530   runTargetDesc(OS, Target, RegBank);
1531 }
1532
1533 namespace llvm {
1534
1535 void EmitRegisterInfo(RecordKeeper &RK, raw_ostream &OS) {
1536   RegisterInfoEmitter(RK).run(OS);
1537 }
1538
1539 } // end namespace llvm