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 "RegisterInfoEmitter.h"
  17 #include "CodeGenTarget.h"
  18 #include "CodeGenRegisters.h"
  19 #include "Record.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/ADT/STLExtras.h"
  22 #include "llvm/Support/Format.h"
  23 #include <algorithm>
  24 #include <set>
  25 using namespace llvm;
  26
  27 // runEnums - Print out enum values for all of the registers.
  28 void RegisterInfoEmitter::runEnums(raw_ostream &OS) {
  29   CodeGenTarget Target(Records);
  30   CodeGenRegBank &Bank = Target.getRegBank();
  31   const std::vector<CodeGenRegister*> &Registers = Bank.getRegisters();
  32
  33   std::string Namespace = Registers[0]->TheDef->getValueAsString("Namespace");
  34
  35   EmitSourceFileHeader("Target Register Enum Values", OS);
  36   OS << "namespace llvm {\n\n";
  37
  38   if (!Namespace.empty())
  39     OS << "namespace " << Namespace << " {\n";
  40   OS << "enum {\n  NoRegister,\n";
  41
  42   for (unsigned i = 0, e = Registers.size(); i != e; ++i)
  43     OS << "  " << Registers[i]->getName() << " = " <<
  44       Registers[i]->EnumValue << ",\n";
  45   assert(Registers.size() == Registers[Registers.size()-1]->EnumValue &&
  46          "Register enum value mismatch!");
  47   OS << "  NUM_TARGET_REGS \t// " << Registers.size()+1 << "\n";
  48   OS << "};\n";
  49   if (!Namespace.empty())
  50     OS << "}\n";
  51
  52   const std::vector<Record*> &SubRegIndices = Bank.getSubRegIndices();
  53   if (!SubRegIndices.empty()) {
  54     OS << "\n// Subregister indices\n";
  55     Namespace = SubRegIndices[0]->getValueAsString("Namespace");
  56     if (!Namespace.empty())
  57       OS << "namespace " << Namespace << " {\n";
  58     OS << "enum {\n  NoSubRegister,\n";
  59     for (unsigned i = 0, e = Bank.getNumNamedIndices(); i != e; ++i)
  60       OS << "  " << SubRegIndices[i]->getName() << ",\t// " << i+1 << "\n";
  61     OS << "  NUM_TARGET_NAMED_SUBREGS = " << SubRegIndices.size()+1 << "\n";
  62     OS << "};\n";
  63     if (!Namespace.empty())
  64       OS << "}\n";
  65   }
  66   OS << "} // End llvm namespace \n";
  67 }
  68
  69 void RegisterInfoEmitter::runHeader(raw_ostream &OS) {
  70   EmitSourceFileHeader("Register Information Header Fragment", OS);
  71   CodeGenTarget Target(Records);
  72   const std::string &TargetName = Target.getName();
  73   std::string ClassName = TargetName + "GenRegisterInfo";
  74
  75   OS << "#include \"llvm/Target/TargetRegisterInfo.h\"\n";
  76   OS << "#include <string>\n\n";
  77
  78   OS << "namespace llvm {\n\n";
  79
  80   OS << "struct " << ClassName << " : public TargetRegisterInfo {\n"
  81      << "  explicit " << ClassName
  82      << "(int CallFrameSetupOpcode = -1, int CallFrameDestroyOpcode = -1);\n"
  83      << "  virtual int getDwarfRegNumFull(unsigned RegNum, "
  84      << "unsigned Flavour) const;\n"
  85      << "  virtual int getLLVMRegNumFull(unsigned DwarfRegNum, "
  86      << "unsigned Flavour) const;\n"
  87      << "  virtual int getDwarfRegNum(unsigned RegNum, bool isEH) const = 0;\n"
  88      << "  virtual bool needsStackRealignment(const MachineFunction &) const\n"
  89      << "     { return false; }\n"
  90      << "  unsigned getSubReg(unsigned RegNo, unsigned Index) const;\n"
  91      << "  unsigned getSubRegIndex(unsigned RegNo, unsigned SubRegNo) const;\n"
  92      << "  unsigned composeSubRegIndices(unsigned, unsigned) const;\n"
  93      << "};\n\n";
  94
  95   const std::vector<CodeGenRegisterClass> &RegisterClasses =
  96     Target.getRegisterClasses();
  97
  98   if (!RegisterClasses.empty()) {
  99     OS << "namespace " << RegisterClasses[0].Namespace
 100        << " { // Register classes\n";
 101
 102     OS << "  enum {\n";
 103     for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) {
 104       if (i) OS << ",\n";
 105       OS << "    " << RegisterClasses[i].getName() << "RegClassID";
 106       OS << " = " << i;
 107     }
 108     OS << "\n  };\n\n";
 109
 110     for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) {
 111       const CodeGenRegisterClass &RC = RegisterClasses[i];
 112       const std::string &Name = RC.getName();
 113
 114       // Output the register class definition.
 115       OS << "  struct " << Name << "Class : public TargetRegisterClass {\n"
 116          << "    " << Name << "Class();\n";
 117       if (!RC.AltOrderSelect.empty())
 118         OS << "    ArrayRef<unsigned> "
 119               "getRawAllocationOrder(const MachineFunction&) const;\n";
 120       OS << "  };\n";
 121
 122       // Output the extern for the instance.
 123       OS << "  extern " << Name << "Class\t" << Name << "RegClass;\n";
 124       // Output the extern for the pointer to the instance (should remove).
 125       OS << "  static TargetRegisterClass * const "<< Name <<"RegisterClass = &"
 126          << Name << "RegClass;\n";
 127     }
 128     OS << "} // end of namespace " << TargetName << "\n\n";
 129   }
 130   OS << "} // End llvm namespace \n";
 131 }
 132
 133 typedef std::pair<unsigned, unsigned> UUPair;
 134 typedef std::vector<UUPair> UUVector;
 135
 136 //
 137 // RegisterInfoEmitter::run - Main register file description emitter.
 138 //
 139 void RegisterInfoEmitter::run(raw_ostream &OS) {
 140   CodeGenTarget Target(Records);
 141   CodeGenRegBank &RegBank = Target.getRegBank();
 142   RegBank.computeDerivedInfo();
 143   std::map<const CodeGenRegister*, CodeGenRegister::Set> Overlaps;
 144   RegBank.computeOverlaps(Overlaps);
 145
 146   EmitSourceFileHeader("Register Information Source Fragment", OS);
 147
 148   OS << "namespace llvm {\n\n";
 149
 150   // Start out by emitting each of the register classes.
 151   const std::vector<CodeGenRegisterClass> &RegisterClasses =
 152     Target.getRegisterClasses();
 153
 154   // Collect all registers belonging to any allocatable class.
 155   std::set<Record*> AllocatableRegs;
 156
 157   // Loop over all of the register classes... emitting each one.
 158   OS << "namespace {     // Register classes...\n";
 159
 160   // Emit the register enum value arrays for each RegisterClass
 161   for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
 162     const CodeGenRegisterClass &RC = RegisterClasses[rc];
 163     ArrayRef<Record*> Order = RC.getOrder();
 164
 165     // Collect allocatable registers.
 166     if (RC.Allocatable)
 167       AllocatableRegs.insert(Order.begin(), Order.end());
 168
 169     // Give the register class a legal C name if it's anonymous.
 170     std::string Name = RC.getName();
 171
 172     // Emit the register list now.
 173     OS << "  // " << Name << " Register Class...\n"
 174        << "  static const unsigned " << Name
 175        << "[] = {\n    ";
 176     for (unsigned i = 0, e = Order.size(); i != e; ++i) {
 177       Record *Reg = Order[i];
 178       OS << getQualifiedName(Reg) << ", ";
 179     }
 180     OS << "\n  };\n\n";
 181   }
 182
 183   // Emit the ValueType arrays for each RegisterClass
 184   for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
 185     const CodeGenRegisterClass &RC = RegisterClasses[rc];
 186
 187     // Give the register class a legal C name if it's anonymous.
 188     std::string Name = RC.getName() + "VTs";
 189
 190     // Emit the register list now.
 191     OS << "  // " << Name
 192        << " Register Class Value Types...\n"
 193        << "  static const EVT " << Name
 194        << "[] = {\n    ";
 195     for (unsigned i = 0, e = RC.VTs.size(); i != e; ++i)
 196       OS << getEnumName(RC.VTs[i]) << ", ";
 197     OS << "MVT::Other\n  };\n\n";
 198   }
 199   OS << "}  // end anonymous namespace\n\n";
 200
 201   // Now that all of the structs have been emitted, emit the instances.
 202   if (!RegisterClasses.empty()) {
 203     OS << "namespace " << RegisterClasses[0].Namespace
 204        << " {   // Register class instances\n";
 205     for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i)
 206       OS << "  " << RegisterClasses[i].getName()  << "Class\t"
 207          << RegisterClasses[i].getName() << "RegClass;\n";
 208
 209     std::map<unsigned, std::set<unsigned> > SuperClassMap;
 210     std::map<unsigned, std::set<unsigned> > SuperRegClassMap;
 211     OS << "\n";
 212
 213     unsigned NumSubRegIndices = RegBank.getSubRegIndices().size();
 214
 215     if (NumSubRegIndices) {
 216       // Emit the sub-register classes for each RegisterClass
 217       for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
 218         const CodeGenRegisterClass &RC = RegisterClasses[rc];
 219         std::vector<Record*> SRC(NumSubRegIndices);
 220         for (DenseMap<Record*,Record*>::const_iterator
 221              i = RC.SubRegClasses.begin(),
 222              e = RC.SubRegClasses.end(); i != e; ++i) {
 223           // Build SRC array.
 224           unsigned idx = RegBank.getSubRegIndexNo(i->first);
 225           SRC.at(idx-1) = i->second;
 226
 227           // Find the register class number of i->second for SuperRegClassMap.
 228           for (unsigned rc2 = 0, e2 = RegisterClasses.size(); rc2 != e2; ++rc2) {
 229             const CodeGenRegisterClass &RC2 =  RegisterClasses[rc2];
 230             if (RC2.TheDef == i->second) {
 231               SuperRegClassMap[rc2].insert(rc);
 232               break;
 233             }
 234           }
 235         }
 236
 237         // Give the register class a legal C name if it's anonymous.
 238         std::string Name = RC.TheDef->getName();
 239
 240         OS << "  // " << Name
 241            << " Sub-register Classes...\n"
 242            << "  static const TargetRegisterClass* const "
 243            << Name << "SubRegClasses[] = {\n    ";
 244
 245         for (unsigned idx = 0; idx != NumSubRegIndices; ++idx) {
 246           if (idx)
 247             OS << ", ";
 248           if (SRC[idx])
 249             OS << "&" << getQualifiedName(SRC[idx]) << "RegClass";
 250           else
 251             OS << "0";
 252         }
 253         OS << "\n  };\n\n";
 254       }
 255
 256       // Emit the super-register classes for each RegisterClass
 257       for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
 258         const CodeGenRegisterClass &RC = RegisterClasses[rc];
 259
 260         // Give the register class a legal C name if it's anonymous.
 261         std::string Name = RC.TheDef->getName();
 262
 263         OS << "  // " << Name
 264            << " Super-register Classes...\n"
 265            << "  static const TargetRegisterClass* const "
 266            << Name << "SuperRegClasses[] = {\n    ";
 267
 268         bool Empty = true;
 269         std::map<unsigned, std::set<unsigned> >::iterator I =
 270           SuperRegClassMap.find(rc);
 271         if (I != SuperRegClassMap.end()) {
 272           for (std::set<unsigned>::iterator II = I->second.begin(),
 273                  EE = I->second.end(); II != EE; ++II) {
 274             const CodeGenRegisterClass &RC2 = RegisterClasses[*II];
 275             if (!Empty)
 276               OS << ", ";
 277             OS << "&" << getQualifiedName(RC2.TheDef) << "RegClass";
 278             Empty = false;
 279           }
 280         }
 281
 282         OS << (!Empty ? ", " : "") << "NULL";
 283         OS << "\n  };\n\n";
 284       }
 285     } else {
 286       // No subregindices in this target
 287       OS << "  static const TargetRegisterClass* const "
 288          << "NullRegClasses[] = { NULL };\n\n";
 289     }
 290
 291     // Emit the sub-classes array for each RegisterClass
 292     for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
 293       const CodeGenRegisterClass &RC = RegisterClasses[rc];
 294
 295       // Give the register class a legal C name if it's anonymous.
 296       std::string Name = RC.TheDef->getName();
 297
 298       OS << "  // " << Name
 299          << " Register Class sub-classes...\n"
 300          << "  static const TargetRegisterClass* const "
 301          << Name << "Subclasses[] = {\n    ";
 302
 303       bool Empty = true;
 304       for (unsigned rc2 = 0, e2 = RegisterClasses.size(); rc2 != e2; ++rc2) {
 305         const CodeGenRegisterClass &RC2 = RegisterClasses[rc2];
 306
 307         // Sub-classes are used to determine if a virtual register can be used
 308         // as an instruction operand, or if it must be copied first.
 309         if (rc == rc2 || !RC.hasSubClass(&RC2)) continue;
 310
 311         if (!Empty) OS << ", ";
 312         OS << "&" << getQualifiedName(RC2.TheDef) << "RegClass";
 313         Empty = false;
 314
 315         std::map<unsigned, std::set<unsigned> >::iterator SCMI =
 316           SuperClassMap.find(rc2);
 317         if (SCMI == SuperClassMap.end()) {
 318           SuperClassMap.insert(std::make_pair(rc2, std::set<unsigned>()));
 319           SCMI = SuperClassMap.find(rc2);
 320         }
 321         SCMI->second.insert(rc);
 322       }
 323
 324       OS << (!Empty ? ", " : "") << "NULL";
 325       OS << "\n  };\n\n";
 326     }
 327
 328     for (unsigned rc = 0, e = RegisterClasses.size(); rc != e; ++rc) {
 329       const CodeGenRegisterClass &RC = RegisterClasses[rc];
 330
 331       // Give the register class a legal C name if it's anonymous.
 332       std::string Name = RC.TheDef->getName();
 333
 334       OS << "  // " << Name
 335          << " Register Class super-classes...\n"
 336          << "  static const TargetRegisterClass* const "
 337          << Name << "Superclasses[] = {\n    ";
 338
 339       bool Empty = true;
 340       std::map<unsigned, std::set<unsigned> >::iterator I =
 341         SuperClassMap.find(rc);
 342       if (I != SuperClassMap.end()) {
 343         for (std::set<unsigned>::iterator II = I->second.begin(),
 344                EE = I->second.end(); II != EE; ++II) {
 345           const CodeGenRegisterClass &RC2 = RegisterClasses[*II];
 346           if (!Empty) OS << ", ";
 347           OS << "&" << getQualifiedName(RC2.TheDef) << "RegClass";
 348           Empty = false;
 349         }
 350       }
 351
 352       OS << (!Empty ? ", " : "") << "NULL";
 353       OS << "\n  };\n\n";
 354     }
 355
 356     // Emit methods.
 357     for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i) {
 358       const CodeGenRegisterClass &RC = RegisterClasses[i];
 359       OS << RC.getName() << "Class::" << RC.getName()
 360          << "Class()  : TargetRegisterClass("
 361          << RC.getName() + "RegClassID" << ", "
 362          << '\"' << RC.getName() << "\", "
 363          << RC.getName() + "VTs" << ", "
 364          << RC.getName() + "Subclasses" << ", "
 365          << RC.getName() + "Superclasses" << ", "
 366          << (NumSubRegIndices ? RC.getName() + "Sub" : std::string("Null"))
 367          << "RegClasses, "
 368          << (NumSubRegIndices ? RC.getName() + "Super" : std::string("Null"))
 369          << "RegClasses, "
 370          << RC.SpillSize/8 << ", "
 371          << RC.SpillAlignment/8 << ", "
 372          << RC.CopyCost << ", "
 373          << RC.Allocatable << ", "
 374          << RC.getName() << ", " << RC.getName() << " + "
 375          << RC.getOrder().size()
 376          << ") {}\n";
 377       if (!RC.AltOrderSelect.empty()) {
 378         OS << "\nstatic inline unsigned " << RC.getName()
 379            << "AltOrderSelect(const MachineFunction &MF) {"
 380            << RC.AltOrderSelect << "}\n\nArrayRef<unsigned> "
 381            << RC.getName() << "Class::"
 382            << "getRawAllocationOrder(const MachineFunction &MF) const {\n";
 383         for (unsigned oi = 1 , oe = RC.getNumOrders(); oi != oe; ++oi) {
 384           ArrayRef<Record*> Elems = RC.getOrder(oi);
 385           OS << "  static const unsigned AltOrder" << oi << "[] = {";
 386           for (unsigned elem = 0; elem != Elems.size(); ++elem)
 387             OS << (elem ? ", " : " ") << getQualifiedName(Elems[elem]);
 388           OS << " };\n";
 389         }
 390         OS << "  static const ArrayRef<unsigned> Order[] = {\n"
 391            << "    ArrayRef<unsigned>(" << RC.getName();
 392         for (unsigned oi = 1, oe = RC.getNumOrders(); oi != oe; ++oi)
 393           OS << "),\n    ArrayRef<unsigned>(AltOrder" << oi;
 394         OS << ")\n  };\n  const unsigned Select = " << RC.getName()
 395            << "AltOrderSelect(MF);\n  assert(Select < " << RC.getNumOrders()
 396            << ");\n  return Order[Select];\n}\n";
 397         }
 398     }
 399
 400     OS << "}\n";
 401   }
 402
 403   OS << "\nnamespace {\n";
 404   OS << "  const TargetRegisterClass* const RegisterClasses[] = {\n";
 405   for (unsigned i = 0, e = RegisterClasses.size(); i != e; ++i)
 406     OS << "    &" << getQualifiedName(RegisterClasses[i].TheDef)
 407        << "RegClass,\n";
 408   OS << "  };\n";
 409
 410   typedef std::map<Record*, std::vector<int64_t>, LessRecord> DwarfRegNumsMapTy;
 411   DwarfRegNumsMapTy DwarfRegNums;
 412   const std::vector<CodeGenRegister*> &Regs = RegBank.getRegisters();
 413
 414   // Emit an overlap list for all registers.
 415   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
 416     const CodeGenRegister *Reg = Regs[i];
 417     const CodeGenRegister::Set &O = Overlaps[Reg];
 418     // Move Reg to the front so TRI::getAliasSet can share the list.
 419     OS << "  const unsigned " << Reg->getName() << "_Overlaps[] = { "
 420        << getQualifiedName(Reg->TheDef) << ", ";
 421     for (CodeGenRegister::Set::const_iterator I = O.begin(), E = O.end();
 422          I != E; ++I)
 423       if (*I != Reg)
 424         OS << getQualifiedName((*I)->TheDef) << ", ";
 425     OS << "0 };\n";
 426   }
 427
 428   // Emit the empty sub-registers list
 429   OS << "  const unsigned Empty_SubRegsSet[] = { 0 };\n";
 430   // Loop over all of the registers which have sub-registers, emitting the
 431   // sub-registers list to memory.
 432   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
 433     const CodeGenRegister &Reg = *Regs[i];
 434     if (Reg.getSubRegs().empty())
 435      continue;
 436     // getSubRegs() orders by SubRegIndex. We want a topological order.
 437     SetVector<CodeGenRegister*> SR;
 438     Reg.addSubRegsPreOrder(SR);
 439     OS << "  const unsigned " << Reg.getName() << "_SubRegsSet[] = { ";
 440     for (unsigned j = 0, je = SR.size(); j != je; ++j)
 441       OS << getQualifiedName(SR[j]->TheDef) << ", ";
 442     OS << "0 };\n";
 443   }
 444
 445   // Emit the empty super-registers list
 446   OS << "  const unsigned Empty_SuperRegsSet[] = { 0 };\n";
 447   // Loop over all of the registers which have super-registers, emitting the
 448   // super-registers list to memory.
 449   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
 450     const CodeGenRegister &Reg = *Regs[i];
 451     const CodeGenRegister::SuperRegList &SR = Reg.getSuperRegs();
 452     if (SR.empty())
 453       continue;
 454     OS << "  const unsigned " << Reg.getName() << "_SuperRegsSet[] = { ";
 455     for (unsigned j = 0, je = SR.size(); j != je; ++j)
 456       OS << getQualifiedName(SR[j]->TheDef) << ", ";
 457     OS << "0 };\n";
 458   }
 459
 460   OS<<"\n  const TargetRegisterDesc RegisterDescriptors[] = { // Descriptors\n";
 461   OS << "    { \"NOREG\",\t0,\t0,\t0,\t0,\t0 },\n";
 462
 463   // Now that register alias and sub-registers sets have been emitted, emit the
 464   // register descriptors now.
 465   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
 466     const CodeGenRegister &Reg = *Regs[i];
 467     OS << "    { \"";
 468     OS << Reg.getName() << "\",\t" << Reg.getName() << "_Overlaps,\t";
 469     if (!Reg.getSubRegs().empty())
 470       OS << Reg.getName() << "_SubRegsSet,\t";
 471     else
 472       OS << "Empty_SubRegsSet,\t";
 473     if (!Reg.getSuperRegs().empty())
 474       OS << Reg.getName() << "_SuperRegsSet,\t";
 475     else
 476       OS << "Empty_SuperRegsSet,\t";
 477     OS << Reg.CostPerUse << ",\t"
 478        << int(AllocatableRegs.count(Reg.TheDef)) << " },\n";
 479   }
 480   OS << "  };\n";      // End of register descriptors...
 481
 482   // Calculate the mapping of subregister+index pairs to physical registers.
 483   // This will also create further anonymous indexes.
 484   unsigned NamedIndices = RegBank.getNumNamedIndices();
 485
 486   // Emit SubRegIndex names, skipping 0
 487   const std::vector<Record*> &SubRegIndices = RegBank.getSubRegIndices();
 488   OS << "\n  const char *const SubRegIndexTable[] = { \"";
 489   for (unsigned i = 0, e = SubRegIndices.size(); i != e; ++i) {
 490     OS << SubRegIndices[i]->getName();
 491     if (i+1 != e)
 492       OS << "\", \"";
 493   }
 494   OS << "\" };\n\n";
 495
 496   // Emit names of the anonymus subreg indexes.
 497   if (SubRegIndices.size() > NamedIndices) {
 498     OS << "  enum {";
 499     for (unsigned i = NamedIndices, e = SubRegIndices.size(); i != e; ++i) {
 500       OS << "\n    " << SubRegIndices[i]->getName() << " = " << i+1;
 501       if (i+1 != e)
 502         OS << ',';
 503     }
 504     OS << "\n  };\n\n";
 505   }
 506   OS << "}\n\n";       // End of anonymous namespace...
 507
 508   std::string ClassName = Target.getName() + "GenRegisterInfo";
 509
 510   // Emit the subregister + index mapping function based on the information
 511   // calculated above.
 512   OS << "unsigned " << ClassName
 513      << "::getSubReg(unsigned RegNo, unsigned Index) const {\n"
 514      << "  switch (RegNo) {\n"
 515      << "  default:\n    return 0;\n";
 516   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
 517     const CodeGenRegister::SubRegMap &SRM = Regs[i]->getSubRegs();
 518     if (SRM.empty())
 519       continue;
 520     OS << "  case " << getQualifiedName(Regs[i]->TheDef) << ":\n";
 521     OS << "    switch (Index) {\n";
 522     OS << "    default: return 0;\n";
 523     for (CodeGenRegister::SubRegMap::const_iterator ii = SRM.begin(),
 524          ie = SRM.end(); ii != ie; ++ii)
 525       OS << "    case " << getQualifiedName(ii->first)
 526          << ": return " << getQualifiedName(ii->second->TheDef) << ";\n";
 527     OS << "    };\n" << "    break;\n";
 528   }
 529   OS << "  };\n";
 530   OS << "  return 0;\n";
 531   OS << "}\n\n";
 532
 533   OS << "unsigned " << ClassName
 534      << "::getSubRegIndex(unsigned RegNo, unsigned SubRegNo) const {\n"
 535      << "  switch (RegNo) {\n"
 536      << "  default:\n    return 0;\n";
 537    for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
 538      const CodeGenRegister::SubRegMap &SRM = Regs[i]->getSubRegs();
 539      if (SRM.empty())
 540        continue;
 541     OS << "  case " << getQualifiedName(Regs[i]->TheDef) << ":\n";
 542     for (CodeGenRegister::SubRegMap::const_iterator ii = SRM.begin(),
 543          ie = SRM.end(); ii != ie; ++ii)
 544       OS << "    if (SubRegNo == " << getQualifiedName(ii->second->TheDef)
 545          << ")  return " << getQualifiedName(ii->first) << ";\n";
 546     OS << "    return 0;\n";
 547   }
 548   OS << "  };\n";
 549   OS << "  return 0;\n";
 550   OS << "}\n\n";
 551
 552   // Emit composeSubRegIndices
 553   OS << "unsigned " << ClassName
 554      << "::composeSubRegIndices(unsigned IdxA, unsigned IdxB) const {\n"
 555      << "  switch (IdxA) {\n"
 556      << "  default:\n    return IdxB;\n";
 557   for (unsigned i = 0, e = SubRegIndices.size(); i != e; ++i) {
 558     bool Open = false;
 559     for (unsigned j = 0; j != e; ++j) {
 560       if (Record *Comp = RegBank.getCompositeSubRegIndex(SubRegIndices[i],
 561                                                          SubRegIndices[j])) {
 562         if (!Open) {
 563           OS << "  case " << getQualifiedName(SubRegIndices[i])
 564              << ": switch(IdxB) {\n    default: return IdxB;\n";
 565           Open = true;
 566         }
 567         OS << "    case " << getQualifiedName(SubRegIndices[j])
 568            << ": return " << getQualifiedName(Comp) << ";\n";
 569       }
 570     }
 571     if (Open)
 572       OS << "    }\n";
 573   }
 574   OS << "  }\n}\n\n";
 575
 576   // Emit the constructor of the class...
 577   OS << ClassName << "::" << ClassName
 578      << "(int CallFrameSetupOpcode, int CallFrameDestroyOpcode)\n"
 579      << "  : TargetRegisterInfo(RegisterDescriptors, " << Regs.size()+1
 580      << ", RegisterClasses, RegisterClasses+" << RegisterClasses.size() <<",\n"
 581      << "                 SubRegIndexTable,\n"
 582      << "                 CallFrameSetupOpcode, CallFrameDestroyOpcode) {\n"
 583      << "}\n\n";
 584
 585   // Collect all information about dwarf register numbers
 586
 587   // First, just pull all provided information to the map
 588   unsigned maxLength = 0;
 589   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
 590     Record *Reg = Regs[i]->TheDef;
 591     std::vector<int64_t> RegNums = Reg->getValueAsListOfInts("DwarfNumbers");
 592     maxLength = std::max((size_t)maxLength, RegNums.size());
 593     if (DwarfRegNums.count(Reg))
 594       errs() << "Warning: DWARF numbers for register " << getQualifiedName(Reg)
 595              << "specified multiple times\n";
 596     DwarfRegNums[Reg] = RegNums;
 597   }
 598
 599   // Now we know maximal length of number list. Append -1's, where needed
 600   for (DwarfRegNumsMapTy::iterator
 601        I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I)
 602     for (unsigned i = I->second.size(), e = maxLength; i != e; ++i)
 603       I->second.push_back(-1);
 604
 605   // Emit reverse information about the dwarf register numbers.
 606   OS << "int " << ClassName << "::getLLVMRegNumFull(unsigned DwarfRegNum, "
 607      << "unsigned Flavour) const {\n"
 608      << "  switch (Flavour) {\n"
 609      << "  default:\n"
 610      << "    assert(0 && \"Unknown DWARF flavour\");\n"
 611      << "    return -1;\n";
 612
 613   for (unsigned i = 0, e = maxLength; i != e; ++i) {
 614     OS << "  case " << i << ":\n"
 615        << "    switch (DwarfRegNum) {\n"
 616        << "    default:\n"
 617        << "      assert(0 && \"Invalid DwarfRegNum\");\n"
 618        << "      return -1;\n";
 619
 620     for (DwarfRegNumsMapTy::iterator
 621            I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I) {
 622       int DwarfRegNo = I->second[i];
 623       if (DwarfRegNo >= 0)
 624         OS << "    case " <<  DwarfRegNo << ":\n"
 625            << "      return " << getQualifiedName(I->first) << ";\n";
 626     }
 627     OS << "    };\n";
 628   }
 629
 630   OS << "  };\n}\n\n";
 631
 632   for (unsigned i = 0, e = Regs.size(); i != e; ++i) {
 633     Record *Reg = Regs[i]->TheDef;
 634     const RecordVal *V = Reg->getValue("DwarfAlias");
 635     if (!V || !V->getValue())
 636       continue;
 637
 638     DefInit *DI = dynamic_cast<DefInit*>(V->getValue());
 639     Record *Alias = DI->getDef();
 640     DwarfRegNums[Reg] = DwarfRegNums[Alias];
 641   }
 642
 643   // Emit information about the dwarf register numbers.
 644   OS << "int " << ClassName << "::getDwarfRegNumFull(unsigned RegNum, "
 645      << "unsigned Flavour) const {\n"
 646      << "  switch (Flavour) {\n"
 647      << "  default:\n"
 648      << "    assert(0 && \"Unknown DWARF flavour\");\n"
 649      << "    return -1;\n";
 650
 651   for (unsigned i = 0, e = maxLength; i != e; ++i) {
 652     OS << "  case " << i << ":\n"
 653        << "    switch (RegNum) {\n"
 654        << "    default:\n"
 655        << "      assert(0 && \"Invalid RegNum\");\n"
 656        << "      return -1;\n";
 657
 658     // Sort by name to get a stable order.
 659
 660
 661     for (DwarfRegNumsMapTy::iterator
 662            I = DwarfRegNums.begin(), E = DwarfRegNums.end(); I != E; ++I) {
 663       int RegNo = I->second[i];
 664       OS << "    case " << getQualifiedName(I->first) << ":\n"
 665          << "      return " << RegNo << ";\n";
 666     }
 667     OS << "    };\n";
 668   }
 669
 670   OS << "  };\n}\n\n";
 671
 672   OS << "} // End llvm namespace \n";
 673 }