[DEMO]

[grimar]

Summary

For demonstration purposes only.

include/llvm/TableGen/Record.h

struct MultiClass {
 
   void dump() const;
 
   MultiClass(StringRef Name, SMLoc Loc, RecordKeeper &Records) :
     Rec(Name, Loc, Records) {}
 };
 
 class RecordKeeper {
-  using RecordMap = std::map<std::string, std::unique_ptr<Record>>;
+  using RecordMap = StringMap<std::unique_ptr<Record>>;
   RecordMap Classes, Defs;
+  std::vector<Record *> ClassesV, DefsV;
 
 public:
-  const RecordMap &getClasses() const { return Classes; }
-  const RecordMap &getDefs() const { return Defs; }
+  const std::vector<Record *> &getClasses() const { return ClassesV; }
+  const std::vector<Record *> &getDefs() const { return DefsV; }
 
   Record *getClass(StringRef Name) const {
     auto I = Classes.find(Name);
     return I == Classes.end() ? nullptr : I->second.get();
   }
 
   Record *getDef(StringRef Name) const {
     auto I = Defs.find(Name);
     return I == Defs.end() ? nullptr : I->second.get();
   }
 
   void addClass(std::unique_ptr<Record> R) {
+    ClassesV.push_back(R.get());
     bool Ins = Classes.insert(std::make_pair(R->getName(),
                                              std::move(R))).second;
     (void)Ins;
     assert(Ins && "Class already exists");
   }
 
   void addDef(std::unique_ptr<Record> R) {
+    DefsV.push_back(R.get());
     bool Ins = Defs.insert(std::make_pair(R->getName(),
                                           std::move(R))).second;
     (void)Ins;
     assert(Ins && "Record already exists");
   }
 
   //===--------------------------------------------------------------------===//
   // High-level helper methods, useful for tablegen backends...

lib/TableGen/Record.cpp

for (const auto &Proto : DefPrototypes)
     Proto->dump();
 }
 
 LLVM_DUMP_METHOD void RecordKeeper::dump() const { errs() << *this; }
 #endif
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const RecordKeeper &RK) {
   OS << "------------- Classes -----------------\n";
-  for (const auto &C : RK.getClasses())
-    OS << "class " << *C.second;
+  for (Record *R : RK.getClasses())
+    OS << "class " << *R;
 
   OS << "------------- Defs -----------------\n";
-  for (const auto &D : RK.getDefs())
-    OS << "def " << *D.second;
+  for (Record *R : RK.getClasses())
+    OS << "def " << *R;
   return OS;
 }
 
 std::vector<Record *>
 RecordKeeper::getAllDerivedDefinitions(StringRef ClassName) const {
   Record *Class = getClass(ClassName);
   if (!Class)
     PrintFatalError("ERROR: Couldn't find the `" + ClassName + "' class!\n");
 
-  std::vector<Record*> Defs;
-  for (const auto &D : getDefs())
-    if (D.second->isSubClassOf(Class))
-      Defs.push_back(D.second.get());
+  std::vector<Record *> Defs;
+  for (Record *R : getDefs())
+    if (R->isSubClassOf(Class))
+      Defs.push_back(R);
 
   return Defs;
 }
 
 static Init *GetStrConcat(Init *I0, Init *I1) {
   // Shortcut for the common case of concatenating two strings.
   if (const StringInit *I0s = dyn_cast<StringInit>(I0))
     if (const StringInit *I1s = dyn_cast<StringInit>(I1))

utils/TableGen/CTagsEmitter.cpp

 
 void CTagsEmitter::run(raw_ostream &OS) {
   const auto &Classes = Records.getClasses();
   const auto &Defs = Records.getDefs();
   std::vector<Tag> Tags;
   // Collect tags.
   Tags.reserve(Classes.size() + Defs.size());
   for (const auto &C : Classes)
-    Tags.push_back(Tag(C.first, locate(C.second.get())));
+    Tags.push_back(Tag(C->getName(), locate(C)));
   for (const auto &D : Defs)
-    Tags.push_back(Tag(D.first, locate(D.second.get())));
+    Tags.push_back(Tag(D->getName(), locate(D)));
   // Emit tags.
   std::sort(Tags.begin(), Tags.end());
   OS << "!_TAG_FILE_FORMAT\t1\t/original ctags format/\n";
   OS << "!_TAG_FILE_SORTED\t1\t/0=unsorted, 1=sorted, 2=foldcase/\n";
   for (const Tag &T : Tags)
     T.emit(OS);
 }
 
 namespace llvm {
 
 void EmitCTags(RecordKeeper &RK, raw_ostream &OS) { CTagsEmitter(RK).run(OS); }
 
 } // End llvm namespace.

utils/TableGen/PseudoLoweringEmitter.cpp

 }
 
 void PseudoLoweringEmitter::run(raw_ostream &o) {
   Record *ExpansionClass = Records.getClass("PseudoInstExpansion");
   Record *InstructionClass = Records.getClass("Instruction");
   assert(ExpansionClass && "PseudoInstExpansion class definition missing!");
   assert(InstructionClass && "Instruction class definition missing!");
 
-  std::vector<Record*> Insts;
-  for (const auto &D : Records.getDefs()) {
-    if (D.second->isSubClassOf(ExpansionClass) &&
-        D.second->isSubClassOf(InstructionClass))
-      Insts.push_back(D.second.get());
-  }
+  std::vector<Record *> Insts;
+  for (Record *R : Records.getDefs())
+    if (R->isSubClassOf(ExpansionClass) && R->isSubClassOf(InstructionClass))
+      Insts.push_back(R);
 
   // Process the pseudo expansion definitions, validating them as we do so.
   for (unsigned i = 0, e = Insts.size(); i != e; ++i)
     evaluateExpansion(Insts[i]);
 
   // Generate expansion code to lower the pseudo to an MCInst of the real
   // instruction.
   emitLoweringEmitter(o);

utils/TableGen/SearchableTableEmitter.cpp

void SearchableTableEmitter::emitMapping(Record *InstanceClass,
   }
 
   OS << "#endif\n";
 }
 
 void SearchableTableEmitter::run(raw_ostream &OS) {
   // Tables are defined to be the direct descendents of "SearchableEntry".
   Record *SearchableTable = Records.getClass("SearchableTable");
-  for (auto &NameRec : Records.getClasses()) {
-    Record *Class = NameRec.second.get();
+  for (Record *Class : Records.getClasses()) {
     if (Class->getSuperClasses().size() != 1 ||
         !Class->isSubClassOf(SearchableTable))
       continue;
     emitMapping(Class, OS);
   }
 }
 
 namespace llvm {
 
 void EmitSearchableTables(RecordKeeper &RK, raw_ostream &OS) {
   SearchableTableEmitter(RK).run(OS);
 }
 
 } // End llvm namespace.